Python基础语法合集（极简）_python基础语法学习

参考【黑马程序员全套Python教程_Python基础入门视频教程，零基础小白自学Python入门教程】

1. 注释

• 单⾏注释 # 注释内容
• 多行注释

"""
	第一⾏行行注释
	第二⾏行行注释
	第三⾏行行注释
"""
'''
	注释1
	注释2
	注释3
'''
1
2
3
4
5
6
7
8
9
10

2. 变量

变量名 = 值

2.1 标识符

• 由数字、字母、下划线组成
• 不能数字开头
• 不能使用内置关键字
• 严格区分⼤小写

2.2 命名习惯

• 大驼峰：即每个单词⾸首字母都大写，如： MyName 。
• 小驼峰：第二个（含）以后的单词⾸首字母大写，如： myName 。
• 下划线：如： my_name 。

2.3 数据类型

• 整型： int
• 浮点型： float
• 字符串串： str
• 布尔型： bool
• 列表：list
• 元组： tuple
• 集合： set
• 字典： dict

3. 格式化输出

• %06d，表示输出的整数显示位数，不不⾜足以0补全，超出当前位数则原样输出
• %.2f，表示⼩小数点后显示的⼩小数位数。

格式化字符串除了%s，还可以写为f'{表达式}'

age = 18;
name = 'Tom'
weight = 75.5
student_id = 1

# 我的名字是TOM
print('我的名字是%s' % name)

# 我的学号是0001
print('我的学号是%4d' % student_id)

# 我的体重是75.50公⽄
print('我的体重是%.2f公斤' % weight)

# 我的名字是TOM，今年18岁了
print('我的名字是%s，今年%d岁了' % (name,age))

# 我的名字是TOM，今年19岁了
print('我的名字是%s，今年%d岁了' % (name,age+1))

# 我的名字是TOM，明年19岁了
print(f'我的名字是{name}，明年{age+1}岁了')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

转义字符
\n：换行
\t：制表符

结束符
想⼀想，为什么两个print会换行输出？

print('输出的内容'，end='\n')
1

在Python中， print()， 默认自带 end="\n" 这个换行结束符，所以导致每两个 print 直接会换⾏展示，用户可以按需求更改结束符。

4. 输入

input（"提示信息"）

• 当程序执行到 input ，等待用户输入，输入完成之后才继续向下执行。
• 在Python中， input 接收用户输入后，一般存储到变量，方便使用。
• 在Python中， input 会把接收到的任意用户输入的数据都当做字符串处理。

password = input("请输入密码：")
print(f'{您输入的密码是{password}}')
#<class 'str'>
print(type(password))
1
2
3
4

5. 数据类型转换

#1.接收用户输入
num = input('请输入幸运数字：')

#2.打印结果
print(f"您的幸运数字是{num}")

#3.检测接收到的用户输入的数据类型-str
print(type(num))

#4.转换数据类型为整型-int
print(type(int(num)))
1
2
3
4
5
6
7
8
9
10
11

6. 运算符

6.1 算数

()
** 指数
*
/
// 整除
%
+ -

6.2 赋值

=

6.3 复合赋值

+= -= *= /= //= %= **=

6.4 比较

== != > < >= <=

6.5 逻辑

and or not

7. 条件语句

if

age = int(input('请输⼊您的年年龄： '))
if age >= 18:
	print(f'您的年龄是{age},已经成年，可以上网')
print('系统关闭')
1
2
3
4

if...else...

age = int(input('请输入您的年龄： '))
if age >= 18:
	print(f'您的年龄是{age},已经成年，可以上网')
else:
	print(f'您的年龄是{age},未成年，请自行回家写作业')
print('系统关闭')
1
2
3
4
5
6

多重判断

age = int(input('请输⼊您的年龄： '))
if age < 18:
	print(f'您的年龄是{age},童工⼀一枚')
elif age >= 18 and age <= 60:
	print(f'您的年龄是{age},合法工龄')
elif age > 60:
	print(f'您的年龄是{age},可以退休')
1
2
3
4
5
6
7

if嵌套

"""
1. 如果有钱，则可以上车
2. 上车后，如果有空座，可以坐下
上车后，如果没有空座，则站着等空座位
如果没钱，不能上⻋车
"""
# 假设⽤ money = 1 表示有钱, money = 0表示没有钱; seat = 1 表示有空座， seat = 0 表示没有空座
money = 1
seat = 0
if money == 1:
	print('土豪，不差钱，顺利上车')
	if seat == 1:
		print('有空座，可以坐下')
	else:
		print('没有空座，站等')
else:
	print('没钱，不能上⻋，追着公交车跑')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

三目运算符
条件成立执行的表达式 if 条件 else 条件不成立执行的表达式

a = 1
b = 2

c = a if a>b else b
print(c)
1
2
3
4
5

8. 循环

8.1 while

i = 1
result = 0
while i <= 100:
	result += i
	i += 1

# 输出5050
print(result)
1
2
3
4
5
6
7
8

break

i = 1
while i <= 5:
	if i == 4:
		print(f'吃饱了不吃了')
		break
	print(f'吃了第{i}个苹果')
	i += 1
1
2
3
4
5
6
7

