1.什么是编程,什么是编程语言?

编程:用代码编写程序

编程语言:用那种语法规则来编写程序

2.编程语言的分类

编译型语言:一次性把源代码进行编译

c语言, go语言

特点:执行效率很高,平台依赖性一般比较高

解释性语言:逐行的对源代码进行翻译和运作

javascript,python, ruby

特定:执行效率相对较低,源代码一般无法加密, 平台的依赖性不高

3.什么是python? 优缺点?

python是一门编程语言

python擅长什么?

1.爬虫

2,自动化

3.科学计算

4.人工智能

4.怎么安装python ?

跟着官网下载就行

Welcome to Python.org

5.第一句代码,把文本打印

print("hello world")  # 输出打印内容hello world

6.执行python文件

解释器 python文件

举例:

python C:\Users\dusk\Desktop\projects\pythonProject\demo.py

7.python编辑器(写代码的地方)

文本

vscode

pycharm

8.安装pycharm

社区版,免费 正式版 收费

9.注释

注释是解释说明的,不会执行的

import os.path
# 输出打印内容hello world  (单行注释)
print("hello world")  
print(os.path.abspath(__file__))
"""
这是一个多行注释,可以多行对代码进行注释
这是一个多行注释,可以多行对代码进行注释
"""

10.变量是什么?

变量:可以变化的量

作用:当数据量大时,可以用变量表示,精简代码.变量是用来区分不同数据的,可以指向一个内存空间,帮我们存储数据

aa = """
床前明月光,
疑是地上霜.
举头望明月,
低头思故乡.
"""
print(aa)
print(aa)
aa = "李白"  # 变量可以变,重新赋值,现在aa就代表"李白'

变量的命名规则:

字符,数字,下划线组成

不能是数字开头

不能用关键字

不要用中文

明确精简

11.常量

两种:一种的正常的不变的量1,2,3,他们永远不会改变,1,永远代表1,,2永远代表2

在python程序中不便的量 大写取名

CLASS_NAME = "二班"
# 在整个程序中,CLASS_NAME 的值永远是代表"二班"

12.数据类型

区分不同的数据,不同的数据应该有不同的操作

字符串str:一段文本

s = "岳飞"
print(s)
s1 = """
多行字符串
多行字符串
多行字符串
多行字符串
"""
 

print(s1)
# 字符串相加
s2 = s + s1
print(s2)
# 字符串多次打印输出
s3 = s1 * 10
print(s3)

布尔bool:判断条件

bool的值有两个,一真一假

s = True
print(s)
s1 = False
print(s)
print(s1)
s2 = 1 < 2 # 1小于2 所以值为真 True
s3 = 1 > 2 # 1 大于2 所以值为假 False
print(s2)
print(s3)

整型int:整数

s = 1
# type(数据)可以查看数据的类型
print(type(s))

浮点型float:小数

s = 1.1
# type(数据)可以查看数据的类型
print(type(s))

13.最简单的用户交互

input 输入

# 就是把输入的值赋值给前面的变量
变量 = input("提示语:")
print(变量)
# 当遇到这个input 程序会暂停,等待用户输入,输入之后把输入的值,赋值给前面的变量
name = input("请输入你的名字")
# 当遇到这个input 程序会暂停,等待用户输入,输入之后把输入的值,赋值给前面的变量
age = input("请输入你的年龄")
print(name, age)
# type(数据)查看数据类型会发现input 传入的值是str
print(type(name), type(age))
num = input("请输入一个数字:")
num1 = input("请输入一个数字")
# 运算之后你会发现只能是拼接
print(num + num1)
# 把输入先转换成整型再相加
num2 = int(input("请输入一个整数"))  # int(数据) 把数据转换成整型
num3 = float(input("请输入一个小数"))  # float(数据) 把数据转换成浮点型
print(num2 + num3)

14.条件判断

# 单分支条件判断
money = 500
if money > 300:
    # 如果条件成立,就执行里面的代码块
    # python是利用缩进控制代码所属
    print(123)
if money < 300:
    # 如条条件不成立,就跳过
    print(345)
# 程序从上到下执行

