Python基础知识点六万字总结，爆肝一周熬夜完成【建议收藏】

如果当前查找的key存在，则返回对应的值；否则则报错。

get()

• 语法

字典序列.get(key, 默认值)

注意：如果当前查找的key不存在则返回第二个参数(默认值)，如果省略第二个参数，则返回None。

• 快速体验

dict1 = {‘name’: ‘Tom’, ‘age’: 20, ‘gender’: ‘男’}

print(dict1.get(‘name’))  # Tom

print(dict1.get(‘id’, 110))  # 110

print(dict1.get(‘id’))  # None

keys()

dict1 = {‘name’: ‘Tom’, ‘age’: 20, ‘gender’: ‘男’}

print(dict1.keys())  # dict_keys([‘name’, ‘age’, ‘gender’])

values()

dict1 = {‘name’: ‘Tom’, ‘age’: 20, ‘gender’: ‘男’}

print(dict1.values())  # dict_values([‘Tom’, 20, ‘男’])

items()

dict1 = {‘name’: ‘Tom’, ‘age’: 20, ‘gender’: ‘男’}

print(dict1.items())  # dict_items([(‘name’, ‘Tom’), (‘age’, 20), (‘gender’, ‘男’)])

总结

• 定义字典

dict1 = {‘name’: ‘Python’, ‘age’: 30}

​

dict2 = {}

​

dict3 = dict()

• 常见操作

• 增/改

字典序列[key] = 值

• 查找

• 字典序列[key]

• keys()

• values()

• items()

集合

–

创建集合

创建集合使用{}或set()， 但是如果要创建空集合只能使用set()，因为{}用来创建空字典。

s1 = {10, 20, 30, 40, 50}

print(s1)

​

s2 = {10, 30, 20, 10, 30, 40, 30, 50}

print(s2)

​

s3 = set(‘abcdefg’)

print(s3)

​

s4 = set()

print(type(s4))  # set

​

s5 = {}

print(type(s5))  # dict

特点：

1. 集合可以去掉重复数据；

2. 集合数据是无序的，故不支持下标

集合常见操作方法

增加数据

---

• add()

s1 = {10, 20}

s1.add(100)

s1.add(10)

print(s1)  # {100, 10, 20}

因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何操作。

• update(), 追加的数据是序列。

s1 = {10, 20}

s1.update(100) # 报错

s1.update([100, 200])

s1.update(‘abc’)

print(s1)

删除数据

---

• remove()，删除集合中的指定数据，如果数据不存在则报错。

s1 = {10, 20}

​

s1.remove(10)

print(s1)

​

s1.remove(10)  # 报错

print(s1)

• discard()，删除集合中的指定数据，如果数据不存在也不会报错。

s1 = {10, 20}

​

s1.discard(10)

print(s1)

​

s1.discard(10)

print(s1)

• pop()，随机删除集合中的某个数据，并返回这个数据。

s1 = {10, 20, 30, 40, 50}

​

del_num = s1.pop()

print(del_num)

print(s1)

查找数据

---

• in：判断数据在集合序列

• not in：判断数据不在集合序列

s1 = {10, 20, 30, 40, 50}

​

print(10 in s1)

print(10 not in s1)

总结

• 创建集合

• 有数据集合

s1 = {数据1, 数据2, …}

• 无数据集合

s1 = set()

• 常见操作

• 增加数据

• add()

• update()

• 删除数据

• remove()

• discard()

公共操作

---

运算符

| 运算符 | 描述 | 支持的容器类型 |

| — | — | — |

| + | 合并 | 字符串、列表、元组 |

| * | 复制 | 字符串、列表、元组 |

| in | 元素是否存在 | 字符串、列表、元组、字典 |

| not in | 元素是否不存在 | 字符串、列表、元组、字典 |

1. 字符串

str1 = ‘aa’

str2 = ‘bb’

str3 = str1 + str2

print(str3)  # aabb

​

​

2. 列表

list1 = [1, 2]

list2 = [10, 20]

list3 = list1 + list2

print(list3)  # [1, 2, 10, 20]

​

3. 元组

t1 = (1, 2)

t2 = (10, 20)

t3 = t1 + t2

print(t3)  # (10, 20, 100, 200)

*

–

1. 字符串

print(‘-’ * 10)  # ----------

​

2. 列表

list1 = [‘hello’]

print(list1 * 4)  # [‘hello’, ‘hello’, ‘hello’, ‘hello’]

​

3. 元组

t1 = (‘world’,)

print(t1 * 4)  # (‘world’, ‘world’, ‘world’, ‘world’)

in或not in

---

1. 字符串

print(‘a’ in ‘abcd’)  # True

print(‘a’ not in ‘abcd’)  # False

​

2. 列表

list1 = [‘a’, ‘b’, ‘c’, ‘d’]

print(‘a’ in list1)  # True

print(‘a’ not in list1)  # False

​

3. 元组

t1 = (‘a’, ‘b’, ‘c’, ‘d’)

print(‘aa’ in t1)  # False

print(‘aa’ not in t1)  # True

公共方法

| 函数 | 描述 |

| — | — |

| len() | 计算容器中元素个数 |

| del 或 del() | 删除 |

| max() | 返回容器中元素最大值 |

| min() | 返回容器中元素最小值 |

| range(start, end, step) | 生成从start到end的数字，步长为 step，供for循环使用 |

| enumerate() | 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。 |

len()

---

1. 字符串

str1 = ‘abcdefg’

print(len(str1))  # 7

​

2. 列表

list1 = [10, 20, 30, 40]

print(len(list1))  # 4

​

3. 元组

t1 = (10, 20, 30, 40, 50)

print(len(t1))  # 5

​

4. 集合

s1 = {10, 20, 30}

print(len(s1))  # 3

​

5. 字典

dict1 = {‘name’: ‘Rose’, ‘age’: 18}

print(len(dict1))  # 2

del()

---

1. 字符串

str1 = ‘abcdefg’

del str1

print(str1)

​

2. 列表

list1 = [10, 20, 30, 40]

del(list1[0])

print(list1)  # [20, 30, 40]

max()

---

1. 字符串

str1 = ‘abcdefg’

print(max(str1))  # g

​

2. 列表

list1 = [10, 20, 30, 40]

print(max(list1))  # 40

min()

---

1. 字符串

str1 = ‘abcdefg’

print(min(str1))  # a

​

2. 列表

list1 = [10, 20, 30, 40]

print(min(list1))  # 10

range()

---

1 2 3 4 5 6 7 8 9

for i in range(1, 10, 1):

print(i)

​

1 3 5 7 9

for i in range(1, 10, 2):

print(i)

​

0 1 2 3 4 5 6 7 8 9

for i in range(10):

print(i)

注意：range()生成的序列不包含end数字。

enumerate()

---

• 语法

enumerate(可遍历对象, start=0)

注意：start参数用来设置遍历数据的下标的起始值，默认为0。

• 快速体验

list1 = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’]

​

for i in enumerate(list1):

print(i)

​

for index, char in enumerate(list1, start=1):

