Python 实例教学一

教学方法

1、利用 Leetcode 学习 Python 基础数据结构；
2、对理解不深的内容，先强行记忆，由点到面。

课前准备

注册 CSND 和 Leetcode 账号；

要求

1、必须记住相关的英语单词，掌握用法；
2、有一定的数学基础；
3、需要较好的理解和记忆能力；
4、要有较好的耐力，不要一有难度就放弃！只要坚持一定有很大的收获。

Python 实例教学_01_基础语法

Python 教学

Python 1-01 环境搭建
Python 1-02 基础语法
Python 1-06 基本数据类型
Python 1-07 数字
Python 1-08 bool NoneType
Python 1-12 条件与循环语句
Python 1-13 运算符

第一课

223. 矩形面积

知识点： return, max(), .min()

class Solution:
    def computeArea(self, ax1: int, ay1: int, ax2: int, ay2: int, bx1: int, by1: int, bx2: int, by2: int) -> int:
        a = (ax1 - ax2) * (ay1 - ay2)
        b = (bx2 - bx1) * (by2 - by1) 
        w = min(ax2, bx2) - max(ax1, bx1)
        h = min(ay2, by2) - max(ay1, by1)
        c = max(w, 0) * max(h, 0)
        
        return a + b - c
1
2
3
4
5
6
7
8
9

基础知识

Python 基础语法

1、标识符： 只包含字母、数字、下划线(_)，汉字也可以，但数字不能开头，自定义标识符不能使用关键字，如：min max if for 等，它们是留给系统用的。
2、变量： 事实上是一个地址，就象一个宿舍或几个宿舍，如：402 宿舍，这学期你住，下学期可能其他人住。地址是不变的，但内容是可变的。
3、＝： 这里的等号不是指相等和数学中的概念不同，这里叫 赋值运算符，b402 = “应用3班”，表示现在 应用3班 在 b402 教室上课，用编程语言来讲，就是 “应用3班” 赋给 b402，前者是值(字符串)，后者是变量。
4、==：双等于号是判断左右两边相等，是 比较运算符，相等结果为 真(True)、不相等为 假(False)。如：b402 == “应用3班”，如果 3班 不在 b402，为假，在为真。
5、min(a, b)、max(a, b) 内置函数，最简单的应用取两数的最小/大值。

a, b, c = 1, 2, 3
a = b = c = 10 # ▲ 等价于 a = 10; b = a; c = a 
1
2

Python 可以按元组装包与解包赋值；简单的说就是一对一赋值。

class Solution:  # 声明 Solution 类 
    def computeArea(self, ax1: int, ay1: int, ...) -> int: # 定义方法 computeArea 
1
2

Python max()、min() 内置函数

函数功能为取传入的多个参数中的最大值，或者传入的 可迭代对象 元素中的最大值。

max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])
1
2

参数：
默认 数值型 参数，取值大者； 字符型 参数，取字母表排序靠后者。
key 可做为一个函数，用来 指定取最大值的方法。
default 用来指定最大值不存在时返回的 默认值。
arg1 字符型参数/数值型参数，默认数值型。

返回值：最大值。

max(1,2,3,4,5,6) # 1、传入多个参数取最大值（元组、列表、集合）。
max('12345') # '5' # 2、传入可迭代对象时，取其元素最大值。
max((), default = 1) # 3、传入可迭代对象为空时，必须指定参数 default，用来返回默认值。
max([]) # ValueError: max() arg is an empty sequence
# 4、传入命名参数 key，其为一个函数，用来指定取最大值的方法。
student = [{'name': 'li', 'age': 24},{'name': 'he', 'age': 45} ]
max(student, key = lambda x: x['age']) # {'name': 'he', 'age': 45}
1
2
3
4
5
6
7

第二课

★860. 柠檬水找零

知识点： boolean, , if elif else, for in

class Solution:
    def lemonadeChange(self, bills: List[int]) -> bool:
        five, ten = 0, 0
        for i in bills:
            if i == 5: five += 1 # 不用找零，直接 五元 + 1
            elif i == 10: # 需要找一张五元
                ten += 1
                five -= 1
            elif i == 20:
            	# 嵌套条件语句
                if ten > 0: # 先找 10 元的
                    ten -= 1; five -= 1
                else: five -= 3
            if five < 0: return False # 说明五元的钞票不够找了，返回 False               
        return True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