# 双分支条件判断
money = int(input("请输入你有多少钱"))
if money > 50:
    # 条件成立就执行里面的代码
    print("吃火锅")
else:
    # 不成立就执行else里的代码
    print("回家和西北风吧")

# 多分支条件判断
money = int(input("请输入你有多少钱"))
if money < 50:
    print("吃小面")
elif money < 100:
    print("吃豌杂面")
elif money < 200:
    print("吃火锅")
else:
    print("吃山珍海味")

15.循环语句

可以让我们的代码循环执行

# while循环
# while 判断条件:  # 一直判断条件,如果执行就执行里面的代码,如果条件不成立就跳出循环
#     代码块
#
# 循环打印数字从1 到 100
num = 1
while num < 101:
    print(num)
    num += 1

# 1+2+3+4+.......+100的值
num = 1
s = 0
while num < 101:
    s += num
    num += 1
    print(s)

停下循环

num = 0
while True:
    num += 1
    print(num)
    if num > 99:
        break  # 停止循环

num = 0
while True:
    num += 1

    if num == 5:
        continue  # 跳过本次循环
    print(num)
    if num > 9:
        break

# for 循环
"""
for 变量 in 可迭代对象:
    每次循环,把可迭代对象的值遍历传给变量
    代码块
"""
for i in range(10):
    print(i + 1)

for i in range(3, 10):  # [3,10)中依次取值给i

    print(i)

for i in range(1, 100, 5):  # [1, 100)中依次赋值给i, 并且间隔5

    print(i)

17:pass站位符

a = int(input("请输入一个数字"))
if a > 10:
    pass  # 如果暂时没想好写什么,就用pass填充,不然会报错

18.数据类型详情

# int 整型, 加减乘除, 大小比较
# a = 10

# float: 小数,浮点型
# a = 10.22
# print(a)
print(10 / 3)  # 小数,数据范围是无限的, 整数在某一个特定的区间可以表示的很清楚
# 0~1
# 计算机是一个二进制产品:0, 1
# 计算机表示的小数会有误差
# bool : 用来做条件判断的
# 值 True, False
# 基础数据类型之间的转化
"""
a = "10"
print(type(a))
b = int(a)
print(type(b))
"""
a = 10
b = bool(a)
print(type(b), b)
a = 0
b = bool(a)
print(type(b), b)
"""
在python中所有非零的数字都是True,零是False
在python中所有非空字符串都是True, 空是False
综上 python中所有非空表示True, 空是False
"""
list = []
if list:
    print("非空")
else:
    print("空")

while 1:
    content = input("请输入内容")
    if content:
        pass
    else:
        break

19.字符串格式化

name = input("请输入你的名字")
address = input("请输入你的住址")
age = int(input("请输入你的年龄"))
hobby = input("请输入你的爱好")
# %s 字符串占位
# %d 占位整数
# %f 占位小数
s = "我叫%s, 我住在%s, 我今年%d岁, 我喜欢%s" % (name, address, age, hobby)
s1 = "我叫{0}. 我住在{1}, 我今年{2}岁, 我喜欢{3}".format(name, address, age, hobby)
s2 = f"我叫{name}, 我住在{address},我今年{age}岁, 我喜欢{hobby}"
print(s)
print(s1)
print(s2)

20.字符串的索引和切片

# 索引:按照位置提取元素
s = "你好李焕英"
"""
索引
根据下标提取指定的某一个字符
0 1 2 3 4
-5 -4 -3 -2 -1
"""
print(s[1])
print(s[-1])
"""
切片:从一个字符串中提取一部分内容
"""
s1 = "你好李焕英"
print(s1[:])  # 全部内容
print(s1[3:])  # 下标3及以后的位置
print(s1[0:3])  # 下表[1,3)的内容
print(s1[::-1])  # 反向提取
print(s1[:4])  # 下标4以前的内容,不包含下标4的内容
print(s1[::2])  # 步长提取

21.字符串常规操作

字符串操作都是返回新的字符串

s1 = "adkfjakgB dgdkjg"
s2 = s1.capitalize()  # 首字母大写,其他小写(针对每个字符串)
print(s2)
s3 = "bdkfjB bdkgjkB"
s4 = s3.title()  # 首字母大写,其他小写(针对每个单词)
print(s4)

