python全集
第一章基础知识
python的语法虽然比较简单，但是只是在入门这一级别，如果需要深入的学习这需要时间的积累和个人的爱好，为此，希望通过编写博客的方式，记录学习的过程,同时希望自己的学习笔记可以帮助到更多想学习编程的朋友
1.python简介
下面是百度关于python的介绍，在这里就不赘述了，编程可以是自己的兴趣爱好，也可以是自己的谋生技能，无论是为什么学习python，我值是希望下面的内容，对此时此刻的你是有帮助的。
网址：https://baike.baidu.com/item/Python/407313?fr=aladdin
-
python的优点是:
- 简单、易学，适应⼈群⼴泛
- 免费、开源
-
应⽤领域⼴泛
python的解释器顾名思义就是用来 解释python语言的工具，因为我们编写的语言虽然我们自己容易理解，但是计算机是没有办法理解我们直接书写的语言，为此需要一个工具将我们的语言翻译成为计算机能够读取的文件。
目前最新的python解释器版本是3.9.6
网址：:https://www.python.org/(可下载最新的Python的编译器)
2.pycharm的下载和安装
PyCharm是⼀种Python IDE（集成开发环境），带有⼀整套可以帮助⽤户在使⽤Python语⾔开发。
-
优点：
- Project管理
- 智能提示
- 语法⾼亮
- 代码跳转
- 调试代码
- 解释代码(解释器)
- 框架和库
版本分类：专业版、社区版（专业版是需要购买的，功能是最全的，但是不建议初学者直接使用破解版，据说后期如果安装正版会有问题，其实基本使用社区版绰绰有余）
下载地址：http://www.jetbrains.com/pycharm/download/#section=windows
（安装过程在网上有很多，这里就不介绍了）
3.代码的书写
3.1注释
示例：此时的#号后面的内容就是注释的内容，编译器在编译代码是不会编译注释的
str1='hello world'
print(str1.find('l'))#此时返回的是str中字符l的数量
| 编译 | 方法 | 简介 |
|---|---|---|
| # | 单行注释 | 注释时只能注释一行快捷键为Ctrl+/ |
| “”" 代码"""或者是’’‘代码’’’ | 多行注释 | 此时可以注释多行 |
# 注释就是方便读取代码信息，便于阅读代码
# 单行注释和多行注释
# 简单的代码才注释在代码后面（#号和注释之间加空格）
"""
print("hello world")
"""
'''
注释1
注释2
注释3
'''
# 一般单行的代码用单行注释
# 较多的代码或者代码块的形式用多行注释
3.2变量
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
3）变量的使用示例
a = 10 # 变量赋值
str1 = 'hello world'
print(str1)
print(a)
3.3bug和debug
1）bug
在程序的书写过程中我们会遇到一些错误，在编译器进行编译的时候，错误分为两类，一类是语法错误，这类错误在语言的学习初期的时候较多，还有一类是语义错误，也就是书写的代码没有实现预期的效果。
str2='nihao'
print(str1)#此时的str1未定义，编译器在执行的时候会报错
错误提示：
2)debug
当书写的程序较多少，有时程序的错误有很多的，为此，我们需要调试代码，通俗点讲就是执行指定的代码，并且通过执行的结果，可以快速的定位错位的位置以及代码执行时程序的输出和变量值的变化，能够及时的帮助程序员发现程序的运行错误。
debug的流程
- 打断点（单击⽬标代码的⾏号右侧空⽩位置。）
-
Debug调试（打成功断点后，在⽂件内部任意位置 — 右键 – Debug’⽂件名’ — 即可调出）
-
Debug⼯具⾯板 – 单击StepOver/F8，即可按步执⾏代码
-
结果查询：Debugger：显示变量和变量的细节，Console：输出内容
3.4数据类型
1）数据类型的分类：
2）数据类型查看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'> -- 集合
= {'name': 'TOM', 'age': 20}
print(type(g)) # <class 'dict'> -- 字典
3.5输入
1）语法
变量名=input（）
2）输入的注意事项
-
输入的特点
-
1.当程序执⾏到 input ，等待⽤户输⼊，输⼊完成之后才继续向下执⾏。
2.在Python中， input 接收⽤户输⼊后，⼀般存储到变量，⽅便使⽤。
3.在Python中， input 会把接收到的任意⽤户输⼊的数据都当做字符串处理。
3）输入示例
password=input('请输入密码：')
print(f'你输入的密码是{password}')
print(type(password))
3.6数据类型转换
场景：
通过上面的小demo，当用户输入的代码是54556666时，打印的数据类型为str也就是字符型，如果我们需要的是int整型，这时候就可以使用到数据类型转换，如果有学习过其他语言的同学，是比较容易接受的，以为在别的语言中，我们也经常使用数据类型转换。
1）类型转换函数
| 函数 | 作用 |
|---|---|
| int（） | 将变量转换为整型 |
| float( ) | 将变量转换为⼀个浮点数 |
| 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 ) | 将⼀个整数转换为⼀个⼆进制字符串 |
2）示例
password=int(input('请输入密码：'))#类型转换函数为int（）
print(f'你输入的密码是{password}')
print(type(password))#此时显示的为int类型
注意：eval（）的使用
eval() -- 将字符串中的数据转换成Python表达式原本类型
str1 = '10'
str2 = '[1, 2, 3]'
str3 = '(1000, 2000, 3000)'
print(type(eval(str1)))#由字符型转换为了int
print(type(eval(str2)))#由字符转为了列表
print(type(eval(str3)))#由字符转为了元组
3.7运算符
1）运算符的分类
-
分类
-
算数运算符
赋值运算符
复合赋值运算符
⽐较运算符
逻辑运算符
2）算数运算符
| 运算符 | 描述 |
|---|---|
| + | 加 |
| - | 减 |
| * | 乘 |
| / | 除 |
| // | 整除 |
| % | 取余 |
| ** | 指数 |
| () | ⼩括号 |
算数运算符的优先级：（）> ** > *> / > // > % > + > -
3）赋值运算符
| 运算符 | 描述 |
|---|---|
| = | 将右侧的变量值赋值给左侧 |
#单个变量赋值
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)
4）复合赋值运算符
| 运算符 | 描述 |
|---|---|
| += | 加法赋值运算符 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 |
示例：
b=1
b+=10#等价于b=b+10
print(b)#11
c=2
c*=20#等价于c=c*20
print(c)#40
5）比较运算符
| 运算符 | 描述 |
|---|---|
| == | 判断相等。如果两个操作数的结果相等，则条件结果为真(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 |
示例：
a = 7
b = 5
print(a == b) # False
print(a != b) # True
print(a < b) # False
print(a > b) # True
print(a <= b) # False
print(a >= b) # True
6）逻辑运算符
| 运算符 | 描述 |
|---|---|
| x and y | 布尔"与"：如果 x 为 False，x and y 返回False，否则它返回 y 的值。True and False， 返回False。 |
| x or y | 布尔"或"：如果 x 是 True，它返回 True，否则它返回 y 的值。False or True， 返回True。 |
| not x | 布尔"⾮"：如果 x 为 True，返回 False 。如果 x为 False，它返回 True。not True 返回 False, notFalse 返回 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
总结
希望每天都可以和各位一起进步!!!
欢迎大家留言！！
第二章条件语句
1.什么是条件语句
**条件语句的作用：条件成立知性某些代码，条件不成立则不执行这些代码
2.if条件语句
2.1if语句的语法
if 条件:
执行语句1
执行语句2
.......
2.2示例
#实现的功能是：输入年龄，判断是否是成年人
age=int(input('请输入你的年龄：'))
if age>=18:#条件成立。执行下方缩进的代码
print(f'你的年龄是{age},已经是成年人l')
print('程序执行结束')#此时的代码不是缩进的代码，无论条件是否成立都执行
-
运行结果：
-
条件成立
-
条件不成立
3.if…else…语句
**实行的功能是：**条件成立执行if缩进下的代码，条件不成立执行else下的代码
3.1 语法
if 条件:
执行语句1
执行语句2
else:
执行语句1
执行语句2
3.2示例
#实行的功能是，输入年龄，判断是否是成年人，若果是显示年龄并且提示成年了，否则提示年龄，和未成立
age=int(input('请输入年龄：'))
if age>=18:
print(f'年龄是{age}，成年了')
else:
print(f'年龄是{age},未成年')
print('程序运行结束')
-
运行结果：
-
条件成立
-
条件不成立
4.多重判断
实行的能是：当判断的条大于两种情况的时候，需要选用多重判断语句对条件进行判断，丰富了程序的多样性。
4.1 语法
if 条件:
执行语句1
执行语句2
elif 条件:
执行语句1
执行语句2
elif 条件:
执行语句1
执行语句2
elif 条件:
执行语句1
执行语句2
.........
else:#上述条件都不满足时执行的语句
执行语句1
执行语句2
4.2示例
#实现的功能是对星期进行判断，如果输入对应的数字1-7判断是星期几，如果不是1-7则提示错误输入
week_day=int(input('请输入1-7：'))
if week_day==1:
print('星期一')
elif week_day==2:
print('星期二')
elif week_day==3:
print('星期三')
elif week_day==4:
print('星期四')
elif week_day==5:
print('星期五')
elif week_day==6:
print('星期六')
elif week_day==7:
print('星期天')
else:
print('输入错误')
-
运行结果：
-
条件成立
-
条件不成立
小提示： 条件（age >= 18 and age <= 60） 可以化简为 （18 <= age <= 60）
5.if嵌套
5.1语法
if 条件1：
条件1成⽴执⾏的代码
条件1成⽴执⾏的代码
if 条件2：
条件2成⽴执⾏的代码
条件2成⽴执⾏的代码
5.2示例
#判断坐公交是否可以上车，是否可以坐下
money=int(input('请输入零钱数：'))
seat=int(input('请输入座位数：'))
if money>=1:
print(f'你的零钱数是{money},可以上车')
if seat>=1:
print(f'车上的座位数为{seat},能坐下')
else:
print('座位数不够不能坐下')
else:
print('零钱数不够，不能坐下')
运行结果：
5.3 if嵌套执⾏流程
5.4基于循环嵌套的小游戏（猜拳）
#实现的功能：
"""
提示：0-⽯头，1-剪⼑，2-布
1. 出拳
玩家输⼊出拳
电脑随机出拳
2. 判断输赢
玩家获胜
平局
电脑获胜
"""
# 导⼊random模块
import random
# 计算电脑出拳的随机数字
computer = random.randint(0, 2)
print(computer)
player = int(input('请出拳：0-⽯头，1-剪⼑，2-布：'))
# 玩家胜利 p0:c1 或 p1:c2 或 p2:c0
if player == 0 and computer == 1 or player == 1 and computer == 2 or player == 2 and computer == 0:
print('玩家获胜')
# 平局：玩家 == 电脑
elif player == computer:
print('平局')
else:
print('电脑获胜')
运行结果：
6. 三⽬运算符（三元表达式）
6.1语法
条件成⽴执⾏的表达式 if 条件 else 条件不成⽴执⾏的表达式
6.2示例
a = 1
b = 2
c = a if a > b else b
print(c)
运行结果：
第三章循环
1. 循环简介
1.1 循环的作用
作用：让代码更高效的执行，减少代码的书写量
1.2 循环的分类
-
循环的分类（循环的形式虽然是有所区别，但是最终都是可以达到同样的目的）
- while
- for
2. while循环
2.1 语法
while 条件:
条件成⽴重复执⾏的代码1
条件成⽴重复执⾏的代码2
......
2.2 示例
示例1
#打印五次hello world
print('hello world')
print('hello world')
print('hello world')
print('hello world')
print('hello world')
#或者
i=0
while i<5:
print('hello world')
i+=1
#显然下方的代码更加简洁
运行结果：
示例2
实现1-100的累加和
i=0
ret=0
while i<=100:#判断的条件
ret+=i
i+=1
print(f'1-100的累加和为{ret}')
示例3
#实现1-100的偶数的和
#法1
i=1
ret=0
while i<=100:
if (i%2==0):#判断是否是偶数
ret+=i
i+=1
print(f'1-100的偶数和为{ret}')
#法2
i=2
ret=0
while i<=100:
ret+=i
i+=2
print(f'1-100的偶数累加和为{ret}')
推荐使用第一种因为第一种更加普遍，如果改变判断的条件，可以求更多区间范围内的偶数和，更加具有普遍性
3. break和continue
break和continue是循环中满⾜⼀定条件退出循环的两种不同⽅式
-
作用
- break控制循环流程，即 终⽌此循环
- continue控制循环流程， 即退出当前⼀次循环继⽽执⾏下⼀次循环代码
3.1示例
3.1.1continue
i=1
while i<=10:
if i==5:
i+=1
continue#此时跳过i=5的循环
print(f'i的数值为：{i}')
i+=1
输出：
3.1.1brake
i=1
while i<=10:
if i==5:
i+=1
brake#直接跳出循环
print(f'i的数值为：{i}')
i+=1
结果：
4. while循环嵌套
所谓while循环嵌套，就是⼀个while⾥⾯嵌套⼀个while的写法，每个while和之前的基础语法是相同的
4.1 语法
while 条件1:
条件1成⽴执⾏的代码
......
while 条件2:
条件2成⽴执⾏的代码
......
4.2 示例
j = 0
while j < 3:
i = 0
while i < 3:
print('你好')
i += 1
print('3遍你好说完了。。。。。。')
j += 1
运行结果：
4.3 执⾏流程
当内部循环执⾏完成之后，再执⾏下⼀次外部循环的条件判断
4.4 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
5. for循环
5.1 语法
for 临时变量 in 序列:
重复执⾏的代码1
重复执⾏的代码2
......
5.2示例
str1='hello world'
for i in str1:
print(i)
运行结果：
5.3brake
作用：直接跳出循环
示例：
for i in str1:
if i==' ':
print('遇到空格退出')
break#此时的break是直接跳出循环直接结束，和while里的break是相同的作用的
print(i)
运行结果：
5.5continue
作用：跳出此次循环执行下一次循环
示例：
str1='hello world'
for i in str1:
if i==' ':
print('遇到空格不打印')
continue#此时的continue和while中的作用是相同的，都是跳出此次循环执行下一次循环
print(i)
运行结果：
6.else
作用：循环可以和else配合使⽤，else下⽅缩进的代码指的是当循环正常结束之后要执⾏的代码
6.1 while…else…
语法：
while 条件:
条件成⽴重复执⾏的代码
else:
循环正常结束之后要执⾏的代码
示例：
i = 1
while i <= 5:
print('hello world')
i += 1
else:
print('程序结束')
运行结果：
6.1 for…else…
语法：
while 条件:
条件成⽴重复执⾏的代码
else:
循环正常结束之后要执⾏的代码
示例：
str1='hello world'
for i in str1:
print(i)
else:
print('程序结束')#程序正常执行结束之后执行的代码
运行结果：
7.1含continue和brake时的else语句
-
作用：
-
else指的是循环正常结束之后要执⾏的代码，即如果是break终⽌循环的情况，else下⽅缩进的代码将不执⾏
continue是退出当前⼀次循环，继续下⼀次循环，所以该循环在continue控制下是可以正常结束的，当循环结束后，则执⾏了else缩进的代码
示例：break
i=1
while i<=5:
print('对不起')
if i==3:
break
i+=1
else:
print('原谅你了')
运行结果：
示例：continue
i = 1
while i <= 5:
if i == 3:
i += 1
continue
print('对不起')
i += 1
else:
print('原谅你了')
运行结果：
注意事项：for…else…中的continue和brake作用的效果是一样的
第四章字符串
1.认识字符串
1.1什么是字符串
字符串是 Python 中最常⽤的数据类型。我们⼀般使⽤引号来创建字符串。创建字符串很简单，只要为变量分配⼀个值即可
示例：
a = 'hello world'
b='nihao'
print(a)
print(type(a))
print(b)
print(type(b))
运行结果：
== <class ‘str’> ， 即数据类型为str(字符串)==
1.2字符串特征
1：一对引号字符串
name1 = 'Tom'
name2 = "rose"
#这两种形式都是可以的
2：双引号字符串
特征：支持换行使用
b = '''hello
world'''
print(b)
#或者
b="""hello
world"""
print(b)
注意事项：如何创建I’m Tom ?
str = "I'm tom"#可以
str1 = 'I\'m tom'#\为转义字符
str2 = '''I'm tom'''#可以
str3 = """I'm tom"""#可以
print(str)
print(str1)
print(str2)
print(str3)
运行结果：
1.3字符串输出
name1='Tom'
print('你的名字是：%s' % name1)
print(f'你的名字是：{name1}')#推荐使用这个
运行结果：
2.下标
下标的作用：“下标” ⼜叫 “索引” ，就是编号。⽐如⽕⻋座位号，座位号的作⽤：按照编号快速找到对应的座位。同理，下标的作⽤即是通过下标快速找到对应的数据
示例：
str1='hello world'
print(str1[0])
print(str1[1])
print(str1[2])
注意事项：下标的索引值是从0开始的，即0对应的是第一个字母，为此在使用时多加注意
3.切片
**作用：**切⽚是指对操作的对象截取其中⼀部分的操作。字符串、列表、元组都⽀持切⽚操作。
3.1切片的语法
序列[开始位置下标:结束位置下标:步⻓]
-
注意事项
-
不包含结束位置下标对应的数据， 正负整数均可
-
步⻓是选取间隔，正负整数均可，默认步⻓为1
示例：`
name = "abcdefg"
print(name[1:5:1])#bcde
print(name[1:5])#bcde
print(name[:5])#bcde
print(name[1:])#bcdefg
print(name[:])#abcdefg
print(name[-4:-1])#def
print(name[::-1])#gfedcba
运行结果：
4.字符串的操作方法
字符串的常⽤操作⽅法有查找、修改和判断三⼤类
4.1查找
查找：即是查找⼦串在字符串中的位置或出现的次数
4.1.1查找的函数：
语法：字符串序列.函数(⼦串, 开始位置下标, 结束位置下标)（注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找）
函数列表：
| 函数 | 解释说明 |
|---|---|
| find | 检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则返回-1 |
| index | 检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则报异常 |
| rfind | 作用和find是相同的，只是默认从右侧查找，返回的下标还是从左侧开始得下标 |
| rindex | 作用和index是相同的，只是默认从右侧查找，返回的下标还是从左侧开始得下标 |
| count | 返回某个⼦串在字符串中出现的次数 |
示例：
str1='hello world'
print(str1.find('h'))#查找的是字符串中字符‘l’的位置，查找到后就停止查找
print(str1.find('p'))#此时返回-1，未查找到
print(str1.index('l'))#查找‘l’的位置，返回下标
#print(str1.index('p'))#未查找到报错ValueError: substring not found
print(str1.rfind('l'))
print(str1.rindex('r'))
print(str1.count('ll'))#查找‘l’在字符串中出现的次数，没有返回
运行结果：
带有开始位置下标的和结束位置下标的请自行尝试
4.2修改
4.2.1修改的函数
1.replace函数（替换）
作用：所谓修改字符串，指的就是通过函数的形式修改字符串中的数据
replace语法：字符串序列.函数(旧⼦串, 新⼦串, 替换次数)
示例：
str2='Happiness is a way station between too much and too little.'
count_too=str2.count('too')#统计too的次数
print(count_too)
new_str2=str2.replace('too','ooo',count_too)#用ooo替换too次数为count_too次
print(new_str2)
运行结果：
注意事项：数据按照是否能直接修改分为可变类型和不可变类型两种。字符串类型的数据修改的时候不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型
2.split函数（分割）
作用：按照指定字符分割字符串
split语法：字符串序列.split(分割字符, num)
示例：
str2='Happiness is a way station between too much and too little.'
count_too=str2.count('too')#统计too的次数
print(count_too)
new_str2=str2.split('too',count_too)
print(new_str2)
运行结果：
-
注意事项
- num表示的是分割字符出现的次数，即将来返回数据个数为num+1个
- 返回的数据类型是列表（<class ‘list’>）
3.join函数（合并）
作用：⽤⼀个字符或⼦串合并字符串，即是将多个字符串合并为⼀个新的字符串
join语法：字符或⼦串.join(多字符串组成的序列)
示例：
lis11=['aa','bb','cc','dd']
new_str='+'.join(lis11)
print(new_str)
运行结果：
4.capitalize()：函数（首字母转换成⼤写）
作用：将字符串第⼀个字符转换成⼤写
capitalize语法：字符或⼦串.capitalize()
示例：
str2='happiness is a way station between too much and too little.'
print(str2.capitalize())
运行结果：
5.title()：函数（每个单词首字母转换成⼤写）
作用：将字符串每个个字符首字母转换成⼤写
capitalize语法：字符或⼦串.title()
示例：
str2='happiness is a way station between too much and too little.'
print(str2.title())
运行结果：
6.lower()：函数（每个单词字母转换成小写）
作用：将字符串每个大写字母转换成小写
lower语法：字符或⼦串.lower()
示例：
str2='happiness is a way station between too much and too little.'
title_str2=str2.title()
print(title_str2)
print(title_str2.lower())
运行结果：
6.upper()：函数（每个单词字母转换成小写）
作用：将字符串每个大写字母转换成大写
upper语法：字符或⼦串.upper()
示例：
str2='happiness is a way station between too much and too little.'
title_str2=str2.title()
print(title_str2)
lower_str2=title_str2.lower()
print(lower_str2.upper())#将字符串每个大写字母转换成大写
运行结果：
7.删除空白函数
语法：字符或⼦串.函数()
函数：
| 函数 | 说明 |
|---|---|
| strip()： | 删除字符串左侧空⽩字符 |
| lstrip（） | 删除字符串右侧空⽩字符 |
| rstrip（） | 删除字符串两侧空⽩字符 |
示例：
str2=' happiness is a way station between too much and too little. '
print(str2.strip())#两侧
print(str2.lstrip())#左侧
print(str2.rstrip())#右侧
运行结果：
8。对齐函数
语法：字符或⼦串.函数(⻓度, 填充字符)
函数：
| 函数 | 说明 |
|---|---|
| ljust()： | 左对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串 |
| rjust（） | 原字符串右对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语法和ljust()相同 |
| center（） | 返回⼀个原字符串居中对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语法和ljust()相同 |
示例：
str1='hello'
print(str1.ljust(10,'.'))
print(str1.rjust(10,'+'))
print(str1.center(10,'-'))
运行结果：
4.3判断
4.3.1判断函数
作用：所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False
| 函数 | 说明 |
|---|---|
| startswith() | 检查字符串是否是以指定⼦串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查，语法：字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标) |
| endswith() | 检查字符串是否是以指定⼦串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查语法：字符串序列.endswith(⼦串, 开始位置下标, 结束位置下标) |
| isalpha() | 如果字符串⾄少有⼀个字符并且所有字符都是字⺟则返回 True, 否则返回 False，语法：字符串.isalpha（） |
| isdigit() | 如果字符串只包含数字则返回 True 否则返回 False,语法：字符串.isdigit（） |
| isalnum() | 如果字符串⾄少有⼀个字符并且所有字符都是字⺟或数字则返 回 True,否则返回False,语法：字符串.isalnum（） |
| isspace() | 如果字符串中只包含空⽩，则返回 True，否则返回 False,语法：字符串.isspace（） |
示例：
startswith()
mystr = "hello world "
# 结果：True
print(mystr.startswith('hello'))
# 结果False
print(mystr.startswith('hello', 5, 10))
endswith()
mystr = "hello world and Python"
# 结果：True
print(mystr.endswith('Python'))
# 结果：False
print(mystr.endswith('python'))
# 结果：False
print(mystr.endswith('Python', 2, 5))
isalpha()
mystr1 = 'hello'
mystr2 = 'hello12345'
# 结果：True
print(mystr1.isalpha())
# 结果：False
print(mystr2.isalpha())
isdigit()
mystr1 = 'aaa12345'
mystr2 = '12345'
# 结果： False
print(mystr1.isdigit())
# 结果：False
print(mystr2.isdigit())
isalnum()
mystr1 = 'aaa12345'
mystr2 = '12345-'
# 结果：True
print(mystr1.isalnum())
# 结果：False
print(mystr2.isalnum())
isspace()
mystr1 = '1 2 3 4 5'
mystr2 = ' '
# 结果：False
print(mystr1.isspace())
# 结果：True
print(mystr2.isspace())
第五章列表
1.列表介绍
在现实的生活中，我们会面对需要存储和读取各种数据类型，如存储学生的信息，有姓名，学号，等等多种数据类型，这是就可以以使用列表来存储各种数据类型
1.1列表的作用：列表可以⼀次性存储多个数据，且可以为不同数据类型
1.2列表的格式：[数据1, 数据2, 数据3, 数据4…]
2 .列表的操作
进⾏的操作有：增、删、改、查
2.1查找
2.1.1下标
name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0]) # Tom
print(name_list[1]) # Lily
print(name_list[2]) # Rose
注意事项：下标从0开始，每个数据以逗号分隔
2.1.2函数
| 函数 | 说明 |
|---|---|
| index() | 返回指定数据所在位置的下标，若是没有则报错语法：列表序列.index(数据, 开始位置下标, 结束位置下标) |
| count() | 统计指定数据在当前列表中出现的次数语法，语法：列表名.count(‘字符’) |
| len() | 访问列表⻓度，即列表中数据的个数语法：len（列表名） |
示例
#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
2.1.3判断是否存在
| 关键字 | 说明 |
|---|---|
| in | 判断指定数据在某个列表序列，如果在返回True，否则返回False |
| not in | 判断指定数据不在某个列表序列，如果不在返回True，否则返回False |
示例：
#in示例
name_list = ['Tom', 'Lily', 'Rose']
# 结果：True
print('Lily' in name_list)
# 结果：False
print('Lilys' in name_list)
#not in示例
name_list = ['Tom', 'Lily', 'Rose']
# 结果：False
print('Lily' not in name_list)
# 结果：True
print('Lilys' not in name_list)
综合示例：
#判断行姓名是否在列表中
name_list=['Tom','Lily','Jack']
name=input('请输入你的姓名：')
if name in name_list:
print(f'你的名字是{name},在列表中')
else:
print(f'你的名字是{name},不在列表中')
运行结果：
2.1.4列表增加函数
列表追加数据的时候，直接在原列表⾥⾯追加了指定数据，即修改了原列表，故列表为可变类型数据
| 函数 | 说明 |
|---|---|
| append() | 列表结尾追加数据，语法：列表序列.append(数据) |
| extend() | 列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表，语法：列表序列.extend(数据) |
| insert() | 指定位置新增数据，语法：列表序列.insert(位置下标, 数据) |
（1） append()示例
name_list=['Tom','Lily','Jack']
name_list.append('xiaoming')
print(name_list)
name_list.append(['xiaofang','xiaosan'])#如果append()追加的数据是⼀个序列，则追加整个序列到列表
print(name_list)
运行结果：
（2）extend()示例
-
增加的数据类型
- 单个数据
name_list=['Tom','Lily','Jack']
name_list.append('xiaoming')
print(name_list)
name_list.append(['xiaofang','xiaosan'])
print(name_list)
name_list.extend('xiaohai')#增加单个数据是逐一添加
print(name_list)
运行结果：
: 序列数据
name_list=['Tom','Lily','Jack']
name_list.append('xiaoming')
print(name_list)
name_list.append(['xiaofang','xiaosan'])
print(name_list)
name_list.extend('xiaohai')
print(name_list)
name_list.extend(['xiaoli','xiaohua'])#添加序列数据
print(name_list)
运行结果：
（3）insert示例
name_list=['Tom','Lily','Jack']
name_list.append('xiaoming')
print(name_list)
name_list.append(['xiaofang','xiaosan'])
print(name_list)
name_list.extend('xiaohai')
print(name_list)
name_list.extend(['xiaoli','xiaohua'])
print(name_list)
name_list.insert(1,'xiaochen')#在列表小标为1的位置插入‘xiaochen’
print(name_list)
运行结果：
2.1.5列表删除函数
| 函数 | 说明 |
|---|---|
| del（） | 删除函数，语法：del 目标 |
| pop() | 删除指定下标的数据(默认为最后⼀个)，并返回该数据，语法：列表数列.pop() |
| remove() | 移除列表中某个数据的第⼀个匹配项,语法：列表序列.remove(数据) |
| clear（） | 清空列表，语法:列表数列.clear（） |
（1）del删除
name_list=['Tom','Lily','Jack']
del name_list[0]#删除单个列表数据
print(name_list)
del name_list#删除整个列表数据，此时打印提示错误
print(name_list)#NameError: name 'name_list' is not defined
运行结果：
（2）pop函数
name_list=['Tom','Lily','Jack']
name_list.pop()#不指定小标默认是删除，最后一个（jack）
print(name_list)
name_list.pop(1)#删除小标为1的列表数据
print(name_list)
运行结果：
（3）remove函数
name_list=['Tom','Lily','Jack']
name_list.remove('Jack')#删除指定数据‘Jack’
print(name_list)
运行结果：
（4）clear函数
name_list=['Tom','Lily','Jack']
name_list.clear()#此时是清空列表数据，此时列表为空列表
print(name_list)
运行结果：
2.1.6列表修改和复制
| 函数或方法 | 说明 |
|---|---|
| 修改指定下标数据 | 示例：name_list[0] = ‘aaa’ |
| reverse（） | 逆置，语法：列表名.reverse() |
| sort() | 排序，语法：列表序列.sort( key=None, reverse=False，：reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）) |
| copy() | 复制，语法：列表数.copy（） |
示例
name_list=['Tom','Lily','Jack']
name_list[0]='xiaoming'#通过小标将小标为1的数据改为‘xiaoming’
print(name_list)
name_list.reverse()#此时是将原来的数据顺序翻转
print(name_list)
name_list.sort()#不加参数默认为升序排列，此时reserves=False
print(name_list)
name_list.sort(reverse=True)#排序，顺序为降序
print(name_list)
name_list1=name_list.copy()#复制列表name_list，用name_list2接收
print(name_list1)
2.2列表的遍历
2.1.1while遍历列表
示例：
name_list=['Tom','Lily','Jack']
list_len=len(name_list)
print(list_len)#列表的长度为3
num=0#以为列表的下标是从0开始的
while num<list_len:#最大为2，故不能等于
print(name_list[num])
num+=1#自增1
运行结果：
2.1.2for遍历列表
示例：
name_list=['Tom','Lily','Jack']
for i in name_list:
print(i)
2.1.3列表的嵌套
所谓列表嵌套指的就是⼀个列表⾥⾯包含了其他的⼦列表
示例：
name_list = [['⼩明', '⼩红', '⼩绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四','王五']]
# 第⼀步：按下标查找到李四所在的列表
print(name_list[2])
# 第⼆步：从李四所在的列表⾥⾯，再按下标找到数据李四
print(name_list[2][1])#类似于矩阵的元素引用
运行结果：
第六章元组
1.元组的使用场景
如果需要存储多种数据类型，而且这些数据是不能修改的，那么用什么来实现呢？之前介绍了，python数据类型（列表），我们对于列表的第一印象是可以存储多种数据类型，但是列表中的数据改变的，为此，我们需要学习一种新的谱python数据类型——元组（可以存储多种数据类型，但是这些数据是没办法改变的）
2.元组的定义
（1）元组特点：定义元组使⽤⼩括号，且逗号隔开各个数据，数据可以是不同的数据类型
（2）示例：
# 多个数据元组
t1 = (10, 20, 30，40)
# 单个数据元组
t2 = (10,)#注意：如果定义的元组只有⼀个数据，那么这个数据后⾯也好添加逗号，否则数据类型为唯⼀的这个数据的数据类型（意思是不加，应该是什么数据类型，就是什么数据类型）
tup=(20,)
print(type(tup))
tup1=(20)
print(type(tup1))
tup2=('nihao')
print(type(tup2))
tup3=('nihao',)
print(type(tup3))
运行结果：
注意事项：
注意：如果定义的元组(有⼀个数据)，那么这个数据后⾯也好添加逗号，否则数据类型为唯⼀的这个数据的数据类型（意思是不加，应该是什么数据类型，就是什么数据类型）
3.元组的常见操作
首先：因为元组是不可以修改的数据类型，为此，元组的常见操作为查找
| 方法 | 说明 |
|---|---|
| 按下标查找数据 | 示例：print(tuple1[0]) ，下标从0开始 |
| index() | 查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index，语法：元组名.indix(数据) |
| count() | 统计某个数据在当前元组出现的次数，语法：元组名.count(数据) |
| len() | 统计元组中数据的个数，语法：len(元组名) |
tup=('aa','bb','vv','aa','cc')#多个数据末尾可以不加，号
print(tup[1])
len_tup= len(tup)
print(len_tup)#5个数据
print(tup.index('cc'))#下标，从0开始为
print(tup.count('aa'))#统计aa的个数
运行结果：
4.注意事项
元组的数据没法更改，但是内部的列表数据是可以更改的
tup=('aa','bb','vv','aa','cc')#多个数据末尾可以不加，号
tup[0]='vv'#报错
print(tup)
运行结果：
tup=('aa','bb','vv','aa','cc',['aa','bb','cc'])#多个数据末尾可以不加，号
print(tup)
tup[5][0]='bb'#此时的索引和matlab类似，但是数据是从0开始计数的
#列表在元组的下标是5，'aa'在列表中的数据为0，所以修改数据‘aa’，小标为[5][0]
print(tup)
运行结果：
提示：合理使用
第七章字典、集合
1.字典
1.1字典的应用场景
列表是可以用来存储多种数据类型，如果列表中的数据顺序发生变化，如果还是使用下标来索引数据是没有办法，来找到之前的数据的，为此，一种新的数据类型，字典——通过键值对的形式进行表示，为此，在使用时，不能使用下标进行索引，只能是使用键名的形式进行索引，为此，在改变，数据的循序后，还是可以使用键名去查找对应的键值。
示例：
list1=['ton',20,'man']
print(list1[0])
list1=[20,'ton','man']
print(list1[0])
#此时列表发生改变后，不可以使用相同的下标去查找对应值
dict1={'name':'tom','year':20,'gender':'man'}
print(dict1['name'])
dict1={'year':20,'name':'tom','gender':'man'}
print(dict1['name'])
#此时字典发生改变后，可以使用相同的键名去查找对应值
1.2字典的创建
-
字典的特点
-
符号为⼤括号
数据为键值对形式出现
各个键值对之间⽤逗号隔开
注意：⼀般称冒号前⾯的为键(key)，简称k；冒号后⾯的为值(value)，简称v
1）有数据字典
dict_demo={'name':'tom','year':20,'gender':'man'}
2） 空字典
dict_demo1={}
print(type(dict_demo1))#<class 'dict'>
dict_demo2=dict()
print(type(dict_demo2))#<class 'dict'>
1.3字典的常见操作
1.3.1增加字典数据
| 使用 | 说明 |
|---|---|
| 字典序列[key] = 值 | 注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对，字典为可变数据类型 |
示例：
dict_demo={'name':'tom','age':30,'gender':'man'}
print(dict_demo)
dict_demo['id']=297483#新增
print(dict_demo)
dict_demo['name']='lily'#修改键name对应的值为lily
print(dict_demo)
运行结果：
1.3.2字典数据的删除
| 使用 | 说明 |
|---|---|
| del/del() | 删除键值对/指定字典 |
| clear（） | 语法：字典名.cleat(),此时的字典为空字典 |
1）del和del（）示例
dict_demo={'name':'tom','age':30,'gender':'man'}
del dict_demo['name']
print(dict_demo)#删除了键值对‘name’：‘tom’
del dict_demo
#print(dict_demo)此时打印报错，因无对应的字典
2）clear()示例
dict_demo={'name':'tom','age':30,'gender':'man'}
dict_demo.clear()
print(dict_demo)#输出为{}
1.3.3字典数据的修改
| 使用 | 说明 |
|---|---|
| 字典序列[key] = 值 | 注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对，字典为可变数据类型 |
1.3.4字典数据的查找
| 使用方法 | 说明 |
|---|---|
| key值查找 | 如果当前查找的key存在，则返回对应的值；否则则报错 |
| get() | 字典序列.get(key, 默认值)，注意：如果当前查找的key不存在则返回第⼆个参数(默认值)，如果省略第⼆个参数，则返回None。 |
| keys() | 语法:字典名.keys() |
| values() | 语法：字典名.values() |
| items() | 语法：字典名。items（） |
1） key值查找示例
dict_demo={'name':'tom','age':30,'gender':'man'}
print(dict_demo['name'])#tom
print(dict_demo['id'])#没有的键值则报错
2）get()示例
dict_demo={'name':'tom','age':30,'gender':'man'}
print(dict_demo.get('name'))#如果存在则直接返回键值
print(dict_demo.get('id',110))#如果不存在且有第二个参数，则返回第二个参数110
print(dict_demo.get('id'))#若第二个参数没有，则直接返回None
运行结果：
3）keys()、vlaues（）、items（）示例
dict_demo={'name':'tom','age':30,'gender':'man'}
key=dict_demo.keys()
print(key)
print(type(key))
print(dict_demo.values())
print(dict_demo.items())
1.4字典的循环遍历
1.4.1遍历字典的key
dict_demo={'name':'tom','age':30,'gender':'man'}
for i in dict_demo.keys():
print(i)
运行结果：
1.4.2遍历字典的value
dict_demo={'name':'tom','age':30,'gender':'man'}
for i in dict_demo.values():
print(i)
运行结果：
1.4.3遍历字典的元素
dict_demo={'name':'tom','age':30,'gender':'man'}
for i in dict_demo.items():
print(i)
运行结果：
1.4.4遍历字典的键值对
dict_demo={'name':'tom','age':30,'gender':'man'}
for key,value in dict_demo.items():
print(f'{key}={value}')
运行结果：
2.集合
2.1创建集合
创建集合使⽤ {} 或 set() ， 但是如果要创建空集合只能使⽤ set() ，因为 {} ⽤来创建空字典
示例：
# 创建集合使⽤ {} 或 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
注意事项：
- 集合可以去掉重复数据；
- 集合数据是⽆序的，故不⽀持下标
2.2集合数据使用
| 使用方法 | 说明 |
|---|---|
| add() | 因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进⾏任何操作。 |
| update() | 追加的数据是序列 |
| remove() | 删除集合中的指定数据，如果数据不存在则报错 |
| discard() | 删除集合中的指定数据，如果数据不存在也不会报错 |
| pop() | 随机删除集合中的某个数据，并返回这个数据 |
| in | 判断数据在集合序列 |
| not in | 判断数据不在在集合序列，返回False or True |
示例：
1）add示例
s1 = {10, 20}
s1.add(100)
s1.add(10)
print(s1) # {100, 10, 20}
2）update示例
s1 = {10, 20}
# s1.update(100) # 报错
s1.update([100, 200])
s1.update('abc')
print(s1)
3）remove示例
s1 = {10, 20}
s1.remove(10)
print(s1)
s1.remove(10) # 报错
print(s1)
4）discard示例
s1 = {10, 20}
s1.discard(10)
print(s1)
s1.discard(10)
print(s1)
5）pop示例
s1 = {10, 20, 30, 40, 50}
del_num = s1.pop()
print(del_num)
print(s1)
6）in、not in示例
s1 = {10, 20, 30, 40, 50}
print(10 in s1)#True
print(10 not in s1)#False
第八章公共操作
1.公共操作
1.1运算符
| 运算符 | 说明 |
|---|---|
| + | 合并 支持的数据类型 （字符串、列表、元组） |
| * | 复制 支持的数据类型 （字符串、列表、元组） |
| in | 元素是否存在 （字符串、列表、元组、字典） |
| not in | 元素是否不存在 （字符串、列表、元组、字典 ） |
示例
合并
str1='hello '
str2='world'
print(str1+str2)#输出为hello world
复制：
list1=['hello']
print(list1*10)#['hello', 'hello', 'hello', 'hello', 'hello', 'hello', 'hello', 'hello', 'hello', 'hello']
in：
list2=['hello','world','ni','hao']
ret='hao'in list2
print(ret)#返回True
print(type(ret))#返回的是bool类型的数据
not in:
list2=['hello','world','ni','hao']
ret ='hello'not in list2
print(type(list2))#类型和in的返回的类型是一样的，都是布尔类型的数据
print(ret)#此时返回的是False因为此时的‘hello’是在数据list2中的
1.2 公共方法
| 函数 | 说明 |
|---|---|
| len() | 计算容器中元素个数 |
| del 或 del() | 删除 |
| max() | 返回容器中元素最⼤值 |
| min() | 返回容器中元素最⼩值 |
| range(start,end, step) | ⽣成从start到end的数字，步⻓为 step，供for循环使⽤ |
| enumerate() | 函数⽤于将⼀个可遍历的数据对象(如列表、元组或字符串)组合为⼀个索引序列，同时列出数据和数据下标，⼀般⽤在 for 循环当中。 |
示例：
len()返回的是数据中的数据的个数：
list2=['hello','world','ni','hao']
str2='hello world'
print(len(str2))#返回的是11,空格也是字符
len_num=len(list2)
print(len_num)#返回的数据个数为4
del():
list2=['hello','world','ni','hao']
del(list2)
print(list2)#报错数据为定义，因为已经是删除了，所以是无法打印该数据的NameError: name 'list2' is not defined
max()和min（）：
list_num=[10,20,30,49]
list_max=max(list_num)
print(list_max)#返回最大值49
list_min=min(list_num)
print(list_min)#返回的是最小值10
range(start,end, step) ：
for num in range(1,10,2):#初始值为1，步长为2，末尾值为10
print(num,end=" ")#输出为1 3 5 7 9 ，此时的print是用空格将输出的num进行连接，不是默认值\n(换行)
注意事项：range()⽣成的序列不包含end数字
enumerate()：
语法：enumerate(可遍历对象, start=0)
示例：
list2=[11,23,34,58,89,19]
for num in enumerate(list2):
print(num)
for indix,number in enumerate(list2):
print(f'下标为{indix}，数值为{number}')
运行结果为：
1.3容器类型转换
| 方法 | 说明 |
|---|---|
| tuple() | 作⽤：将某个序列转换成元组 |
| list() | 作⽤：将某个序列转换成列表 |
| set() | 作⽤：将某个序列转换成集合 |
示例：
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. 集合不⽀持下标
第九章函数
1.函数基础
1.1函数的作用
函数： 是将实现固定功能的代码，聚合成函数，为此在使用是直接可以是调用函数就可以实现底代码的重复调用，进而实现缩减代码的书写时间。
1.2函数的使⽤步骤
第一步是函数的定义
函数定义的语法：
def 函数名(参数):
代码1
代码2 ......
第二步是函数的调用
函数的调用语法：
函数名(参数)
-
注意事项：
- 1.不同的需求，参数可有可⽆
- 2.在Python中，函数必须先定义后使⽤
1.3 函数的参数作⽤
函数的参数的作用：使代码更加灵活，函数的实用性更强
函数的实现的功能：两个数的加法.并返回计算结果
如1+1
#示例一
#函数的定义
def add_num1():
return 1+1
#函数的调用
num1=add_num1()
print(num1)
#函数的定义
def add_num2(a,b):# 定义函数时同时定义了接收⽤户数据的参数a和b，a和b是形参
return a+b
#函数的调用
num2=add_num2(1,1)# 调⽤函数时传⼊了真实的数据1 和 1，真实数据为实参
num3=add_num2(2,3)
print(num2)
print(num3)
通过上述例子，可以知道函数add_num1（）只能是返回2，但是函数add_num2可以通过传入不同的参数值，进而计算这两个数的和，并返回该值
1.4函数的返回值作⽤
应用场景：例如：我们去购物，⽐如买‘王冰冰’，给钱之后，返回给我们‘王冰冰’，在函数中，如果需要返回结果给⽤户需要使⽤函数返回值
def buy():
return '王冰冰'
print(buy())#此时的买的是‘王冰冰’，为此函数的返回值定义的是‘王冰冰’
1.5函数的说明⽂档
注释： 定义⼀个函数后，程序员能够快速提示这个函数的作用
函数的说明⽂档： 更⽅便的查看函数的作⽤（函数的说明⽂档也叫函数的⽂档说明）
def 函数名(参数):
""" 说明⽂档的位置 """ #定义说明文档
代码 ......
help(函数名)#可以查看说明1文档的内容就是：""" 说明⽂档的位置 """中的内容
1.6函数嵌套
所谓函数嵌套调⽤指的是⼀个函数⾥⾯⼜调⽤了另外⼀个函数
示例：
def test1():
print('这是函数1执行的内容')
def test2():
test1()
print('这是函数2执行的内容')
test2()#此时是调用函数2，但是此时函数2内部是使用了函数1，此时是函数的嵌套
执行结果：
#此时函数的执行流程是先执行函数test2,再执行函数内部的test1函数
1.7函数的使用
示例1：计算三个数的平均数
def average_num(num1,num2,num3):#定义函数
sum_ret=(num1+num2+num3)/3
return sum_ret
#调用函数
ret=average_num(1,2,3)
print(ret)#2
2.函数进阶
2.1变量作⽤域函数的
变量作⽤域指的是变量⽣效的范围，主要分为两类：局部变量和全局变量
局部变量： 定义在函数体内部的变量，即只在函数体内部⽣效
全局变量： 函数体内、外都能⽣效的变量
注意事项：
1.局部变量的作⽤：在函数体内部，临时保存数据，即当函数调⽤完成后，则销毁局部变量，如果在函数外部使用该变量则会提示报错
示例1：
def test1():
a=10
print(a)
#print(a)#此时提示错误，a为函数内部定义的局部变量
test1()#20
示例2：
a=12#此时a为全局变量，所有的函数都是可以调用的
def test1():
print(a)
def test2():
print(a)
test1()#12
test2()#12
示例3：如何在函数体内部修改全局变量
a=12
def test1():
a=100#此时是在函数的内部修改a的值但是实际上为修改全局变量a的值还是为12
print(a)
def test2():
global a#函数内部修改全局变量的值先定义再修改值
a=200
print(a)
test1()#100
test2()#200
print(a)#200
2.2多函数程序执⾏流程
⼀般在实际开发过程中，⼀个程序往往由多个函数（后⾯知识中会讲解类）组成，并且多个函数共享某些数据
1.共⽤全局变量
global_num=0
def test1():
"""是修改全局变量的函数"""
global global_num
global_num=100
print(global_num)
def test2():
"""是打印全局变量的函数"""
print(global_num)
print(global_num)
help(test1)#查看函数test1的功能
test1()
help(test2)#查看函数test2的功能
test2()
2.返回值作为参数传递
def test1():
return 10
def test2(num):
print(num)
ret=test1()#函数1的返回值作为函数2的参数
test2(ret)#10
#也可以直接是使用test2(test1())
2.3函数的返回值
1.两个return的执行结果
def test1():
return 1#返回值为1
return 2#返回值为2
print(test1())#1此时的输出结果为1是因为，在返回1后，函数直接结束运行，就不在执行return 2了
2.返回两个值return a,b
def test1():
return 1 ,2
print(test1())#输出的是函数返回的值
print(type(test1()))#输出的是函数返回值的类型默认为元组
运行结果：
-
注意事项：
-
1. return a, b写法，返回多个数据的时候，默认是元组类型
-
2. return后⾯可以连接列表、元组或字典，以返回多个值
2.4函数的参数
2.4.1位置参数
位置参数： 调⽤函数时根据函数定义的参数位置来传递参数
示例：
def test1(name,age,gender):
print(f'姓名是：{name},年龄是：{age},性别是：{gender}')
test1('zhangsan',29,'男')#此时输入的实参必须和函数的形参位置是一致的，否则数据在输出时的结果是与预期的是不符合的
注意事项：传递和定义参数的顺序及个数必须是一致的
2.4.2关键字参数
函数调⽤，通过“键=值”形式加以指定。可以让函数更加清晰、容易使⽤，同时也清除了参数的顺序需求
示例：
def test1(name,age,gender):
print(f'你的名字是：{name},你的年龄是：{age}，你的性别是：{gender}')
test1(name='xiaoming',age=13,gender='男')
test1(gender='女',name='xiaofang',age=18)#此时的顺序就不重要了，只要是关键字正确就是可以的
输出的结果：
注意事项：如果有位置参数那么位置参数的位置，必须是位于关键字参数前面，但是关键字参数之间不存在顺序
2.4.3缺省参数
缺省参数也叫默认参数，⽤于定义函数，为参数提供默认值，调⽤函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调⽤）
示例：
def test1(name,age,gender='男'):此时的缺省参数为gender默认为男
print(f'你的名字是：{name},你的年龄是{age},你的性别是:{gender}')
test1(name='xiaoming',age=24)#如果不赋值则为默认值男
test1(name='xiaofang',age=18,gender='女')如果赋值则为新赋予的值
注意事项：函数在调用时，如果为缺省参数传值则修改默认参数值，否则还是使用这个默认值
2.4.4不定长参数
不定⻓参数也叫可变参数。⽤于不确定调⽤的时候会传递多少个参数(不传参也可以)的场景。此时，可⽤包裹(packing)位置参数，或者包裹关键字参数，来进⾏参数传递，会显得⾮常⽅便
示例：
#不定长参数
def test1(*args):
print(args)
test1('xiaoming',18,'男')
test1('xiaofang',18,'女',12343434)
运行结果：
注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为⼀个元组(tuple)，args是元组类型，这就是包裹位置传递
示例2：
def user_info(**kwargs):
print(kwargs)
user_info(name='xiaoming',age=18,gender='男')
运行结果：
2.5拆包和交换两个变量的值
拆包：
1.拆包：元组
示例：
def test1():
return 10,20
num1,num2=test1()
print(num1)#10
print(num2)#20
2.拆包：字典
示例：
dict1={'name':'xiaoming','age':18}
a,b=dict1#此时拆包出来的是字典的key值
print(a)
print(b)
print(dict1[a])
print(dict1(b))
交换两个变量的值
1.用第三个变量
a=10
b=20
c=a
a=b
b=c
print(a)#20
print(b)#10
2.直接交换
a,b=10,20
a,b=b,a
print(a)#20
print(b)#10
2.6引用
在python中，值是靠引⽤来传递来的。我们可以⽤id()id()来判断两个变量是否为同⼀个值的引⽤。 我们可以将id值理解为那块内存的地址标识。
示例：
a=1
b=a
print(b)#1
print(id(a))#1880759101744
print(id(b))#1880759101744
b=2
print(b)#2
print(id(b))#改变了为1880759101776
2.7可变和不可变类型
所谓可变类型与不可变类型是指：数据能够直接进⾏修改，如果能直接修改那么就是可变，否则是不可变.
可变类型
: 列表
: 字典
：集合
-
不可变类型
- 整型
- 浮点型
- 字符串
- 元组
3.学员信息管理系统
def info_print():
"""界面函数"""
print('请选择功能-----------')
print('1.添加学员')
print('2.删除学员')
print('3.修改学员')
print('4.查询学员')
print('5.显示所有的学员')
print('6.退出系统')
print('-' * 20)
info = []#存放学生信息的列表
def add_info():
"""添加学生信息函数"""
global info#因为在函数内部修改全局变量先定义再修改
new_id = input('请输入ID：')
new_name = input('请输入姓名：')
new_tel = input('请输入tel：')
#先遍历再查看学生是否存在
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)
def del_info():
"""删除学生信息的函数"""
del_name = input('请输入要删除的学生姓名：')
global info#作用同上
#遍历判断学生是否存在
for i in info:
if del_name == i['name']:
info.remove(i)
break
else:
print('该用户不存在')
print(info)
def modify_name():
"""修改学生姓名的函数"""
modify_name = input('请输入要修改的学生姓名：')
global info#作用同上
for i in info:
if modify_name == i['name']:
i['tel'] = input('输入要修改的手机号：')
break
else:
print('要修改的用户不存在')
print('info')
def search_info():
"""查询学生信息的函数"""
search_name = input('请输入需要查询的学生姓名：')
global info
for i in info:
if search_name == i['name']:
print('查询到的信息如下：')
print(f"id是{i['id']},姓名是：{i['name']},tel是：{i['tel']}")
break
else:
print('查找的学生不存在')
def all_print():
"""打印所有的学生信息函数"""
print('学号\t姓名\t电话\t')
for i in info:
print(f"学员的学号是：{i['id']},姓名是：{i['name']},电话是：{i['tel']}")
#通过循环可以重复执行该程序，直到输出指定命令是才可以退出程序的运行
while True:
info_print()
i = input('请输入（1-6）：')
if i == '1':
print('添加学员')
add_info()
elif i == '2':
print('删除学员')
del_info()
elif i == '3':
print('修改学员')
modify_name()
elif i == '4':
print('查询学员')
search_info()
elif i == '5':
print('显示所有的学员')
all_print()
elif i == '6':
print('退出系统')
exit_mess = input('请输入yes or no:')
if exit_mess == 'yes':
break
break
else:
print('输入错误，请重新输入')
4.函数提高
4.1函数递归
1）递归的特点
函数内部⾃⼰调⽤⾃⼰
必须有出口
2）示例
求一个数的前n项和如n=10求1+2+3…+10
# 3 + 2 + 1
def sum_numbers(num): # 1.如果是1，直接返回1 -- 出⼝
if num == 1:
return 1 # 2.如果不是1，重复执⾏累加并返回结果
return num + sum_numbers(num-1)#这里使用的是函数的递归
num=int(input('请输入需要求的累加和数n:'))
sum_result = sum_numbers(num)# 如果输入3输出结果为6
print(sum_result)
执行流程：
4.2 lambda 表达式
1）lambda使用的场景：如果⼀个函数有⼀个返回值，并且只有⼀句代码，可以使⽤ lambda简化
2）lambda语法：lambda 参数列表 ： 表达式
-
注意事项：
- lambda表达式的 参数可有可⽆，函数的参数在lambda表达式中完全适⽤
- lambda表达式能接收任何数量的参数但 只能返回⼀个表达式的值
示例1：
def test():
return 200
print(test())
print(test)#此时输入的是函数的地址
test1=lambda:200
print(test1)#此时输出的是lambda的地址
print(test1())
运行结果：
示例2：
#示例
#函数实现两个数的加法器
def add(num1,num2):
return num1+num2
ret=add(10,20)
print(ret)#30
#lambda实现两个数的加法
add2=lambda num1,num2:num1+num2
ret2=add2(10,20)
print(ret2)#30
4.3 lambda表达式的参数
1）无参数
2）一个参数
3）默认参数
4）可变参数*args
5）可变参数kwargs **
示例：
ret1=lambda:200
print(ret1)
#一个参数
ret2=lambda num1:num1
print(ret2(100))
#默认参数
ret3=lambda num1,num2,num3=10:num1+num2+num3
print(ret3(10,20))#此时为40，num3默认为10
print(ret3(10,20,30))#此时为60，因num3重新赋值
#可变参数*args
ret4=lambda *args:args
print(ret4(10,20,30))
#可变参数**kwargs
ret5=lambda **kwargs:kwargs
print(ret5(name='xiaoming',age=19))
运行结果：
4.4高阶函数
把函数作为参数传⼊，这样的函数称为⾼阶函数，⾼阶函数是函数式编程的体现。函数式编程就是指这种⾼度抽象的编程范式
示例：任意两个数字，按照指定要求整理数字后再进⾏求和计算
#法1
def abs_add(num1,num2):
return abs(num1)+abs(num2)
ret1=abs_add(-19,20)
print(ret1)#39
#法2，就是高阶函数的使用案例，代码更加简洁
def abs_add1(num1,num2,f):
return f(num1)+f(num2)
ret2=abs_add1(10,-10,abs)
print(ret2)#20
| 内置高阶函数 | 说明 |
|---|---|
| map() | map(func, lst)，将传⼊的函数变量func作⽤到lst变量的每个元素中，并将结果组成新的列表(Python2)/迭代器(Python3)返回 |
| reduce() | reduce(func，lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下⼀个元素做累积计算注意：reduce()传⼊的参数func必须接收2个参数 |
| filter() | filter(func, lst)函数⽤于过滤序列, 过滤掉不符合条件的元素, 返回⼀个 filter 对象。如果要转换为列表,可以使⽤ list() 来转换 |
1.map()示例
#计算列表中数据的的平方和
list1=[10,-19,20,1,2,-1]
def func(num):
return num**2
ret =map(func,list1)
print(ret)
print(list(ret))#[100, 361, 400, 1, 4, 1]
2.reduce示例
import functools
list1 = [1, 2, 3, 4, 5]
def func(a, b):
return a + b
result = functools.reduce(func, list1)
print(result) # 15
3.filter示例
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def func(x):
return x % 2 == 0
result = filter(func, list1)
print(result)
print(list(result)) # [2, 4, 6, 8, 10]
第十章文件操作
1.文件操作的作用
⽂件操作的作⽤就是把⼀些内容(数据)存储存放起来，可以让程序下⼀次执⾏的时候直接使⽤，⽽不必重新制作⼀份，省时省⼒
2.文件的基本操作
2.1文件的操作步骤
- 打开⽂件
- 读写等操作
- 关闭⽂件
注意：可以只打开和关闭⽂件，不进⾏任何读写操作
2.1.1打开文件
在python，使⽤open函数，可以打开⼀个已经存在的⽂件，或者创建⼀个新⽂件
语法：open(name, mode)
解释：
**name：**是要打开的⽬标⽂件名的字符串(可以包含⽂件所在的具体路径)。
**mode：**设置打开⽂件的模式(访问模式)：只读、写⼊、追加等
mode的分类：
| mode类型 | 说明（标黄的mode重点关注） |
|---|---|
| r | 以只读⽅式打开⽂件。⽂件的指针将会放在⽂件的开头。这是默认模式。 |
| rb | 以⼆进制格式打开⼀个⽂件⽤于只读。⽂件指针将会放在⽂件的开头。这是默认模式。 |
| r+ | 打开⼀个⽂件⽤于读写。⽂件指针将会放在⽂件的开头。 |
| rb+ | 以⼆进制格式打开⼀个⽂件⽤于读写。⽂件指针将会放在⽂件的开头。 |
| w | 打开⼀个⽂件只⽤于写⼊。如果该⽂件已存在则打开⽂件，并从开头开始编辑，即原有内容会被删除。如果该⽂件不存在，创建新⽂件。 |
| wb | 以⼆进制格式打开⼀个⽂件只⽤于写⼊。如果该⽂件已存在则打开⽂件，并从开头开始编辑，即原有内容会被删除。如果该⽂件不存在，创建新⽂件。 |
| w+ | 打开⼀个⽂件⽤于读写。如果该⽂件已存在则打开⽂件，并从开头开始编辑，即原有内容会被删除。如果该⽂件不存在，创建新⽂件。 |
| wb+ | 以⼆进制格式打开⼀个⽂件⽤于读写。如果该⽂件已存在则打开⽂件，并从开头开始编辑，即原有内容会被删除。如果该⽂件不存在，创建新⽂件。 |
| a | 打开⼀个⽂件⽤于追加。如果该⽂件已存在，⽂件指针将会放在⽂件的结尾。也就是说，新的内容将会被写⼊到已有内容之后。如果该⽂件不存在，创建新⽂件进⾏写⼊。 |
| ab | 以⼆进制格式打开⼀个⽂件⽤于追加。如果该⽂件已存在，⽂件指针将会放在⽂件的结尾。也就是说，新的内容将会被写⼊到已有内容之后。如果该⽂件不存在，创建新⽂件进⾏写⼊。 |
| a+ | 打开⼀个⽂件⽤于读写。如果该⽂件已存在，⽂件指针将会放在⽂件的结尾。⽂件打开时会是追加模式。如果该⽂件不存在，创建新⽂件⽤于读写。 |
| ab+ | 以⼆进制格式打开⼀个⽂件⽤于追加。如果该⽂件已存在，⽂件指针将会放在⽂件的结尾。如果该⽂件不存在，创建新⽂件⽤于读写 |
示例：（打开文件）
f=open('test.txt','w')#打开文件test.txt并进行读操作
#注意：此时的 f 是 open 函数的⽂件对象
示例：（文件的写操作）
语法：对象.write('内容‘）
f=open('test.txt','w')
#打开文件
f.write('hello wrld')
#对文件执行写操作
f.close
#关闭文件，这一步是必不可少的
注意事项：
1. w 和 a 模式：如果⽂件不存在则创建该⽂件；如果⽂件存在， w 模式先清空再写⼊， a 模式直接末尾追加。
2. r 模式：如果⽂件不存在则报错
示例：（read文件的读操作）
语法：⽂件对象.read(num)
f=open('test.txt')
con=f.read()
print(con)
f.close#此时必须加这个关闭文件的命令
注意事项： num表示要从⽂件中读取的数据的⻓度（单位是字节），如果没有传⼊num，那么就表示读取⽂件中所有的数据
示例：（readlines()解释：readlines可以按照⾏的⽅式把整个⽂件中的内容进⾏⼀次性读取，并且返回的是⼀个列表，其中每⼀⾏
的数据为⼀个元素）
f = open('test.txt')
content = f.readlines()
print(content)#此时返回的是一个列表，一个数据为文件中的一行数据
# 关闭⽂件
f.close()
示例：（readline()一次读取一行数据）
f=open('test.txt')
first_line=f.readline()
print(f'第一行数据是：{first_line}')
second_line=f.readline()
print(f'第二行的数据是：{second_line}')
f.close#关闭文件
示例：（seek用来移动文件的指针）
语法；⽂件对象.seek(偏移量, 起始位置)
起始位置：
0：⽂件开头
1：当前位置
2：⽂件结尾
3.文件备份
1.实现的功能
⽤户输⼊当前⽬录下任意⽂件名，程序完成对该⽂件的备份功能(备份⽂件名为xx[备份]后缀，例如：test[备份].txt)
2.实现的步骤
1. 接收⽤户输⼊的⽂件名
2. 规划备份⽂件名
3. 备份⽂件写⼊数据
3.代码的实现
# 1. 接收⽤户输⼊的⽂件名
file_name=input('请输入需要备份的文件名：')#输入test.txt
# 2. 规划备份⽂件名test[备份].txt
#2.1 提取⽬标⽂件后缀
index = file_name.rfind('.')#找到文件名中.的下标位置
#2.2 组织备份的⽂件名，xx[备份]后缀
print(index) # 后缀中.的下标
print(file_name[:index]) # 源⽂件名（⽆后缀）test
print(file_name[index:])#.txt
copy_filename=file_name[:index]+'[备份]'+file_name[index:]
print(copy_filename)
# 3. 备份⽂件写⼊数据
# 3.1 打开源⽂件 和 备份⽂件
file=open(file_name,'rb')
new_file=open(copy_filename,'wb')
# 3.2 将源⽂件数据写⼊备份⽂件
while True:
con=file.read()
if len(con)==0:
break
new_file.write(con)
# 3.3 关闭⽂件
file.close
new_file.close
如果输入的文件是.txt是不合格的文件名（file_name），此时是需要提前判断文件名是否符合要求
修改后的程序为：
while True:
# 1. 接收⽤户输⼊的⽂件名
file_name=input('请输入需要备份的文件名：')#输入test.txt
# 2. 规划备份⽂件名test[备份].txt
#2.1 提取⽬标⽂件后缀
index = file_name.rfind('.')#找到文件名中.的下标位置
if index>0:
#2.2 组织备份的⽂件名，xx[备份]后缀
# print(index) # 后缀中.的下标
# print(file_name[:index]) # 源⽂件名（⽆后缀）test
# print(file_name[index:])#.txt
copy_filename=file_name[:index]+'[备份]'+file_name[index:]
print(copy_filename)
# 3. 备份⽂件写⼊数据
# 3.1 打开源⽂件 和 备份⽂件
file=open(file_name,'rb')
new_file=open(copy_filename,'wb')
# 3.2 将源⽂件数据写⼊备份⽂件
while True:
con=file.read()
if len(con)==0:
break
new_file.write(con)
# 3.3 关闭⽂件
file.close
new_file.close
break
else:
print(f'你输入的文件名为：{file_name},不符合要求')
4.文件和文件夹操作
在Python中⽂件和⽂件夹的操作要借助os模块⾥⾯的相关功能，具体步骤如下：
1导入os模块（import os）
2.使用os模块里的函数(os.函数名（）)
1）文件重命名
os.rename(⽬标⽂件名, 新⽂件名)
2）删除文件
os.remove(⽬标⽂件名)
3）创建文件夹
os.mkdir(⽂件夹名字)
4）删除文件夹
os.rmdir(⽂件夹名字)
5）获取当前目录
os.getcwd()
6）改变默认目录
os.chdir(⽬录)
7）获取目录列表
os.listdir(⽬录)
示例：
实现的功能：
需求：批量修改⽂件名，既可添加指定字符串，⼜能删除指定字符串。
步骤
- 设置添加删除字符串的的标识
- 获取指定⽬录的所有⽂件
- 将原有⽂件名添加/删除指定字符串，构造新名字
- 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)
修改后的程序更加方便；
import os
# 设置重命名标识：如果为1则添加指定字符，flag取值为2则删除指定字符
flag =int(input('请输入你想要执行的操作1为添加字符2为删除字符：'))
# 获取指定⽬录
dir_name = './'
# 获取指定⽬录的⽂件列表
file_list = os.listdir(dir_name)
print(file_list)
# 遍历⽂件列表内的⽂件
file_name=input('请输入需要修改的文件名：')
for name in file_list:
# 添加指定字符
if name==file_name:
str_new=input('请输入需要添加的字符：')
if flag == 1:
new_name = str_new + name
# 删除指定字符
elif flag == 2:
num = len(str_new)
new_name = name[num:]
else:
print('你输入的文件名不存在')
# 打印新⽂件名，测试程序正确性
print(new_name)
# 重命名
os.rename(dir_name+name, dir_name+new_name)
第十一章面向对象（基础）
1.什么是面向对象
⾯向对象就是将编程当成是⼀个事物，对外界来说，事物是直接使⽤的，不⽤去管他内部的情况。⽽编程就是设置事物能够做什么事
面向对象的思想简化了过程，在使用时可以更加方便直观
2.类和对象
在⾯向对象编程过程中，有两个重要组成部分：类 和 对象
类和对象的关系：⽤类去创建⼀个对象
2.1理解什么是类和对象
2.1.1什么是类
**类是对⼀系列具有相同特征和⾏为的事物的统称，是⼀个抽象的概念，不是真实存在的事物。*
2.1.2什么是对象
对象是类创建出来的真实存在的事物
注意：开发中，先有类，再有对象(例如在动物这个类里面有许多的)
2.2面向对象的实现方法
2.2.1定义类
语法：
class 类名():
代码 ......
示例：
class wahser():
def wash(self):
print('洗衣服')
2.2.2定义对象（实例）
语法：对象名=类名（）
示例：
class Wahser():
def wash(self):
print('洗衣服')
haier=Wahser()#创建对象haier（没给广告费）
print(haier)
haier.wash()
运行结果：
2.2.3self（调用该函数的对象）
示例：
class Wahser():
def wash(self):
print(self)
print(Wahser())#<__main__.Wahser object at 0x00000230D8521E20>
haier1=Wahser()#第一个对象
haier1.wash()#<__main__.Wahser object at 0x00000230D8521E20>
此时的print(self)和print（Washer）的结果是一样的
注意：打印对象和self得到的结果是⼀致的，都是当前对象的内存中存储地址
3.添加和获取对象属性
3.1 类外⾯添加对象属性
1）语法：对象名.属性名 = 值
2）示例：
haier1.width=1000
haier1.height=20
3.2 类外⾯获取对象属性
示例：
class Wahser():
def wash(self):
print(self)
haier1=Wahser()#第一个对象
haier1.width=1000
haier1.height=20
print(f'洗衣机的宽度是{haier1.width},高度是{haier1.height}')
运行结果:
3.3 类⾥⾯获取对象属性
示例：
class Wahser():
def wash(self):
print(f'haire1的宽度是{haier1.width},haier1的高度是{haier1.height}')#此时是在类里面获取对象属性
print('上面的是函数内的执行')
haier1=Wahser()#第一个对象
haier1.width=1000
haier1.height=20
haier1.wash()
print(f'洗衣机的宽度是{haier1.width},高度是{haier1.height}')
4.魔法方法
在Python中，xx()的函数叫做魔法⽅法，指的是具有特殊功能的函数
4.1__init__()
示例：
class Washer():
def __init__(self) -> None:
self.height=1000
self.width=10
def wash(self):
print(f'宽度是：{self.width},高度是{self.height}')
haier1=Washer()
print(haier1.height)
print(haier1.width)
haier1.wash()
运行结果：
-
注意事项：
-
init()⽅法，在创建⼀个对象时默认被调⽤，不需要⼿动调⽤
init(self)中的self参数，不需要开发者传递，python解释器会⾃动把当前的对象引⽤传递过去
4.2 带参数的__init__()
应用场景：⼀个类可以创建多个对象，如何对不同的对象设置不同的初始化属性？——传参数
class Washer():
# 定义初始化功能的函数
def __init__(self,height,width) -> None:#此时的初始化函数，带参数height和width
self.height=height
self.width=width
def wash(self):
print(f'宽度是：{self.width},高度是{self.height}')
haier1=Washer(100,20)#传入参数100和20
print(haier1.height)
print(haier1.width)
haier1.wash()
运行结果：
4.3 str()
当使⽤print输出对象的时候，默认打印对象的内存地址。如果类定义了__str__⽅法，那么就会打印从在这个⽅法中 return 的数据
示例：
class Washer():
# 定义初始化功能的带参数的函数
def __init__(self,height,width) -> None:#此时的初始化函数，带参数height和width
self.height=height
self.width=width
def __str__(self) -> str:
return '这是haier洗衣机'
def wash(self):
print(f'宽度是：{self.width},高度是{self.height}')
haier1=Washer(10,29)
print(haier1)
运行结果：
4.4__del__()（当执行del时会调用的代码）
当删除对象时，python解释器也会默认调⽤__del__()⽅法
示例：
class Washer():
# 定义初始化功能的带参数的函数
def __init__(self,height,width) -> None:#此时的初始化函数，带参数height和width
self.height=height
self.width=width
def __str__(self) -> str:
return '这是haier洗衣机'
def wash(self):
print(f'宽度是：{self.width},高度是{self.height}')
#删除对象执行的代码
def __del__(self):
print('当删除对象时执行的代码')
haier=Washer(10,200)
del haier
5.面向对象实例
1）实例1
class Sweetpotato():
def __init__(self):
"""初始化实例对象的属性"""
self.cooktime=0
self.cook_static='生的'
self.add=[]
def cook_time(self,time):
"""制作的时间，以及随着时间变化食物的状态"""
self.cooktime+=time
if self.cooktime<=3:
self.cook_static='生的'
elif 3<self.cooktime<=6:
self.cook_static='半生不熟'
elif 6<self.cooktime<=9:
self.cook_static='熟了'
else:
self.cook_static='烤焦了'
def add_food(self,food):
"""添加食物"""
self.add.append(food)
def __str__(self):
"""定义str属性，返回此时sweetpotato的制作状态print(对象名）"""
return f'此时的sweetpotato的制作时间是{self.cooktime},烤制的状态是{self.cook_static}。烤制添加的食物是{self.add}'
sweetpotato1=Sweetpotato()
print(sweetpotato1)
sweetpotato1.cook_time(5)#添加烤制时间
sweetpotato1.add_food('lajiao')#添加食物
print(sweetpotato1)
#注意事项:变量名和函数名不要使用时搞错了
运行结果：
2）实例2
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.free_area-=item.area
self.furniture.append(item.name)
else:
print('空间不足')
bed=Furniture('双人床',10)
home1=Home('北京',1000)
print(home1)
home1.add_furniture(bed)
print(home1)
sofa=Furniture('沙发',6)
home1.add_furniture(sofa)
print(home1)
playgrond=Furniture('操场',2000)
home1.add_furniture(playgrond)
print(home1)
第十二章面向对象（进阶）
1.继承的概念
生活中的继承：子辈继承父类的财产
python中的继承关系：Python⾯向对象的继承指的是多个类之间的所属关系，即⼦类默认继承⽗类的所有属性和⽅法
**注意事项：**在Python中，所有类默认继承object类，object类是顶级类或基类；其他⼦类叫做派⽣类
class Wash():#此时默认是继承object类，所以加不加object都是可以的
def __init__(self,width,height):
"""定义固有属性"""
self.width=width
self.height=height
def print_info(self):
"""打印固有属性值"""
print(f'宽度是：{self.width},高度是：{self.height}')
class Haier(Wash):#haier类继承了wash类，此时就是继承关系
def __str__(self):
return f'这是海尔类洗衣机，继承了洗衣机类'
haier1=Haier(100,2000)
print(haier1)
haier1.print_info()
运行结果：
2.单继承
就是在继承的时候，子类将完全继承父类的方法
示例：
class Fu():
def __init__(self):
self.house='big house'
self.money=100000
def print_info(self):
print(f'Fu类的继承给子类的房子为：{self.house},继承给子类的钱为：{self.money}')
class Zi(Fu):#子类继承父类
def __str__(self) -> str:
return '子类Zi继承父类Fu'
zi=Zi()
print(zi)
zi.print_info()
运行结果：
3.多继承
所谓多继承意思就是⼀个类同时继承了多个⽗类
示例：
class Fu1():
def __init__(self):
self.house='big house'
self.money=100000
def print_info(self):
print(f'Fu1类的继承给子类的房子为：{self.house},继承给子类的钱为：{self.money}')
class Fu2():
def __init__(self):
self.house='small house'
self.money=-100000
def print_info(self):
print(f'Fu2类的继承给子类的房子为：{self.house},继承给子类的钱为：{self.money}')
class Zi(Fu1,Fu2):#子类继承父类
def __str__(self) -> str:
return '子类Zi继承父类Fu'
zi=Zi()
print(zi)
zi.print_info()#此时默认继承的是Fu1的方法，即有1多个父类的同名属性和方法优先是使用第一个方法和属性
运行结果：
注意事项：
当⼀个类有多个⽗类的时候，默认使⽤第⼀个⽗类的同名属性和⽅法
4.⼦类重写⽗类同名⽅法和属性
当子类中的属性和方法和父类的属性和方法是相同的，此时优先是使用子类的方法和属性
示例：
class Fu1():
def __init__(self):
self.house = 'big house'
self.money = 100000
def print_info(self):
print(f'Fu1类的继承给子类的房子为：{self.house},继承给子类的钱为：{self.money}')
def print_demo(self):
print('这是父类1的方法')
class Fu2():
def __init__(self):
self.house = 'small house'
self.money = -100000
def print_info(self):
print(f'Fu2类的继承给子类的房子为：{self.house},继承给子类的钱为：{self.money}')
def print_demo(self):
print('这是父类2的方法')
class Zi(Fu1, Fu2): # 子类继承父类
# 定义与父类fu1或者fu2相同的方法和属性
def __init__(self):
self.money = 50000
self.house='big big house'
def print_info(self):
print(f'Zi类的房子为：{self.house},子类的钱为：{self.money}') # 此时的房子是继承父类1的此时，钱数自己定义的
def print_demo(self):
print('这是子类的方法')
def __str__(self):
return '子类Zi继承父类Fu'
zi = Zi()
print(zi)
zi.print_info()#Zi类的房子为：big big house,子类的钱为：5000
#此时在子类的属性和父类是相同时，优先使用的是子类的属性，子类的方法在使用时也是优先使用的
zi.print_demo()
5.⼦类调⽤⽗类的同名⽅法和属性
当子类的方法和父类是一样的，在使用时是优先使用子类的方法和属性的，如果需要在使用时调用父类的方法和属性
示例：
class Fu1():
def __init__(self):
self.house = 'big house'
self.money = 100000
def print_info(self):
print(f'Fu1类的继承给子类的房子为：{self.house},继承给子类的钱为：{self.money}')
def print_demo(self):
print('这是父类1的方法')
class Fu2():
def __init__(self):
self.house = 'small house'
self.money = -100000
def print_info(self):
print(f'Fu2类的继承给子类的房子为：{self.house},继承给子类的钱为：{self.money}')
def print_demo(self):
print('这是父类2的方法')
class Zi(Fu1, Fu2): # 子类继承父类
# 定义与父类fu1或者fu2相同的方法和属性
def __init__(self):
self.money = 50000
self.house='big big house'
def print_info(self):
self.__init__()#此时是不需要添加self的，因为此时只是在自己的方法执行前，先执行def ——init———，
#此时的作用是，在执行父类的方法，之后此时会默认还是使用该父类的属性
print(f'Zi类的房子为：{self.house},子类的钱为：{self.money}') # 此时的房子是继承父类1的此时，钱数自己定义的
def print_demo(self):
print('这是子类的方法')
def Fu1_print_info(self):
#定义函数调用父类fu1同名方法
Fu1.__init__(self)#此时需要添加self,为了在使用时调用的是fu1的属性必须在使用前先初始化
Fu1.print_info(self)
def Fu2_print_info(self):
Fu2.__init__(self)#此时需要添加self,为了在使用时调用的是fu1的属性必须在使用前先初始化
Fu2.print_info(self)
def __str__(self):
return '子类Zi继承父类Fu'
zi = Zi()
print(zi)
zi.Fu1_print_info()#调用fu1的print_info函数
zi.Fu1_print_info()#调用fu2的print_info函数
zi.print_info()
zi.print_demo()
运行结果：
6.多层继承
简单点理解就是，爷爷传给父亲，父亲再传给自己
示例：
class Fu1():#爷爷1
def __init__(self):
self.house = 'big house'
self.money = 100000
def print_info(self):
print(f'Fu1类的继承给子类的房子为：{self.house},继承给子类的钱为：{self.money}')
def print_demo(self):
print('这是父类1的方法')
class Fu2():#爷爷2
def __init__(self):
self.house = 'small house'
self.money = -100000
def print_info(self):
print(f'Fu2类的继承给子类的房子为：{self.house},继承给子类的钱为：{self.money}')
def print_demo(self):
print('这是父类2的方法')
class Zi(Fu1, Fu2): # 子类继承父类（父亲）
# 定义与父类fu1或者fu2相同的方法和属性
def __init__(self):
self.money = 50000
self.house='big big house'
def print_info(self):
self.__init__()#此时是不需要添加self的，因为此时只是在自己的方法执行前，先执行def ——init———，
#此时的作用是，在执行父类的方法，之后此时会默认还是使用该父类的属性
print(f'Zi类的房子为：{self.house},子类的钱为：{self.money}') # 此时的房子是继承父类1的此时，钱数自己定义的
def print_demo(self):
print('这是子类的方法')
def Fu1_print_info(self):
#定义函数调用父类fu1同名方法
Fu1.__init__(self)#此时需要添加self,为了在使用时调用的是fu1的属性必须在使用前先初始化
Fu1.print_info(self)
def Fu2_print_info(self):
Fu2.__init__(self)#此时需要添加self,为了在使用时调用的是fu1的属性必须在使用前先初始化
Fu2.print_info(self)
def __str__(self):
return '子类Zi继承父类Fu'
class Ziji(Zi):#此时是直接继承父亲，那么父亲的方法都是可以直接使用的
pass
ziji = Ziji()#创建自己
print(ziji)#调用父类的方法
ziji.Fu1_print_info()
ziji.Fu1_print_info()
ziji.print_info()
ziji.print_demo()
运行结果：
7.super()调⽤⽗类⽅法
注意：使⽤super() 可以⾃动查找⽗类。调⽤顺序遵循 mro 类属性的顺序。⽐较适合单继承使⽤
示例：
class Fu1(object):
def __init__(self):
self.way='这是Fu1的属性'
def print_info(self):
print(f'{self.way}')
class Fu1_next(Fu1):
def __init__(self):
self.way='这是Fu1_next的属性'
def print_info(self):
#print(f'{self.way}')
#此时子类需要直接调用父类方法
# super(Fu1,self).__init__()
# super(Fu1, self).print_info()
super().__init__()
super().print_info()
class Fu1_next_next(Fu1_next):
def __init__(self):
self.way='这是Fu1_next_next的属性'
def print_info(self):
# print(f'{self.way}')
super().__init__()
super().print_info()
#创建子类
Fu1_next1=Fu1_next()
Fu1_next1.print_info()
Fu1_next_next1=Fu1_next_next()
Fu1_next_next1.print_info()
注意事项：
1.使⽤super() 可以⾃动查找⽗类。调⽤顺序遵循 mro 类属性的顺序。⽐适合单继承使⽤
2.使用super（）只能是调用上一级，而另一级还是需要继续调用super
8.私有权限
8.1定义私有属性和⽅法
在Python中，可以为实例属性和⽅法设置私有权限，即设置某个实例属性或实例⽅法不继承给⼦类
设置私有权限的⽅法：在属性名和⽅法名 前⾯ 加上两个下划线 _ _
注意事项：
私有属性和私有⽅法只能在类⾥⾯访问和修改
8.2 获取和修改私有属性值
== 在Python中，⼀般定义函数名get_xx⽤来获取私有属性，定义set_xx⽤来修改私有属性值==
示例：
class Fu():
def __init__(self,money,house):
self.money=money
self.__house=house#此时的房子为私有属性，是没办法继承的，为此在子类继续使用是会提示错误，方法也是一样的
def __print_info(self):
print(f'可继承的财产为{self.money}和{self.__house}')
#定义获取私有属性和修改私有属性
def get_house(self):#获取私有属性的值并返回该值
return self.__house
def set_house(self,new_house):#修改私有属性值为new_house
self.__house=new_house
class Zi(Fu):
pass
zi1=Zi(5000,'BIG HOUSE')
print(zi1.money)#5000
#print(zi1.__house)#AttributeError: 'Zi' object has no attribute '__house'
print(zi1.get_house())
zi1.set_house('large house')#调用修改的方法修改私有属性值__house为large house
print(zi1.get_house())
运行结果：
第十三章面向对象（总结）
1.面向对象的三大特征
封装
将属性和⽅法书写到类的⾥⾯的操作即为封装
封装可以为属性和⽅法添加私有权限
继承
⼦类默认继承⽗类的所有属性和⽅法
⼦类可以重写⽗类属性和⽅法
多态
多态传⼊不同的对象，产⽣不同的结果
2.多态
多态指的是一种使用对象的方式，子类重写父类方法，为此，在调用不同的子类对象的相同方法，可以产生不同的结果 （这样就实现了代码的多样性以及缩减重复代码的书写量）
优点： 调用更加灵活，有了多更加容易写出通用的代码，更加通用的编程可以适应需求的不断变化
示例：
class Dog(object):#此时定义的是一个大类：狗类
def work(self):
print('指哪打哪。。。。')
class ArmyDog(Dog):#此时定义的是一个类为战斗犬类
def work(self):
print('追击敌人')
class DrugDog(Dog):#此时定义的一个类为缉毒犬类
def work(self):
print('追缉毒品')
class Police(object):#此时定义的类为警察类
def work_with_dog(self,dog):#此时定义的方法是，警察和狗的协作
dog.work()
dog_drug=DrugDog()
dog_army=ArmyDog()
police1=Police()
police1.work_with_dog(dog_drug)
police1.work_with_dog(dog_army)
运行结果：
多态的实现过程：
1）定义父类
2）定义子类对象，继承父类的方法，并重写父类的方法
3）传递子类对象给调用者，此时可以看到不同的子类可以实现不同的执行效果
示例：
3.类属性和实例属性
3 .1类属性
类属性就是 类对象 所拥有的属性，它被 该类的所有实例对象 所共有
类属性可以使⽤ 类对象 或 实例对象 访问
示例：
class ArmyDog(object):#此时定义的是一个类为战斗犬类
func='攻击敌人'#此时定义的是类属性，此时可以使用类直接访问还可以是直接使用对象去访问
def work(self):
print('帮助警察追击敌人')
print(ArmyDog.func)#用类访问，输出为：攻击敌人
armydog1=ArmyDog()
print(armydog1.func)#用对象去访问,输出为：攻击敌人
注意事项：
类属性的优点记录的某项数据 始终保持⼀致时，则定义类属性。
实例属性 要求 每个对象 为其 单独开辟⼀份内存空间 来记录数据，⽽ 类属性 为全类所共有，仅占⽤⼀份内存，更加节省内存空间
3.1.1设置和访问类属性
类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了⼀个实例属性
示例：
class ArmyDog(object):#此时定义的是一个类为战斗犬类
func='攻击敌人'#此时定义的是类属性，此时可以使用类直接访问还可以是直接使用对象去访问
def work(self):
print('帮助警察追击敌人')
print(ArmyDog.func)#用类访问，输出为：攻击敌人
armydog1=ArmyDog()
armydog2=ArmyDog()
print(armydog1.func)#用对象去访问输出为：攻击敌人
print(armydog2.func)#用对象去访问输出为：攻击敌人
3.1.2修改类属性
class ArmyDog(object):#此时定义的是一个类为战斗犬类
func='攻击敌人'#此时定义的是类属性，此时可以使用类直接访问还可以是直接使用对象去访问
def work(self):
print('帮助警察追击敌人')
print(ArmyDog.func)#用类访问，输出为：攻击敌人
armydog1=ArmyDog()
armydog2=ArmyDog()
print(armydog1.func)#用对象去访问输出为：攻击敌人
print(armydog2.func)#用对象去访问输出为：攻击敌人
#如果是需要修改类属性，只能是使用类访问并修改类属性，此时对象去修改类属性只是添加了一个实例属性，没有改变类属性的值
ArmyDog.func='搜查毒品'
print(armydog1.func)#用对象去访问输出为：搜查毒品
print(armydog2.func)#用对象去访问输出为：搜查毒品
armydog2.func='这是用实例对象去修改'
print(armydog2.func)#此时修改相当于是创建了新的实例对象输出为：这是实例对象去修改
print(armydog1.func)#此时修改并为改变类里面的属性，只是在实例对象armydog2中的修改的输出为：搜查毒品
3.2实例属性
class Dog(object):
def __init__(self):
self.name='金毛'
def print_info(self):
print(f'这只狗的名字是{self.name}')
dog1=Dog()
print(dog1.name)#金毛
#print(Dog.name)实例对象不能通过类访问
注意事项：实例属性，是定义在__Init__中的属性，是不可以用类进行访问的，只能是用实例对象进行访问
4.类方法和静态方法
4.1类方法
4.1.1类方法的特点
需要⽤装饰器@classmethod来标识其为类⽅法，对于类⽅法，第⼀个参数必须是类对象，⼀般以cls作为第⼀个参数
4.1.2类方法的使用场景
使用场景：当方法中需要使用类对象（如访问私有属性）时，定义类方法
类方法一般和类属性配合使用
4.2静态方法
示例：
class Dog(object):
__name='金毛'
@classmethod
def get_name(cls):
return cls.__name
@classmethod
def set_name(cls,name):
cls.__name=name
dog1=Dog()
print(dog1.get_name())#金毛
dog1.set_name('二哈')
print(dog1.get_name())#二哈
4.2.1静态方法的特点
需要通过装饰器@staticmethod来进⾏修饰，静态⽅法既不需要传递类对象也不需要传递实例对象（形参没有self/cls）。静态⽅法 也能够通过 实例对象 和 类对象 去访问
4.2.2静态方法的使用场景
当⽅法中 既不需要使⽤实例对象(如实例对象，实例属性)，也不需要使⽤类对象 (如类属性、类⽅法、创建实例等)时，定义静态⽅法取消不需要的参数传递，有利于 减少不必要的内存占⽤和性能消耗
示例：
class Dog(object):
__name='金毛'
@classmethod#这是类方法
def get_name(cls):
return cls.__name
@classmethod#这是类方法
def set_name(cls,name):
cls.__name=name
@staticmethod #只是静态方法，没有参数（类属性和实例属性时）
def print_func():
print('这是一个狗类')
dog1=Dog()
dog1.print_func()#输出为：这是一个狗类
第十四章异常、模块、包
1.异常
1.1什么是异常
异常：通俗点理解就是运行错误,当检查到错误之后，就是去就没有办法执行，此时就会出现一些错误（语法错误），至于程序的逻辑错误是需要调试才能查找的，解释器只能检查语法错误
示例：
num1=50
print(num2)#NameError: name 'num2' is not defined此时解释器提示num2未定义
1.2异常的写法
1.2.1异常的语法
示例：
num1=50
try:
print(num2)
except:
print('执行错误')
print(num1)
此时程序在执行时：
判断try下的语句是否是正确的，如果可以执行就直接执行，如果此时是错误的那么就会执行except语句，此时程序不会提示错误，可以继续执行下去
1.2.2捕获指定异常
语法：
try:
可能发⽣错误的代码
except 异常类型:
如果捕获到该异常类型执⾏的代码
示例：
#捕获指定异常
num1=50
try:
print(num2)
except NameError:#判断上述的错误是否为name error，如果是执行下面的代码
print('此时的错误是NameError')
print(num1)
运行结果;
注意事项：
1. 如果尝试执⾏的代码的异常类型和要捕获的异常类型不⼀致，则⽆法捕获异常
== 2. ⼀般try下⽅只放⼀⾏尝试执⾏的代码 ==
1.2.3捕获多个指定异常
捕获多个异常时可以把要捕获的异常类型的名字，放到except 后，并使⽤元组的⽅式进⾏书写
示例1：捕获对个异常
try:
print(1/0)
except (NameError,ZeroDivisionError):
print('执行上述语句print(1/0)有错误')
1.2.4捕获异常描述信息
示例1：捕获异常描述信息
try:
print(1/0)
except (NameError,ZeroDivisionError) as ret:
print(ret)#输出结果为：division by zero
1.2.5捕获所有异常
Exception是所有程序异常类的⽗类，随意在使用是用Exceotion接收所有的异常
示例
num1=1
try:
print(num2/0)#此时有两个错误，在捕捉是只捕捉优先的一个
except Exception as ret:
print(ret)#输出结果为：name 'num2' is not defined
1.3异常的else
else表示的是如果没有异常要执⾏的代码
示例：
num1=1
try:
print(num1/2)
except Exception as ret:
print(ret)#输出结果为：division by zero
else:
print('此时未捕捉到错误')
此时的运行结果为，此时未捕捉到错误，因为此时的except为执行，所以在执行else后的语句
1.4异常的finally
finally表示的是⽆论是否异常都要执⾏的代码，例如关闭⽂件等
示例：
num1=1
try:
print(num1/2)
except Exception as ret:
print(ret)#输出结果为：division by zero
else:
print('此时未捕捉到错误')
finally:
print('程序执行结束')
运行结果：
1.5异常传递
示例：
import time
try:
f=open('test.txt')
try:
while True:
con=f.readline()
if len(con)==0:
break
time.sleep(2)
print(con)
except:
print('意外终止程序读取')
finally:
f.close()
print('关闭文件')
except:
print('文件不存在')
1.6自定义异常
在Python中，抛出⾃定义异常的语法为raise 异常类对象
示例：密码⻓度不⾜，则报异常（⽤户输⼊密码，如果输⼊的⻓度不⾜3位，则报错，即抛出⾃定义异常，并捕获该异常）
示例：
class Short_Input_Erroe(Exception):
def __init__(self,len,min_len):
self.len=len
self.min_len=min_len
def __str__(self):
return f'你输入的密码的长度是{self.len},最短的密码长度为{self.min_len}'
def main():
try:
con=input('请输入密码；')
if len(con)<3:
raise Short_Input_Erroe(len(con),3)
except Exception as ret:
print(ret)
else:
print('密码符合长度要求')
main()#调用函数
运行结果：
2.模块
Python 模块(Module)，是⼀个 Python ⽂件，以 .py 结尾，包含了 Python 对象定义和Python语句
模块能定义函数，类和变量，模块⾥也能包含可执⾏的代码
2.1导入模块
2.1.1导入模块的方式
- import 模块名
- from 模块名 import 功能名
- from 模块名 import *
- import 模块名 as 别名
- from 模块名 import 功能名 as 别名
1.import 模块名
语法：import 模块名1，模块名2
使用模块：模块名1.功能名（）
示例：
import math#导入模块
print(math.sqrt(9))#调用模块的功能，输出为3.0
2.from 模块名 import 功能名
此时的含义是直接从模块中调用具体的功能，在使用是直接使用sqrt,而且是没法使用模块下别的函数
语法：from 模块名 import 功能名1，功能名2
示例：
from math import sqrt#此时的意思是直接从模块中调用功能sqrt，此时可以直接使用功能
print(sqrt(9))#输出为：3.0
**3.from 模块名 import ***
此时是导入模块下的所有的功能，此时可以直接使用所有的功能
示例：
from math import*
import math
print(sqrt(9))#此时直接使用开根号函数sqrt，输出为3.0
print(sin(pi/2))#此时直接使用sin函数，输出为1
4.import 模块名 as 别名
此时的含义是将模块名重命名为ma，使用的方法还是和math是一样的
示例：
import math as ma#此时的含义是将模块math重新命名为ma
print(ma.sqrt(9))#此时的使用方法和import math是一样的，只是将math改为ma，输出为3.0
5.from 模块名 import 功能名 as 别名
此时的作用是将导入模块中的功能名重新命名为别名，在使用是可以直接是使用自己命名的别名使用该功能
示例：
from math import sqrt as jueduizhi#此时是将math中的sqrt功能命名为jueduizhi，在重命名时，推荐使用英文
print(jueduizhi(9))#输出为3.0，使用的方法是和sqrt是一样的
2.2制作模块
在Python中，每个Python⽂件都可以作为⼀个模块，模块的名字就是⽂件的名字。也就是说⾃定义模块名必须要符合标识符命名规则
2.2.1 定义模块
**示例：**新建⼀个Python⽂件，命名为my_add.py，并定义testA函数，实现两个数的加法
2.2.2 测试模块（判断模块是否实现了需要实现的功能）
在实际开中，当⼀个开发⼈员编写完⼀个模块后，为了让模块能够在项⽬中达到想要的效果，这个开发⼈员会⾃⾏在py⽂件中添加⼀些测试信息.
例如，在my_add.py⽂件中添加测试代码：
def add(num1,num2):
return num1+num2
#测试自己的add函数是否是实现了想要实现的功能
add1=add(50,40)
print(add1)#90
注意事项：此时的代码：
add1=add(50,40)
print(add1)#90
在调用该模块时也会执行，而现实中不需要其执行，解决的办法就是定义一个方法，在该模块内执行该文件时，才会执行该代码，而在调用该模块时不执行该代码
改进：
def add(num1,num2):
return num1+num2
#测试自己的add函数是否是实现了想要实现的功能
#定义代码只在执行该文件时执行测试代码，而在调用时不执行该代码
if __name__=='__main__':
add1=add(50,40)
print(add1)#90
2.2.3调用模块
示例：
import my_add
ret=my_add.add(10,20)
print(ret)#30
执行结果为：
注意事项：
如果使⽤from … import …或from … import *导⼊多个模块的时候，且模块内有同名功能。当调⽤这个同名功能的时候，调⽤到的是后⾯导⼊的模块的功能（即最近调用的）
# 模块1代码
def my_add(a, b):
print(a + b)
# 模块2代码
def my_add(a, b):
print(a - b)
# 导⼊模块和调⽤功能代码
from my_add1 import my_add
from my_add2 import my_add
# my_add函数是模块2中的函数
my_add(1, 1)#执行的结果是0
2.2.4模块的搜素顺序
当导⼊⼀个模块，Python解析器对模块位置的搜索顺序是：
- 当前⽬录
- 如果不在当前⽬录，Python则搜索在shell变量PYTHONPATH下的每个⽬录
- 如果都找不到，Python会察看默认路径。UNIX下，默认路径⼀般为/usr/local/lib/python/模块搜索路径存储在system模块的sys.path变量中。变量⾥包含当前⽬录，PYTHONPATH和由安装过程决定的默认⽬录
注意事项：
1.== ⾃⼰的⽂件名不要和已有模块名重复，否则导致模块功能⽆法使⽤==
2. 使⽤from 模块名 import 功能的时候，如果功能名字重复，调⽤到的是最后定义或导⼊的功能。
示例：
#定义模块中的功能
__all__=['subtra']#此时的含义是，只有在列表中的功能才可以导入该功能本次为subtra可以使用，使用add时则报错
def add(num1,num2):
return num1+num2
def subtra(num1,num2):
return num1-num2
#测试自己的add函数是否是实现了想要实现的功能
#定义代码只在执行该文件时执行测试代码，而在调用时不执行该代码
if __name__=='__main__':
add1=add(50,40)
print(add1)#90
sub=subtra(20,10)
print(sub)#10
#导入模块中的功能，并使用
from my_add import*
print(subtra(20,10))#计算20-10=10
#print(add(20,10))提示：NameError: name 'add' is not defined
3.包
**什么是包：**包将有联系的模块组织在⼀起，即放到同⼀个⽂件夹下，并且在这个⽂件夹创建⼀个名字为__init__.py ⽂件，那么这个⽂件夹就称之为包
3.1制作包
[New] — [Python Package] — 输⼊包名 — [OK] — 新建功能模块(有联系的模块)
注意事项：
新建包后，包内部会⾃动创建__init__.py⽂件，这个⽂件控制着包的导⼊⾏为
3.2导入包
语法：
#法1
import 包名.模块名
使用方法：包名.模块名.⽬标
#法2
from 包名 import *
使用方法：模块名.⽬标
注意事项：
必须在__init__.py⽂件中添加__all__ = []，控制允许导⼊的模块列表
（和在模块中定义可以通过模块使用的功能的__all__类似，具体的使用请见上文，只是一个控制的是模块中的功能，一个控制的是包中的模块）
第十五章面向的对象学生管理系统
1.主要内容
python种的.py文件如图所示
第一个文件是用来管理文件中包中各个模块的关系的文件
第二个文件是主函数文件，就是在主函数文件调用其余文件和模块
第三个模块式学生信息管理的模块
第四个文件是用来存放学生数据的文件
第五个文件是学生信息的定义和显示模块
2.实现代码
1)第一个文件是包中的管理文件自动生成且不需要修改
2）main.py文件
from managerSystem import *#导入模块managerSystem,可以使用其中的功能
if __name__=='__main__':#定义只能在运行main.py文件中运行，才执行的代码
student_manager=StudentManager()
student_manager.run()
3）学生信息管理模块
from student import *
class StudentManager(object):
def __init__(self):
self.student_list = []
def run(self):
self.load_student()
while True:
self.show_menu()
ret = int(input('请输入数字1——7：'))
if ret == 1:
self.add_student()
elif ret == 2:
self.del_student()
elif ret == 3:
self.modify_student()
elif ret == 4:
self.search_student()
elif ret == 5:
self.show_student()
elif ret == 6:
self.save_student()
elif ret == 7:
break
@staticmethod#此方法在执行时，不需要传入任何参数
def show_menu():
print('请选择如下序号：')
print('1.添加学员')
print('2.删除学员')
print('3.修改学员信息')
print('4.查找学员')
print('5.显示学员信息')
print('6.保存学员信息')
print('7.退出系统')
def add_student(self):
name = input('请输入学员姓名：')
gender = input('请输入学员性别：')
tel = input('请输入电话号码：')
student = Student(name, gender, tel)
self.student_list.append(student)
# print(self.student_list)
# print(student)
def del_student(self):
del_name = input('请输入需要删除的学员姓名：')
for i in self.student_list:
if i.name == del_name:
self.student_list.remove(i)
break
else:
print('查无此人')
# print(self.student_list)
def modify_student(self):
modify_name = input('请输入需要修改的学员姓名：')
for i in self.student_list:
if i.name == modify_name:
i.name = input('亲输入需要修改的学员姓名：')
i.gender = input('请输入需要修过的学员性别：')
i.tel = input('请输入需要修改的学员手机号：')
print(f'修改的信息为{i.name},{i.gender},{i.tel}')
break
else:
print('需要修改的学员不存在')
def search_student(self):
searce_name = input('请输入需要查询的学员姓名：')
for i in self.student_list:
if i.name == searce_name:
print(f'姓名：{i.name},性别：{i.gender},手机号：{i.tel}')
break
else:
print('查无此人')
def show_student(self):
print('姓名：\t性别：\t手机号：')
for i in self.student_list:
print(f'{i.name}\t{i.gender}\t{i.tel}')
def save_student(self):
f = open('student.data', 'w')
new_list = [i.__dict__ for i in self.student_list]
print(new_list)
f.write(str(new_list))
f.close()
def load_student(self):
# 1. 打开文件：尝试r打开，如果有异常w
try:
f = open('student.data', 'r')
except:
f = open('student.data', 'w')
else:
# 2. 读取数据：文件读取出的数据是字符串还原列表类型；[{}] 转换 [学员对象]
data = f.read() # 字符串
if data != '': # 此时需要添加判断文件是否为空，否则会发生报错
new_list = eval(data)
self.student_list = [Student(i['name'], i['gender'], i['tel']) for i in new_list]
finally:
# 3. 关闭文件
f.close()
4）存储数据的文件不需要编辑
5）student.py文件主要是用来存放学生的主要信息的模块，以及可以查看学生信息的方法
class Student(object):
def __init__(self, name, gender, tel):
self.name = name
self.gender = gender
self.tel = tel
def __str__(self):
return f'{self.name}，{self.gender}, {self.tel}'
151
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