continue

i = 1
while i <= 5:
	if i == 3:
		print(f'⼤大⾍虫⼦子，第{i}个不不吃了了')
		# 在continue之前⼀一定要修改计数器器，否则会陷⼊入死循环
		i += 1
		continue
	print(f'吃了第{i}个苹果')
	i += 1
1
2
3
4
5
6
7
8
9

嵌套

# 重复打印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
1
2
3
4
5
6
7
8
9
10

else

i = 1
while i <= 5:
	print('媳妇儿，我错了')
	i += 1
else:
	print('媳妇原谅我了，真开心，哈哈哈')
1
2
3
4
5
6

8.2 for

str1 = 'itheima'
	for i in str1:
		print(i)
1
2
3

break

str1 = 'itheima'
for i in str1:
	if i == 'e':
		print('遇到e不不打印')
		break
	print(i)
1
2
3
4
5
6

continue

str1 = 'itheima'
for i in str1:
	if i == 'e':
		print('遇到e不不打印')
		continue
	print(i)
1
2
3
4
5
6

else

str1 = 'itheima'
for i in str1:
	print(i)
else:
	print('循环正常结束之后执行的代码')
1
2
3
4
5

9. 字符串

三引号形式的字符串支持换行

name1 = 'Tom'
name2 = "Rose"
a =  '''i am Tom,
			nice to meet you! '''
1
2
3
4

name = input('请输⼊入您的名字： ')
print(f'您输⼊入的名字是{name}')
print(type(name))
password = input('请输⼊入您的密码： ')
print(f'您输⼊入的密码是{password}')
print(type(password))
1
2
3
4
5
6

索引

name = "abcdef"
print(name[1])   # b
print(name[0])   # a
print(name[2])   # c
1
2
3
4

9.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
1
2
3
4
5
6
7
8
9
10
11

9.2 查找

字符串序列.find(子串，开始位置下标，结束位置下标) 返回子串开始位置的下标，否则返回-1

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
1
2
3
4

字符串序列.index(子串，开始位置下标，结束位置下标) 返回子串开始位置的下标，否则报异常

mystr = "hello world and itcast and itheima and Python"
print(mystr.index('and')) # 12
print(mystr.index('and', 15, 30)) # 23
print(mystr.index('ands')) # 报错
1
2
3
4

• rfind()： 和find()功能相同，但查找方向为右侧开始。
• rindex()：和index()功能相同，但查找方向为右侧开始。
• count()：返回某个子串在字符串中出现的次数

字符串序列.count(子串，开始位置下标，结束位置下标)

mystr = "hello world and itcast and itheima and Python"
print(mystr.count('and')) # 3
print(mystr.count('ands')) # 0
print(mystr.count('and', 0, 20)) # 1
1
2
3
4

9.3 修改

9.3.1 replace替换

字符串序列.replace(旧子串，新子串，替换次数)

mystr = "hello world and itcast and itheima and Python"
# 结果： hello world he itcast he itheima he Python
print(mystr.replace('and', 'he'))
# 结果： hello world he itcast he itheima he Python
print(mystr.replace('and', 'he', 10))
# 结果： hello world and itcast and itheima and Python
print(mystr)
1
2
3
4
5
6
7

9.3.2 split分隔

字符串序列.split(分隔字符，num)

mystr = "hello world and itcast and itheima and Python"
# 结果： ['hello world ', ' itcast ', ' itheima ', ' Python']
print(mystr.split('and'))
# 结果： ['hello world ', ' itcast ', ' itheima and Python']
print(mystr.split('and', 2))
# 结果： ['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'Python']
print(mystr.split(' '))
# 结果： ['hello', 'world', 'and itcast and itheima and Python']
print(mystr.split(' ', 2))
1
2
3
4
5
6
7
8
9

9.3.3 join合并

字符或子串.join(多字符串组成的序列)

list1 = ['chuan', 'zhi', 'bo', 'ke']
t1 = ('aa', 'b', 'cc', 'ddd')
# 结果： chuan_zhi_bo_ke
print('_'.join(list1))
# 结果： aa...b...cc...ddd
print('...'.join(t1))
1
2
3
4
5
6

9.3.4 capitalize

将字符串第一个字符转换成大写
capitalize()函数转换后，只有字符串第一个字符大写，其他的字符全都小写

mystr = "hello world and itcast and itheima and Python"
# 结果： Hello world and itcast and itheima and python
print(mystr.capitalize())
1
2
3

9.3.5 title

将字符串每个单词首字母转换成大写

mystr = "hello world and itcast and itheima and Python"
# 结果： Hello World And Itcast And Itheima And Python
print(mystr.title())
1
2
3

9.3.6 lower

将字符串中大写转小写

mystr = "hello world and itcast and itheima and Python"
# 结果： hello world and itcast and itheima and python
print(mystr.lower())
1
2
3

9.3.7 upper

将字符串中小写转大写

mystr = "hello world and itcast and itheima and Python"
# 结果： HELLO WORLD AND ITCAST AND ITHEIMA AND PYTHON
print(mystr.upper())
1
2
3

9.3.8 lstrip、rstrip、strip

删除字符串左、右、两侧空白字符

