这篇文章基于Python3.8.6，开发平台为VSCode
注释
注释分为单行注释和多行注释
单⾏注释，只能注释一行内容，快捷键： ctrl + /
# 单行注释
多行注释，可以注释多行内容，⼀般用在注释⼀段代码的情况， 语法如下：
"""
双引号是第一种注释方式
第⼀⾏注释
第⼆⾏注释
"""
'''
单引号是第一种注释方式
注释1
注释2
'''
变量
变量名 = 值
变量名自定义，要满足标识符命名规则。
标识符
标识符命名规则是Python中定义各种名字的时候的统⼀规范，具体如下：
- 由数字、字母、下划线组成
- 不能数字开头
- 不能使用内置关键字
- 严格区分大小写
False None True and as assert break class continue def del
elif else except finally for from global if import in is
lambda nonlocal not or pass raise return try while with yield
命名习惯
- 见名知义。
- 大驼峰：即每个单词首字母都大写，例如： MyName 。
- 小驼峰：第二个（含）以后的单词首字母大写，例如： myName 。
- 下划线：例如： my_name 。
数据类型
检测数据类型的⽅法：type()
a = 1
print(type(a)) # <class 'int'> -- 整型
b = 1.1
print(type(b)) # <class 'float'> -- 浮点型
c = True
print(type(c)) # <class 'bool'> -- 布尔型
d = '12345'
print(type(d)) # <class 'str'> -- 字符串
e = [10, 20, 30]
print(type(e)) # <class 'list'> -- 列表
f = (10, 20, 30)
print(type(f)) # <class 'tuple'> -- 元组
h = {10, 20, 30}
print(type(h)) # <class 'set'> -- 集合
g = {'name': 'TOM', 'age': 20}
print(type(g)) # <class 'dict'> -- 字典
输出
直接输出
print('hello Python')
age = 18
print(age)
格式化输出
所谓的格式化输出即按照⼀定的格式输出内容。
- 格式化符号
| 格式化符号 | 转换 |
|---|---|
| %s | 字符串 |
| %d | 有符号的⼗进制整数 |
| %f | 浮点数 |
| %c | 字符 |
| %u | ⽆符号⼗进制整数 |
| %o | ⼋进制整数 |
| %x | ⼗六进制整数（⼩写ox） |
| %X | ⼗六进制整数（⼤写OX） |
| %e | 科学计数法（⼩写'e'） |
| %E | 科学计数法（⼤写'E'） |
| %g | %f和%e的简写 |
| %G | %f和%E的简写 |
技巧
- %06d，表示输出的整数显示位数，不足以0补全，超出当前位数则原样输出
- %.2f，表示小数点后显示的小数位数。
格式化字符串除了%s，还可以写为 f'{表达式}
- f-字符串
f-格式化字符串是Python3.6中新增的格式化方法，该方法更简单易读。
# 我的名字是TOM，明年19岁了
print('我的名字是%s，明年%d岁了' % (name, age + 1))
# 我的名字是TOM，明年19岁了
print(f'我的名字是{name}, 明年{age + 1}岁了')
1.3 转义字符
\n ：换行。
\t ：制表符，⼀个tab键（4个空格）的距离。
1.4 结束符
想⼀想，为什么两个print会换行输出？
print('输出的内容', end="\n")
在Python中，print()， 默认自带 end="\n" 这个换行结束符，所以导致每两个 print 直接会换行展示，用户可以按需求更改结束符。
输入
输⼊的特点
- 当程序执行到 input ，等待用户输入，输入完成之后才继续向下执行。
- 在Python中， input 接收用户输⼊后，⼀般存储到变量，方便使用。
- 在Python中， input 会把接收到的任意用户输入的数据都当做字符串处理。
password = input('请输⼊您的密码：')
print(f'您输⼊的密码是{password}')
# <class 'str'>
print(type(password))
转换数据类型
⼀. 转换数据类型的作用
问：input()接收用户输⼊的数据都是字符串类型，如果用户输入1，想得到整型该如何操作？
答：转换数据类型即可，即将字符串类型转换成整型。
⼆. 转换数据类型的函数
| 函数 | 说明 |
|---|---|
| int(x [,base ]) | 将x转换为⼀个整数 |
| float(x) | 将x转换为⼀个浮点数 |
| complex(real [,imag ]) | 创建⼀个复数，real为实部，imag为虚部 |
| str(x) | 将对象 x 转换为字符串 |
| repr(x) | 将对象 x 转换为表达式字符串 |
| eval(str) | ⽤来计算在字符串中的有效Python表达式,并返回⼀个对象 |
| tuple(s) | 将序列 s 转换为⼀个元组 |
| list(s) | 将序列 s 转换为⼀个列表 |
| chr(x) | 将⼀个整数转换为⼀个Unicode字符 |
| ord(x) | 将⼀个字符转换为它的ASCII整数值 |
| hex(x) | 将⼀个整数转换为⼀个⼗六进制字符串 |
| oct(x) | 将⼀个整数转换为⼀个⼋进制字符串 |
| bin(x) | 将⼀个整数转换为⼀个⼆进制字符串 |
举例1
# 1. 接收⽤户输⼊
num = input('请输⼊您的幸运数字：')
# 2. 打印结果
print(f"您的幸运数字是{num}")
# 3. 检测接收到的⽤户输⼊的数据类型 -- str类型
print(type(num))
# 4. 转换数据类型为整型 -- int类型
print(type(int(num)))
举例2
# 1. tuple() -- 将⼀个序列转换成元组
list1 = [10, 20, 30]
print(tuple(list1))
print(type(tuple(list1)))
# 2. list() -- 将⼀个序列转换成列表
t1 = (100, 200, 300)
print(list(t1))
print(type(list(t1)))
# 3. eval() -- 将字符串中的数据转换成Python表达式原本类型
str1 = '10'
str2 = '[1, 2, 3]'
str3 = '(1000, 2000, 3000)'
print(type(eval(str1)))
print(type(eval(str2)))
print(type(eval(str3)))
运算符
- 算数运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 | 1 + 1 输出结果为 2 |
| - | 减 | 1 - 1 输出结果为 0 |
| * | 乘 | 2 * 2 输出结果为 4 |
| / | 除 | 10 / 2 输出结果为 5 |
| // | 整除 | 9 // 4 输出结果为2 |
| % | 取余 | 9 % 4 输出结果为 1 |
| ** | 指数 | 2 ** 4 输出结果为 16，即 2 * 2 * 2 * 2 |
| () | 小括号 | ⼩括号⽤来提高运算优先级，即 (1 + 2) * 3 输出结果为 9 |
- 赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 赋值 | 将 = 右侧的结果赋值给等号左侧的变量 |
单个变量赋值
num = 1
print(num)
多个变量赋值
num1, float1, str1 = 10, 0.5, 'hello world'
print(num1)
print(float1)
print(str1)
多个变量赋相同值
a = b = 10
print(a)
print(b)
- 复合赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| += | 加法赋值运算符 | c += a 等价于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等价于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等价于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等价于 c = c / a |
| //= | 整除赋值运算符 | c //= a 等价于 c = c // a |
| %= | 取余赋值运算符 | c %= a 等价于 c = c % a |
| **= | 幂赋值运算符 | c ** = a 等价于 c = c ** a |
- ⽐较运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 判断相等。如果两个操作数的结果相等，则条件结果为真(True)，否则条件结果为假(False) | 如a=3,b=3，则（a == b) 为 True |
| ！= | 不等于 。如果两个操作数的结果不相等，则条件为真(True)，否则条件结果为假(False) | 如a=3,b=3，则（a == b) 为 True如a=1,b=3，则(a != b) 为 True |
| >. | 运算符左侧操作数结果是否⼤于右侧操作数结果，如果⼤于，则条件为真，否则为假 | 如a=7,b=3，则(a > b) 为 True |
| < | 运算符左侧操作数结果是否⼩于右侧操作数结果，如果⼩于，则条件为真，否则为假 | 如a=7,b=3，则(a < b) 为 False |
| >= | 运算符左侧操作数结果是否⼤于等于右侧操作数结果，如果⼤于，则条件为真，否则为假 | 如a=7,b=3，则(a < b) 为 False如a=3,b=3，则(a >= b) 为 True |
| <= | 运算符左侧操作数结果是否⼩于等于右侧操作数结果，如果⼩于，则条件为真，否则为假 | 如a=3,b=3，则(a <= b) 为 True |
- 逻辑运算符
| 运算符 | 逻辑表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 布尔"与"：如果 x 为 False，x and y 返回False，否则它返回 y 的值。 | True and False， 返回False。 |
| or | x or y | 布尔"或"：如果 x 是 True，它返回 True，否则它返回 y 的值。 | False or True， 返回True。 |
| not | not x | 布尔"⾮"：如果 x 为 True，返回 False 。如果 x为 False，它返回 True。 | not True 返回 False, not False 返回 True |
a = 1
b = 2
c = 3
print((a < b) and (b < c)) # True
print((a > b) and (b < c)) # False
print((a > b) or (b < c)) # True
print(not (a > b)) # True
字符串
什么是字符串？
- ⼀对引号字符串
name1 = 'Tom'
name2 = "Rose"
- 三引号字符串
name3 = ''' Tom '''
name4 = """ Rose """
a = ''' i am Tom,
nice to meet you! '''
b = """ i am Rose,
nice to meet you! """
三引号形式的字符串支持换⾏。
字符串输出
字符串输入
下标 “下标” 又叫 “索引” ，就是编号。
切片
切片是指对操作的对象截取其中⼀部分的操作。字符串、列表、元组都支持切片操作。
序列[开始位置下标:结束位置下标:步长]
注意
- 不包含结束位置下标对应的数据， 正负整数均可；
- 步⻓是选取间隔，正负整数均可，默认步⻓为1。
name = "abcdefg"
print(name[2:5:1]) # cde
print(name[2:5]) # cde
print(name[:5]) # abcde
print(name[1:]) # bcdefg
print(name[:]) # abcdefg
print(name[::2]) # aceg
print(name[:-1]) # abcdef, 负1表示倒数第⼀个数据
print(name[-4:-1]) # def
print(name[::-1]) # gfedcba
4.字符串的常用操作 字符串的常用操作方法有查找、修改和判断三大类。 4.1查找 所谓字符串查找方法即是查找子串在字符串中的位置或出现的次数。
find()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1。
- 语法
字符串序列.find(⼦串, 开始位置下标, 结束位置下标)
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
mystr = "hello world and itcast and itheima and Python"
print(mystr.find('and')) # 12
print(mystr.find('and', 15, 30)) # 23
print(mystr.find('ands')) # -1
rfind()： 和find()功能相同，但查找方向为右侧开始。rindex()：和index()功能相同，但查找方向为右侧开始。count()：返回某个子串在字符串中出现的次数
字符串序列.count(子串, 开始位置下标, 结束位置下标)
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
4.2修改 所谓修改字符串，指的就是通过函数的形式修改字符串中的数据。
replace()：替换。
字符串序列.replace(旧子串, 新子串, 替换次数)
注意：替换次数如果查出⼦串出现次数，则替换次数为该⼦串出现次数。
split()：按照指定字符分割字符串。join()：⽤一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串。capitalize()：将字符串第一个字符转换成大写。title()：将字符串每个单词首字母转换成大写。lower()：将字符串中大写转小写。upper()：将字符串中小写转大写。lstrip()：删除字符串左侧空白字符。rstrip()：删除字符串右侧空白字符。strip()：删除字符串两侧空白字符。ljust()：返回一个原字符串左对齐，并使用指定字符(默认空格)填充至对应长度的新字符串。
4.3判断 所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False。
startswith()：检查字符串是否是以指定子串开头，否则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标)
mystr = "hello world and itcast and itheima and Python "
# 结果：True
print(mystr.startswith('hello'))
# 结果False
print(mystr.startswith('hello', 5, 20))
endswith()：检查字符串是否是以指定子串结尾，否则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查
字符串序列.endswith(⼦串, 开始位置下标, 结束位置下标)
mystr = "hello world and itcast and itheima and Python"
# 结果：True
print(mystr.endswith('Python'))
# 结果：False
print(mystr.endswith('python'))
# 结果：False
print(mystr.endswith('Python', 2, 20))
-
isalpha()：如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False。 -
isdigit()：如果字符串只包含数字则返回 True ，否则返回 False。
mystr1 = 'aaa12345'
mystr2 = '12345'
# 结果： False
print(mystr1.isdigit())
# 结果：True
print(mystr2.isdigit())
isalnum()：如果字符串至少有一个字符并且所有字符都是字⺟或数字则返回True,否则返回False。
mystr1 = 'aaa12345'
mystr2 = '12345-'
# 结果：True
print(mystr1.isalnum())
# 结果：False
print(mystr2.isalnum())
isspace()：如果字符串中只包含空白，则返回True，否则返回False。
mystr1 = '1 2 3 4 5'
mystr2 = ' '
# 结果：False
print(mystr1.isspace())
# 结果：True
print(mystr2.isspace())
列表
⼀. 列表的应用场景 如果⼀个班级100位学⽣，每个⼈的姓名都要存储，应该如何书写程序？声明100个变量吗？
答：列表即可， 列表⼀次性可以存储多个数据。
⼆. 列表的格式
[数据1, 数据2, 数据3, 数据4......]
列表可以⼀次性存储多个数据，且可以为不同数据类型。
三. 列表的常用操作
列表的作用是⼀次性存储多个数据，程序员可以对这些数据进行的操作有：增、删、改、查。
3.1 查找
3.1.1 下标
name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0]) # Tom
print(name_list[1]) # Lily
print(name_list[2]) # Rose
3.1.2 函数
index()：返回指定数据所在位置的下标 。
- 语法
列表序列.index(数据, 开始位置下标, 结束位置下标)
name_list = ['Tom', 'Lily', 'Rose']
print(name_list.index('Lily', 0, 2)) # 1
注意：如果查找的数据不存在则报错。
count()：统计指定数据在当前列表中出现的次数。
name_list = ['Tom', 'Lily', 'Rose']
print(name_list.count('Lily')) # 1
len()：访问列表长度，即列表中数据的个数。
name_list = ['Tom', 'Lily', 'Rose']
print(len(name_list)) # 3
3.1.3 判断是否存在
in：判断指定数据在某个列表序列，如果在返回True，否则返回Falsenot in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False
name_list = ['Tom', 'Lily', 'Rose']
name = input('请输⼊您要搜索的名字：')
if name in name_list:
print(f'您输⼊的名字是{name}, 名字已经存在')
else:
print(f'您输⼊的名字是{name}, 名字不存在')
3.2 增加
作用：增加指定数据到列表中。
- append()：列表结尾追加数据。
- 语法
列表序列.append(数据)
name_list = ['Tom', 'Lily', 'Rose']
name_list.append('xiaoming')
# 结果：['Tom', 'Lily', 'Rose', 'xiaoming']
print(name_list)
列表追加数据的时候，直接在原列表⾥⾯追加了指定数据，即修改了原列表，故列表为可变类型数据。
注意：
如果append()追加的数据是⼀个序列，则追加整个序列到列表
- extend()：列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表。
- 语法
列表序列.extend(数据)
2.1 单个数据
name_list = ['Tom', 'Lily', 'Rose']
name_list.extend('xiaoming')
# 结果：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
print(name_list)
2.2 序列数据
name_list = ['Tom', 'Lily', 'Rose']
name_list.extend(['xiaoming', 'xiaohong'])
# 结果：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']
print(name_list)
- insert()：指定位置新增数据。
- 语法
列表序列.insert(位置下标, 数据)
- 快速体验
name_list = ['Tom', 'Lily', 'Rose']
name_list.insert(1, 'xiaoming')
# 结果：['Tom', 'xiaoming', 'Lily', 'Rose']
print(name_list)
3.3 删除
- del()
- pop()
- remove()
- clear()
3.4 修改
- 修改指定下标数据
- 逆置：reverse()
- 排序：sort()
3.5 复制
- copy()
name_list = ['Tom', 'Lily', 'Rose']
name_li2 = name_list.copy()
# 结果：['Tom', 'Lily', 'Rose']
print(name_li2)
列表的循环遍历
- while
- for
列表嵌套
所谓列表嵌套指的就是⼀个列表⾥⾯包含了其他的子列表。
name_list = [['小明', '小红', '小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四','王五']]
思考： 如何查找到数据"李四"？ 答： 逐层查找！
# 第一步：按下标查找到李四所在的列表
print(name_list[2])
# 第二步：从李四所在的列表里面，再按下标找到数据李四
print(name_list[2][1])
元组
⼀. 元组的应用场景
思考：如果想要存储多个数据，但是这些数据是不能修改的数据，怎么做？
答：列表可以一次性存储多个数据，但是列表中的数据允许更改。
num_list = [10, 20, 30]
num_list[0] = 100
一个元组可以存储多个数据，元组内的数据是不能修改的。
注意：如果定义的元组只有一个数据，那么这个数据后面也要添加逗号，否则数据类型为唯一的这个数据的数据类型
t1 = (10, 20, 30)
print(type(t1)) # tuple
t2 = (10,)
print(type(t2)) # tuple
t3 = (20)
print(type(t3)) # int
t4 = ('hello')
print(type(t4)) # str
三. 元组的常见操作
元组数据不支持修改，只支持查找，具体如下：
- 按下标查找数据
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0]) # aa
index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index方法相同。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.index('aa')) # 0
count()：统计某个数据在当前元组出现的次数。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.count('bb')) # 2
len()：统计元组中数据的个数。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(len(tuple1)) # 4
注意：元组内的直接数据如果修改则立即报错
tuple1 = ('aa', 'bb', 'cc', 'bb')
tuple1[0] = 'aaa'
但是如果元组里面有列表，修改列表里面的数据则是支持的。
tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple2[2]) # 访问到列表
# 结果：(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
tuple2[2][0] = 'aaaaa'
print(tuple2)
字典
思考4：数据顺序发生变化，每个数据的下标也会随之变化，如何保证数据顺序变化前后能使⽤同一的标准查找数据呢？
答：字典，字典里面的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可。
⼆. 创建字典的语法
字典特点：
- 符号为大括号
- 数据为键值对形式出现
- 各个键值对之间用逗号隔开
# 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 空字典
dict2 = {}
dict3 = dict()
注意：⼀般称冒号前面的为键(key)，简称k；冒号后⾯的为值(value)，简称v。
三. 字典常见操作 3.1 增
写法：字典序列[key] = 值
注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1['name'] = 'Rose'
# 结果：{'name': 'Rose', 'age': 20, 'gender': '男'}
print(dict1)
dict1['id'] = 110
# {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
print(dict1)
注意：字典为可变类型。
3.2 删
-
del() / del：删除字典或删除字典中指定键值对。
-
clear()：清空字典
3.3 改
写法：字典序列[key] = 值
注意：如果key存在则修改这个key对应的值 ；如果key不存在则新增此键值对。
3.4 查
- key值查找
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1['name']) # Tom
print(dict1['id']) # 报错
如果当前查找的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','男')])
四. 字典的循环遍历
4.1 遍历字典的key 注意这里和.keys()方法的区别，上面输出的是一个关键字数组，这里遍历输出，得到的是三个字符串
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():
print(key)
4.2 遍历字典的value
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value in dict1.values():
print(value)
4.3 遍历字典的元素
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
print(item)
4.4 遍历字典的键值对
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
print(f'{key} = {value}')
集合
⼀. 创建集合 创建集合使⽤ {} 或 set() ， 但是如果要创建空集合只能使⽤ set() ，因为 {} ⽤来创建空字典。
s1 = {10, 20, 30, 40, 50} # 创建有数据集合
print(s1) # {10,20,30,40,50}
s2 = {10, 30, 20, 10, 30, 40, 30, 50}
print(s2) # {10,20,30,40,50}
s3 = set('abcdefg')
print(s3) # {'c','g','b','f','a','d','e'}
s4 = set() # 创建无数据集合
print(type(s4)) # <class 'set'>
s5 = {}
print(type(s5)) # <class 'dict'>
特点：
- 集合可以去掉重复数据；
- 集合数据是无序的，故不支持下标
⼆. 集合常见操作方法
2.1 增加数据
- 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) # {100, 200, 10, 'a', 20, 'b', 'c'}
2.2 删除数据
- remove()，删除集合中的指定数据，如果数据
不存在则报错。
s1 = {10, 20}
s1.remove(10)
print(s1) # {20}
s1.remove(10) # 报错
print(s1) # {20}
- 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() # 40
print(del_num)
print(s1) # {10, 50, 20, 30}
2.3 查找数据
- in：判断数据在集合序列
- not in：判断数据不在集合序列
s1 = {10, 20, 30, 40, 50}
print(10 in s1) # True
print(10 not in s1) # False
条件语句
条件语句，即条件成⽴执⾏某些代码，条件不成⽴则不执⾏这些代码。
if True:
print('条件成⽴执⾏的代码1')
print('条件成⽴执⾏的代码2')
# 下⽅的代码没有缩进到if语句块，所以和if条件⽆关
print('我是⽆论条件是否成⽴都要执⾏的代码')
if...else...
age = int(input('请输⼊您的年龄：'))
if age >= 18:
print(f'您的年龄是{age},已经成年，可以上⽹')
else:
print(f'您的年龄是{age},未成年，请⾃⾏回家写作业')
print('系统关闭')
多重判断
if 条件1:
条件1成立执⾏的代码1
条件1成立执⾏的代码2
......
elif 条件2：
条件2成立执⾏的代码1
条件2成立执⾏的代码2
......
......
else:
以上条件都不成立执⾏的代码
if嵌套
if 条件1：
条件1成⽴执⾏的代码
条件1成⽴执⾏的代码
if 条件2：
条件2成⽴执⾏的代码
条件2成⽴执⾏的代码
money = 1
seat = 0
if money == 1:
print('⼟豪，不差钱，顺利上⻋')
if seat == 1:
print('有空座，可以坐下')
else:
print('没有空座，站等')
else:
print('没钱，不能上⻋，追着公交⻋跑')
⼋. 三目运算符 三目运算符也叫三元运算符或三元表达式。
语法如下：
条件成⽴执⾏的表达式 if 条件 else 条件不成⽴执⾏的表达式
a = 1
b = 2
c = a if a > b else b
print(c)
循环
1.2 循环的分类
在Python中，循环分为 while 和 for 两种，最终实现效果相同。 ⼆. while的语法
2.1 快速体验
需求：复现重复执⾏100次 print('媳妇⼉，我错了') （输出更简洁⼀些，我们这⾥设置5次）。
while 条件:
条件成⽴重复执⾏的代码1
条件成⽴重复执⾏的代码2
......
四、break和continue
break和continue是循环中满⾜⼀定条件退出循环的两种不同⽅式。 4.1 理解
举例：⼀共吃5个苹果，吃完第⼀个，吃第⼆个…，这⾥"吃苹果"的动作是不是重复执⾏？
情况⼀：如果吃的过程中，吃完第三个吃饱了，则不需要再吃第4个和第五个苹果，即是吃苹果的动作
停⽌，这⾥就是break控制循环流程，即终⽌此循环。
情况⼆：如果吃的过程中，吃到第三个吃出⼀个⼤⾍⼦...,是不是这个苹果就不吃了，开始吃第四个苹
果，这⾥就是continue控制循环流程，即退出当前⼀次循环继⽽执⾏下⼀次循环代码。
4.1.1 情况⼀：break
i = 1
while i <= 5:
if i == 4:
print(f'吃饱了不吃了')
break
print(f'吃了第{i}个苹果')
i += 1
4.1.2 情况⼆：continue
i = 1
while i <= 5:
if i == 3:
print(f'⼤⾍⼦，第{i}个不吃了')
# 在continue之前⼀定要修改计数器，否则会陷⼊死循环
i += 1
continue
print(f'吃了第{i}个苹果')
i += 1
五. while循环嵌套
打印九九乘法表
# 重复打印9⾏表达式
j = 1
while j <= 9:
# 打印⼀⾏⾥⾯的表达式 a * b = a*b
i = 1
while i <= j:
print(f'{i}*{j}={j*i}', end='\t')
i += 1
print()
j += 1
七、for循环
7.1 语法
for 临时变量 in 序列:
重复执⾏的代码1
重复执⾏的代码2
......
str1 = 'itheima'
for i in str1:
print(i)
⼋. else
循环可以和else配合使⽤，else下⽅缩进的代码指的是当循环正常结束之后要执⾏的代码。
8.1 while...else
i = 1
while i <= 5:
print('媳妇⼉，我错了')
i += 1
else:
print('媳妇原谅我了，真开⼼，哈哈哈哈')
8.2 for...else
8.2.1 语法
for 临时变量 in 序列:
重复执⾏的代码
...
else:
循环正常结束之后要执⾏的代码
所谓else指的是循环正常结束之后要执行的代码，即如果是break终止循环的情况，else下方缩进的代码将不执行。
总结：
- break退出整个循环
- continue退出本次循环，继续执⾏下⼀次重复执⾏的代码
- else
- while和for都可以配合else使⽤
- else下⽅缩进的代码含义：当循环正常结束后执⾏的代码
- break终⽌循环不会执⾏else下⽅缩进的代码
- continue退出循环的⽅式执⾏else下⽅缩进的代码
推导式
- 推导式的作用：简化代码
- 推导式写法
# 列表推导式
[xx for xx in range()]
# 字典推导式
{xx1: xx2 for ... in ...}
# 集合推导式
{xx for xx in ...}
观察发现，推导式基于for循环实现，for循环之前是要实现的结果，for循环是取值条件。而列表、字典和集合推导式的区别就是外部符号不同而已
一. 列表推导式
作用：用⼀个表达式创建⼀个有规律的列表或控制⼀个有规律列表。
列表推导式又叫列表生成式。 需求：创建⼀个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)
1.2 带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)
1.3 多个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(0, 3)]
print(list1)
二. 字典推导式
思考：如果有如下两个列表：
list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']
如何快速合并为⼀个字典？
答：字典推导式
字典推导式作用：快速合并列表为字典或提取字典中目标数据。
list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']
dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)
提取字典中目标数据
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}
注意：集合有数据去重功能。
公共操作
⼀. 运算符
| 运算符 | 描述 | 支持的容器类型 |
|---|---|---|
| + | 合并 | 字符串、列表、元组 |
| * | 复制 | 字符串、列表、元组 |
| in | 元素是否存在 | 字符串、列表、元组、字典 |
| not in | 元素是否不存在 | 字符串、列表、元组、字典 |
1.1 +运算符
# 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.2 *运算符
# 1. 字符串
print('-' * 10) # ----------
# 2. 列表
list1 = ['hello']
print(list1 * 4) # ['hello', 'hello', 'hello', 'hello']
# 3. 元组
t1 = ('world',)
print(t1 * 4) # ('world', 'world', 'world', 'world')
1.3 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 循环当中。 |
2.1 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
2.2 del()
# 1. 字符串
str1 = 'abcdefg'
del str1
print(str1)
# 2. 列表
list1 = [10, 20, 30, 40]
del(list1[0])
print(list1) # [20, 30, 40]
2.3 max()
# 1. 字符串
str1 = 'abcdefg'
print(max(str1)) # g
# 2. 列表
list1 = [10, 20, 30, 40]
print(max(list1)) # 40
2.4 min()
# 1. 字符串
str1 = 'abcdefg'
print(min(str1)) # a
# 2. 列表
list1 = [10, 20, 30, 40]
print(min(list1)) # 10
2.5 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数字。
2.6 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}')
三. 容器类型转换 3.1 tuple() 作⽤：将某个序列转换成元组
list1 = [10, 20, 30, 40, 50, 20]
s1 = {100, 200, 300, 400, 500}
print(tuple(list1))
print(tuple(s1))
3.2 list()
作⽤：将某个序列转换成列表
t1 = ('a', 'b', 'c', 'd', 'e')
s1 = {100, 200, 300, 400, 500}
print(list(t1))
print(list(s1))
3.3 set()
作⽤：将某个序列转换成集合
list1 = [10, 20, 30, 40, 50, 20]
t1 = ('a', 'b', 'c', 'd', 'e')
print(set(list1))
print(set(t1))
注意：
- 集合可以快速完成列表去重
- 集合不支持下标
函数
- 函数的作用：封装代码，高效的代码重用
- 函数使用步骤
- 定义函数
def 函数名():
代码1
代码2
...
- 调用函数
函数名()
- 函数的参数：函数调用的时候可以传入真实数据，增大函数的使用的灵活性
- 形参：函数定义时书写的参数(非真实数据)
- 实参：函数调用时书写的参数(真实数据)
# 定义函数时同时定义了接收⽤户数据的参数a和b，a和b是形参
def add_num2(a, b):
result = a + b
print(result)
# 调⽤函数时传⼊了真实的数据10 和 20，真实数据为实参
add_num2(10, 20)
-
函数的返回值
- 作用：函数调用后，返回需要的计算结果
- 写法
return 表达式
def buy():
return '烟'
# 使⽤变量保存函数返回值
goods = buy()
print(goods)
- 多个函数返回值
用多个变量去接收多个返回值即可
def test_return():
x,y = retrun 1,2
print(x)
print(y)
-
函数的说明⽂档
- 作用：保存函数解释说明的信息
- 写法
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)
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 是定义了⼀个局部变量。
思考：如何在函数体内部修改全局变量？
在函数内部使用全局变量时需要用global声明
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
三. 函数的返回值 思考：如果⼀个函数如些两个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)
注意：
return a, b写法，返回多个数据的时候，默认是元组类型。- return后⾯可以连接列表、元组或字典，以返回多个值。
四. 函数的参数
4.1 位置参数 位置参数：调用函数时根据函数定义的参数位置来传递参数。
def user_info(name, age, gender):
print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('TOM', 20, '男')
注意：传递和定义参数的顺序及个数必须⼀致。
4.2 关键字参数
函数调用，通过“键=值”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。
def user_info(name, age, gender):
print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('Rose', age=20, gender='⼥')
user_info('⼩明', gender='男', age=16)
注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。
4.3 缺省参数
缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）。
def user_info(name, age, gender='男'):
print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('TOM', 20)
user_info('Rose', 18, '⼥')
注意：函数调用时，如果为缺省参数传值则修改默认参数值；否则使用这个默认值。
4.4 不定长参数 不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。此时，可用包裹(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，key是关键字，value是值
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(c)
可变和不可变类型 所谓可变类型与不可变类型是指：数据能够直接进⾏修改，如果能直接修改那么就是可变，否则是不可变.
- 可变类型
- 列表
- 字典
- 集合
- 不可变类型
- 整型
- 浮点型
- 字符串
- 元组
lambda 表达式
3.1 lambda的应用场景
如果⼀个函数有⼀个返回值，并且只有⼀句代码，可以使用lambda简化。
3.2 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
3.4 lambda的参数形式
可以发现：第一个括号中，冒号前是要赋值的参数，冒号后是返回值，第二个括号中是传递的参数列表
3.4.1.无参数
print((lambda: 100)())
3.4.2.⼀个参数
print((lambda a: a)('hello world'))
3.4.3.默认参数
print((lambda a, b, c=100: a + b + c)(10, 20))
3.4.4.可变参数：**args
print((lambda *args: args)(10, 20, 30))
注意：这⾥的可变参数传⼊到lambda之后，返回值为元组。
3.4.5.可变参数：**kwargs
print((lambda **kwargs: kwargs)(name='python', age=20))
3.5 lambda的应⽤
3.5.1. 带判断的lambda
print((lambda a, b: a if a > b else b)(1000, 500))
3.5.2. 列表数据按字典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)
高阶函数
把函数作为参数传⼊，这样的函数称为高阶函数，高阶函数是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式
作用：把函数作为参数传入，化简代码 举例：
def add_num(a, b):
return abs(a) + abs(b)
result = add_num(-1, 2)
print(result) # 3
def sum_num(a, b, f):
return f(a) + f(b)
result = sum_num(-1, 2, abs)
print(result) # 3
注意：两种方法对比之后，发现，方法2的代码会更加简洁。
函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快。
内置高阶函数
- map()
- reduce()
- filter
4.2.1 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]
4.2.2 reduce()
reduce(func(x,y)，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
4.2.3 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]
面向对象基础：类和对象
面向对象是⼀种抽象化的编程思想，很多编程语言中都有的⼀种思想。
面向对象就是将编程当成是一个事物，对外界来说，事物是直接使用的，不⽤去管他内部的情况。⽽编程就是设置事物能够做什么事。
在面向对象编程过程中，有两个重要组成部分：类 和 对象。
类和对象的关系：⽤类去创建⼀个对象。
2.1 理解类和对象
2.1.1 类
类是对一系列具有相同特征和行为的事物的统称，是一个抽象的概念，不是真实存在的事物。
- 特征即是属性
- 行为即是方法
类比如是制造洗衣机时要用到的图纸，也就是说类是用来创建对象
2.1.2 对象
对象是类创建出来的真实存在的事物，例如：洗⾐机。
注意：开发中，先有类，再有对象。
2.2 ⾯向对象实现⽅法
2.2.1 定义类
Python2中类分为：经典类 和 新式类
class 类名():
代码
......
class Washer():
def wash(self):
print('我会洗衣服')
拓展：经典类
不由任意内置类型派生出的类，称之为经典类
2.2.2 创建对象
对象⼜名实例。
对象名 = 类名()
注意：创建对象的过程也叫实例化对象。
2.2.3 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得到的结果是⼀致的，都是当前对象的内存中存储地址。
三. 添加和获取对象属性
属性即是特征，⽐如：洗⾐机的宽度、⾼度、重量...
对象属性既可以在类外⾯添加和获取，也能在类⾥⾯添加和获取。
3.1 类外面添加对象属性
语法
对象名.属性名 = 值
haier1.width = 500
haier1.height = 800
3.2 类外面获取对象属性
语法
对象名.属性名
print(f'haier1洗⾐机的宽度是{haier1.width}')
print(f'haier1洗⾐机的高度是{haier1.height}')
面向对象：继承、多态
文件操作
- 文件操作的作用
- 文件的基本操作
- 打开
- 读写
- 关闭
- 文件备份
- 文件和文件夹的操作
总结：文件操作的作用就是把一些内容(数据)存储存放起来，可以让程序下⼀次执行的时候直接使用而不必重新制作⼀份，省时省力。
异常
⼀. 了解异常
当检测到⼀个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的"异常"。
例如：以 r ⽅式打开⼀个不存在的⽂件。
⼆. 异常的写法
2.1 语法
try:
可能发⽣错误的代码
except:
如果出现异常执⾏的代码
2.2 快速体验 需求：尝试以 r 模式打开⽂件，如果⽂件不存在，则以 w ⽅式打开。
try:
f = open('test.txt', 'r')
except:
f = open('test.txt', 'w')
我可以理解为尝试执行try部分的代码后，如果异常则返回false，然后去执行except部分的代码。因为except代表除了false的那部分，而false的对立事件就是true
2.3 捕获指定异常
2.3.1 语法
try:
可能发⽣错误的代码
except 异常类型:
如果捕获到该异常类型执⾏的代码
try:
print(num)
except NameError:
print('有错误')
注意：
- 如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常。
- ⼀般try下方只放一行尝试执行的代码。
2.3.3 捕获多个指定异常 当捕获多个异常时，可以把要捕获的异常类型的名字，放到except 后，并使用元组的方式进行书写。
try:
print(1/0)
except (NameError, ZeroDivisionError):
print('有错误')
2.3.4 捕获异常描述信息
try:
print(num)
except (NameError, ZeroDivisionError) as result:
print(result)
2.3.5 捕获所有异常 Exception是所有程序异常类的父类。
try:
print(num)
except Exception as result:
print(result)
出现异常后不会影响后续代码的执行
2.4 异常的else
else表示的是如果没有异常要执行的代码。
try:
print(1)
except Exception as result:
print(result)
else:
print('我是else，是没有异常的时候执⾏的代码')
2.5 异常的finally
finally表示的是无论是否异常都要执行的代码，例如关闭文件。
try:
f = open('test.txt', 'r')
except Exception as result:
f = open('test.txt', 'w')
else:
print('没有异常，真开⼼')
finally:
f.close()
三. 异常的传递
需求：
-
尝试只读方式打开test.txt⽂件，如果文件存在则读取文件内容，文件不存在则提示用户即可。
-
读取内容要求：尝试循环读取内容，读取过程中如果检测到用户意外终止程序，则 except 捕获异常并提示用户。
import time
try:
f = open('test.txt')
try:
while True:
content = f.readline()
if len(content) == 0:
break
time.sleep(2)
print(content)
except:
# 如果在读取⽂件的过程中，产⽣了异常，那么就会捕获到
# ⽐如 按下了 ctrl+c
print('意外终⽌了读取数据')
finally:
f.close()
print('关闭⽂件')
except:
print("没有这个⽂件")
四. 自定义异常
在Python中，抛出自定义异常的语法为 raise 异常类对象 。
需求：密码长度不足，则报异常（用户输入密码，如果输入的长度不足3位，则报错，即抛出自定义异常，并捕获该异常）。
# ⾃定义异常类，继承Exception
class ShortInputError(Exception):
def __init__(self, length, min_len):
self.length = length
self.min_len = min_len
# 设置抛出异常的描述信息
def __str__(self):
return f'你输⼊的⻓度是{self.length}, 不能少于{self.min_len}个字符'
def main():
try:
con = input('请输⼊密码：')
if len(con) < 3:
raise ShortInputError(len(con), 3)
except Exception as result:
print(result)
else:
print('密码已经输⼊完成')
main()
五、总结
- 异常语法
try:
可能发生异常的代码
except:
如果出现异常执行的代码
else:
没有异常执行的代码
finally:
无论是否异常都要执行的代码
- 捕获异常
except 异常类型:
代码
except 异常类型 as xx:
代码
- 自定义异常（注意自定类中函数的参数self）
# 1. 自定义异常类
class 异常类类名(Exception):
代码
# 设置抛出异常的描述信息
def __str__(self):
return ...
# 2. 抛出异常
raise 异常类名()
# 捕获异常
except Exception...