s5 = "DKAFJK"
print(s5.lower())  # 小写
s6 = "dkjakgjakg"
print(s6.upper())  # 大写

# 如何忽略验证码大小写判断
verify_code = "XAsd"
user_input = input(f"请输入验证码({verify_code}):")
if verify_code.lower() == user_input.lower():
    print("验证码正确")
else:
    print("验证码错误")

字符串替换和切割()

s = "   李白   杜甫   白居易  "
print(s.strip())  # 去除两边空格
# 案例登录
username = input("请输入用户名").strip()
password = input("请输入密码").strip()
print(username, password, type(username), type(password))
if username == "admin":
    if password == "123456":
        print("登录成功")
    else:
        print("登录失败")
else:
    print("没有此账户")

"""
replace(old, new) 字符串替换
"""
s = "你好呀,  李焕英"  # 去掉空格
s1 = s.replace(" ", "")
print(s1)
"""
str.split("x") 根据X切割
"""
s2 = "李白, 杜甫, 白居易"
s3 = s2.split(",")
print(s3)

字符串查找和判断

"""
s = "你好啊,李焕英"
s1 = s.find("你好123")  # 没找到就返回-1
print(s1)
s2 = s.index("你好123")  # 没找到就报错
print(s2)
"""

# 判断是否包含字符串
s3 = "你好啊,李焕英"
print("李焕英" in s3)

name = input('请输入你的名字')
if name.startswith("张"):  # 判断是否是张开头
    print("你姓张")
else:
    print("你不姓张")

money = input("请输入你包里的钱")
if money.isdigit():  # 判断是否是整数
    money = int(money)
    print("可以吃火锅")
else:
    print("对不起你输入有误")

s5 = "adkgjakgj"
print(len(s5))  # 统计字符串的长度

# 把列表连接成字符串
s6 = ["李白", "是", "诗仙"]
s7 = "_".join(s6)
print(s7)

22.列表操作

# 列表:能装东西的东西,并且可以修改
# 在python中[]表示一个列表
a = ["张无忌", "金毛狮王", "韦蝠王"]
"""
可以像字符串一样进行索引和切片
索引如果超过范围会报错
可以用for遍历
用len统计列表的长度
"""
a1 = a[1]
print(a1)
# a2 = a[5] 会报错超出下标范围
for i in a:
    print(i)
print(len(a))

# 列表的增删改查
a.append("杨逍")  # 追加
print(a)
a.insert(0, "赵云")  # 在该下标插入,其他的顺延
print(a)
a.extend(["武则天", "孙悟空"])  # 合并两个列表
print(a)
# 删除
a.pop(3)  # 指定下标
print(a)
a.pop()  # 默认删除最后一个
print(a)
a.remove("杨逍")  # 删除指定的元素
print(a)
# 修改
a[0] = "关云长"  # 指定下标删除元素
print(a)
# 查询
print(a[3])
a.append("张飞")
# 小联系 把姓张的人改成姓王
for index, i in enumerate(a):
    if i.startswith("张"):
        a[index] = a[index].replace("张", "王")
print(a)

# 列表的其他操作
s_list = ["1", 2, 3, "胡桃"]  # 列表按照顺序来保存
print(s_list)
s_slst1 = [222, 333, 444, 123, 133]
s_slst1.sort()  # 排序
print(s_slst1)
s_slst1.sort(reverse=True)  # 执行翻转操作
print(s_slst1)
# 列表的嵌套
s = [[1, 2, [1, 2, 3], "你好, 李焕英"]]
print(s[0][2][2])

# 列表的循环删除
s1 = ["胡桃", "胡军", "武田", "殷紫萍", "胡玮"]
for i in s1:  # 删除的时候元素前移,所以没删除完全
    if i.startswith("胡"):
        s1.remove(i)
print(s1)

# 解决办法 创建一个临时列表
s1 = ["胡桃", "胡军", "武田", "殷紫萍", "胡玮"]
s2 = ["胡桃", "胡军", "武田", "殷紫萍", "胡玮"]
for i in s2:
    if i.startswith("胡"):
        s1.remove(i)
