最累的时候，家人是你最好的归宿。

1. 字符串的常规操作

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
# 字符串的首字母变成大写
s = "python"
s.capitalize()

"""
结果: Python
"""

# 每个单词的首字母变成大写
s = "I have a dream!" 
s.title()

"""
结果: I Have A Dream!
"""

# 字符串变成小写字母
s = "I HAVE A DREAM"
s.lower()

"""
结果: i have a dream
"""

# 把所有字母变成大写字母
s = "I have a dream!" 
s.upper()

"""
结果: I HAVE A DREAM!
"""
 
# 如何忽略大小写来进行判断
verify_code = "xAd1"
user_input = input(f"请输入验证码({verify_code}): ")
if verify_code.upper() == user_input.upper():
   print("验证码正确")
else:
   print("验证码不正确")

2. 字符串的切割/拼接和替换

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
# 去掉字符串左右两端(空格 \t  \n)
s = "     你好,   我叫  周杰伦     "
s.strip()

"""
结果: 你好,   我叫  周杰伦
"""

# 字符串替换,将德玛西亚替换为盲僧
s = "你好, 我叫德玛西亚"
s.replace("德玛西亚","盲僧")

"""
结果: 你好, 我叫盲僧
"""

# 字符串切割
a = "python_java_c_c#_javascript"
a.split('_')

"""
结果: ['python', 'java', 'c', 'c#', 'javascript']
"""

# 字符串拼接
lst = ["赵本山","王大拿","大张伟"]
# 用_ 把上面的人的名字连起来
"_".join(lst)

"""
结果: 赵本山_王大拿_大张伟
"""

3. 字符串的查找和判断

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
# 查找1 
# find: 如果没找到就返回-1
s = "你好,我叫周润发"
ret = s.find("周润发")
print(ret)

"""
结果: 7
"""

# 查找2 
# index: 没找到就报错
s = "你好,我叫周润发"
ret = s.index("周润发")
print(ret)

"""
结果: 7
"""

# 判断1
name = "请输入你得名字: "
# startswith: 判断字符串是不是以......开头
# endswith(): 判断字符串是不是以......结尾
if name.startswith("张"): 
   print("姓张")
else: 
   print("不姓张")

# 判断2
money = input("请输入你兜里的钱：")
# isdigit(): 判断字符串是否由整数组成
# isdecimal(): 判断字符串是否由小数组
if money.isdigit():
   money = int(money)
   print("可以花钱了")
else:
   print("对不起,您输入有误......")

4. 列表增删改查

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
# 1. 向列表中添加内容
# append() 追加
lst = []
lst.append("王老五")

# insert() 插入 第一个字段为索引，第二个为要插入的字符串
lst.insert(0,"赵敏")

# extend() 可以合并两个列表,批量的添加
lst.extend(["武则天","嬴政","马超"])

# 2. 删除中的内容 
# pop 给出被删除的索引，返回被删除的元素
lst.pop(3)

# 删除某个元素
lst.remove("马超")

# 3. 修改
# 直接用索引就可以进行修改操作
lst[4] = "凯"

# 4. 查询
# 直接用索引进行查询操作
print(lst[0])

5. 元组

     t = (“张无忌”,“赵敏”,“呵呵”)

  1. tuple 元组，特点: 不可变的列表
  2. 运用场景: 固定了某些数据，不允许外界修改
  3. 元组如果只有1个元素，需要在元素的末尾添加一个逗号

6. set集合

     t = {1,2,3,“呵呵”,(123,111)}

  1. set是无序的，可用于去重
  2. 只能存放不可变数据：int,str,tuple,bool 不能存放可变的数据有：list,dict,set
  3. 创建空结合 s = set() 空元组 s = tuple() 空列表 s = list() 空字符串 s = str()
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
# 添加数据
t = set()
s.add("王二傻")

# 删除数据
s.pop() # pop默认删除最后一个，因为存储数据不确定，很少用  相当于随机删除一个
s.remove("王二傻")

# 修改数据(必须先删除再新增)
s.remove("王二傻")
s.add("王三傻")

# 查询(只能通过for循环拿数据)
for i in s:
  print(i)

# 集合的交集，并集，差集
s1 = {"刘能","赵四","皮长山"}
s2 = {"刘科长","冯科长","皮长山"}
print(s1 & s2) # 交集：两个列表都有的数据
print(s1.intersection(s2)) # 交集：两个列表都有的数据

