函数参数
def func(name: str, age: int) -> str:
print(f"姓名>>>{name}")
print(f"年龄>>>{age}")
return "信息已展示"
if __name__ == '__main__':
print(func("Tony", 18))
print(func.__annotations__)
三元表达式
def func(x, y):
if x > y:
return x
else:
return y
# 以上的代码可用‘三元表达式’实现
x = 6
y = 3
res = x if x > y else y
生成器
"""生成器"""
"""普通方法"""
g = []
for x in range(10 + 1):
g.append(x)
"""使用"生成器"方法（用多少数字生成多少数字）"""
def generator():
for i in range(10 + 1):
yield i
aa = generator()
next(aa)
next(aa)
"""生成器原理介绍"""
def generator_1():
print("函数开始...")
while True:
res = yield 666
print("当前的res为--->", res)
tt = generator_1()
print(next(tt))
print("——" * 10)
print(next(tt))
"""
程序执行过程解析:
1.程序开始执行以后，因为函数中有yield关键字，所以函数并不会真的执行，而是先得到一个生成器tt(相当于一个对象)
2.直到调用next方法，函数正式开始执行，先执行函数中的print方法，然后进入while循环
3.程序遇到yield关键字，然后把yield当成return，return了一个666之后，程序停止，并没有执行赋值给res操作，
此时next(tt)语句执行完成，所以输出666
4.程序执行print("——"*10)，输出10个——
5.又开始执行下面的print(next(tt)),这个时候和上面那个差不多，
不过不同的是，这个时候是从刚才那个next程序停止的地方开始执行的，
也就是要执行res的赋值操作，
这时候要注意，这个时候赋值操作的右边是没有值的，
因为刚才那个是return出去了，并没有给赋值操作的左边传参数，
所以这个时候res赋值是None,所以接着下面的输出就是当前的res为---> None，
6.程序会继续在while里执行，又一次碰到yield，这个时候同样return出666，然后函数暂停，print函数输出的666
到这里你可能就明白yield和return的关系和区别了，
带yield的函数是一个生成器，而不是一个函数了，
这个生成器有一个函数就是next函数，
next就相当于“下一步”生成哪个数，
这一次的next开始的地方是接着上一次的next停止的地方执行的，
所以调用next的时候，生成器并不会从函数的头部开始执行，
而是接着上一步停止的地方开始，然后遇到yield后，return出要生成的数，然后暂停...
"""
def generator_2():
print("函数开始...")
while True:
res = yield 666
print("当前的res为--->", res)
mm = generator_2()
print()
next(mm)
print("*" * 20)
next(mm)
mm.send(520)
迭代器
"""迭代器"""
"""
1.
迭代器对象从集合的第一个元素开始访问，
直到所有的元素被访问完结束。
迭代器只能往前不能后退
2.
迭代器是Python中的容器类的数据类型，
可以同时存储多个数据，取迭代器中的数据只能一个一个地取，
而且取出来的数据在迭代器中就不存在了。
3.
迭代器有两个基本的方法：iter() 和 next()
4.
所有的序列都可以转换成迭代器，
包括字符串、列表、元组、字典对象等
"""
"""创建迭代器(iterate:迭代)"""
iter1 = iter('abcd')
for index, date in enumerate(iter1):
print(index, date)
iter2 = iter([1, 2, 3, 4])
for i in iter2:
print(i)
iter3 = iter({'name': 'aaa'})
print(iter3)
"""通过next()方法取迭代器中的元素(iterate:迭代)"""
iter4 = iter([10, 5, 2])
print(next(iter4, 0))
print(next(iter4, 0))
print(next(iter4, 0))
print(next(iter4, 'end'))
可变长参数
"""可变长度参数"""
'''
约定成俗 *args **kwargs
'''
def func1(a, b, *c, **d):
print(a)
print(b)
print(type(c), c)
print(type(d), d)
return None
func1(1, 2, 3, 4, name="王强")
def func2(a, b, *c, **d):
print(a)
print(b)
print(*c)
print(d.get("name"))
return None
func2(5, 4, 3, 2, name="小明")
递归函数
"""函数的递归"""
def the_sum(i):
if i == 0:
return 0
return i + the_sum(i - 1)
print(the_sum(10))
def hano(n, A, B, C):
"""注释：
整体法 + 树状图反推法 ---> 汉诺塔算法
A:start_position
B:wait_position
C:end_position
"""
if n == 1:
print(f"{A} ---> {C}")
else:
hano(n - 1, A, C, B)
print(f"{A} ---> {C}")
hano(n - 1, B, A, C)
num = int(input("请输入盘子个数>>>"))
hano(num, "A", "B", "C")
匿名函数
"""匿名函数"""
def func(x, y):
return x + y
res = (lambda x, y: x + y)(2, 5)
print(res)
"""匿名函数的应用"""
""" 应用1：找出薪资最高的那个人的名字 """
info = {
'jack': 5000,
'tony': 2500,
'andy': 8000,
'amy': 6000,
'lucy': 11000
}
res = max(info, key=(lambda k: info[k]))
print(res)
res = min(info, key=lambda k: info[k])
print(res)
""" 应用2：给列表内的所有元素添上一个后缀 ---> _老坛酸菜 """
list_info = [
'康师傅',
'景观狼',
'大今野',
'白象叶',
]
list_new = [name + "_老坛酸菜" for name in list_info]
print(list_new)
res = map(lambda name: name + '_老坛酸菜', list_info)
print(next(res))
装饰器
无参装饰器
"""装饰器（无参）"""
import time
"""我的世界~Game"""
def minecraft(name, ability):
print("\n欢迎来到————我的世界!")
print("你好，%s，欢迎回来！" % name)
print("你的%s技能得到了10点提升\n" % ability)
minecraft("史蒂夫", "锋利II")
"""完美世界~Game"""
def time_statistics(func):
def wrapper(*args, **kwargs):
t1 = time.time()
res = func(*args, **kwargs)
t2 = time.time()
print("游戏已结束...")
print("在线游戏时间：%.1f" % (t2 - t1))
return res
return wrapper
@time_statistics
def perfectworld(name, behavior):
time.sleep(1)
print("欢迎来到————完美世界!")
time.sleep(1)
print("玩家 >%s< 正在%s" % (name, behavior))
time.sleep(1)
perfectworld("荒天帝", "战斗")
含参装饰器
"""装饰器（含参）"""
import time
from functools import wraps # 导入工具模块,为下面的调用‘完美伪装’做准备
def game_time(account, address):
def out_wrapper(func):
@wraps(func) # 完美装饰！
def wrapper(*args, **kwargs):
print(f"欢迎{account}来到《时间猎人》游戏")
print(f"{account}前往了游戏{address}区")
t1 = time.time()
res = func(*args, **kwargs)
t2 = time.time()
print(f"\n\n{account}已退出游戏...")
print("游戏时长>>> %.2f秒" % (t2 - t1))
return res
return wrapper
return out_wrapper
# 时间猎人~源代码
@game_time(25988, 1)
def time_hunter(name, ability, blood):
print(f"\n时间猎人 >%s< 正遭受攻击" % name)
print(f"{name}正在使用{ability}进行反击")
for i in range(blood, -1, -1):
print(f"\r当前血条>>> {i}", end="")
time.sleep(0.05)
time_hunter("雷鸣", "时间冻结", 100)
案例演示
import time
# 装饰器部分:
def outer_1(func):
def wrapper_1():
while True:
name = input('\r请输入账号：').strip()
password = input('请输入密码：').strip()
if name == '叶寻' and password == '123':
res = func()
return res
else:
print('账号或密码错误！')
return wrapper_1
def outer_2(func):
def wrapper_2(*args, **kwargs):
print('''\r正在打开登录系统，请稍等...''', end='')
for i in range(5 + 1):
time.sleep(1)
print(f'\r倒计时 ————)))- {5 - i}秒', end='')
res = func(*args, **kwargs)
return res
return wrapper_2
def outer_3(func):
def wrapper(*args, **kwargs):
p = '正在前往登录系统'
k = p.center(2, '*')
print(k, end='')
time.sleep(2)
res = func(*args, **kwargs)
return res
return wrapper
# 原始功能被‘三层装饰器’装饰
@outer_3
@outer_2
@outer_1
def login():
print('登录成功！')
return 520
# 执行功能
login()
记忆函数
"""带有记忆功能的函数"""
def outer():
x = 0
y = 0
def inner(x1, y1):
nonlocal x, y
x = x + x1
y = y + y1
print("当前坐标位置为(%s,%s)" % (x, y))
return inner
move = outer()
while True:
s = input("Q退出").strip()
if (s == "Q" or s == "q"):
break
x = int(input("沿着X方向走>>>").strip())
y = int(input("沿着y方向走>>>").strip())
move(x, y)