print(s1)
# 方法2, 创建一个空的临时列表
s3 = ["胡桃", "胡军", "武田", "殷紫萍", "胡玮"]
s4 = []
for i in s3:
    if i.startswith("胡")
        s4.append(i)
for i in s4:
    s3.remove(i)
print(s3)
        

23.元组操作

# tuple 元组, 特点:不可变的列表
t = ("赵敏", "张无忌", "胡桃")
print(t)
# 元素如果只有一个值,需在元组的末尾加一个逗号
t1 = ("武田")
print(type(t1), t1)
t2 = ("武田",)
print(type(t2), t2)
print((1 + 3,) * 3)
print((1 + 3) * 3)
# 元素不可见的坑,元组的内存地址不能变,但是里面的内容可以变
t3 = ("火男", "蓝顶", "颠勺", "冲拳", [1, 2, 3])
t3[4].append("三娘")
print(t3)

24.集合操作

# set集合
s = {}  # 默认情况是字典
print(type(s))
# set集合是无序的
s1 = {"胡桃", "李焕英"}
print(type(s1))
s2 = {"胡军", (1, 2, 3)}
"""
什么值可以加入集合呢-可哈希(不可变)
假如集合的时候需要对数据进行哈希计算,所以需要可哈希的数据才能放入set
"""
# 不可哈希 list dict
# 创建空集合
s3 = set()
# 增加
s3.add("赵本山")
s3.add("夏目彩春")
s3.add("胡桃")
print(s3)
# 删除
s3.remove("赵本山")
# 修改  先删除再增加 相对修改
s3.remove("胡桃")
s3.add("胡军")

# 查询
for i in s3:
    print(i)
# 去重 顺序会变
s5 = ["你好", "你好", "胡桃", "胡桃"]
s5 = list(set(s5))
print(s5)
"""
交集,并集,差集
"""
t1 = {"岳山", "岳飞", "尼古拉斯"}
t2 = {"岳山", "太行山", "胡桃"}
print(t2 | t1)
print(t2 & t1)
print(t2.difference(t1))
print(t2 - t1)
print(t2.union(t1))
print(t2.intersection(t1))

25.字典操作

"""
字典:字符串的形式存储数据
"""
dic = {"name": "李白", "work": "诗仙", "age": 18}
# 字典的key必须是可哈希,也就是不可变的
# 字典的value可以存储任何数据

print(dic["name"])
"""
字典的增删改查
"""
dic1 = dict()
dic1["name"] = "杜甫"
dic1[1] = 123
print(dic1)
dic1[1] = 345  # 修改
print(dic1)
dic1.setdefault("age", "18")  # 设置默认值
dic1.setdefault("age", "20")  # 设置默认值
print(dic1)
"""
删除
"""
dic1.pop("name")
print(dic1)
"""
查询
"""
print(dic1[1])  # 如果不存在会报错
print(dic1.get(1))  # 如果不存在会返回None
# None  # 表示为空,无
# 例子
dic2 = {"殷紫萍": "奶妈", "武田": "夺刃", "火男": "冲拳"}
name = input("请输入你想了解的永劫的角色信息")
val = dic2.get(name)
if val:
    print(val)
else:
    print("里面没有这个角色")

"""
用for 循环拿到key
"""
dic = {"name": "李白", "age": 18, "work": "诗仙"}
for i in dic:
    print(i)
    print(dic[i])
print(list(dic.values()))
print(dic.values())
print(dic.keys())
print(list(dic.keys()))
print(dic.items())
print(list(dic.items()))
for item in dic.items():
    key, value = item
    print(key, value)
for key, value in dic.items():
    print(key, value)
"""
字典嵌套:类似元组嵌套
字典循环删除;类似列表循环删除,创建一个临时字典
"""

26.字符集和编码

"""
字符集和编码
1.ascil:8bit  1byte
2.gbk: 16bit  2 byte   windows默认
3.unicode: 32 bit 4byte(没法用只是一个标准)
4.utf-8   mac默认
英文: 8bit 1byte
欧洲:16bit 2byte
中文:24bit 3byte

gbk和utf-8不能直接转化

gbk ---> 文本  ---> utf-8
"""