mystr = " hello world "

# "hello world "
print(mystr.lstrip())
# " hello world"
print(mystr.rstrip())
# "hello world"
print(mystr.strip())
1
2
3
4
5
6
7
8

9.3.9 ljust、rjust、center

左对齐、右对齐、居中对齐，并指定字符填充值至对应长度
字符串序列.ljust(长度，填充字符)

mystr = 'hello'

# 'hello.....'
print(mystr.ljust(10,'.'))
# 'hello     '
print(mystr.ljust(10))
# '  hello   '
print(mystr.center(10))
# '..hello...'
print(mystr.center(10,'.'))
1
2
3
4
5
6
7
8
9
10

9.4 判断

9.4.1 startswitch

字符串序列.startswith(子串, 开始位置下标, 结束位置下标)
检查字符串是否是以指定⼦子串开头，是则返回 True，否则返回 False。

mystr = "hello world and itcast and itheima and Python "
# 结果： True
print(mystr.startswith('hello'))
# 结果False
print(mystr.startswith('hello', 5, 20))
1
2
3
4
5

9.4.2 endswitch

字符串序列.endswith(子串, 开始位置下标, 结束位置下标)
检查字符串是否是以指定子串结尾，是则返回 True，否则返回 False。

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))
1
2
3
4
5
6
7

9.4.3 isalpha

如果字符串至少有⼀个字符并且所有字符都是字母则返回 True, 否则返回 False。

mystr1 = 'hello'
mystr2 = 'hello12345'
# 结果： True
print(mystr1.isalpha())
# 结果： False
print(mystr2.isalpha())
1
2
3
4
5
6

9.4.4 isdigit

如果字符串只包含数字则返回 True 否则返回 False。

mystr1 = 'aaa12345'
mystr2 = '12345'
# 结果： False
print(mystr1.isdigit())
# 结果： False
print(mystr2.isdigit())
1
2
3
4
5
6

9.4.5 isalnum

如果字符串至少有⼀个字符并且所有字符都是字母或数字则返回 True,否则返回False。

mystr1 = 'aaa12345'
mystr2 = '12345-'
# 结果： True
print(mystr1.isalnum())
# 结果： False
print(mystr2.isalnum())
1
2
3
4
5
6

9.4.6 isspace

如果字符串中只包含空白，则返回 True，否则返回 False。

mystr1 = '1 2 3 4 5'
mystr2 = ' '
# 结果： False
print(mystr1.isspace())
# 结果： True
print(mystr2.isspace())
1
2
3
4
5
6

10. 列表

列表中数据允许修改
[数据1，数据2，数据3，数据4....]

10.1 查找

name_list = ['Tom','Lily','Rose']

print(name_list[0])
print(name_list[1])
print(name_list[2])
1
2
3
4
5

列表序列.index(数据，开始位置下标，结束位置下标) 返回指定数据所在位置的下标
count() 统计指定数据在当前列表中出现的次数
len() 访问列表长度

name_list = ['Tom','Lily','Rose']
print(name_list.index('Lily',0,2))    #1
print(name_list.count('Lily'))        #1
print(len(name_list))                 #3
1
2
3
4

in 判断指定数据在某个列表序列，在返回True，否则返回False
not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False

name_list = ['Tom', 'Lily', 'Rose']
# 结果： True
print('Lily' in name_list)
# 结果： False
print('Lilys' in name_list)
1
2
3
4
5

10.2 增加

10.2.1 append

列表序列.append(数据)