基础知识

一、if … elif … else … 条件语句

if 条件:  # 条件成立（即为真）执行下面的代码，冒号结束。
	语句块：用缩进表示
elif 条件:
	语句块	
else: # 上面的条件不成立（即为假）执行下面的代码
	语句块
1
2
3
4
5
6

语句块：python 用缩进表示

二、for、while 循环语句

基本用法有三种： ⑴ ⑵ ⑶ 、⑷ 是 Python 语言的特殊用法。

三、in 成员运算符

in 如果在指定的序列中找到值返回 True，否则返回 False。in 能够快速判断某个元素是否在序列中。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。

四、list 列表

list 是一种顺序存储的数据结构，是一种 数据类型，可以存储不同类型的数据，就象一个列表，其中数据叫 元素。

五、range、enumerate 内置函数

range(10) 是一个对象 表示一个范围的数这里是 0 到 9，注意从 0 开始，不包含 10。

六、+= 加法赋值运算符

c += a 等效于 c = c + a

arr = [1,2,3,4,5,6] # 列表用 [] 表示，逗号分隔元素。
for i in range(len(arr)): # ⑴ i 是索引，对应元素 arr[i]
	循环体
for i, e in enumerate(arr): # ⑶ 同时需要索引与元素
for e in arr: # ⑵ e 是元素, e 是引用类型，对 e 的修改会影响到 arr。
	# ...
	# break 终止当前层循环，也就是跳出本层循环。同时跳过 else 部分。
	# continue 结束本次循环，相当短路操作。
else: 
	# ⑷ 不是通过 break 结束循环时执行。
1
2
3
4
5
6
7
8
9
10

六、布尔类型（boolean）

python 0，“”、[]、()、set()、{}，None 为 False，非零为 True。

第三课

1217. 玩筹码

第 i 个芯片的 位置 是 position[i]，注意不是筹码数。
知识点： for, %, min(), +=

class Solution:
    def minCostToMoveChips(self, position: List[int]) -> int:        
        # odd = even = 0
        # for k in position:
        #     if k % 2: odd += 1
        #     else: even += 1
        # return min(even, odd)
        
        # d = [0, 0]
        # for i in position: d[i%2] += 1
        # return min(d)

        return min(x := sum(i & 1 for i in position), len(position) - x) 
1
2
3
4
5
6
7
8
9
10
11
12
13

1184. 公交站间的距离

知识点： 交换 sum

class Solution:
    def distanceBetweenBusStops(self, distance: List[int], start: int, destination: int) -> int:       
        if destination < start: # 交换出发点和目的地距离相等
            start, destination = destination, start            
        d = sum(distance[start : destination]) # 出发点到目的地距离
        return min(d, sum(distance) - d)
1
2
3
4
5
6

基础知识

判断奇偶性

% 模运算符，n % 2
& 位运算符 与，n & 1 # 位运算符 与（&）

切片

切片指的是对序列进行截取，选取序列中的某一段。
切片的语法是： list[start：end：step]

以 冒号分割索引，start 代表 起点索引，end 代表 结束点索引。省略 start 表示以0开始，省略 end 表示到列表的结尾。注意，区间是左闭右开的！。分片不会修改原有的列表，可以将结果保存到新的变量。

如果提供的是负整数下标，则从列表的最后开始往头部查找。
切片过程中还可以设置 步长，以第二个冒号分割，例如 list[3：9：2]，表示每隔多少距离取一个元素。

求和

sum(iterable[, start]) # python 内置函数
1

iterable – 可迭代对象，如：列表(list)、元组(tuple)、集合(set)、字典(dictionary)。
start – 指定相加的参数，如果没有设置这个值，默认为 0。

sum([1,2,3])         # in list
sum([1,2,3],5)       # in list +start
sum((1,2,3))         # in tuple
sum({1,2,3})         # in set
sum({1:5,2:6,3:7})   # in dictionary key
sum(range(1,4))      # in range()

sum(i % 2 == 0 for i in position) # 生成器 偶数的个数
1
2
3
4
5
6
7
8