"""
2.bytes
所有的数据单位都是byte
"""
s = "胡桃"
print(s.encode("gbk"))
print(s.encode("utf-8"))
s1 = b'\xe8\x83\xa1\xe6\xa1\x83'
s = s1.decode("utf-8")
s1 = s.encode("gbk")
print(s1)

27.运算符

"""
算术运算
"""
a = 10
b = 3
c = a + b
c1 = a - b
c2 = a * b
c3 = a / b
c4 = a % b  # 取余
c5 = a // b  # 取整
c6 = a ** b  # 幂运算
"""
比较运算
"""
a = 10
b = 20
print(a > b)
print(a >= b)
print(a < b)
print(a <= b)
print(a == b)
print(a != b)
a, b = b, a  # 互换
print(a, b)
"""
赋值运算
"""
s = 12
s1 = 13
s += 1
s -= 2
s *= 2
s /= 2
"""
逻辑运算
"""
a = True
b = False
print(a and b)
print(a or b)
print(not a)
"""
成员运算
"""
s4 = 12
s5 = {12, 24, 35}
print(s4 in s5)

28.文件读取

"""
1.找到文件,双击打开
"""
# open(文件路径, mode="" encoding='')
"""
文件路径:相对路径,绝对路径
../上一层文件夹
mode:
r 读取
w 写
a 追加
encoding utf-8
"""
f = open("文件.txt", mode="r", encoding="utf-8")
content = f.read()  # 全部读取
line = f.readline()  # 一行行读取
print(line)
# print() 默认最后换行
line1 = f.readline().strip()
print(line1)  # 正常换行
lines = f.readlines()  # 放入列表
for line in f:
    print(line.strip())  # 循环读取每一行
# 写入文件
# w 文件如果不存在会创建一个文件
# w 如果文件有内容会清空文件重新写入
f = open("文件.txt", mode="w", encoding="utf-8")
f.write("hello world")
f.close()
f1 = open("文件.txt", mode="w", encoding="utf-8")
list_1 = [1, 2, 3, 4]
for item in list_1:
    f1.write(item)
    f1.write("\n")

# a追加
f2 = open("文件.txt", mode="a", encoding="utf-8")
f2.write("你好")
# with
with open("文件.txt", mode="r", encoding="utf-8") as f:
    for item in f:
        print(item.strip())

# 读取图片
with open("文件.jpeg", mode="rb") as f:
    for line in f:
        print(line.strip())
# 复制图片
with open("文件1.jpeg", mode="rb") as f1, \
        open("文件2.jpeg", mode="wb") as f2:
    for line in f1:
        f2.write(line)

29.文件修改

"""
1.找到文件,双击打开
"""
import os

# open(文件路径, mode="" encoding='')
"""
文件路径:相对路径,绝对路径
../上一层文件夹
mode:
r 读取
w 写
a 追加
encoding utf-8
"""
f = open("文件.txt", mode="r", encoding="utf-8")
content = f.read()  # 全部读取
line = f.readline()  # 一行行读取
print(line)
# print() 默认最后换行
line1 = f.readline().strip()
print(line1)  # 正常换行
lines = f.readlines()  # 放入列表
for line in f:
    print(line.strip())  # 循环读取每一行
# 写入文件
# w 文件如果不存在会创建一个文件
# w 如果文件有内容会清空文件重新写入
f = open("文件.txt", mode="w", encoding="utf-8")
f.write("hello world")
f.close()
f1 = open("文件.txt", mode="w", encoding="utf-8")
list_1 = [1, 2, 3, 4]
for item in list_1:
    f1.write(item)
    f1.write("\n")

# a追加
f2 = open("文件.txt", mode="a", encoding="utf-8")
f2.write("你好")
# with
with open("文件.txt", mode="r", encoding="utf-8") as f:
    for item in f:
        print(item.strip())

# 读取图片
with open("文件.jpeg", mode="rb") as f:
    for line in f:
        print(line.strip())
# 复制图片
with open("文件1.jpeg", mode="rb") as f1, \
        open("文件2.jpeg", mode="wb") as f2:
    for line in f1:
        f2.write(line)