name_list = ['Tom', 'Lily', 'Rose']
name_list.append('xiaoming')
# 结果： ['Tom', 'Lily', 'Rose', 'xiaoming']
print(name_list
1
2
3
4

如果append()追加的数据是一个序列，则追加整个序列到列表

name_list = ['Tom', 'Lily', 'Rose']
name_list.append(['xiaoming', 'xiaohong'])
# 结果： ['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]
print(name_list)
1
2
3
4

10.2.2 extend

extend()列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表。
列表序列.extend(数据)

name_list = ['Tom', 'Lily', 'Rose']
name_list.extend('xiaoming')
# 结果： ['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
print(name_list)
1
2
3
4

name_list = ['Tom', 'Lily', 'Rose']
name_list.extend(['xiaoming', 'xiaohong'])
# 结果： ['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']
print(name_list)
1
2
3
4

10.2.3 insert

指定位置新增数据
列表序列。insert(位置下标，数据)、

name_list = ['Tom', 'Lily', 'Rose']
name_list.insert(1, 'xiaoming')
# 结果： ['Tom', 'xiaoming', 'Lily', 'Rose']
print(name_list)
1
2
3
4

10.3 删除

10.3.1 del

del 目标

name_list = ['Tom', 'Lily', 'Rose']
# 结果：报错提示： name 'name_list' is not defined
del name_list
print(name_list)
1
2
3
4

name_list = ['Tom', 'Lily', 'Rose']
del name_list[0]
# 结果： ['Lily', 'Rose']
print(name_list)
1
2
3
4

10.3.2 pop

删除指定下标的数据(默认为最后一个)，并返回该数据。

name_list = ['Tom', 'Lily', 'Rose']
del_name = name_list.pop(1)
# 结果： Lily
print(del_name)
# 结果： ['Tom', 'Rose']
print(name_list)
1
2
3
4
5
6

10.3.3 remove

移除列表中某个数据的第⼀个匹配项。

name_list = ['Tom', 'Lily', 'Rose']
name_list.remove('Rose')
# 结果： ['Tom', 'Lily']
print(name_list)
1
2
3
4

10.3.4 clear

name_list = ['Tom', 'Lily', 'Rose']
name_list.clear()
print(name_list) # 结果： []
1
2
3

10.4 修改

name_list = ['Tom', 'Lily', 'Rose']
name_list[0] = 'aaa'
# 结果： ['aaa', 'Lily', 'Rose']
print(name_list)
1
2
3
4

reverse()

num_list = [1, 5, 2, 3, 6, 8]
num_list.reverse()
# 结果： [8, 6, 3, 2, 5, 1]
print(num_list)
1
2
3
4

列表序列.sort( key=None, reverse=False)
True – 降序 ； False – 升序

num_list = [1, 5, 2, 3, 6, 8]
num_list.sort()
# 结果： [1, 2, 3, 5, 6, 8]
print(num_list)
1
2
3
4

10.5 复制

name_list = ['Tom', 'Lily', 'Rose']
name_li2 = name_list.copy()
# 结果： ['Tom', 'Lily', 'Rose']
print(name_li2)
1
2
3
4

10.6 遍历

name_list = ['Tom','Lily','Rose']

i = 0
while i < len(name_list):
	print(name_list[i])
	i+=1
1
2
3
4
5
6

name_list = ['Tom', 'Lily', 'Rose']
for i in name_list:
print(i)
1
2
3

10.7 嵌套

name_list = [['⼩小明', '⼩小红', '⼩小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李李四', '王五']

# 第⼀步：按下标查找到李四所在的列表
print(name_list[2])
# 第⼆步：从李四所在的列表里面，再按下标找到数据李四
print(name_list[2][1])
1
2
3
4
5
6

11. 元组

一个元组可以存储多个数据，元组内的数据是不能修改的
元组特点：定义元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型

# 多个数据元组
t1 = (10,20,30)
# 单个数据元组
t2 = (10,)
1
2
3
4

注意：如果定义的元组只有⼀个数据，那么这个数据后面也好添加逗号，否则数据类型为唯一的这个数据的数据类型

t2 = (10,)
print(type(t2)) # tuple
t3 = (20)
print(type(t3)) # int
t4 = ('hello')
print(type(t4)) # str
1
2
3
4
5
6

按下标查找

tuple1 = ('aa', 'bb','cc','dd')
print(tuple1[0])   # aa
1
2

index()

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.index('aa')) # 0
1
2

count()

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.count('bb')) # 2
1
2

len()

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(len(tuple1)) # 4
1
2

注意：元组内的直接数据如果修改则立即报错

tuple1 = ('aa', 'bb', 'cc', 'bb')
tuple1[0] = 'aaa'
1
2

但是如果元组里面有列表，修改列表里面的数据则是支持的，故自觉很重要。

tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple2[2]) # 访问到列表
# 结果： (10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
tuple2[2][0] = 'aaaaa'
print(tuple2)
1
2
3
4
5

12. 集合

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

s1 = {10, 20, 30, 40, 50}
print(s1)         # {40, 10, 50, 20, 30}
s2 = {10, 30, 20, 10, 30, 40, 30, 50}
print(s2)          # {40, 10, 50, 20, 30}
s3 = set('abcdefg')
print(s3)          # {'c','g','b','f','a','d','e'}
s4 = set()
print(type(s4)) # set
s5 = {}
print(type(s5)) # dict
1
2
3
4
5
6
7
8
9
10

• 1. 集合可以去掉重复数据；
• 2. 集合数据是无序的，故不支持下标

12.1 增加

add()

s1 = {10, 20}
s1.add(100)
s1.add(10)
print(s1) # {100, 10, 20}
1
2
3
4

update()追加的数据是序列

s1 = {10, 20}
# s1.update(100) # 报错
s1.update([100, 200])
s1.update('abc')
print(s1)     #{'a',100,200,10,'b','c',20}
1
2
3
4
5

12.2 删除

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

s1 = {10, 20}
s1.remove(10)
print(s1)
s1.remove(10) # 报错
print(s1)
1
2
3
4
5

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

s1 = {10, 20}
s1.discard(10)
print(s1)
s1.discard(10)
print(s1)
1
2
3
4
5

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

s1 = {10, 20, 30, 40, 50}
del_num = s1.pop()
print(del_num)
print(s1)
1
2
3
4

12.3 查找

in not in

s1 = {10, 20, 30, 40, 50}
print(10 in s1)
print(10 not in s1)
1
2
3

13. 字典

• 符号为大括号
• 数据为键值对形式出现
• 各个键值对之间用逗号隔开
• 字典为可变类型

#有数据字典
dict1 = {'name':'Tom','age':20,'gender':'男'}
#空字典
dict2 = {};
dict3 = dict();
1
2
3
4
5

13.1 增