print(s1 | s2) # 并集：把两个列表合并到一起，去除重复数据
print(s1.union(s2)) # 并集：把两个列表合并到一起，去除重复数据

print(s1 - s2) # 差集：两个列表将列表s1有  列表s2没有的数据展示出来
print(s1.difference(s2)) # 差集：两个列表将列表s1有  列表s2没有的数据展示出来

# 去重
# 去除重复之后的数据是无序的
lst = ['周杰伦','蔡依林','神仙姐姐','蔡依林','大摆锤']
print(set(lst))

7. dict字典

     t = {‘jay’:‘周杰伦’,‘金毛狮王’:‘谢逊’}

  1. 字典是以键值对的形式存储数据的
  2. 字典的key必须是可哈希(不可变)的数据类型
  3. 字典的value可以是任何数据类型
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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
# 1. 字典的增删改查
dic = dict()

dic['jay'] = "周杰伦" # 添加数据

dic['jay'] = "昆凌" # 修改数据

dic.setdefault("tom","呵呵哒") # 设置默认值,如何以前已经有了tom了，setdefault就不起作用了

dic.pop("jay") # 通过key删除数据

print(dic['jay']) # 查询数据: 如果key不存在则报错,当确定key是没问题的时候可以用
print(doc.get('jay')) # 查询数据: 如果key不存在则返回None,当不确定key的时候可以用

"""

dic = {
   "赵四": "歪嘴",
   "大脚": "跟这个和那个搞对象"
}
name = input("请输入你想知道我们村的人的名字：")
val = dic.get(name)
if val is None:
   print("我们村没这个人~~~")
else:
   print(val)

"""

# 2. 字典的循环与嵌套
# 字典的循环
dic = {
   "赵四": "歪嘴",
   "大脚": "跟这个和那个搞对象",
   "大脑袋": "瞎折腾..."
}

# 用for循环直接拿到key
for key in dic:
    print(key, dic[key])

# 希望把所有的key全都保存到一个列表中 keys(): 拿出所有的key
print(list(dic.keys()))

# 希望把所有的value都放到用一个列表中  values(): 拿出所有的value
print(list(dic.values()))

# 直接拿到字典中的key和value  a,b = (1,2)这种方法为解包
for key, value in dic.items():
    print(key, value)


# 字典的嵌套
wangfeng = {
    "name": "汪峰",
    "age": 18,
    "wife": {
        "name": "章子怡",
        "hobby": "演戏",
        "assistant": {
            "name": "二傻",
            "age": 18,
            "hobby": "打游戏"
        }
    },
    "children": [
        {"name": "孩子1", "age": 13},
        {"name": "孩子2", "age": 10},
        {"name": "孩子3", "age": 8}
    ]
}

# 查看汪峰妻子助手的名字
name = wangfeng["wife"]["assistant"]["name"]

# 给王峰的第二个孩子加1岁
wangfeng['children'][1]['age'] = wangfeng['children'][1]['age'] + 1

# 字典的循环删除
dic = {
   "赵四": "歪嘴",
   "大脚": "跟这个和那个搞对象",
   "大脑袋": "瞎折腾..."
}
temp = [] # 存放即将要删除的key
for key in dic:
   if key.startswith("大"):
      temp.append(key)
for t in temp: # 循环列表，删除字典中的内容
   dic.pop(t)
print(dic)

8. 算数运算符

运算符号 运算名称 表达式
+ 加 a + b 计算a+b
- 减 a - b 计算a-b
* 乘 a * b 计算a*b
/ 除 a / b 计算a/b
% 计算余数 a % b 计算a除以b的余数
// 整除 a // b 计算a除以b的商
** 计算幂 2 ** 3 计算2的3次方

9. 文件操作

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
59
60
61
62
63
64
# 1. 读取操作 r: read 读取
f = open("test.txt", mode='r', encoding='utf-8')

f.read() # 全部读取
f.readline() # 一行一行读取
f.readlines() # 读取全部数据并存到列表
# 最重要的一种文本读取方式
for line in f: # 从f 中读取到每一行数据
    print(line.strip())

# 2. 写入文件 w: write 写
# w模式下，如果文件不存在，则自动创建一个文件
# w模式下，每一次open都会清空掉open的内容
f = open("halo.txt", mode='w', encoding='utf-8')
f.write("笑啦")
f.close()