自己编写代码实现最大值和求和

arr = [1,2,3,4,5,6]
max_ = -float("inf") # 注意初始化时取 arr 中最小数或更小的数，一般取无穷小 -float("inf")
sum_ = 0 
for x in arr:
	if x > max_: max_ = x
	sum_ += x # 累加
print("最大值：", max_, "和：", sum_)
1
2
3
4
5
6
7

swap 交换

a, b = b, a # 右边取得的原来的值 注意和 a = b; b = a 不同。
1

第四课

1518. 换酒问题

知识点： while, /, %

class Solution:
    def numWaterBottles(self, numBottles: int, numExchange: int) -> int:
        res = rem = numBottles # 全部喝完，rem 为空瓶数
        while rem >= numExchange:
            numBottles, rem = divmod(rem, numExchange) # 可换酒 numBottles 瓶，剩余 rem 个空瓶。
            res += numBottles # 全部喝完
            rem += numBottles # + 空瓶           
        return res
1
2
3
4
5
6
7
8

基础知识

整除

d, r = divmod(a, b) <=> d = a // b, r = a % b
// 整除
/ 除，结果是浮点数。

while 循环

while 条件:
	# 循环体
else:
	# break 终止循环时不执行
1
2
3
4

divmod() 内置函数

divmod(a, b) 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。

第五课

2057. 值相等的最小索引

class Solution:
    def smallestEqual(self, nums: List[int]) -> int:
        for i, x in enumerate(nums):
            if i % 10 == x: return i
        return -1
1
2
3
4
5

412. Fizz Buzz

class Solution:
    def fizzBuzz(self, n: int) -> List[str]:
        res = [''] * 列表包含 n # n 个 空串
        # res = []
        for i in range(1, n + 1):
            if i % 15 == 0: x = "FizzBuzz" # 先处理 15 的倍数
            elif i % 3 == 0: x = "Fizz"
            elif i % 5 == 0: x = "Buzz"
            else: x = str(i) # 转换成字符串
            res[i - 1] = x
            # res.append(x)
        return res

        # return ['Fizz'[i%3*4:]+"Buzz"[i%5*4:] or str(i) for i in range(1, n+1)]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

第六课

2239. 找到最接近 0 的数字

class Solution:
    def findClosestNumber(self, nums: List[int]) -> int:
        ans = inf
        for x in nums:
            if abs(x) == abs(ans): ans = max(x, ans)
            elif abs(x) < abs(ans):  ans = x                
        return ans
1
2
3
4
5
6
7

747. 至少是其他数字两倍的最大数

知识点： 条件表达式

class Solution:
    def dominantIndex(self, nums: List[int]) -> int:
        # 方法一：最大值 >= 2 倍次大值
        first = second = id = 0
        for i, n in enumerate(nums):
            if n > first:
                first, second = n, first
                id = i
            elif n > second:
                second = n
        
        return id if first >= 2 * second else -1
        # 方法二：求最大值
        ans = max_ = -1        
        for i, x in enumerate(nums):  
            if x >= max_ * 2: ans = i # 当前的 max_ 对当前的 x 是满足条件的，先保存下来，但不一定是最终值。
            elif x > max_ // 2: ans = -1 # 说明 max_ 不符合条件，先记 ans = -1           
            max_ = max(max_, x) 
        return ans
        # 方法三：最大值函数
        max_, ans = max(nums), -1
        for i, x in enumerate(nums):
            if max_ == x: ans = i
            elif x > max_ // 2: return -1
        return ans
        # 方法四：离线排序
        q = sorted(range(len(nums)), key=lambda i:nums[i])
        return -1 if nums[q[-2]]*2 > nums[q[-1]] else q[-1]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

基础知识

条件表达式

结果 a if 条件 else 结果 b

单元测试

2235. 两整数相加

258. 各位相加

2432… 处理用时最长的那个任务的员工

class Solution:
    def hardestWorker(self, n: int, logs: List[List[int]]) -> int:

        ans = pre = most = 0
        for i, t in logs: 
            dif = t - pre
            pre = t
            if most < dif or most == dif and ans > i:
                ans = i
                most = dif

        return ans
1
2
3
4
5
6
7
8
9
10
11
12