字典序列[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
1
2
3
4
5
6
7

13.2 删

del()/del

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
del dict1['gender']
# 结果： {'name': 'Tom', 'age': 20}
print(dict1
1
2
3
4

clear()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1.clear()
print(dict1) # {}
1
2
3

13.3 改

字典序列[key] = 值

13.4 查

13.4.1 key值查找

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1['name']) # Tom
print(dict1['id']) # 报错
1
2
3

13.4.2 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
1
2
3
4

13.4.3 keys()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])
1
2

13.4.4 values()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values()) # dict_values(['Tom', 20, '男'])
1
2

13.4.5 items()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender',
'男')])
1
2
3

13.5 遍历

dict1 = {'name':'Tom','age':20,'gender':'男'}
for key in dict1.keys():
	print(key)
1
2
3

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value in dict1.values():
print(value)
1
2
3

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
print(item)
1
2
3

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
print(f'{key} = {value}')
1
2
3

14. 公共操作

14.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)  #(1,2,10,20)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

*

# 1. 字符串
print('-' * 10) # ----------
# 2. 列表
list1 = ['hello']
print(list1 * 4) # ['hello', 'hello', 'hello', 'hello']
# 3. 元组
t1 = ('world',)
print(t1 * 4) # ('world', 'world', 'world', 'world')
1
2
3
4
5
6
7
8

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
1
2
3
4
5
6
7
8
9
10
11

14.2 公共方法

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

del()

# 1. 字符串
str1 = 'abcdefg'
del str1
print(str1)
# 2. 列表
list1 = [10, 20, 30, 40]
del(list1[0])
print(list1) # [20, 30, 40]
1
2
3
4
5
6
7
8

max()

# 1. 字符串
str1 = 'abcdefg'
print(max(str1)) # g
# 2. 列表
list1 = [10, 20, 30, 40]
print(max(list1)) # 40
1
2
3
4
5
6

min()

# 1. 字符串
str1 = 'abcdefg'
print(min(str1)) # a
# 2. 列表
list1 = [10, 20, 30, 40]
print(min(list1)) # 10
1
2
3
4
5
6

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)
1
2
3
4
5
6
7
8
9

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

list1 = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(list1):
print(i)  #(0,'a')  (1,'b') (2,'c') (3,'d')  (4,'e')
for index, char in enumerate(list1, start=1):
print(f'下标是{index}, 对应的字符是{char}')
1
2
3
4
5

14.3 类型转换

元组tuple()

list1 = [10, 20, 30, 40, 50, 20]
s1 = {100, 200, 300, 400, 500}
print(tuple(list1))
print(tuple(s1))
1
2
3
4

列表list()

t1 = ('a', 'b', 'c', 'd', 'e')
s1 = {100, 200, 300, 400, 500}
print(list(t1))
print(list(s1))
1
2
3
4

集合set()

list1 = [10, 20, 30, 40, 50, 20]
t1 = ('a', 'b', 'c', 'd', 'e')
print(set(list1))
print(set(t1))
1
2
3
4

15. 推导式

15.1 列表推导式

# 1. 准备⼀个空列列表
list1 = []
# 2. 书写循环，依次追加数字到空列表list1中
i = 0
while i < 10:
	list1.append(i)
	i += 1
print(list1)
1
2
3
4
5
6
7
8

list1 = []
for i in range(10):
	list1.append(i)
print(list1
1
2
3
4

列表推导式

list1 = [i for i in range(10)]
print(list1)
1
2

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

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

list1= [(i,j) for i in range(1,3) for j in range(3)]
print(list1)  # [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
1
2

15.2 字典推导式

dict1 = {i:i**2 for i in range(1,5)}
print(dict1) #{1:1,2:4,3:9,4:16}
1
2

list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']
dict1 = {list1[i]:list2[i] for i in range(len(list1))}
print(dict1)
1
2
3
4

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}
1
2
3
4

15.3 集合推导式

list1 = [1,1,2]
set1 = {i**2 for i in list1}
print(set1)  #{1,4}
1
2
3

16. 函数

16.1 基本使用

先定义后使用

def 函数名(参数):
	代码1
	代码2
	.....

函数名(参数)
1
2
3
4
5
6

# 定义函数时同时定义了接收用户数据的参数a和b， a和b是形参
def add_num(a,b):
	result = a + b
	print(result)
# 调⽤用函数时传⼊了真实的数据10 和 20，真实数据为实参
add_num(10,20)
1
2
3
4
5
6

def sum_num(a,b):
	return a + b

#用result变量保存函数返回值
result = sum_num(1,2)
print(result)
1
2
3
4
5
6

函数返回多个数据时，默认是元组类型

def return_num():
	return 1, 2
	
result = return_num()
print(result) # (1, 2)
1
2
3
4
5

16.2 函数说明文档

def 函数名(参数):
	"""说明文档的位置"""
	代码
	......
1
2
3
4

def sum_num(a,b):
	"""求和函数"""
	return a + b
help(sum_num)
1
2
3
4

16.3 嵌套调用

def testB():
	print('----testB start----')
	print('执行代码')
	print('----testB end----')

def testA():
	print('---- testA start----')
	testB()
	print('---- testA end----')
testA()
	