# 文件修改
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")

30.函数

"""
函数的概念:对特定的功能或者代码块进行封装,在需要使用该功能的时候直接调用就可以了
函数的参数
函数的返回值
python的内置函数
"""
# 定义函数
def 函数的名字():
    """
    封装的代码块
    :return:
    """
    print("这里面是我写的代码块")
函数的名字() #直接调用
"""
参数:
形参 准备变量接收
实参 实际的变量
传递给函数的数据
"""

"""
位置参数在前面,默认参数放后面
"""
def func(name, age, sex="男"):
    print(f"我的名字是{name}, 今年{age}岁了,性别为{sex}")
func("张强", 13)
"""
执行时所有的形参必须有值
"""

"""
位置参数和默认参数一起使用时先位置在默认
"""

"""
动态参数
传入一个*x列表或者传入一个字典**x
"""
"""
各个参数的位置
位置 * 默认值 **
"""

"""
解包
"""
def func2(*loc):
    print(loc)

"""
结果
"""
return 就是函数结束返回的结果 如果没有,默认返回None
return 后面代码不执行

31.高级函数用法

"""
作用域:变量的访问权限
"""
a = 10  # 全局变量 全局作用域
print(a)


def func():
    b = 20  # 局部变量
    print(a)


func()
# print(b) 局部变量

"""
里面可以访问外面,外面不能访问里面
"""

"""
函数的嵌套
"""


def func1():
    b = 20

    def func2():
        print(3)

        def func3():
            print(4)

        func3()

    func2()
    print(1)


func1()

"""
函数返回
"""


def func4():
    def func5():
        print(4)

    return func5


a = func4()
a()
"""
实参可以是函数
"""


def func6(func):
    func()


func6(a)

"""
总结:函数可以作为返回值进行返回
函数可以作为参数进行互相传递
函数名实际上就是一个变量名,都表示一个内存地址
"""

a = 10


def func_110():
    a = 20  # 创建的是局部变量


func_110()
print(a)


def func_120():
    global a
    a = 20


func_120()
print(a)


def func_130():
    a = 30

    def func_140():
        nonlocal a  # 向外找一层,看看有没有该变量,如果有就引入如果没有就继续往前找
        a = 40

    func_140()
    print(a)


func_130()

"""
闭包:内存函数对外层函数的局部变量的使用,内层函数被称为闭包函数
可以让一个变量常驻于内存
可以避免全局被修改
"""


def func():
    a = 10

    def inner():
        print(a)
        return a

    return inner


def func1():
    a = 20

    def inner():
        nonlocal a
        a += 2
        return a

    return inner


a = func1()
print(a())
print(a())
print(a())
print(a())
print(a())
print(a())

"""
装饰器
函数可以作为参数进行传递
函数可以作为返回值进行返回
函数名称可以当做变量一样赋值操作
"""


def func():
    print("我是函数")


def ggg(fun):
    fun()


def func1():
    def func2():
        print("内存函数")

    return func2


fun = func1()
fun()


# 函数名称可以当做变量一样赋值操作
def fun_1():
    print("我是函数一")


def fun_2():
    print("我是函数二")


fun_1 = fun_2
fun_1()
"""
装饰器使用
"""


def func_100(func):
    def func_200():
        print("新功能")
        func()
        print("新功能")

    return func_200


@func_100
def func_300():
    print("装饰器")


func_300()

"""
作用:
在不改变原有函数调用的情况下,给函数增加新的功能
"""

"""
装饰器
函数可以作为参数进行传递
函数可以作为返回值进行返回
函数名称可以当做变量一样赋值操作
"""


def func():
    print("我是函数")


def ggg(fun):
    fun()


def func1():
    def func2():
        print("内存函数")

    return func2


fun = func1()
fun()


# 函数名称可以当做变量一样赋值操作
def fun_1():
    print("我是函数一")


def fun_2():
    print("我是函数二")


fun_1 = fun_2
fun_1()
"""
装饰器使用
"""


def func_100(func):
    def func_200():
        print("新功能")
        func()
        print("新功能")

    return func_200