print(f’下标是{index}, 对应的字符是{char}')

容器类型转换

tuple()

---

作用：将某个序列转换成元组

list1 = [10, 20, 30, 40, 50, 20]

s1 = {100, 200, 300, 400, 500}

​

print(tuple(list1))

print(tuple(s1))

list()

---

作用：将某个序列转换成列表

t1 = (‘a’, ‘b’, ‘c’, ‘d’, ‘e’)

s1 = {100, 200, 300, 400, 500}

​

print(list(t1))

print(list(s1))

set()

---

作用：将某个序列转换成集合

list1 = [10, 20, 30, 40, 50, 20]

t1 = (‘a’, ‘b’, ‘c’, ‘d’, ‘e’)

​

print(set(list1))

print(set(t1))

注意：

1. 集合可以快速完成列表去重

2. 集合不支持下标

总结

• 运算符

• in / not in

• 公共方法

• len()

• del()

• range()

• enumerate()

• 数据类型转换

• tuple()

• list()

• set()

推导式

---

作用：用一个表达式创建一个有规律的列表或控制一个有规律列表。

列表推导式又叫列表生成式。

快速体验

---

需求：创建一个0-10的列表。

• while循环实现

1. 准备一个空列表

list1 = []

​

2. 书写循环，依次追加数字到空列表list1中

i = 0

while i < 10:

list1.append(i)

i += 1

​

print(list1)

• for循环实现

list1 = []

for i in range(10):

list1.append(i)

​

print(list1)

• 列表推导式实现

list1 = [i for i in range(10)]

print(list1)

带if的列表推导式

需求：创建0-10的偶数列表

• 方法一：range()步长实现

list1 = [i for i in range(0, 10, 2)]

print(list1)

• 方法二：if实现

list1 = [i for i in range(10) if i % 2 == 0]

print(list1)

多个for循环实现列表推导式

---

需求：创建列表如下：

[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

• 代码如下：

list1 = [(i, j) for i in range(1, 3) for j in range(3)]

print(list1)

字典推导式

思考：如果有如下两个列表：

list1 = [‘name’, ‘age’, ‘gender’]

list2 = [‘Tom’, 20, ‘man’]

如何快速合并为一个字典？

答：字典推导式

字典推导式作用：快速合并列表为字典或提取字典中目标数据。

快速体验

1. 创建一个字典：字典key是1-5数字，value是这个数字的2次方。

dict1 = {i: i**2 for i in range(1, 5)}

print(dict1)  # {1: 1, 2: 4, 3: 9, 4: 16}

1. 将两个列表合并为一个字典

list1 = [‘name’, ‘age’, ‘gender’]

list2 = [‘Tom’, 20, ‘man’]

​

dict1 = {list1[i]: list2[i] for i in range(len(list1))}

print(dict1)

1. 提取字典中目标数据

counts = {‘MBP’: 268, ‘HP’: 125, ‘DELL’: 201, ‘Lenovo’: 199, ‘acer’: 99}

​

需求：提取上述电脑数量大于等于200的字典数据

count1 = {key: value for key, value in counts.items() if value >= 200}

print(count1)  # {‘MBP’: 268, ‘DELL’: 201}

集合推导式

需求：创建一个集合，数据为下方列表的2次方。

list1 = [1, 1, 2]

代码如下：

list1 = [1, 1, 2]

set1 = {i ** 2 for i in list1}

print(set1)  # {1, 4}

注意：集合有数据去重功能。

总结

• 推导式的作用：简化代码

• 推导式写法

列表推导式

[xx for xx in range()]

​

字典推导式

{xx1: xx2 for … in …}

​

集合推导式

{xx for xx in …}

函数一

---

函数的作用

需求：用户到ATM机取钱：

1. 输入密码后显示"选择功能"界面

2. 查询余额后显示"选择功能"界面

3. 取2000钱后显示"选择功能"界面

特点：显示“选择功能”界面需要重复输出给用户，怎么实现？

函数就是将一段具有独立功能的代码块 整合到一个整体并命名，在需要的位置调用这个名称即可完成对应的需求。

函数在开发过程中，可以更高效的实现代码重用。

函数的使用步骤

定义函数

---

def 函数名(参数):

代码1

代码2

…

调用函数

---

函数名(参数)

注意：

1. 不同的需求，参数可有可无。

2. 在Python中，函数必须先定义后使用。

快速体验

---

需求：复现ATM取钱功能。

1. 搭建整体框架(复现需求)

print(‘密码正确登录成功’)

​

显示"选择功能"界面

​

print(‘查询余额完毕’)

​

显示"选择功能"界面

​

print(‘取了2000元钱’)

​

显示"选择功能"界面

1. 确定“选择功能”界面内容

print(‘查询余额’)

print(‘存款’)

print(‘取款’)

1. 封装"选择功能"

注意：一定是先定义函数，后调用函数。

封装ATM机功能选项 – 定义函数

def select_func():

print(‘-----请选择功能-----’)

print(‘查询余额’)

print(‘存款’)

print(‘取款’)

print(‘-----请选择功能-----’)

1. 调用函数

在需要显示“选择功能”函数的位置调用函数。

print(‘密码正确登录成功’)

显示"选择功能"界面 – 调用函数

select_func()

​

print(‘查询余额完毕’)

显示"选择功能"界面 – 调用函数

select_func()

​

print(‘取了2000元钱’)

显示"选择功能"界面 – 调用函数

select_func()

函数的参数作用

思考：完成需求如下：一个函数完成两个数1和2的加法运算，如何书写程序？

定义函数

def add_num1():

result = 1 + 2

print(result)

​

​

调用函数

add_num1()

思考：上述add_num1函数只能完成数字1和2的加法运算，如果想要这个函数变得更灵活，可以计算任何用户指定的两个数字的和，如何书写程序？

分析：用户要在调用函数的时候指定具体数字，那么在定义函数的时候就需要接收用户指定的数字。函数调用时候指定的数字和定义函数时候接收的数字即是函数的参数。

定义函数时同时定义了接收用户数据的参数a和b，a和b是形参

def add_num2(a, b):

result = a + b

print(result)

​

​

调用函数时传入了真实的数据10 和 20，真实数据为实参

add_num2(10, 20)

函数的返回值作用

例如：我们去超市购物，比如买烟，给钱之后，是不是售货员会返回给我们烟这个商品，在函数中，如果需要返回结果给用户需要使用函数返回值。

def buy():

return ‘烟’

​

使用变量保存函数返回值

goods = buy()

print(goods)

应用

–

需求：制作一个计算器，计算任意两数字之和，并保存结果。

def sum_num(a, b):

return a + b

​

​

用result变量保存函数返回值

result = sum_num(1, 2)

print(result)

函数的说明文档

思考：定义一个函数后，程序员如何书写程序能够快速提示这个函数的作用？

答：注释

思考：如果代码多，我们是不是需要在很多代码中找到这个函数定义的位置才能看到注释？如果想更方便的查看函数的作用怎么办？

答：函数的说明文档

函数的说明文档也叫函数的文档说明。

语法

–

• 定义函数的说明文档

def 函数名(参数):

“”" 说明文档的位置 “”"

代码

…

• 查看函数的说明文档

help(函数名)

快速体验

---

def sum_num(a, b):

“”" 求和函数 “”"

return a + b

​

​

help(sum_num)

函数嵌套调用

所谓函数嵌套调用指的是一个函数里面又调用了另外一个函数。

• 示例

def testB():

print(‘---- testB start----’)

print(‘这里是testB函数执行的代码…(省略)…’)

print(‘---- testB end----’)

​

def testA():

print(‘---- testA start----’)

testB()

print(‘---- testA end----’)

​

testA()

• 如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置。

函数应用

函数计算

---

1. 求三个数之和

def sum_num(a, b, c):

return a + b + c

​

​

result = sum_num(1, 2, 3)

print(result)  # 6

1. 求三个数平均值

def average_num(a, b, c):

sumResult = sum_num(a, b, c)

return sumResult / 3

​

result = average_num(1, 2, 3)

print(result)  # 2.0

总结

• 函数的作用：封装代码，高效的代码重用

• 函数使用步骤

• 定义函数

def 函数名():

代码1

代码2

…

• 调用函数

函数名()

• 函数的参数：函数调用的时候可以传入真实数据，增大函数的使用的灵活性

• 形参：函数定义时书写的参数(非真实数据)

• 实参：函数调用时书写的参数(真实数据)

• 函数的返回值

• 作用：函数调用后，返回需要的计算结果

• 写法

return 表达式

• 函数的说明文档

• 作用：保存函数解释说明的信息

• 写法

def 函数名():

“”" 函数说明文档 “”"

• 函数嵌套调用：一个函数内部嵌套调用另外一个函数

函数二

---

变量作用域

变量作用域指的是变量生效的范围，主要分为两类：局部变量和全局变量。

• 局部变量

所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效。

def testA():

a = 100

​

print(a)

​

​

testA()  # 100

print(a)  # 报错：name ‘a’ is not defined

变量a是定义在testA函数内部的变量，在函数外部访问则立即报错。

局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量。

• 全局变量

所谓全局变量，指的是在函数体内、外都能生效的变量。

思考：如果有一个数据，在函数A和函数B中都要使用，该怎么办？

答：将这个数据存储在一个全局变量里面。

定义全局变量a

a = 100

​

​

def testA():

print(a)  # 访问全局变量a，并打印变量a存储的数据

​

​

def testB():

print(a)  # 访问全局变量a，并打印变量a存储的数据

​

​

testA()  # 100

testB()  # 100

思考：testB函数需求修改变量a的值为200，如何修改程序？

a = 100

​

​

def testA():

print(a)

​

​

def testB():

a = 200

print(a)

​

​

testA()  # 100

testB()  # 200

print(f’全局变量a = {a}')  # 全局变量a = 100

思考：在testB函数内部的a = 200中的变量a是在修改全局变量a吗？

答：不是。观察上述代码发现，15行得到a的数据是100，仍然是定义全局变量a时候的值，而没有返回

testB函数内部的200。综上：testB函数内部的a = 200是定义了一个局部变量。

思考：如何在函数体内部修改全局变量？

a = 100

​

​

def testA():

print(a)

​

​

def testB():

global 关键字声明a是全局变量

global a

a = 200

print(a)

​

​

testA()  # 100

testB()  # 200

print(f’全局变量a = {a}')  # 全局变量a = 200

多函数程序执行流程

一般在实际开发过程中，一个程序往往由多个函数（后面知识中会讲解类）组成，并且多个函数共享某些数据，如下所示：

• 共用全局变量

1. 定义全局变量

glo_num = 0

​

​

def test1():

global glo_num

修改全局变量

glo_num = 100

​

​

def test2():

调用test1函数中修改后的全局变量

print(glo_num)

​

2. 调用test1函数，执行函数内部代码：声明和修改全局变量

test1()

3. 调用test2函数，执行函数内部代码：打印

test2()  # 100

• 返回值作为参数传递

def test1():

return 50

​

​

def test2(num):

print(num)

​

​

1. 保存函数test1的返回值

result = test1()

​

​

2.将函数返回值所在变量作为参数传递到test2函数

test2(result)  # 50

函数的返回值

思考：如果一个函数如些两个return (如下所示)，程序如何执行？

def return_num():

return 1

return 2

​

​

result = return_num()

print(result)  # 1

答：只执行了第一个return，原因是因为return可以退出当前函数，导致return下方的代码不执行。

思考：如果一个函数要有多个返回值，该如何书写代码？

def return_num():

return 1, 2

​

​

result = return_num()

print(result)  # (1, 2)

注意：

1. return a, b写法，返回多个数据的时候，默认是元组类型。

2. return后面可以连接列表、元组或字典，以返回多个值。

函数的参数

位置参数

---

位置参数：调用函数时根据函数定义的参数位置来传递参数。

def user_info(name, age, gender):

print(f’您的名字是{name}, 年龄是{age}, 性别是{gender}')

​

​

user_info(‘TOM’, 20, ‘男’)

注意：传递和定义参数的顺序及个数必须一致。

关键字参数

---

函数调用，通过“键=值”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。

def user_info(name, age, gender):

print(f’您的名字是{name}, 年龄是{age}, 性别是{gender}')

​

​

user_info(‘Rose’, age=20, gender=‘女’)

user_info(‘小明’, gender=‘男’, age=16)

注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。

缺省参数

---

缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）。

def user_info(name, age, gender=‘男’):

print(f’您的名字是{name}, 年龄是{age}, 性别是{gender}')

​

​

user_info(‘TOM’, 20)

user_info(‘Rose’, 18, ‘女’)

注意：函数调用时，如果为缺省参数传值则修改默认参数值；否则使用这个默认值。

不定长参数

---

不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。此时，可用包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。

• 包裹位置传递

def user_info(*args):

print(args)

​

​

(‘TOM’,)

user_info(‘TOM’)

(‘TOM’, 18)

user_info(‘TOM’, 18)

注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是包裹位置传递。

• 包裹关键字传递

def user_info(**kwargs):

print(kwargs)

​

​

{‘name’: ‘TOM’, ‘age’: 18, ‘id’: 110}

user_info(name=‘TOM’, age=18, id=110)

综上：无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程。

拆包和交换变量值

拆包

–

• 拆包：元组

def return_num():

return 100, 200

​

​

num1, num2 = return_num()

print(num1)  # 100

print(num2)  # 200

• 拆包：字典

dict1 = {‘name’: ‘TOM’, ‘age’: 18}

a, b = dict1

​

对字典进行拆包，取出来的是字典的key

print(a)  # name

print(b)  # age

​

print(dict1[a])  # TOM

print(dict1[b])  # 18

交换变量值

---

需求：有变量a = 10和b = 20，交换两个变量的值。

• 方法一

借助第三变量存储数据。

1. 定义中间变量

c = 0

​

2. 将a的数据存储到c

c = a

​

3. 将b的数据20赋值到a，此时a = 20

a = b

​

4. 将之前c的数据10赋值到b，此时b = 10

b = c

​

print(a)  # 20

print(b)  # 10

• 方法二

a, b = 1, 2

a, b = b, a

print(a)  # 2

print(b)  # 1

引用

了解引用

---

在python中，值是靠引用来传递来的。

我们可以用id()来判断两个变量是否为同一个值的引用。 我们可以将id值理解为那块内存的地址标识。

1. int类型

a = 1

b = a

​

print(b)  # 1

​

print(id(a))  # 140708464157520

print(id(b))  # 140708464157520

​

a = 2

print(b)  # 1,说明int类型为不可变类型

​

print(id(a))  # 140708464157552，此时得到是的数据2的内存地址

print(id(b))  # 140708464157520

​

​

2. 列表

aa = [10, 20]

bb = aa

​

print(id(aa))  # 2325297783432

print(id(bb))  # 2325297783432

​

​

aa.append(30)

print(bb)  # [10, 20, 30], 列表为可变类型

​

print(id(aa))  # 2325297783432

print(id(bb))  # 2325297783432

引用当做实参

---

代码如下：

def test1(a):

print(a)

print(id(a))

​

a += a

​

print(a)

print(id(a))

​

​

int：计算前后id值不同

b = 100

test1(b)

​

列表：计算前后id值相同

c = [11, 22]

test1©

可变和不可变类型

所谓可变类型与不可变类型是指：数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变.

• 可变类型

• 列表

• 字典

• 集合

• 不可变类型

• 整型

• 浮点型

• 字符串

• 元组

总结

• 变量作用域

• 全局：函数体内外都能生效

• 局部：当前函数体内部生效

• 函数多返回值写法

return 表达式1, 表达式2…

• 函数的参数

• 位置参数

• 形参和实参的个数和书写顺序必须一致

• 关键字参数

• 写法： key=value

• 特点：形参和实参的书写顺序可以不一致；关键字参数必须书写在位置参数的后面

• 缺省参数

• 缺省参数就是默认参数

• 写法：key=vlaue

• 不定长位置参数

• 收集所有位置参数，返回一个元组

• 不定长关键字参数

• 收集所有关键字参数，返回一个字典

• 引用：Python中，数据的传递都是通过引用

函数三

---

应用：学员管理系统

系统简介

---

需求：进入系统显示系统功能界面，功能如下：

• 1、添加学员

• 2、删除学员

• 3、修改学员信息

• 4、查询学员信息

• 5、显示所有学员信息

• 6、退出系统

系统共6个功能，用户根据自己需求选取。

步骤分析

---

1. 显示功能界面

2. 用户输入功能序号

3. 根据用户输入的功能序号，执行不同的功能(函数)

3.1 定义函数

3.2 调用函数

需求实现

显示功能界面

定义函数print_info，负责显示系统功能。

def print_info():

print(‘-’ * 20)

print(‘欢迎登录学员管理系统’)

print(‘1: 添加学员’)

print(‘2: 删除学员’)

print(‘3: 修改学员信息’)

print(‘4: 查询学员信息’)

print(‘5: 显示所有学员信息’)

print(‘6: 退出系统’)

print(‘-’ * 20)

print_info()

用户输入序号，选择功能

user_num = input(‘请选择您需要的功能序号：’)

根据用户选择，执行不同的功能

if user_num == ‘1’:

print(‘添加学员’)

elif user_num == ‘2’:

print(‘删除学员’)

elif user_num == ‘3’:

print(‘修改学员信息’)

elif user_num == ‘4’:

print(‘查询学员信息’)

elif user_num == ‘5’:

print(‘显示所有学员信息’)

elif user_num == ‘6’:

print(‘退出系统’)

工作中，需要根据实际需求调优代码。

1. 用户选择系统功能的代码需要循环使用，直到用户主动退出系统。

2. 如果用户输入1-6以外的数字，需要提示用户。

while True:

1. 显示功能界面

print_info()

2. 用户选择功能

user_num = input(‘请选择您需要的功能序号：’)

​

3. 根据用户选择，执行不同的功能

if user_num == ‘1’:

print(‘添加学员’)

elif user_num == ‘2’:

print(‘删除学员’)

elif user_num == ‘3’:

print(‘修改学员信息’)

elif user_num == ‘4’:

print(‘查询学员信息’)

elif user_num == ‘5’:

print(‘显示所有学员信息’)

elif user_num == ‘6’:

print(‘退出系统’)

else:

print(‘输入错误，请重新输入!!!’)

定义不同功能的函数

所有功能函数都是操作学员信息，所有存储所有学员信息应该是一个全局变量，数据类型为列表。

info = []

1.3.4.1 添加学员

• 需求分析

1. 接收用户输入学员信息，并保存

2. 判断是否添加学员信息

2.1 如果学员姓名已经存在，则报错提示

2.2 如果学员姓名不存在，则准备空字典，将用户输入的数据追加到字典，再列表追加字典数据

3. 对应的if条件成立的位置调用该函数

• 代码实现

def add_info():

“”" 添加学员 “”"

接收用户输入学员信息

new_id = input(‘请输入学号：’)

new_name = input(‘请输入姓名：’)

new_tel = input(‘请输入手机号：’)

​

声明info是全局变量

global info

​

检测用户输入的姓名是否存在，存在则报错提示

for i in info:

if new_name == i[‘name’]:

print(‘该用户已经存在！’)

return

​

如果用户输入的姓名不存在，则添加该学员信息

info_dict = {}

将用户输入的数据追加到字典

info_dict[‘id’] = new_id

info_dict[‘name’] = new_name

info_dict[‘tel’] = new_tel

将这个学员的字典数据追加到列表

info.append(info_dict)

print(info)

删除学员

• 需求分析

按用户输入的学员姓名进行删除

1. 用户输入目标学员姓名

2. 检查这个学员是否存在

2.1 如果存在，则列表删除这个数据

2.2 如果不存在，则提示“该用户不存在”

3. 对应的if条件成立的位置调用该函数

• 代码实现

删除学员

def del_info():

“”“删除学员”“”

1. 用户输入要删除的学员的姓名

del_name = input(‘请输入要删除的学员的姓名：’)

​

global info

2. 判断学员是否存在:如果输入的姓名存在则删除，否则报错提示

for i in info:

if del_name == i[‘name’]:

info.remove(i)

break

else:

print(‘该学员不存在’)

​

print(info)

修改学员信息

• 需求分析

1. 用户输入目标学员姓名

2. 检查这个学员是否存在

2.1 如果存在，则修改这位学员的信息，例如手机号

2.2 如果不存在，则报错

3. 对应的if条件成立的位置调用该函数

• 代码实现

修改函数

def modify_info():

“”“修改函数”“”

1. 用户输入要修改的学员的姓名

modify_name = input(‘请输入要修改的学员的姓名：’)

​

global info

2. 判断学员是否存在：如果输入的姓名存在则修改手机号，否则报错提示

for i in info:

if modify_name == i [‘name’]:

i[‘tel’] = input(‘请输入新的手机号：’)

break

else:

print(‘该学员不存在’)

print(info)

查询学员信息

• 需求分析

1. 用户输入目标学员姓名

2. 检查学员是否存在

2.1 如果存在，则显示这个学员的信息

2.2 如果不存在，则报错提示

3. 对应的if条件成立的位置调用该函数

• 代码实现

查询学员

def search_info():

“”“查询学员”“”

1. 输入要查找的学员姓名：

search_name = input(‘请输入要查找的学员姓名：’)

​

global info

2. 判断学员是否存在：如果输入的姓名存在则显示这位学员信息，否则报错提示

for i in info:

if search_name == i[‘name’]:

print(‘查找到的学员信息如下：----------’)

print(f"该学员的学号是{i[‘id’]}, 姓名是{i[‘name’]}, 手机号是{i[‘tel’]}")

break

else:

print(‘该学员不存在’)

显示所有学员信息

• 需求分析

打印所有学员信息

• 代码实现

显示所有学员信息

def print_all():

“”" 显示所有学员信息 “”"

print(‘学号\t姓名\t手机号’)

for i in info:

print(f’{i[“id”]}\t{i[“name”]}\t{i[“tel”]}')

1.3.4.6 退出系统

在用户输入功能序号6的时候要退出系统，代码如下：

…

elif user_num == ‘6’:

exit_flag = input(‘确定要退出吗？yes or no’)

if exit_flag == ‘yes’:

break

递归

递归是一种编程思想，应用场景：

1. 在我们日常开发中，如果要遍历一个文件夹下面所有的文件，通常会使用递归来实现；

2. 在后续的算法课程中，很多算法都离不开递归，例如：快速排序。

递归的特点

• 函数内部自己调用自己

• 必须有出口

应用：3以内数字累加和

---

• 代码

3 + 2 + 1

def sum_numbers(num):

1.如果是1，直接返回1 – 出口

if num == 1:

return 1

2.如果不是1，重复执行累加并返回结果

return num + sum_numbers(num-1)

​

​

sum_result = sum_numbers(3)

输出结果为6

print(sum_result)

lambda 表达式

如果一个函数有一个返回值，并且只有一句代码，可以使用 lambda简化。

lambda语法

lambda 参数列表 ： 表达式

注意

• lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用。

• lambda表达式能接收任何数量的参数但只能返回一个表达式的值。

快速入门

函数

def fn1():

return 200

​

​

print(fn1)

print(fn1())

​

​

lambda表达式

fn2 = lambda: 100

print(fn2)

print(fn2())

注意：直接打印lambda表达式，输出的是此lambda的内存地址

示例：计算a + b

---

函数实现

def add(a, b):

return a + b

​

​

result = add(1, 2)

print(result)

思考：需求简单，是否代码多？

lambda实现

fn1 = lambda a, b: a + b

print(fn1(1, 2))

lambda的参数形式

---

无参数

fn1 = lambda: 100

print(fn1())

一个参数

fn1 = lambda a: a

print(fn1(‘hello world’))

默认参数

fn1 = lambda a, b, c=100: a + b + c

print(fn1(10, 20))

可变参数：*args

fn1 = lambda *args: args

print(fn1(10, 20, 30))

注意：这里的可变参数传入到lambda之后，返回值为元组。

可变参数：**kwargs

fn1 = lambda **kwargs: kwargs

print(fn1(name=‘python’, age=20))

lambda的应用

---

带判断的lambda

fn1 = lambda a, b: a if a > b else b

print(fn1(1000, 500))

列表数据按字典key的值排序

students = [

{‘name’: ‘TOM’, ‘age’: 20},

{‘name’: ‘ROSE’, ‘age’: 19},

{‘name’: ‘Jack’, ‘age’: 22}

]

​

按name值升序排列

students.sort(key=lambda x: x[‘name’])

print(students)

​

按name值降序排列

students.sort(key=lambda x: x[‘name’], reverse=True)

print(students)

​

按age值升序排列

students.sort(key=lambda x: x[‘age’])

print(students)

高阶函数

==把函数作为参数传入==，这样的函数称为高阶函数，高阶函数是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式。

体验高阶函数

---

在Python中，abs()函数可以完成对数字求绝对值计算。

abs(-10)  # 10

round()函数可以完成对数字的四舍五入计算。

round(1.2)  # 1

round(1.9)  # 2

需求：任意两个数字，按照指定要求整理数字后再进行求和计算。

• 方法1

def add_num(a, b):

return abs(a) + abs(b)

​

​

result = add_num(-1, 2)

print(result)  # 3

• 方法2

def sum_num(a, b, f):

return f(a) + f(b)

​

​

result = sum_num(-1, 2, abs)

print(result)  # 3

注意：两种方法对比之后，发现，方法2的代码会更加简洁，函数灵活性更高。

函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快。

内置高阶函数

---

map()

---

map(func, lst)，将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的列表(Python2)/迭代器(Python3)返回。

需求：计算list1序列中各个数字的2次方。

list1 = [1, 2, 3, 4, 5]

​

​

def func(x):

return x ** 2

​

​

result = map(func, list1)

​

print(result)  # <map object at 0x0000013769653198>

print(list(result))  # [1, 4, 9, 16, 25]

reduce()

reduce(func，lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累积计算。

注意：reduce()传入的参数func必须接收2个参数。

需求：计算list1序列中各个数字的累加和。

import functools

​

list1 = [1, 2, 3, 4, 5]

​

​

def func(a, b):

return a + b

​

​

result = functools.reduce(func, list1)

​

print(result)  # 15

filter()

filter(func, lst)函数用于过滤序列, 过滤掉不符合条件的元素, 返回一个 filter 对象。如果要转换为列表, 可以使用 list() 来转换。

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

​

​

def func(x):

return x % 2 == 0

​

​

result = filter(func, list1)

​

print(result)  # <filter object at 0x0000017AF9DC3198>

print(list(result))  # [2, 4, 6, 8, 10]

总结

• 递归

• 函数内部自己调用自己

• 必须有出口

• lambda

• 语法

lambda 参数列表: 表达式

• lambda的参数形式

• 无参数

lambda: 表达式

• 一个参数

lambda 参数: 表达式

• 默认参数

lambda key=value: 表达式

• 不定长位置参数

lambda *args: 表达式

• 不定长关键字参数

lambda **kwargs: 表达式

• 高阶函数

• 作用：把函数作为参数传入，化简代码

• 内置高阶函数

• map()

• reduce()

• filter()

文件操作

---

文件操作的作用

思考：什么是文件？

思考：文件操作包含什么？

答：打开、关闭、读、写、复制…

思考：文件操作的的作用是什么？

答：读取内容、写入内容、备份内容…

总结：文件操作的作用就是把一些内容(数据)存储存放起来，可以让程序下一次执行的时候直接使用，而不必重新制作一份，省时省力。

文件的基本操作

文件操作步骤

---

1. 打开文件

2. 读写等操作

3. 关闭文件

注意：可以只打开和关闭文件，不进行任何读写操作。

打开

在python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件，语法如下：

open(name, mode)

name：是要打开的目标文件名的字符串(可以包含文件所在的具体路径)。

mode：设置打开文件的模式(访问模式)：只读、写入、追加等。

打开文件模式

| 模式 | 描述 |

| — | — |

| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |

| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。 |

| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |

| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 |

| w | 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |

| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |

| w+ | 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |

| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |

| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |

| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |

| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |

| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |

快速体验

f = open(‘test.txt’, ‘w’)

注意：此时的f是open函数的文件对象。

文件对象方法

写

• 语法

对象对象.write(‘内容’)

• 体验

1. 打开文件

f = open(‘test.txt’, ‘w’)

​

2.文件写入

f.write(‘hello world’)

​

3. 关闭文件

f.close()

注意：

1. w和a模式：如果文件不存在则创建该文件；如果文件存在，w模式先清空再写入，a模式直接末尾追加。

2. r模式：如果文件不存在则报错。

读

• read()

文件对象.read(num)

num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据。

• readlines()

readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。

f = open(‘test.txt’)

content = f.readlines()

​

[‘hello world\n’, ‘abcdefg\n’, ‘aaa\n’, ‘bbb\n’, ‘ccc’]

print(content)

​

关闭文件

f.close()

• readline()

readline()一次读取一行内容。

f = open(‘test.txt’)

​

content = f.readline()

print(f’第一行：{content}')

​

content = f.readline()

print(f’第二行：{content}')

​

关闭文件

f.close()

seek()

作用：用来移动文件指针。

语法如下：

文件对象.seek(偏移量, 起始位置)

起始位置：

• 0：文件开头

• 1：当前位置

• 2：文件结尾

关闭

文件对象.close()

文件备份

需求：用户输入当前目录下任意文件名，程序完成对该文件的备份功能(备份文件名为xx[备份]后缀，例如：test[备份].txt)。

步骤

–

1. 接收用户输入的文件名

2. 规划备份文件名

3. 备份文件写入数据

代码实现

---

1. 接收用户输入目标文件名

old_name = input(‘请输入您要备份的文件名：’)

1. 规划备份文件名

2.1 提取目标文件后缀

2.2 组织备份的文件名，xx[备份]后缀

2.1 提取文件后缀点的下标

index = old_name.rfind(‘.’)

​

print(index) # 后缀中.的下标

​

print(old_name[:index]) # 源文件名（无后缀）

​

2.2 组织新文件名 旧文件名 + [备份] + 后缀

new_name = old_name[:index] + ‘[备份]’ + old_name[index:]

​

打印新文件名（带后缀）

print(new_name)

1. 备份文件写入数据

3.1 打开源文件 和 备份文件

3.2 将源文件数据写入备份文件

3.3 关闭文件

3.1 打开文件

old_f = open(old_name, ‘rb’)

new_f = open(new_name, ‘wb’)

​

3.2 将源文件数据写入备份文件

while True:

con = old_f.read(1024)

if len(con) == 0:

break

new_f.write(con)

​

3.3 关闭文件

old_f.close()

new_f.close()

思考

–

如果用户输入.txt，这是一个无效文件，程序如何更改才能限制只有有效的文件名才能备份？

答：添加条件判断即可。

old_name = input(‘请输入您要备份的文件名：’)

​

index = old_name.rfind(‘.’)

​

​

if index > 0:

postfix = old_name[index:]

​

new_name = old_name[:index] + ‘[备份]’ + postfix

​

old_f = open(old_name, ‘rb’)

new_f = open(new_name, ‘wb’)

​

while True:

con = old_f.read(1024)

if len(con) == 0:

break

new_f.write(con)

​

old_f.close()

new_f.close()

文件和文件夹的操作

在Python中文件和文件夹的操作要借助os模块里面的相关功能，具体步骤如下：

1. 导入os模块

import os

1. 使用os模块相关功能

os.函数名()

文件重命名

---

os.rename(目标文件名, 新文件名)

删除文件

---

os.remove(目标文件名)

创建文件夹

---

os.mkdir(文件夹名字)

删除文件夹

---

os.rmdir(文件夹名字)

获取当前目录

---

os.getcwd()

改变默认目录

---

os.chdir(目录)

获取目录列表

---

os.listdir(目录)

应用案例

需求：批量修改文件名，既可添加指定字符串，又能删除指定字符串。

• 步骤

1. 设置添加删除字符串的的标识

2. 获取指定目录的所有文件

3. 将原有文件名添加/删除指定字符串，构造新名字

4. os.rename()重命名

• 代码

import os

​

设置重命名标识：如果为1则添加指定字符，flag取值为2则删除指定字符

flag = 1

​

获取指定目录

dir_name = ‘./’

​

获取指定目录的文件列表

file_list = os.listdir(dir_name)

print(file_list)

​

​

遍历文件列表内的文件

for name in file_list:

​

添加指定字符

if flag == 1:

new_name = ‘Python-’ + name

删除指定字符

elif flag == 2:

num = len(‘Python-’)

new_name = name[num:]

​

打印新文件名，测试程序正确性

print(new_name)

重命名

os.rename(dir_name+name, dir_name+new_name)

总结

• 文件操作步骤

• 打开

文件对象 = open(目标文件, 访问模式)

• 操作

• 读

文件对象.read()

文件对象.readlines()

文件对象.readline()

• 写

文件对象.write()

• seek()

• 关闭

文件对象.close()

• 主访问模式

• w：写，文件不存在则新建该文件

• r：读，文件不存在则报错

• a：追加

• 文件和文件夹操作

• 重命名：os.rename()

• 获取当前目录：os.getcwd()

• 获取目录列表：os.listdir()

面向对象基础

---

理解面向对象

面向对象是一种抽象化的编程思想，很多编程语言中都有的一种思想。

总结：面向对象就是将编程当成是一个事物，对外界来说，事物是直接使用的，不用去管他内部的情况。而编程就是设置事物能够做什么事。

类和对象

在面向对象编程过程中，有两个重要组成部分：类 和 对象

类和对象的关系：用类去创建一个对象。

理解类和对象

---

类

类是对一系列具有相同特征和行为的事物的统称，是一个抽象的概念，不是真实存在的事物。

• 特征即是属性

• 行为即是方法

对象

对象是类创建出来的真实存在的事物

注意：开发中，先有类，再有对象。

面向对象实现方法

---

定义类

Python2中类分为：经典类 和 新式类

• 语法

class 类名():

代码

…

注意：类名要满足标识符命名规则，同时遵循大驼峰命名习惯。

• 体验

class Washer():

def wash(self):

print(‘我会洗衣服’)

• 拓展：经典类

不由任意内置类型派生出的类，称之为经典类

class 类名:

代码

…

创建对象

对象又名实例。

• 语法

对象名 = 类名()

• 体验

创建对象

haier1 = Washer()

​

<main.Washer object at 0x0000018B7B224240>

print(haier1)

​

haier对象调用实例方法

haier1.wash()

注意：创建对象的过程也叫实例化对象。

self

self指的是调用该函数的对象。

1. 定义类

class Washer():

def wash(self):

print(‘我会洗衣服’)

<main.Washer object at 0x0000024BA2B34240>

print(self)

​

​

2. 创建对象

haier1 = Washer()

<main.Washer object at 0x0000018B7B224240>

print(haier1)

haier1对象调用实例方法

haier1.wash()

​

​

haier2 = Washer()

<main.Washer object at 0x0000022005857EF0>

print(haier2)

注意：打印对象和self得到的结果是一致的，都是当前对象的内存中存储地址。

添加和获取对象属性

对象属性既可以在类外面添加和获取，也能在类里面添加和获取。

类外面添加对象属性语法

对象名.属性名 = 值

• 体验

haier1.width = 500

haier1.height = 800

类外面获取对象属性

• 语法

对象名.属性名

• 体验

print(f’haier1洗衣机的宽度是{haier1.width}')

print(f’haier1洗衣机的高度是{haier1.height}')

类里面获取对象属性

---

• 语法

self.属性名

• 体验

定义类

class Washer():

def print_info(self):

类里面获取实例属性

print(f’haier1洗衣机的宽度是{self.width}')

print(f’haier1洗衣机的高度是{self.height}')

​

创建对象

haier1 = Washer()

​

添加实例属性

haier1.width = 500

haier1.height = 800

​

haier1.print_info()

魔法方法

在Python中，__xx__()的函数叫做魔法方法，指的是具有特殊功能的函数。

__init__()

---

体验__init__()

==__init__()方法的作用：初始化对象。==

class Washer():

定义初始化功能的函数

def init(self):

添加实例属性

self.width = 500

self.height = 800

​

​

def print_info(self):

类里面调用实例属性

print(f’洗衣机的宽度是{self.width}, 高度是{self.height}')

​

​

haier1 = Washer()

haier1.print_info()

注意：

• __init__()方法，在创建一个对象时默认被调用，不需要手动调用

• __init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去。

带参数的__init__()

思考：一个类可以创建多个对象，如何对不同的对象设置不同的初始化属性呢？

答：传参数。

class Washer():

def init(self, width, height):

self.width = width

self.height = height

​

def print_info(self):

print(f’洗衣机的宽度是{self.width}')

print(f’洗衣机的高度是{self.height}')

​

​

haier1 = Washer(10, 20)

haier1.print_info()

​

​

haier2 = Washer(30, 40)

haier2.print_info()

__str__()

---

当使用print输出对象的时候，默认打印对象的内存地址。如果类定义了__str__方法，那么就会打印从在这个方法中 return 的数据。

class Washer():

def init(self, width, height):

self.width = width

self.height = height

​

def str(self):

return ‘这是海尔洗衣机的说明书’

​

​

haier1 = Washer(10, 20)

这是海尔洗衣机的说明书

print(haier1)

__del__()

---

当删除对象时，python解释器也会默认调用__del__()方法。

class Washer():

def init(self, width, height):

self.width = width

self.height = height

​

def del(self):

print(f’{self}对象已经被删除’)

​

​

haier1 = Washer(10, 20)

​

<main.Washer object at 0x0000026118223278>对象已经被删除

del haier1

综合应用

烤地瓜

---

需求

需求主线：

1. 被烤的时间和对应的地瓜状态：

0-3分钟：生的

3-5分钟：半生不熟

5-8分钟：熟的

超过8分钟：烤糊了

2. 添加的调料：

用户可以按自己的意愿添加调料

步骤分析

需求涉及一个事物： 地瓜，故案例涉及一个类：地瓜类。

5.1.2.1 定义类

• 地瓜的属性

• 被烤的时间

• 地瓜的状态

• 添加的调料

• 地瓜的方法

• 被烤

• 用户根据意愿设定每次烤地瓜的时间

• 判断地瓜被烤的总时间是在哪个区间，修改地瓜状态

• 添加调料

• 用户根据意愿设定添加的调料

• 将用户添加的调料存储

• 显示对象信息

5.1.2.2 创建对象，调用相关实例方法

代码实现

5.1.3.1 定义类

• 地瓜属性

• 定义地瓜初始化属性，后期根据程序推进更新实例属性

class SweetPotato():

def init(self):

被烤的时间

self.cook_time = 0

地瓜的状态

self.cook_static = ‘生的’

调料列表

self.condiments = []

5.1.3.2 定义烤地瓜方法

class SweetPotato():

…

def cook(self, time):

“”“烤地瓜的方法”“”

self.cook_time += time

if 0 <= self.cook_time < 3:

self.cook_static = ‘生的’

elif 3 <= self.cook_time < 5:

self.cook_static = ‘半生不熟’

elif 5 <= self.cook_time < 8:

self.cook_static = ‘熟了’

elif self.cook_time >= 8:

self.cook_static = ‘烤糊了’

5.1.3.3 书写str魔法方法，用于输出对象状态

class SweetPotato():

…

​

def str(self):

return f’这个地瓜烤了{self.cook_time}分钟, 状态是{self.cook_static}’

​

5.1.3.4 创建对象，测试实例属性和实例方法

digua1 = SweetPotato()

print(digua1)

digua1.cook(2)

print(digua1)

5.1.3.5 定义添加调料方法，并调用该实例方法

class SweetPotato():

…

​

def add_condiments(self, condiment):

“”“添加调料”“”

self.condiments.append(condiment)

def str(self):

return f’这个地瓜烤了{self.cook_time}分钟, 状态是{self.cook_static}, 添加的调料有{self.condiments}’

​

digua1 = SweetPotato()

print(digua1)

​

digua1.cook(2)

digua1.add_condiments(‘酱油’)

print(digua1)

​

digua1.cook(2)

digua1.add_condiments(‘辣椒面儿’)

print(digua1)

​

digua1.cook(2)

print(digua1)

​

digua1.cook(2)

print(digua1)

代码总览

定义类

class SweetPotato():

def init(self):

被烤的时间

self.cook_time = 0

地瓜的状态

self.cook_static = ‘生的’

调料列表

self.condiments = []

​

def cook(self, time):

“”“烤地瓜的方法”“”

self.cook_time += time

if 0 <= self.cook_time < 3:

self.cook_static = ‘生的’

elif 3 <= self.cook_time < 5:

self.cook_static = ‘半生不熟’

elif 5 <= self.cook_time < 8:

self.cook_static = ‘熟了’

elif self.cook_time >= 8:

self.cook_static = ‘烤糊了’

​

def add_condiments(self, condiment):

“”“添加调料”“”

self.condiments.append(condiment)

​

def str(self):

return f’这个地瓜烤了{self.cook_time}分钟, 状态是{self.cook_static}, 添加的调料有{self.condiments}’

​

​

digua1 = SweetPotato()

print(digua1)

​

digua1.cook(2)

digua1.add_condiments(‘酱油’)

print(digua1)

​

digua1.cook(2)

digua1.add_condiments(‘辣椒面儿’)

print(digua1)

​

digua1.cook(2)

print(digua1)

​

digua1.cook(2)

print(digua1)

搬家具

---

需求

将小于房子剩余面积的家具摆放到房子中

步骤分析

需求涉及两个事物：房子 和 家具，故被案例涉及两个类：房子类 和 家具类。

5.2.2.1 定义类

• 房子类

• 实例属性

• 房子地理位置

• 房子占地面积

• 房子剩余面积

• 房子内家具列表

• 实例方法

• 容纳家具

• 显示房屋信息

• 家具类

• 家具名称

• 家具占地面积

5.2.2.2 创建对象并调用相关方法

代码实现

5.2.3.1 定义类

• 家具类

class Furniture():

def init(self, name, area):

家具名字

self.name = name

家具占地面积

self.area = area

• 房子类

class Home():

def init(self, address, area):

地理位置

self.address = address

房屋面积

self.area = area

剩余面积

self.free_area = area

家具列表

self.furniture = []

​

def str(self):

return f’房子坐落于{self.address}, 占地面积{self.area}, 剩余面积{self.free_area}, 家具有{self.furniture}’

​

def add_furniture(self, item):

“”“容纳家具”“”

if self.free_area >= item.area:

self.furniture.append(item.name)

家具搬入后，房屋剩余面积 = 之前剩余面积 - 该家具面积

self.free_area -= item.area

else:

print(‘家具太大，剩余面积不足，无法容纳’)

创建对象并调用实例属性和方法

bed = Furniture(‘双人床’, 6)

jia1 = Home(‘北京’, 1200)

print(jia1)

​

jia1.add_furniture(bed)

print(jia1)

​

sofa = Furniture(‘沙发’, 10)

jia1.add_furniture(sofa)

print(jia1)

​

ball = Furniture(‘篮球场’, 1500)

jia1.add_furniture(ball)

print(jia1)

总结

• 面向对象重要组成部分

• 类

• 创建类

class 类名():

代码

• 对象

对象名 = 类名()

• 添加对象属性

• 类外面

对象名.属性名 = 值

• 类里面

self.属性名 = 值

• 获取对象属性

• 类外面

对象名.属性名

• 类里面

self.属性名

• 魔法方法

• __init__(): 初始化

• __str__():输出对象信息

• __del__():删除对象时调用

面向对象-继承

---

继承的概念

生活中的继承，一般指的是子女继承父辈的财产。

• 拓展1：经典类或旧式类

不由任意内置类型派生出的类，称之为经典类。

class 类名:

代码

…

• 拓展2：新式类

class 类名(object):

代码

Python面向对象的继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法，具体如下：

父类A

class A(object):

def init(self):

self.num = 1

​

def info_print(self):

print(self.num)

​

子类B

class B(A):

pass

​

​

result = B()

result.info_print()  # 1

在Python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类。

单继承

故事主线：一个煎饼果子老师傅，在煎饼果子界摸爬滚打多年，研发了一套精湛的摊煎饼果子的技术。师父要把这套技术传授给他的唯一的最得意的徒弟。

分析：徒弟是不是要继承师父的所有技术？

1. 师父类

class Master(object):

def init(self):

self.kongfu = ‘[古法煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

2. 徒弟类

class Prentice(Master):

pass

​

​

3. 创建对象daqiu

daqiu = Prentice()

4. 对象访问实例属性

print(daqiu.kongfu)

5. 对象调用实例方法

daqiu.make_cake()

多继承

故事推进：小明是个爱学习的好孩子，想学习更多的煎饼果子技术，于是，在百度搜索学习

所谓多继承意思就是一个类同时继承了多个父类。

class Master(object):

def init(self):

self.kongfu = ‘[古法煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

创建学校类

class School(object):

def init(self):

self.kongfu = ‘[煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

class Prentice(School, Master):

pass

​

​

daqiu = Prentice()

print(daqiu.kongfu)

daqiu.make_cake()

注意：当一个类有多个父类的时候，默认使用第一个父类的同名属性和方法。

子类重写父类同名方法和属性

故事：小明掌握了师父和培训的技术后，自己潜心钻研出自己的独门配方的一套全新的煎饼果子技术。

class Master(object):

def init(self):

self.kongfu = ‘[古法煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

class School(object):

def init(self):

self.kongfu = ‘[煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

独创配方

class Prentice(School, Master):

def init(self):

self.kongfu = ‘[独创煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

daqiu = Prentice()

print(daqiu.kongfu)

daqiu.make_cake()

​

print(Prentice.mro)

子类和父类具有同名属性和方法，默认使用子类的同名属性和方法。

子类调用父类的同名方法和属性

故事：很多顾客都希望也能吃到古法和黑马的技术的煎饼果子。

class Master(object):

def init(self):

self.kongfu = ‘[古法煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

class School(object):

def init(self):

self.kongfu = ‘[黑马煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

class Prentice(School, Master):

def init(self):

self.kongfu = ‘[独创煎饼果子配方]’

​

def make_cake(self):

如果是先调用了父类的属性和方法，父类属性会覆盖子类属性，故在调用属性前，先调用自己子类的初始化

self.init()

print(f’运用{self.kongfu}制作煎饼果子’)

​

调用父类方法，但是为保证调用到的也是父类的属性，必须在调用方法前调用父类的初始化

def make_master_cake(self):

Master.init(self)

Master.make_cake(self)

​

def make_school_cake(self):

School.init(self)

School.make_cake(self)

​

​

daqiu = Prentice()

​

daqiu.make_cake()

​

daqiu.make_master_cake()

​

daqiu.make_school_cake()

​

daqiu.make_cake()

多层继承

故事：N年后，小明老了，想要把所有技术传承给自己的徒弟。

class Master(object):

def init(self):

self.kongfu = ‘[古法煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

class School(object):

def init(self):

self.kongfu = ‘[煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

class Prentice(School, Master):

def init(self):

self.kongfu = ‘[独创煎饼果子配方]’

​

def make_cake(self):

self.init()

print(f’运用{self.kongfu}制作煎饼果子’)

​

def make_master_cake(self):

Master.init(self)

Master.make_cake(self)

​

def make_school_cake(self):

School.init(self)

School.make_cake(self)

​

​

徒孙类

class Tusun(Prentice):

pass

​

​

xiaoqiu = Tusun()

​

xiaoqiu.make_cake()

​

xiaoqiu.make_school_cake()

​

xiaoqiu.make_master_cake()

​

super()调用父类方法

class Master(object):

def init(self):

self.kongfu = ‘[古法煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

class School(Master):

def init(self):

self.kongfu = ‘[煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

方法2.1

super(School, self).init()

super(School, self).make_cake()

​

方法2.2

super().init()

super().make_cake()

​

​

class Prentice(School):

def init(self):

self.kongfu = ‘[独创煎饼果子技术]’

​

def make_cake(self):

self.init()

print(f’运用{self.kongfu}制作煎饼果子’)

​

子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装

def make_master_cake(self):

Master.init(self)

Master.make_cake(self)

​

def make_school_cake(self):

School.init(self)

School.make_cake(self)

​

一次性调用父类的同名属性和方法

def make_old_cake(self):

方法一：代码冗余；父类类名如果变化，这里代码需要频繁修改

Master.init(self)

Master.make_cake(self)

School.init(self)

School.make_cake(self)

​

方法二: super()

方法2.1 super(当前类名, self).函数()

super(Prentice, self).init()

super(Prentice, self).make_cake()

​

方法2.2 super().函数()

super().init()

super().make_cake()

​

​

daqiu = Prentice()

​

daqiu.make_old_cake()

注意：使用super() 可以自动查找父类。调用顺序遵循 __mro__ 类属性的顺序。比较适合单继承使用。

私有权限

定义私有属性和方法

在Python中，可以为实例属性和方法设置私有权限，即设置某个实例属性或实例方法不继承给子类。

故事：小明把技术传承给徒弟的同时，不想把自己的钱(2000000个亿)继承给徒弟，这个时候就要为钱这个实例属性设置私有权限。

设置私有权限的方法：在属性名和方法名 前面 加上两个下划线 __。

class Master(object):

def init(self):

self.kongfu = ‘[古法煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

class School(object):

def init(self):

self.kongfu = ‘[煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

class Prentice(School, Master):

def init(self):

self.kongfu = ‘[独创煎饼果子配方]’

定义私有属性

self.__money = 2000000

​

定义私有方法

def __info_print(self):

print(self.kongfu)

print(self.__money)

​

def make_cake(self):

self.init()

print(f’运用{self.kongfu}制作煎饼果子’)

​

def make_master_cake(self):

Master.init(self)

Master.make_cake(self)

​

def make_school_cake(self):

School.init(self)

School.make_cake(self)

​

​

徒孙类

class Tusun(Prentice):

pass

​

​

daqiu = Prentice()

对象不能访问私有属性和私有方法

print(daqiu.__money)

daqiu.__info_print()

​

xiaoqiu = Tusun()

子类无法继承父类的私有属性和私有方法

print(xiaoqiu.__money) # 无法访问实例属性__money

xiaoqiu.__info_print()

注意：私有属性和私有方法只能在类里面访问和修改。

获取和修改私有属性值

---

在Python中，一般定义函数名get_xx用来获取私有属性，定义set_xx用来修改私有属性值。

class Master(object):

def init(self):

self.kongfu = ‘[古法煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

class School(object):

def init(self):

self.kongfu = ‘[煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

class Prentice(School, Master):

def init(self):

self.kongfu = ‘[独创煎饼果子配方]’

self.__money = 2000000

​

获取私有属性

def get_money(self):

return self.__money

​

修改私有属性

def set_money(self):

self.__money = 500

​

def __info_print(self):

print(self.kongfu)

print(self.__money)

​

def make_cake(self):

self.init()

print(f’运用{self.kongfu}制作煎饼果子’)

​

def make_master_cake(self):

Master.init(self)

Master.make_cake(self)

​

def make_school_cake(self):

School.init(self)

School.make_cake(self)

​

​

徒孙类

class Tusun(Prentice):

pass

​

​

daqiu = Prentice()

​

xiaoqiu = Tusun()

调用get_money函数获取私有属性money的值

print(xiaoqiu.get_money())

调用set_money函数修改私有属性money的值

xiaoqiu.set_money()

print(xiaoqiu.get_money())

总结

• 继承的特点

• 子类默认拥有父类的所有属性和方法

• 子类重写父类同名方法和属性

• 子类调用父类同名方法和属性

• super()方法快速调用父类方法

• 私有权限

• 不能继承给子类的属性和方法需要添加私有权限

• 语法

class 类名():

私有属性

__属性名 = 值

​

私有方法

def __函数名(self):

代码

面向对象-其他

---

面向对象三大特性

• 封装

• 将属性和方法书写到类的里面的操作即为封装

• 封装可以为属性和方法添加私有权限

• 继承

• 子类默认继承父类的所有属性和方法

• 子类可以重写父类属性和方法

• 多态

• 传入不同的对象，产生不同的结果

多态

了解多态

多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）。

• 定义：多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果

• 好处：调用灵活，有了多态，更容易编写出通用的代码，做出通用的编程，以适应需求的不断变化！

• 实现步骤：

• 定义父类，并提供公共方法

• 定义子类，并重写父类方法

• 传递子类对象给调用者，可以看到不同子类执行效果不同

体验多态

class Dog(object):

def work(self):  # 父类提供统一的方法，哪怕是空方法

print(‘指哪打哪…’)

​

​

class ArmyDog(Dog):  # 继承Dog类

def work(self):  # 子类重写父类同名方法

print(‘追击敌人…’)

​

​

class DrugDog(Dog):

def work(self):

print(‘追查毒品…’)

​

​

class Person(object):

def work_with_dog(self, dog):  # 传入不同的对象，执行不同的代码，即不同的work函数

dog.work()

​

​

ad = ArmyDog()

dd = DrugDog()

​

daqiu = Person()

daqiu.work_with_dog(ad)

daqiu.work_with_dog(dd)

类属性和实例属性

类属性

设置和访问类属性

• 类属性就是 类对象 所拥有的属性，它被 该类的所有实例对象 所共有。

• 类属性可以使用 类对象 或 实例对象 访问。

class Dog(object):

tooth = 10

​

​

wangcai = Dog()

xiaohei = Dog()

​

print(Dog.tooth)  # 10

print(wangcai.tooth)  # 10

print(xiaohei.tooth)  # 10

类属性的优点

• 记录的某项数据 始终保持一致时，则定义类属性。

• 实例属性 要求 每个对象 为其 单独开辟一份内存空间 来记录数据，而 类属性 为全类所共有 ，仅占用一份内存，更加节省内存空间。

修改类属性

类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了一个实例属性。

class Dog(object):

tooth = 10

​

​

wangcai = Dog()

xiaohei = Dog()

​

修改类属性

Dog.tooth = 12

print(Dog.tooth)  # 12

print(wangcai.tooth)  # 12

print(xiaohei.tooth)  # 12

​

不能通过对象修改属性，如果这样操作，实则是创建了一个实例属性

wangcai.tooth = 20

print(Dog.tooth)  # 12

print(wangcai.tooth)  # 20

print(xiaohei.tooth)  # 12

实例属性

---

class Dog(object):

def init(self):

self.age = 5

​

def info_print(self):

print(self.age)

​

​

wangcai = Dog()

print(wangcai.age)  # 5

print(Dog.age) # 报错：实例属性不能通过类访问

wangcai.info_print()  # 5

类方法和静态方法

类方法

类方法特点

• 需要用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数。

类方法使用场景

• 当方法中 需要使用类对象 (如访问私有类属性等)时，定义类方法

• 类方法一般和类属性配合使用

class Dog(object):

__tooth = 10

​

@classmethod

def get_tooth(cls):

return cls.__tooth

​

​

wangcai = Dog()

result = wangcai.get_tooth()

print(result)  # 10

静态方法

静态方法特点

• 需要通过装饰器@staticmethod来进行修饰，静态方法既不需要传递类对象也不需要传递实例对象（形参没有self/cls）。

• 静态方法 也能够通过 实例对象 和 类对象 去访问。

静态方法使用场景

---

• 当方法中 既不需要使用实例对象(如实例对象，实例属性)，也不需要使用类对象 (如类属性、类方法、创建实例等)时，定义静态方法

• 取消不需要的参数传递，有利于 减少不必要的内存占用和性能消耗

class Dog(object):

@staticmethod

def info_print():

print(‘这是一个狗类，用于创建狗实例…’)

​

​

wangcai = Dog()

静态方法既可以使用对象访问又可以使用类访问

wangcai.info_print()

Dog.info_print()

总结

• 面向对象三大特性

• 封装

• 继承

• 多态

• 类属性

• 归属于类对象的属性，所有对象共有的属性

• 实例属性

• 类方法

@classmethod

def xx():

代码

• 静态方法

@staticmethod

def xx():

代码

异常

–

了解异常

当检测到一个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的"异常"。

例如：以r方式打开一个不存在的文件。

open(‘test.txt’, ‘r’)

异常的写法

语法

–

try:

可能发生错误的代码

except:

如果出现异常执行的代码

快速体验

需求：尝试以r模式打开文件，如果文件不存在，则以w方式打开。

try:

f = open(‘test.txt’, ‘r’)

except:

f = open(‘test.txt’, ‘w’)

捕获指定异常

语法

try:

可能发生错误的代码

except 异常类型:

如果捕获到该异常类型执行的代码

体验

try:

print(num)

except NameError:

print(‘有错误’)

注意：

1. 如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常。

2. 一般try下方只放一行尝试执行的代码。

捕获多个指定异常

当捕获多个异常时，可以把要捕获的异常类型的名字，放到except 后，并使用元组的方式进行书写。

try:

print(1/0)

​

except (NameError, ZeroDivisionError):

print(‘有错误’)

捕获异常描述信息

try:

print(num)

except (NameError, ZeroDivisionError) as result:
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注Python）

名 前面 加上两个下划线 __。

class Master(object):

def init(self):

self.kongfu = ‘[古法煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

class School(object):

def init(self):

self.kongfu = ‘[煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

class Prentice(School, Master):

def init(self):

self.kongfu = ‘[独创煎饼果子配方]’

定义私有属性

self.__money = 2000000

​

定义私有方法

def __info_print(self):

print(self.kongfu)

print(self.__money)

​

def make_cake(self):

self.init()

print(f’运用{self.kongfu}制作煎饼果子’)

​

def make_master_cake(self):

Master.init(self)

Master.make_cake(self)

​

def make_school_cake(self):

School.init(self)

School.make_cake(self)

​

​

徒孙类

class Tusun(Prentice):

pass

​

​

daqiu = Prentice()

对象不能访问私有属性和私有方法

print(daqiu.__money)

daqiu.__info_print()

​

xiaoqiu = Tusun()

子类无法继承父类的私有属性和私有方法

print(xiaoqiu.__money) # 无法访问实例属性__money

xiaoqiu.__info_print()

注意：私有属性和私有方法只能在类里面访问和修改。

获取和修改私有属性值

---

在Python中，一般定义函数名get_xx用来获取私有属性，定义set_xx用来修改私有属性值。

class Master(object):

def init(self):

self.kongfu = ‘[古法煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

class School(object):

def init(self):

self.kongfu = ‘[煎饼果子配方]’

​

def make_cake(self):

print(f’运用{self.kongfu}制作煎饼果子’)

​

​

class Prentice(School, Master):

def init(self):

self.kongfu = ‘[独创煎饼果子配方]’

self.__money = 2000000

​

获取私有属性

def get_money(self):

return self.__money

​

修改私有属性

def set_money(self):

self.__money = 500

​

def __info_print(self):

print(self.kongfu)

print(self.__money)

​

def make_cake(self):

self.init()

print(f’运用{self.kongfu}制作煎饼果子’)

​

def make_master_cake(self):

Master.init(self)

Master.make_cake(self)

​

def make_school_cake(self):

School.init(self)

School.make_cake(self)

​

​

徒孙类

class Tusun(Prentice):

pass

​

​

daqiu = Prentice()

​

xiaoqiu = Tusun()

调用get_money函数获取私有属性money的值

print(xiaoqiu.get_money())

调用set_money函数修改私有属性money的值

xiaoqiu.set_money()

print(xiaoqiu.get_money())

总结

• 继承的特点

• 子类默认拥有父类的所有属性和方法

• 子类重写父类同名方法和属性

• 子类调用父类同名方法和属性

• super()方法快速调用父类方法

• 私有权限

• 不能继承给子类的属性和方法需要添加私有权限

• 语法

class 类名():

私有属性

__属性名 = 值

​

私有方法

def __函数名(self):

代码

面向对象-其他

---

面向对象三大特性

• 封装

• 将属性和方法书写到类的里面的操作即为封装

• 封装可以为属性和方法添加私有权限

• 继承

• 子类默认继承父类的所有属性和方法

• 子类可以重写父类属性和方法

• 多态

• 传入不同的对象，产生不同的结果

多态

了解多态

多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）。

• 定义：多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果

• 好处：调用灵活，有了多态，更容易编写出通用的代码，做出通用的编程，以适应需求的不断变化！

• 实现步骤：

• 定义父类，并提供公共方法

• 定义子类，并重写父类方法

• 传递子类对象给调用者，可以看到不同子类执行效果不同

体验多态

class Dog(object):

def work(self):  # 父类提供统一的方法，哪怕是空方法

print(‘指哪打哪…’)

​

​

class ArmyDog(Dog):  # 继承Dog类

def work(self):  # 子类重写父类同名方法

print(‘追击敌人…’)

​

​

class DrugDog(Dog):

def work(self):

print(‘追查毒品…’)

​

​

class Person(object):

def work_with_dog(self, dog):  # 传入不同的对象，执行不同的代码，即不同的work函数

dog.work()

​

​

ad = ArmyDog()

dd = DrugDog()

​

daqiu = Person()

daqiu.work_with_dog(ad)

daqiu.work_with_dog(dd)

类属性和实例属性

类属性

设置和访问类属性

• 类属性就是 类对象 所拥有的属性，它被 该类的所有实例对象 所共有。

• 类属性可以使用 类对象 或 实例对象 访问。

class Dog(object):

tooth = 10

​

​

wangcai = Dog()

xiaohei = Dog()

​

print(Dog.tooth)  # 10

print(wangcai.tooth)  # 10

print(xiaohei.tooth)  # 10

类属性的优点

• 记录的某项数据 始终保持一致时，则定义类属性。

• 实例属性 要求 每个对象 为其 单独开辟一份内存空间 来记录数据，而 类属性 为全类所共有 ，仅占用一份内存，更加节省内存空间。

修改类属性

类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了一个实例属性。

class Dog(object):

tooth = 10

​

​

wangcai = Dog()

xiaohei = Dog()

​

修改类属性

Dog.tooth = 12

print(Dog.tooth)  # 12

print(wangcai.tooth)  # 12

print(xiaohei.tooth)  # 12

​

不能通过对象修改属性，如果这样操作，实则是创建了一个实例属性

wangcai.tooth = 20

print(Dog.tooth)  # 12

print(wangcai.tooth)  # 20

print(xiaohei.tooth)  # 12

实例属性

---

class Dog(object):

def init(self):

self.age = 5

​

def info_print(self):

print(self.age)

​

​

wangcai = Dog()

print(wangcai.age)  # 5

print(Dog.age) # 报错：实例属性不能通过类访问

wangcai.info_print()  # 5

类方法和静态方法

类方法

类方法特点

• 需要用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数。

类方法使用场景

• 当方法中 需要使用类对象 (如访问私有类属性等)时，定义类方法

• 类方法一般和类属性配合使用

class Dog(object):

__tooth = 10

​

@classmethod

def get_tooth(cls):

return cls.__tooth

​

​

wangcai = Dog()

result = wangcai.get_tooth()

print(result)  # 10

静态方法

静态方法特点

• 需要通过装饰器@staticmethod来进行修饰，静态方法既不需要传递类对象也不需要传递实例对象（形参没有self/cls）。

• 静态方法 也能够通过 实例对象 和 类对象 去访问。

静态方法使用场景

---

• 当方法中 既不需要使用实例对象(如实例对象，实例属性)，也不需要使用类对象 (如类属性、类方法、创建实例等)时，定义静态方法

• 取消不需要的参数传递，有利于 减少不必要的内存占用和性能消耗

class Dog(object):

@staticmethod

def info_print():

print(‘这是一个狗类，用于创建狗实例…’)

​

​

wangcai = Dog()

静态方法既可以使用对象访问又可以使用类访问

wangcai.info_print()

Dog.info_print()

总结

• 面向对象三大特性

• 封装

• 继承

• 多态

• 类属性

• 归属于类对象的属性，所有对象共有的属性

• 实例属性

• 类方法

@classmethod

def xx():

代码

• 静态方法

@staticmethod

def xx():

代码

异常

–

了解异常

当检测到一个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的"异常"。

例如：以r方式打开一个不存在的文件。

open(‘test.txt’, ‘r’)

异常的写法

语法

–

try:

可能发生错误的代码

except:

如果出现异常执行的代码

快速体验

需求：尝试以r模式打开文件，如果文件不存在，则以w方式打开。

try:

f = open(‘test.txt’, ‘r’)

except:

f = open(‘test.txt’, ‘w’)

捕获指定异常

语法

try:

可能发生错误的代码

except 异常类型:

如果捕获到该异常类型执行的代码

体验

try:

print(num)

except NameError:

print(‘有错误’)

注意：

1. 如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常。

2. 一般try下方只放一行尝试执行的代码。

捕获多个指定异常

当捕获多个异常时，可以把要捕获的异常类型的名字，放到except 后，并使用元组的方式进行书写。

try:

print(1/0)

​

except (NameError, ZeroDivisionError):

print(‘有错误’)

捕获异常描述信息

try:

print(num)

except (NameError, ZeroDivisionError) as result:
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-XxS1oZ97-1712516667224)]

[外链图片转存中…(img-BQvZlTS2-1712516667225)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注Python）