1
2
3
4
5
6
7
8
9
10
11

16.4 变量作用域

局部变量和全局变量

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
2
3
4
5
6
7
8
9
10
11
12

16.5 参数

16.5.1 位置参数

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

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

user_info('TOM', 20, '男')
1
2
3
4

16.5.2 关键字参数

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

user_info('Rose', age=20, gender='女')
user_info('⼩明', gender='男', age=16)
1
2
3
4
5

16.5.3 缺省参数

def user_info(name, age, gender='男'):
	print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')

user_info('TOM', 20)
user_info('Rose', 18, '女')
1
2
3
4
5

16.5.4 不定长参数

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

def user_info(*args):
	print(args)

#('TOM',)
user_info('TOM')
#('TOM',18)
user_info('TOM',18)
1
2
3
4
5
6
7

包裹关键词传递

def user_info(**kwargs):
	print(kwargs)
	
# {'name': 'TOM', 'age': 18, 'id': 110}
user_info(name='TOM', age=18, id=110)
1
2
3
4
5

16.6 拆包

拆包元组

def return_num()
	return 100,200

num1, num2 = return_num();
print(num1)  #100
print(num2)  #200
1
2
3
4
5
6

拆包字典

dict1 = {'name':'Tom', 'age':18}
a, b = dict1;
# 对字典进行拆包，取出来的是字典的key
print(a)  #name
print(b)  #age

print(dict1[a])  #Tom
print(dict1[b])  #18
1
2
3
4
5
6
7
8

16.7 交换变化量

# 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
1
2
3
4
5
6
7
8
9
10

a, b =1, 2
a, b = b, a
print(a)  #2
print(b)  #1
1
2
3
4

16.8 引用

我们可以⽤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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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)
1
2
3
4
5
6
7
8
9
10
11
12
13

16.9 递归

# 3+2+1
def sum_numbers(num):
	#1.如果是1，直接返回1
	if num == 1:
		return 1
	#2.如果不是1，重复执行累加
	result = num + sum_numbers(num-1)

	#3.返回累加结果

sum_result = sum_numbers(3)
#输出结果为6
print(sum_result)
1
2
3
4
5
6
7
8
9
10
11
12
13

16.10 lambda表达式

lambda 参数列表 ： 表达式

• lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用。
• lambda函数能接收任何数量的参数但只能返回⼀个表达式的值
• 直接打印lambda表达式，输出的是此lambda的内存地址

#函数
def fn1():
	return 200

print(fn1)
print(fn1())

fn2 = lambda : 100
print(fn2)
print(fn2())
1
2
3
4
5
6
7
8
9
10

def add(a,b):
	return a+b

result = add(1,2)
print(result)

print((lambda a,b:a+b)(1,2))
1
2
3
4
5
6
7

16.10.1 无参数

print((lambda:100)())
1

16.10.2 一个参数

print((lambda a:a)('hello world'))
1

16.10.3 默认参数

print((lambda a,b,c=100 : a+b+c)(10,20))
1

16.10.4 可变参数 *args

print((lambda *args:args)(10,20,30))
1

16.10.5 可变参数 **kwargs

print((lambda **kwargs:kwargs)(name='python',age=20))
1

16.10.6 带判断

print((lambda a,b : a if a > b else b)(1000, 500))
1

16.10.7 列表数据按字典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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

16.11 高阶函数

把函数作为参数传入

def add_num(a, b):
	return abs(a) + abs(b)

result = add_num(-1, 2)
print(result) # 3
1
2
3
4
5

def sum_num(a, b, f):
	return f(a) + f(b)

result = sum_num(-1, 2, abs)
print(result) # 3
1
2
3
4
5

16.12 内置高阶函数

16.12.1 map()

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

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]
1
2
3
4
5
6
7
8
9

16.12.2 reduce

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

import functools

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

def func(a,b):
	return a + b

result = functools.reduce(func,list1)
print(result)  #15
1
2
3
4
5
6
7
8
9

16.12.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]
1
2
3
4
5
6
7
8
9

17. 文件操作

17.1 打开与关闭

open(name, mode)
文件对象.close()

文件对象.write('内容')

# 1. 打开⽂件
f = open('test.txt', 'w')

# 2.⽂件写入
f.write('hello world')

# 3. 关闭文件
f.close()
1
2
3
4
5
6
7
8

文件对象.read(num) num是从文件中读取的数据的长度(字节)，没有就是全部
readlines() 按照行的方式把整个文件中的内容进行⼀次性读取，并且返回的是⼀个列表，其中每⼀行的数据为⼀个元素。

f = open('test.txt')
content = f.readlines()

# ['hello world\n', 'abcdefg\n', 'aaa\n', 'bbb\n', 'ccc']
print(content)

# 关闭文件
f.close()
1
2
3
4
5
6
7
8

readline() 一次读取一行内容

f = open('test.txt')
content = f.readline()
print(f'第⼀行： {content}')
content = f.readline()
print(f'第⼆行： {content}')
# 关闭⽂文件
f.close()
1
2
3
4
5
6
7

seek() 用来移动文件指针
⽂件对象.seek(偏移量, 起始位置)
起始位置： 0：⽂文件开头，1：当前位置， 2：⽂文件结尾

