第三四章笔记
# 第三章
#字符串
概念：
字符串：由0个或多个字符组成的有序字符序列
字符串由一对单引号或一对双引号表示
字符串是字符的有序序列，可以对其中的字符进行索引
"hello"---->h e l l o
索引 0 1 2 3 4
| 操作符及使用 | 描述 |
|---|---|
| x+y | 连接连个字符x和y |
| nx或xn | 复制n次字符串x |
| x in s | 如果x是s的字串，返回True,否则返回False |
正向递增反向递减
使用[ ]获取字符串中一个或多个字符
数值小的在前面
索引：返回字符串中单个字符 <字符串>[M]
切片：返回字符串中一段字符子串 <字符串>[M: N]
左开右闭
举例
正向递增 0 1 2 3 4 5 6
反向递减 -7 -6 -5 -4 -3 -2 -1
云 想 衣 裳 花 想 容
Str = "云想衣裳花想容"
print(Str[2:4])
print(Str[-5:-3])
print(Str[-5:4])
AI写代码#转义字符
1.转义符形成一些组合，表达一些不可打印的含义
"\b"回退
"\n"换行(光标移动到下行首)
"\r" 回车(光标移动到本行首)
让这个双引号去掉本身含义，就打印双引号
print("我想\"嫁给\"秦霄贤")
AI写代码常用函数
len() 获取字符串的长度
a = len("去某个国家追个星")
print(a)
AI写代码str() 把任意数据类型转换成string
b = 30
print(type(b))
c = str(b)
print(type(c))
AI写代码#Type()输出数据类型的
#hex() 十进制转换成十六进制(0x)
print(hex(99))
AI写代码#oct() 十进制转换成八进制(0o)
print(oct(99)
AI写代码#chr() 十进制转换成字符
print(chr(68))
AI写代码#ord() 字符转换成十进制
print(ord('A'))
AI写代码| 函数及使用 | 描述 |
|---|---|
| len(x) | 长度，返回字符串x的长度 len("一二三456")结果为6 |
| str(x) | 任意类型x所对应的字符串形式 str(1.23)结果为"1.23"str([1,2])结果为"[1,2]" |
| hex(x)或oct(x) | 整数x的十六进制或八进制小写形式字符串 hex(425)结果为"0x1a9" oct(456)结果为"0o651" |
方法是一个特殊的函数
方法vs 函数
函数--->函数名字() 方法 类/模块.方法名字()
方法是一个特殊的函数
str.lower() 把字符串转换成小写 返回字符串
a = "AASDFGH"
print(a.lower())
AI写代码#str.upper() 把字符串转换成大写 返回字符串
b = "luck"
print(b.upper())
AI写代码#str.split(按照什么拆分) 拆分 返回的是list列表[]
c = "I,love,you"
print(c.split(","))
AI写代码#str.count(子串) 某一个子串在str(字符串)中出现的次数 返回值整数类型
d = "o"
#o在I,love,you中出现了多少次 2
print(c.count(d))
print(type(c.count(d)))
AI写代码#str.replace(old,new) str中的任意一个子串替换成新的子串 返回字符串
Str01 = "I,LOVE,YOU"
Str02 = Str01.replace("YOU", "李雪琴")
print(Str02)
AI写代码#str.center(宽度,新的字符) Str字符串根据某一个宽度进行居中 返回值字符串
"""
宽度 = 新的字符+str
新的字符必须是一个字符
"""
Str03 = "刘华强"
Str04 = Str03.center(10)
print(Str04)
Str05 = Str03.center(10,"牛")
print(Str05)
AI写代码#str.strip(字符) 去掉左右两边的字符 返回字符串
Str06 = "==I,LIVE,YOU=="
Str07 = Str06.strip("=L")
print(Str07)
AI写代码一些以方法形式提供的字符串处理功能
| 方法及使用 | 描述 |
|---|---|
| str.lower()或str.upper() | 返回字符串的副本，全部字符小写/大写 "AbCdEfGh".lower()结果为"abcdefgh" |
| str.split(sep=None) | 返回一个列表，由str根据sep被分隔的部分组成 "A,B,C".split(",")结果为['A','B','C'] |
| str.count(sub) | 返回字串sub在str中出现的次数 "a apple a day".count("a")结果为4 |
#格式化
第一种方式
使用百分号进行格式化输出的方式，用法如下：
%s，表示字符串；
%d，表示整数；
%f，表示浮点数。
%代表一个占位符
name = "张三"
age = 18
print("%s is %d year old"%(name,age))
AI写代码1.字符串和int不能拼接
2.对数据有未知性
格式化：让数据更加明了
# List
概念
列表是序列类型的一种扩展，十分常用
列表是一种序列类型，创建后可以随意被修改
创建
使用方括号 [] 或list() 创建，元素间用逗号 , 分隔
列表中各元素类型可以不同，无长度限制
● list01 = [1,2,3,4]
● """
● [] 空列表
● list() 里面什么都没有，创建空列表
● list(["张三","李四"])
● """
● list02 = list() #[]
● list03 = list(["张三","李四"])
● print(list01)
● print(list02)
● print(list03)
● list04 = [12.3,10,3.14e2,"张三"]
● print(list04) #[12.3, 10, 314.0, '张三']
AI写代码常用函数
#创建list
list01 = [1,2,5,7,-2,-9]
AI写代码#len(列表) 统计列表中元素的个数
a = len(list01)
print(a) #6
AI写代码#sum(列表) 求和
b = sum(list01)
print(b) #4
AI写代码#max(列表) 最大值
c= max(list01)
print(c) #7
AI写代码#min(列表) 最小值
d = min(list01)
print(d) #9
AI写代码# 增
# 元组
概念
元组是序列类型的一种扩展
• 元组是一种序列类型，一旦创建就不能被修改 不能增删改
创建
• 使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔
•#创建
•tuple01 = (1,2,3)
•tuple02 = tuple() #空元组 ()
•tuple03 = tuple((5,6,7))
•print(tuple01)
•print(tuple02)
•print(tuple03)
AI写代码# 查
运算符
# set
概念
集合是多个元素的无序(没有下标)组合
集合类型与数学中的集合概念一致
集合元素之间无序，每个元素唯一，不存在相同元素
集合元素不可更改，不能是可变数据类型
为什么？ 无序唯一
创建
集合用大括号 {} 表示，元素间用逗号分隔
建立集合类型用 {} 或 set()
建立空集合类型，必须使用set()
1. ● #创建
2. ● set01 = {1,2,3,4,5}
3. ● set02 = set() #set()
4. ● set03 = set({9,10,11})
5. ● print(set01)
6. ● print(set02)
7. ● print(set03)
AI写代码空列表 []
空元组 ()
空字典 {}
空集合 set()
原因是字典的创建也是{}，两者冲突了
所以我们的空集合是set(),创建空集合的时候必须使用set()
1. ● print(type({})) #<class 'dict'>
2. ● print(type(set())) #<class 'set'>
AI写代码#增
#删
#改
不可以更改数据
集合元素不可更改，不能是可变数据类型
为什么？ 无序唯一
#查
直接打印集合名字去查询
不能使用索引进行查询，因为我们集合是无序的
1. print(set01)
2. print(set02)
3. print(set03)
AI写代码# 第四章
#判断语句if
#单分支
语法
if 条件:
代码块
1.冒号必须是英文状态下
2.必须要缩进
执行流程
代码
eval(字符串)
1.把字符串转换成int类型
a = eval("10")
print(a) #10
print(type(a)) #<class 'int'>
2.对字符串进行计算
a = "3*2"
print(a) #3*2
b = eval(a)
print(b) #6
1. #input("请猜一个数字") ---Str
2. #eval() 把Str转换成int
3. guess = eval(input("请猜一个数字"))
4. if guess ==99:
5. print("恭喜你猜对了") #恭喜你猜对了
AI写代码#二分支
语法
if 条件:
代码块
else:
代码块
执行流程
代码
1. guess = eval(input("请猜一个数字"))
2. if guess == 99:
3. print("恭喜你猜对了")
4. else:
5. print("谢谢惠顾")
AI写代码#多分支
语法
if 条件:
代码块
elif 条件:
代码块
elif 条件:
代码块
........
else:
代码块
执行流程图
代码
1. score = eval(input("请输入一个成绩："))
2. if score >= 90:
3. print("a")
4. elif 90 > score>=80:
5. print("B")
6. elif 80 >score>=70:
7. print("C")
8. elif 70>score>=60:
9. print("D")
10. else:
11. print("不及格")
AI写代码#三目运算符
语法
满足条件的代码块 if 条件 else 不满足条件的代码块
"""
三目运算符
if的缩写
满足条件的代码块 if 条件 else 不满足条件的代码块
"""
执行流程
代码
guess = eval(input("请猜一个数字"))
AI写代码 print("恭喜你，猜对了")if guess == 99 else print("谢谢惠顾")
AI写代码注意
1. 必须是二分支语句
条件判断以及组合
| 操作符 | 操作符 | 描述 |
|---|---|---|
| < | < | 小于 |
| <= | ≤ | 小于等于 |
| >= | ≥ | 大于等于 |
| > | > | 大于 |
| == | = | 等于 |
| ! = | ≠ | 不等于 |
| 操作符及使用 | 描述 |
|---|---|
| x and y | 两个条件x和y的逻辑与 |
| x or y | 两个条件x和y的逻辑或 |
| not x | 条件x的逻辑非 |
##循环语句for
语法
for 变量 in 遍历结构:
代码块
执行流程
用法
字符串遍历
1. Str = "hello python"
2. for i in Str:
3. print(i)
AI写代码列表遍历
1. list01 = ["赵丽颖","舒畅","戚薇","朱梓骁"]
2. for i in list01:
3. print(i)
AI写代码字典遍历
1. dict01 = {"天龙八部":"段誉","倚天屠龙记":"张无忌","九阴真经":"周芷若","射雕英雄传":"郭靖"}
2.
3. """
4. 1.用普通遍历,只能打印key
5. 天龙八部
6. 倚天屠龙记
7. 九阴真经
8. 射雕英雄传
9. """
10. for i in dict01:
11. print(i)
12. """
13. 2.字典.items() 返回一个元组("天龙八部","段誉")
14. ('天龙八部', '段誉')
15. <class 'tuple'>
16. ('倚天屠龙记', '张无忌')
17. <class 'tuple'>
18. ('九阴真经', '周芷若')
19. <class 'tuple'>
20. ('射雕英雄传', '郭靖')
21. <class 'tuple'>
22. """
23. for t in dict01.items():
24. print(t)
25. print(type(t))
26. """
27. 3.获取单独的key和value，就是想办法把元组拆分,返回基本数据类型
28. 把元组赋值给两个变量
29. 天龙八部
30. <class 'str'>
31. 段誉
32. <class 'str'>
33. """
34. for k,v in dict01.items():
35. print(k)
36. print(type(k)) #Str
37. print(v)
38. print(type(v)) #Str
AI写代码#Set集合遍历****
1. set01 = {1,2,3,4}
2. for i in set01:
3. print(i)
AI写代码******无限循环(**while)
语法
while 条件:
变量改变公式
代码块
代码
1. a = 10
2. while a>0:
3. #变量不断改变，为了满足条件，避免进入死循环
4. a -= 1
5. print(a)
AI写代码breakcontinue****
break跳出并结束当前整个循环，不执行循环后的语句
continue结束当次循环，继续执行后续次数循环
执行流程
代码
1. for i in [1,2,3,4,5]:
2. if i==2:
3. break
4. print(i) #1
5.
6. for i in [1,2,3,4,5]:
7. if i==2:
8. continue
9. print(i) #1
AI写代码#循环加else
语法
for 变量 in 遍历结构:
代码块
else:
代码块
执行流程
1.先执行完for循环
2.执行完以后执行else
代码
1. for i in [1,2,3,4,5]:
2. print(i)
3. else:
4. print("循环结束")
AI写代码同理，while能不能加else，可以，和上面一样
#while语法
while <条件> :
<语句块1>
else :
<语句块2>
#循环结束后，会执行else的代码
#参数传递
参数传递机制
函数参数传递机制和赋值机制是一样的，其本质就是传递内存地址，这就是引用传递
a传进来的时候传进来的是内存地址
如果实在不理解，你可以以为是 x= a
1. def isid(x):
2. #打印参数的内存地址
3. print(id(x))
4.
5. a = 10
6. #变量的内存地址
7. print(id(a)) #140731588047408
8.
9. #a变成的参数，打印参数内存地址
10. isid(a) #140731588047408
AI写代码#默认参数
1. #定义一个带有默认参数的函数
2. def add(x,y=10):
3. sum01 = x+y
4. return sum01
5.
6. """
7. 1.add(2) x=2 y=10
8. 2.add(2,3) x=2 y=3
9. """
10. print(add(2)) #12
11. print(add(2,3)) #5
12.
13.
14. """
15. 能不能传参传入一个序列类型，比如list，让他默认是[]
16. """
17. def add(list01 = []):
18. list01.append(1)
19. return list01
20.
21. #第一调用
22. print(add()) #[1]
23. #第二次调用
24. print(add()) #[1, 1]
25. #第三次调用
26. print(add()) #[1, 1, 1]
AI写代码
不定数目的参数
******一个 *******
一个* ：代表的是可变参数（就是可以是多个值）
1. def add(x,*y):
2. sum01 = x
3. for i in y:
4. sum01 += i
5. return sum01
6.
7. print(add(1,2,3,4,5)) #15
AI写代码两个*
**y代表可以使用任意 键值（字典） 作为参数
**y就相当于字典类型
1. def func_add(x,**y):
2. sum01 = x
3. #切记这里是字典的循环
4. for k,v in y.items():
5. print(k,v)
6. #把v（值）进行和x相加
7. sum01 += v
8. return sum01
9.
10. """
11. 调用
12. a=3,b=4,c=5 ----> {"a":3,"b":4,"c":5}
13. """
14. print(func_add(1,a=3,b=4,c=5)) #13
AI写代码name
****1.执行本文件的时候，name==main
#打印name这个属性
#执行本文件的时候，打印的是main，name == main
print("1、"+__name__) #1、__main__
AI写代码2.在被import导入到别的文件的时候，name==文件名字
一个文件就是一个模块，导入模块，就相当于导入文件，可以直接写
import 文件名字
1. import 本文件 as bwj
2. #在其他类中运行导入的文件名字，__name__==文件名字
3. print(bwj.__name__) #本文件
AI写代码#高阶函数
高阶函数
定义
高阶函数是一个（ 以函数为参数，或者以函数为返回值的）函数
函数可以是参数，参数是变量，那么函数可以是变量吗
参数其实就是变量进行了赋值，函数能不能是变量
1. #定义一个函数，传入一个参数，求这个参数的平方
2. def func_pf(x):
3. return pow(x,2)
4.
5. #字典
6. #已知李四的年龄是5的平方，求李四的年龄
7. dict01 = {"张三":20,"李四":func_pf}
8.
9. """
10. 调用
11. 1.func_pf = dict01["李四"] 根据key获取value,vaule是一个函数对象
12. 2.age02 = func_pf(5) #调用函数就能获取年龄
13. """
14. #字典的特点是根据key获取value
15. age01 = dict01["张三"]
16. print(age01) #20
17.
18. #顾名思义，通过李四，我们可以拿到函数func_pf
19. #拿到的是函数对象，我们不能直接打印
20. func_pf = dict01["李四"]
21. print(func_pf) #<function func_pf at 0x000001E25A23D048>
22.
23. age02 = func_pf(5)
24. print(age02) #25
AI写代码
函数为参数
1.
2. 定义
3. #普通函数
4. def func_pf(x):
5. return x**2
6.
7. #高阶函数，以函数为参数
8. def func_add(func_pf):
9. #x**2+10
10. return func_pf+10
11.
12. #2**2+10
13. a = func_add(func_pf(2))
14. print(a) #14
AI写代码常用的高阶函数
这些常用的高阶函数是以函数为参数的高阶函数
map()
定义
map(fun,x) 转换，接受一个序列，按照fun的函数逻辑转换成新的序列，返回一个map对象
1.x必须是一个序列
- 返回一个map对象
执行流程
map(fun,x) 转换，接受一个序列，按照fun的函数逻辑转换成新的序列，返回一个map对象
1. x必须是一个序列
2.返回一个map对象
代码
1. def func_add(x):
2. return x+1
3.
4. """
5. 把原来的数据，经过func_add函数以后，每一个都加1，然后输出新的列表
6. """
7. m = map(func_add,[1,2,3,4,5])
8. print(m) #<map object at 0x00000248E965C788>
9. print(list(m)) #[2, 3, 4, 5, 6]
AI写代码filter()
定义
filter(func,x) 过滤，接受一个序列x，按照func函数要求进行转换,
func函数返回 True 或 False，最后将返回 True 的元素放到新列表中。
返回filter对象
执行流程
filter(func,x) 过滤，接受一个序列x，按照func函数要求进行转换,
func函数返回 True 或 False，最后将返回 True 的元素放到新列表中。
返回filter对象
代码
1. def func_ifScore(x):
2. #比较运算符，本身就是返回布尔值的
3. #如果大于等于60就是Ture，否则就是False
4. return x>=60
5.
6. f = filter(func_ifScore,[80,98,70,34,60,59,10])
7. print(f) #<filter object at 0x00000232CC78C808>
8. print(list(f)) #[80, 98, 70, 60]
AI写代码##reduce()
定义
reduce(func,x) 计算，接受一个序列，把列表中的每一个值按照函数进行累加或者别的运算
返回一个计算数值
1.因为是计算，所以我们的func是两个参数
2.必须要导包
执行流程
代码
from functools import reduce
AI写代码reduce(func,x) 计算，接受一个序列，把列表中的每一个值按照函数进行累加或者别的运算
返回一个计算数值
1.因为是计算，所以我们的func是两个参数
2.必须要导包
1. #累加 1+2+3+4+5
2. def func_add(x,y):
3. return x+y
4.
5. a = reduce(func_add,[1,2,3,4,5])
6. print(a) #15
AI写代码zip()
定义
zip(list01,list02) 拉链、压缩
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，返回一个对象
1.参数必须是可迭代的序列类型
2.对象里面放的是一个一个的元组
3.返回一个zip对象
代码
1. list03 = [1,3,5,7,9,11,13]
2. list04 = [2,4,6]
3. a = zip(list03,list04)
4. #print(list(a)) #[(1, 2), (3, 4), (5, 6)]
5.
6. """
7. a是一个压缩、拉链数据，能不能解压呢，
8. 1.符号是*
9. 2.zip(*list类型)
10. 3.声明两个变量去承接
11. 4.zip对象如果执行过了，就不存在了
12. """
13. b = list(a)
14. list05,list06 = zip(*b)
15. print(list05) #(1, 3, 5)
16. print(list06) #(2, 4, 6)
AI写代码sorted()
sorted()
定义
sorted(序列类型的对象,key=函数,reverse=True/False) 排序
1.reverse=True/False 升序是False 降序是Ture
执行流程
代码
1. #list里面可以放任何数据类型
2. list01 = [{"name":"张三","age":20},
3. {"name":"李四","age":30},
4. {"name":"王五","age":18},
5. {"name":"小明","age":8}
6. ]
7.
8. #按照年龄进行排序
9. #定义一个函数，返回一个年龄
10. def func_age(list01):
11. #根据key（age）获取value（年龄）
12. age01 = list01["age"]
13. return age01
14.
15. s = sorted(list01,key=func_age,reverse=False)
16. print(s)
AI写代码函数为返回值
语法
def func_name01(参数1)：
def func_name02(参数2)：
return 逻辑
return fun_name02
执行流程图
代码
1. #x的y次方
2. def func01(x,y):
3. return x**y
AI写代码 1.
2.
3. """
4. 简化1
5. 以函数为返回值进行简化
6. 1.闭包。函数里面的子函数，叫做闭包
7. 8. """
9. #f01 高阶函数
10. def f01(x):
11. #f02是f01的子函数，又叫做闭包函数
12. def f02(y):
13. return x**y
14. #把闭包函数返回出来
15. return f02
16.
17. """
18. 调用
19. 1.f = f01(2) f是谁，f就是f02(y),相当于f=f02(y)
20. """
21. f = f01(2) #意义就是x=2
22. a = f(3) #意义就是y=3
23. #a=x**y=2**3 = 8
24. print(a) #8
AI写代码lambda表达式
定义
lambda表达式是一行函数。在其他语言中叫做匿名函数
语法
lambda 参数1,参数2,参数n : 逻辑
代码
1. def func01(x,y):
2. return x**y
3.
4. lambda x,y:x**y
AI写代码#函数的递归
定义
"""
递归是指函数在执行过程中调用了本身。简单来说就是自己调用了自己
1.自己调用自己
2.一定要有一个条件，进行退出调用
"""
代码
"""
递归是指函数在执行过程中调用了本身。简单来说就是自己调用了自己
1.自己调用自己
2.一定要有一个条件，进行退出调用
"""
"""
阶乘：
比如说给一个数据5，阶乘54321
n = 5*(5-1)
n =n*(4-1)
n =n*(3-1)
n =n*(2-1)
总结规律
n! = n*(n-1)
1. def func_jc(n):
2. if n==1:
3. return 1
4. else:
5. return n*func_jc(n-1)
6.
7. print(func_jc(5)) #120
AI写代码流程
# 装饰器
定义
1.装饰器是一个函数
2.装饰器是一个 为函数添加新的属性 的函数
3.通过闭包对函数添加新的属性
闭包函数:函数的子函数就是闭包函数
#异常
定义
语法
Try – except-else
1.
2.
3. try:
4. s = eval(input("请输入一个数字："))
5. a = 10/s
6. except ZeroDivisionError:
7. print("除数不能是零")
8. else:
9. print("除数是正常的，运行成功")
AI写代码Try-finally
1. Try-finally
2. try：
3. 代码块
4. finally:
5. 代码块
AI写代码##Raise关键字
raise：无论代码是否异常，他自己会触发异常
语法：
raise 异常名称
1. try:
2. s = eval(input("请输入一个除数："))
3. a = 10/s
4. #无论你的除数等不等于0，他都会报错
5. raise ZeroDivisionError
6. except ZeroDivisionError:
7. #except是异常的时候给出的警告
8. print("警告：除数不能为0")
AI写代码常见的异常列表
| BaseException | 所有异常的基类 |
|---|---|
| SystemExit | 解释器请求退出 |
| KeyboardInterrupt | 用户中断执行(通常是输入^C) |
| Exception | 常规错误的基类 |
| StopIteration | 迭代器没有更多的值 |
| GeneratorExit | 生成器(generator)发生异常来通知退出 |
| StandardError | 所有的内建标准异常的基类 |
| ArithmeticError | 所有数值计算错误的基类 |
| FloatingPointError | 浮点计算错误 |
| ValueError | 传入无效的参数 |
| ZeroDivisionError | 除(或取模)零 (所有数据类型) |
| KeyError | 映射中没有这个键 |
| AttributeError | 对象没有这个属性 |
#作用域
是按照变量的查找顺序 L>E>G>B
L**(local)**局部作用域
1. def func():
2. #a是函数中的变量，是局部变量,只能在函数中使用
3. a=10
4. print(a)
5. #a是不存在的
6. print(a)
AI写代码******E(********Enclosing)**闭包函数中的作用域
nonlocal :把闭包外的变量引用过来
1. age = 1
2. def qunian():
3. #闭包外的变量，局部变量 4-11能用
4. age = 19
5. def jinian():
AI写代码******G(********Global)**全局作用域
global****把全局的age引用过来
G(Global) 全局作用域
1. #全局
2. age = 20
3. def func():
4. #把全局的age引用过来
5. global age
6. #局部
7. #前面的a相当于是重新赋值的a，是局部的
8. #后面的a是要进行相加的数据，所以要有这个数据，所以是全局的
9. age=1 + age
10. return age
11.
12. print(func()) #30
AI写代码(Built-in) 内建作用域
系统固定模块里面的变量，比如 int, bytearray 等。
比如函数名 abs、char 和异常名称 BaseException、Exception 等等。