@func_100
def func_300():
    print("装饰器")


func_300()

"""
作用:
在不改变原有函数调用的情况下,给函数增加新的功能
"""

"""
装饰器使用参数&返回值举例
"""


def function(func):
    def function1(*args, **kwargs):
        print("新增功能")
        val = func(*args, **kwargs)
        print("新增功能")
        return val
    return function1


@function
def func_00(name, age, sex="女"):
    print(name, age, sex)
    return name, age, sex


print(func_00("李白", 176, sex="男"))

"""
函数可以被多个装饰器装饰
"""
def func1(func):
    def inner(*args, **kwargs):
        print(1)
        func()
        print(2)
    return inner
def func2(func):
    def inner(*args, **kwargs):
        print(3)
        func()
        print(4)
    return inner
@func1
@func2
def func3():
    print(5)

func3()

32.迭代器

"""
迭代器的使用
"""
s = ["李白", "杜甫", "白居易"]
for i in s:
    print(i)

t = iter(s)
while 1:
    try:
        print(next(t))
    except:
        break

"""
迭代器最大的作用,统一了不同数据类型的遍历方式
"""
"""
迭代器本身也可以被迭代
"""
"""
迭代器本身的特性:
只能向前不能反复
特别省内存
惰性机制,什么时候调用在往前走
"""

33.生成器

"""
生成器:本质就是迭代器
创建生成器的两种方案
生成器函数
生成器表达式
"""

"""
生成器函数
关键字yield
生成器函数执行时,得到生成器,并不会执行函数
"""


def func():
    print(11)
    return 12


a = func()
print(a)


def func1():
    print(11)
    yield 12


a = func1()
print(next(a))

"""
举例
"""


def fun2():
    s = []
    for i in range(1000):
        s1 = f"这是第{i + 1}件衣服"
        s.append(s1)
        if len(s) == 50:
            yield s
            s = []


a = fun2()
print(next(a))
print(next(a))
print(next(a))
print(next(a))
print(next(a))

"""
推导式 简化代码
语法:
列表推导式: [数据] for循环 if条件判断
"""
lis = [i for i in range(1, 100, 5)]
print(lis)
lis1 = [f"衣服{i}" for i in range(100)]
print(lis1)

"""
集合推导式
"""
set1 = {f"衣服{i}" for i in range(100)}
print(set1)

"""
字典推导式
将列表修改成字典,要求索引为key,数据为value
"""
list1 = ["胡桃", "岳山", "三娘"]
dict1 = {item: i for item, i in enumerate(list1)}
print(dict1)

"""
生成器表达式 一次性的
"""
t1 = (2**i for i in range(100))
print(t1)
for i in t1:
    print(i)
t1 = (2**i for i in range(100))
aa = list(t1)
print(aa)

"""
匿名函数/lambda表达式
"""


def func():
    print(123456)
    return 9999


a = lambda x, y: x + y
print(a(1, 2))

34.内置函数

"""
zip
"""
list = [1, 2, 3, 4, 5]
list2 = ["李白", "苏轼", "东坡肉", "飞到", "数学"]
print(zip(list, list2))
for item, i in zip(list, list2):
    print(item, i)

"""
locals 看当前作用域的内容
"""
a = 1
print("-------")
print(locals())
print("--------")


def fun():
    a = 12
    print(locals())


fun()
"""
globals() 是全局作用域的内容
"""

"""
sorted
"""
lst = ["李白", "hello", "2"]
print(sorted(lst, key=lambda x: len(x)))
print(lst)

dic = [
    {"age": 1},
    {"age": 2},
    {"age": 4},
    {"age": 3},
]
print(sorted(dic, key=lambda x: x["age"]))

"""
filter 筛选
"""
lst = ["张无忌", "张三丰", "赵敏"]
s = filter(lambda x: x.startswith("张"), lst)
print(list(s))
"""
map
"""
lst1 = [1, 2, 3, 4, 5, 6]
list2 = [i ** 2 for i in lst1]
print(list2)
s = map(lambda x: x ** 2, lst1)
print(list(s))

"""
递归:默认没有拦截就是死循环
函数自己调用自己
尽量不使用递归
"""