17.2 备份

old_name = input('请输⼊您要备份的⽂件名：')
# 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)

# 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()
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

17.3 文件和文件夹的操作

import 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) 
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

18. 面向对象

用类创建对象
类：对一系列具有相同特征和行为的事物的统称，类是图纸
对象：类创建出来的真实存在的事物

18.1 类

大驼峰命名

# 新式类
class 类名():
	代码
	.....

# 经典类--不由任意内置类型派生出的类
class 类名：
	代码
	.....
1
2
3
4
5
6
7
8
9

class Washer():
	def wash(self):
		print('我会洗衣服')
1
2
3

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

18.2 对象/实例

对象名 = 类名()

# 创建对象
haier1 = Washer()

# <__main__.Washer object at 0x0000018B7B224240>
print(haier1)

# haier对象调⽤实例方法
haier1.wash()
1
2
3
4
5
6
7
8

类外添加对象属性
对象名.属性值 = 值

类外获取对象属性
对象名.属性名

类内获取对象属性
self.属性名

18.3 魔法方法

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

18.3.1 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()
1
2
3
4
5
6
7
8
9
10
11

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()
1
2
3
4
5
6
7
8
9
10
11
12

18.3.2 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)
1
2
3
4
5
6
7
8
9
10

18.3.3 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
2
3
4
5
6
7
8
9
10
11

18.4 继承

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

# 父类A
class A(object):
	def __init__(self):
		self.num = 1
	def info_print(self):
		print(self.num)

# 子类B
class B(A):
	pass

reuslt = B()
result.info_print() #1
1
2
3
4
5
6
7
8
9
10
11
12
13

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

18.4.1 单继承

# 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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

18.4.2 多继承

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

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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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

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

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__)
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

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

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 = Pretice()
daqiu.make_cake()
daqiu.make_master_cake()
daqiu.make_school_cake()
daqiu.make_cake()
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
29
30
31
32
33
34
35
36
37
38
39

18.4.5 多层继承

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(Pretice):
	pass

xiaoqiu = Tusun()
xiaoqiu.make_cake()
xiaoqiu.make_school_cake()
xiaoqiu.make_master_cake()
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
29
30
31
32
33
34
35
36
37
38
39
40
41

18.5 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(Pretice,self).__init__()
		# super(Pretice,self).make_cake()

		# 方法2.2 super().函数()
		super().__init__()
		super().make_cake()

daqiu = Prentice()
daqiu.make_old_cake()
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

18.6 私有权限

calss 类名():
	# 私有属性
	__属性名 = 值

	# 私有方法
	def __函数名(self):
		代码
1
2
3
4
5
6
7

18.6.1 定义私有属性和方法

在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 Pretice(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()
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

18.6.2 获取和修改私有属性值

在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())
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

18.7 三大特性

• 封装：

  • 将属性和方法书写到类的里面的操作即为封装
  • 封装可以为属性和方法添加私有权限

• 继承：

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

• 多态

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

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

18.8 类属性和实例属性

类属性就是类对象所拥有的属性，被该类的所有实例对象所共有
类属性可以使用类对象或实例对象访问

类属性的优点

• 类的实例 记录的某项数据 始终保持⼀致时，则定义类属性。
• 实例属性 要求 每个对象 为其 单独开辟一份内存空间 来记录数据，而 类属性 为全类所共有， 仅占⽤用一份内存， 更加节省内存空间。

class Dog(object):
	tooth = 10

wangcai = Dog()
xiaohei = Dog()

print(Dog.tooth)
print(wangcai.tooth)
print(xiaohei.tooth)
1
2
3
4
5
6
7
8
9

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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
1
2
3
4
5
6
7
8
9
10
11

18.9 类方法和静态方法

18.9.1 类方法

• 第一个形参是类对象的方法
• 需要用装饰器 @classmethod 来标识其为类方法，对于类方法， 第一个参数必须是类对象，一般以cls 作为第⼀个参数。
• 当方法中需要使用类对象（如访问私有类属性）时，定义类方法
• 类方法一般和类属性配合使用

class Dog(object):
	__tooth = 10

	@classmethod
	def get_tooth(cls):
		return cls.tooth

wangcai =Dog()
result = wangcai.get_tooth()
print(result)  #10
1
2
3
4
5
6
7
8
9
10

18.9.2 静态方法

• 通过修饰器@staticmethod进行修饰，静态方法既不需要传递类对象也不需要传递实例对象(形参没有self/cls)
• 静态方法也能够通过实例对象和类对象去访问
• 当方法中 既不需要使用实例对象(如实例对象，实例属性)， 也不需要使用类对象 (如类属性、类方法、创建实例等)时，定义静态方法
• 取消不需要的参数传递，有利于减少不必要的内存占用和性能消耗

class Dog(object):
	@staticmethod
	def info_print():
		print('这是⼀个狗类，用于创建狗实例....')

wangcai = Dog()
# 静态方法既可以使用对象访问又可以使用类访问
wangcai.info_print()
Dog.info_print()
1
2
3
4
5
6
7
8
9

19. 异常

try:
	可能发生错误的代码
except:
	如果出现异常执行的代码