# 案例 准备一个列表，要求把所有列表中的每一项内容，写入到文件中
lst = ["张无忌", "汪峰", "周杰伦"]
f = open("打架.txt",mode='w',encoding='utf-8')
for item in lst:
    f.write(item)
    f.write("\n")
f.close()

# 3. 追加写入文件 a: append: 追加写入
lst = ["张无忌", "汪峰", "周杰伦"]
f = open("打架.txt",mode='a',encoding='utf-8')
f.write('你好厉害')
f.close()

# 4. with: 不用手动关闭文件
with open('打架.txt', mode='r', encoding='utf-8') as f:
    for line in f:
        print(line.strip())

# 5. 读取图片
# 在读写非文本文件的时候要加上b
with open('1.bmp', mode='rb') as f:
    for line in f:
        print(line)

# 6. 文件的复制
with open('1.bmp', mode='rb') as f1, \
        open("666/2.bmp", "wb") as f2:
    for line in f1:
        f2.write(line)

# 7. 文件修改
# 将文件中的周 -> 张
import os
with open("打架.txt", mode='r', encoding='utf-8') as f1, \
     open("打架副本.txt", mode='w', encoding='utf-8') as f2:
    for line in f1:
        line = line.strip()  # 去掉换行
        if line.startswith('周'):
            line = line.replace('周', '张')  # 修改
        f2.write(line)
        f2.write("\n")
# 删除原文件
os.remove("打架.txt")
# 把副本文件重命名成源文件
os.rename("打架副本.txt", "打架.txt")

10. 函数的实参

  1. 实参，实际在调用的时候传递的信息
         ★ 位置参数，按照位置进行传递参数
         ★ 关键字参数，按照参数的名字进行传递参数
         ★ 混合参数
           顺序: 位置参数放前面，关键字参数放后面
1
2
3
4
5
6
7
8
9
def chi(zhu, fu, tang, tian):
    print(zhu, fu, tang, tian)

# 位置参数
chi("大米饭", "西红柿炒鸡蛋", "紫菜蛋花汤", "哈根达斯")
# 关键字参数
chi(zhu="小米饭",tang="胡辣汤",fu="韭菜炒鸡蛋",tian="老北京冰棍")
# 混合参数
chi("小米饭", "韭菜炒鸡蛋", tang="胡辣汤", tian="老北京冰棍")

11. 函数的形参

  1. 形参，在函数定义的时候，需要准备一些变量来接收信息
         ★ 位置参数，按照位置进行传递参数
         ★ 默认值参数，在函数声明的时候给变量一个默认值，如果实参不传递信息，此时默认值生效，否则就不生效
         ★ 动态传参
           *args, 表示接收所有位置参数的动态传参
           **kwargs, 表示接收所有关键字参数的动态传参
           ★ 顺序: 位置 > *args > 默认值 > **kwargs
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
# 1. 位置参数和默认参数
def luru(name, age, gender="男"):
    print(name, age, gender)
luru('张三', 18)
luru('李四', 20,gender='女')

# 2. 动态传参

# 位置参数
def chi(*args):  # *表示位置参数的动态传参 *接收到的值会被统一放到一个元组里面
    print(args)

chi('大米饭', '烧茄子', '紫菜蛋花汤', '哈根达斯')
chi('大米饭', '哈根达斯')
chi('大米饭')


# 关键字参数
def chi(**kwargs):  # **表示接收关键字的动态传参，接收到的所有参数都会被处理成字典
    print(kwargs)

chi(fu="木须柿子", zhu="小米饭")

# 混合参数 使用形参 *args **kwargs可以接收任何类型的参数
def func(a, b, *args, c="哈哈", **kwargs):
    print(a, b, c, args, kwargs)

func(1, 2, 3, 4, c="呵呵", hello=123456, hahalou=654)

# 将列表打散成位置参数传递
stu_list = ["流川枫", "樱木", "大老王", "隔壁二老王", ]
def func(*args):
    print(args)
# * 在实参位置，把列表打散成位置参数进行传递
# ** 在实参位置，可以把字典自动转换成关键字参数进行传参
func(*stu_list)

12. Python的内置函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
lst = [12,456,32,18,64,57]
# 计算出列表中最大数
max(lst)
# 计算出列表中最小数
main(lst)
# 计算出列表中的和
sum(lst)

# 将字典转换为列表，如果是字符串则循环遍历字符串加入列表
s = {1,2,3}
list(s)