1
2
3
4

try:
	f = open('test.txt','r')
except:
	f = open('test.txt','w')
1
2
3
4

19.1 捕获指定异常

try:
	可能发生错误的代码
except 异常类型:
	如果捕获到该异常类型执行的代码
1
2
3
4

1. 如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常。
2. ⼀般try下方只放一行尝试执行的代码。

try:
	print(num)
except NameError:
	print('有错误')
1
2
3
4

19.2 捕获多个指定异常

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

try:
	print(1/0)
except (NameError,ZeroDivisionError):
	print('有错误')
1
2
3
4

19.3 捕获异常描述信息

try:
	print(num)
except (NameError,ZeroDivisionError) as result:
	print(result)
1
2
3
4

19.4 捕获所有异常

Exception是所有程序异常类的父类

try:
	print(num)
except Exception as result:
	print(result)
1
2
3
4

19.5 异常的else

else表示的是如果没有异常执行的代码

try:
	print(1)
except Exception as result:
	print(result)
else:
	print('我是else，是没有异常的时候执行的代码')
1
2
3
4
5
6

19.6 异常的finally

finally表示的是无论是否异常都要执行的代码

try:
	f = open('test.txt','r')
except Exception as result:
	f = open('test.txt','w')
else:
	print('没异常')
finally:
	f.close()
1
2
3
4
5
6
7
8

19.7 异常的传递

需求：

1. 尝试只读方式打开test.txt文件，如果文件存在则读取文件内容，文件不存在则提示用户即可。
2. 读取内容要求：尝试循环读取内容，读取过程中如果检测到用户意外终止程序，则 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("没有这个文件")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

19.8 自定义异常

在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()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

20. 模块和包

20.1 模块

20.1.1 导入

# 1. 导入模块
import 模块名
import 模块名1，模块2...

# 2. 调用功能
模块名.功能名()
1
2
3
4
5
6

import math
print(math.sqrt(9)) #3.0
1
2

from 模块名 import 功能1， 功能2， 功能3..
1

from math import sqrt
print(sqrt(9))
1
2

from 模块名 import *
1

from math improt *
print(sqrt(9))
1
2

# 模块定义别名
import 模块名 as 别名

# 功能定义别名
from 模块名 import 功能 as 别名
1
2
3
4
5

# 模块别名
import time as tt

tt.sleep(2)
print('hello')

#功能别名
from time import sleep as sl
sl(2)
print('hello')
1
2
3
4
5
6
7
8
9
10

20.1.2 制作模块

在Python中，每个Python文件都可以作为⼀个模块，模块的名字就是文件的名字。 也就是说自定义模块名必须要符合标识符命名规则。

# my_module1.py

def testA(a,b):
	print (a + b)

# 只有当前文件中调用该函数，其他导入的文件内不符合该条件，则不执行testA函数调用
if __name__ == '__main++':
	testA(1,1)	
1
2
3
4
5
6
7
8

20.1.3 调用模块

import my_module1
my_module1.testA(1,1)
1
2

如果使用 from .. import .. 或 from .. import * 导入多个模块的时候，且模块内有同名功能。当调用这个同名功能的时候，调用到的是后面导入的模块的功能。

# 模块1代码
def my_test(a,b):
	print(a + b)

# 模块2代码
def my_test(a,b)
	print(a - b)

#导入模块和调用功能代码
from my_module1 import my_test
from my_module1 import my_test

# my_test函数是模块2中的函数
my_test(1,1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

20.1.4 模块定位顺序

当导⼊一个模块， Python解析器对模块位置的搜索顺序是：

1. 当前目录
2. 如果不在当前目录， Python则搜索在shell变量PYTHONPATH下的每个目录。
3. 如果都找不到， Python会查看默认路径。 UNIX下，默认路径一般为/usr/local/lib/python/

模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录， PYTHONPATH和由安装过程决定的默认目录。

20.1.5 all

如果⼀个模块文件中有 __all__ 变量，当使用 from xxx import * 导入时，只能导入这个列表中的元素。

__all__ = ['testA']

def testA():
	print('testA')

def testB():
	print('testB')
1
2
3
4
5
6
7

from my_module1 import *
testA()
testB()    # 异常  未定义
1
2
3

20.2 包

包将有联系的模块组织在⼀起，即放到同⼀个文件夹下，并且在这个文件夹创建一个名字为 init.py 文件，那么这个⽂件夹就称之为包。

20.2.1 制作

[New] — [Python Package] — 输⼊入包名 — [OK] — 新建功能模块(有联系的模块)。(PyCharm)
注意：新建包后，包内部会自动创建 __init__.py 文件，这个文件控制着包的导入行为。

# my_module1
print(1)
def info_print1():
	print('my_module1')
1
2
3
4

# my_module2
print(2)
def info_print2():
`print('my_module2')
1
2
3
4

20.2.2 导入

import 包名.模块名
包名.模块名.目标
1
2

import my_package.my_module1
my_package.my_module1.info_print1()
1
2

必须在 __init__.py 文件中添加 __all__ = [] ，控制允许导入的模块列表。

from 包名 import *
模块名.目标
1
2

from my_package import *
my_module1.info_print1()
1
2