# 将列表转换为元组 例：["333","222","666"]转换为(0,'333')(1,'222')(2,'666')
lst = ['eeeee','qqqqqq','dgggg']
for key,value in enumerate(lst):
    print(key,value)
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
# zip: 可以把多个可跌倒内容进行合并
lst1 = ["赵本山", "范伟", "苏有朋"]
lst2 = [40, 38, 42]
lst3 = ["卖拐", "耳朵大", "情深深雨蒙蒙"]
result = zip(lst1, lst2, lst3)
lst = list(result)
print(lst)


# sorted: 排序
lst = [
    {"id": 1, "name": "周润发", "age": 18, "salary": "5200"},
    {"id": 2, "name": "陈星星", "age": 28, "salary": "511100"},
    {"id": 3, "name": "刘海美", "age": 78, "salary": "561230"},
    {"id": 4, "name": "黄伯通", "age": 12, "salary": "532100"},
    {"id": 5, "name": "白大兴", "age": 35, "salary": "53210"},
    {"id": 6, "name": "赵有辣", "age": 47, "salary": "520"},
    {"id": 7, "name": "宋扒皮", "age": 8, "salary": "12"},
]
# 1. 根据每个人的年龄排序
s = sorted(lst, key=lambda d: d['age'])
print(s)
# 2. 根据工资进行排序，从大到小
s = sorted(lst, key=lambda d: d['salary'], reverse=True)
print(s)
# 3. 按照字母首拼排序 使用了pypinyin a = pypinyin.pinyin('姓名', style=pypinyin.FIRST_LETTER) 把汉字转换为字母 通过字母排序
import pypinyin
s = sorted(lst, key=lambda d: pypinyin.pinyin(d['name'], style=pypinyin.FIRST_LETTER)[0][0][0:1])
print(s)


# filter: 筛选
lst = ["张无忌", "张三丰", "张翠山", "灭绝小师太", "小狐仙"]
# 由函数返回真或假  以下为：筛选只提取姓张的
f = filter(lambda x: x.startswith("张"), lst)
print(list(f))


# map: 映射
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 求平方用列表推导式
result = [item * item for item in lst]
# 1. 求平方用map方法
r = map(lambda x: x * x, lst)
print(list(r))

# 2. 将列表中的数据转为大写
words = ['apple', 'banana', 'cherry']
upper_words = map(str.upper, words)
print(list(upper_words))

13. global和nonlocal

  1. global: 把外面的全局变量引入到局部
  2. nonlocal: 向外找一层，看看有没有该变量，如果有就引入，如果没有，继续向外一层，直到全局(不包括)
1
2
3
4
5
6
7
8
9
10
11
12
13
# global
a = 10
def func():
    # 此时想要在函数内部修改全局的变量a
    # 把外面的全局变量引入到局部
    global a
    a = 20
func()
print(a)

"""
结果：20
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
def func():
    a = 10
    def func2():
        # 向外找一层，看看有没有该变量，如果有就引入，如果没有，继续向外一层，直到全局(不包括)
        nonlocal a
        a = 20
    func2()
    print(a)
func()

"""
结果：20
"""

14. 闭包

  1. 可以让一个变量常驻于内存
  2. 可以避免全局变量被修改
1
2
3
4
5
6
7
8
9
10
11
12
def func():
    a = 10
    def inner():
        nonlocal a
        a += 1
        return a
    return inner

ret = func()
b = ret()
c = ret()
print(b,c)

15. 装饰器

  1. 装饰器本质上是一个闭包 作用：可以在函数前后添加新功能，但是不改原来的代码
  2. 使用场景：在用户登录的地方、日志
  3. 一个装饰器可以被多个装饰器装饰

15.1 装饰器雏形

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
# 场景：我要打游戏，雇佣管家在我打游戏前自动开外挂，打开游戏后自动关外挂  不改变原有代码

def guanjia(game):
    # 重新封装的游戏
    def innner():
        print('打开外挂')
        game() # 玩游戏
        print("关闭外挂")
    return innner

# 标记,相当于 play_dnf = guanjia(play_dnf)
@guanjia
def play_dnf():
    print('你好啊，我叫赛利亚，今天又是美好的一天！')

# 标记,相当于 play_lol = guanjia(play_lol)
@guanjia
def play_lol():
    print('德玛西亚！')

# 让管家把游戏重新封装一遍，我这边把原来的游戏替换了
# play_dnf = guanjia(play_dnf)
# play_lol = guanjia(play_lol)
play_dnf()
play_lol()
1
2
3
4
5
6
7
8
9
10
11
12
13
# wrapper: 装饰器    fn: 目标函数
def wrapper(fn):
    def inner(*args,**kwargs):
        # 在目标函数执行之前......
        ret = fn(*args,**kwargs) # 执行目标函数
        # 在目标函数执行之后......
        return ret
    return inner

@wrapper
def target():
    pass
target() # => inner()

15.2 装饰器动态传参

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def guanjia(game):
    # *,**表示接收所有参数，打包成元组和字典
    def innner(*args,**kwargs): # inner添加了参数，args一定是一个元组  kwargs一定是字典
        print('打开外挂')
        # *,** 表示把args元组和kwargs字典打散成位置参数及关键字参数传递进去
        game(*args,**kwargs) # 玩游戏 # game("admin","123456")
        print("关闭外挂")
    return innner

@guanjia
def play_dnf(username,password):
    print("打开dnf客户端输入密码",username,password)
    print('你好啊，我叫赛利亚，今天又是美好的一天！')

@guanjia
def play_lol(username,password,hero):
    print("打开lol客户端输入密码", username, password,hero)
    print('德玛西亚！')
    
play_dnf("admin","123456") # inner
play_lol("admin","123456","盖伦")

15.3 装饰器的返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def guanjia(game):
    def innner(*args,**kwargs):
        print('打开外挂')
        ret = game(*args,**kwargs) # 这里是目标函数的执行，这里是能够拿到从目标函数返回的返回值
        print("关闭外挂")
        return ret
    return innner

@guanjia
def play_dnf(username,password):
    print("打开dnf客户端输入密码",username,password)
    print('你好啊，我叫赛利亚，今天又是美好的一天！')
    return "一把屠龙刀"

def play_lol(username,password,hero):
    print("打开lol客户端输入密码", username, password,hero)
    print('德玛西亚！')

ret = play_dnf("admin","123456") # inner
print(ret)

15.4 多个装饰器

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
def wrapper1(fn): # fn: wrapper2.innner
    def inner(*args, **kwargs):
        print('这里是wrapper1 进入') # 1
        ret = fn(*args, **kwargs)
        print('这里是wrapper1 出去') # 5
        return ret
    return inner

def wrapper2(fn):
    def inner(*args, **kwargs):
        print('这里是wrapper2 进入') # 2
        ret = fn(*args, **kwargs)
        print('这里是wrapper2 出去') # 4
        return ret
    return inner

@wrapper1  # 然后执行1   target = wrapper1(wrapper2.innner) ==> target: wrapper1.innner
@wrapper2  # 首先执行2   target = wrapper2(target) ==> target:wrapper2.innner
def target():
    print('我是目标') # 3

target()


"""
结果：
这里是wrapper1 进入
这里是wrapper2 进入
我是目标
这里是wrapper2 出去
这里是wrapper1 出去
"""

15.5 装饰器实战案例分享

  • 场景: 写个添加员工信息、删除员工信息、修改员工信息、查询员工信息的函数，写一个登录装饰器给4个函数全部应用上。当用户第一次登录成功后，后面无需再次登录直接执行其他函数的后续操作，如果登录失败则需要重新登录直至成功。
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
# 场景: 写个登录装饰器，如果登录成功无需再次登录，如果登录失败继续执行登录

login_flag = False
# 登录装饰器
def login_verify(fn):
    def inner(*args, **kwargs):
        # 引入全局变量 修改
        global login_flag
        # 如果login_flag为False 进入登录  成功则无需登录
        if login_flag == False:
            # 这里完成登录校验
            print('开始登录验证...')
            while True:
                username = input("用户名：")
                password = input("密码：")
                if username == "admin" and password == "123":
                    print('登录成功')
                    # 记录状态
                    login_flag = True
                    break
                else:
                    print('登录失败，用户名或密码错误')
        ret = fn(*args, **kwargs)
        return ret
    return inner

@login_verify
def add():
    print('添加员工信息')

@login_verify
def delete():
    print('删除员工信息')

@login_verify
def upd():
    print('修改员工信息')

@login_verify
def search():
    print('查询员工信息')

add()
delete()
upd()
search()

16. 迭代器

  1. interable: 可迭代的东西
  2. 能够迭代的有： str、list、tuple、dict、set、open()
  3. 可迭代的数据类型都会提供一个叫迭代器的东西，这个迭代器可以帮我们把数据类型中的所有数据逐一的拿到
  4. 获取迭代器的两种方案：
         ★ inter() 内置函数可以直接拿到迭代器
         ★ 一般不常用___iter___() 特殊方法
  5. 从迭代器中拿到数据两个方案：
         ★ next() 内置函数
         ★ 一般不常用___next___() 特殊方法
  6. for里面一定是要拿迭代器的，所以说有不可迭代的东西不能用fou循环，for循环里面一定有___next___()出现
  7. 迭代器本身也是可迭代的
  8. 迭代器本身的特性：
         ★ 只能从上向下走不能反复
         ★ 特别省内存
         ★ 有惰性机制,主要不获取数据就不往后走
  9. 总结：迭代器统一了不同数据类型的遍历工作
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
# 第一种获取迭代器  iter()
it = iter("你好啊")
"""
结果：<str_iterator object at 0x0000028746FEC320>
"""
# 第一种从迭代器拿到数据 next()
print(next(it))
print(next(it))
print(next(it))

"""
结果：
你
好
啊
"""

# 第二种获取迭代器  __iter__()
it = "你好阿".__iter__()
"""
结果：<str_iterator object at 0x0000028746FEC320>
"""
#第二种从迭代器拿到数据 __iter__()
print(it.__next__())
print(it.__next__())
print(it.__next__())

"""
结果：
你
好
啊
"""

17. 生成器

  1. 生成器的本质就是迭代器
  2. 创建生成器的两种方案：
         ★ 生成器函数
         ★ 生成器表达式
  3. 生成器函数：
         ★ 生成器函数中有一个关键字: yield
         ★ 生成器函数执行的时候，并不会执行函数，得到的是生成器
         ★ 只要函数中出现了yield，它就是一个生成器函数
         ★ yield作用：
            ★ 可以返回数据
            ★ 可以分段的执行函数中的内容，通过___next___()可以执行到下一个yield位置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 分段取数据
def order():
    print(123)
    yield 456
    print(789)
    yield 147
rt = order()
print(rt.__next__())
print(rt.__next__())

# 去工厂定制一万件衣服，每次拿50条数据
def order():
    lst = []
    for i in range(10000):
        lst.append(f"衣服{i}")
        if len(lst) == 50:
            yield lst
            # 下一次拿数据
            lst = []

gen = order()
print(gen.__next__())
print(gen.__next__())
print(gen.__next__())

18. 推导式及生成器表达式

  1. 语法：
         ★ 列表推导式 ：[数据 for循环 if条件判断]
         ★ 集合推导式 ：{数据 for循环 if条件判断}
         ★ 字典推导式 ：{k:v for循环 if条件判断}
         ★ 生成器表达式：(数据 for循环 if条件判断)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 1. 请创建一个列表[1,3,5,7,9]
lst = [i for i in range(1, 10, 2)]
lst1 = [i for i in range(10) if i % 2 == 1]
print(lst1)
"""
结果：[1, 3, 5, 7, 9]
"""

# 2. 生成50件衣服
lst = [f"衣服{i}" for i in range(50)]
print(lst)
"""
结果：['衣服0', '衣服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']
"""

# 3. 将如下列表中所有的英文字母修改成大写
lst = ["allen", "tony", "kevin", "sylar"]
lst1 = [item.upper() for item in lst]
print(lst1)
"""
结果：['ALLEN', 'TONY', 'KEVIN', 'SYLAR']
"""
1
2
3
4
5
6
s = {i for i in range(10)}
print(s)

"""
结果：{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
"""
1
2
3
4
5
6
7
8
# 请将下列的列表修改成字典，要求索引作为key，数据作为value
lst = ['赵本山', '潘长江', '高达', '奥特曼']
dic = {i:lst[i] for i in range(len(lst))}
print(dic)

"""
结果：{0: '赵本山', 1: '潘长江', 2: '高达', 3: '奥特曼'}
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
gen = (i**2 for i in range(10))
for item in gen:
    print(item)

"""
结果：
0
1
4
9
16
25
36
49
64
81
"""

19. 匿名函数

  1. 匿名函数：lambda表达式
  2. 语法规则：变量 = lambda 参数,参数2… : 返回值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 计算a+b的结果
def func(a, b):
    return a + b
ret = func(13, 12)
print(ret)
# 转换为lambda表达式
fn = lambda a, b: a + b
ret1 = fn(13, 12)
print(ret1)

"""
结果：25
"""