生成式
生成式就是生成器的简写
1）语法1
生成器 = （表达式 for 变量 in 序列）
a.说明：表达式 - 任何有结果的语句，数据，赋值后的变量，非赋值的运算表达式
b.展开为生成器：
def 函数名()：
for 变量 in 序列：
yield 表达式
生成器 = 函数名()
1.1生成式产生生成器
gen = (100 for x in 'hello')
print(type(gen)) # <class 'generator'> 生成器
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))
# print(next(gen)) # StopIteration
# 该生成式的值的个数与for循环的次数有关
1.2列表生成式
list1 = list(x for x in range(5))
print(list1)
gen1 = (x*10 for x in range(5))
list2 = list(gen1)
print(list2)
# print(next(gen1)) # StopIteration
list3 = [s for s in 'sss']
print(list3)
1.3字典生成式
dict1 = dict((x, x*2) for x in range(5))
print(dict1) # {0: 0, 1: 2, 2: 4, 3: 6, 4: 8}
2)语法2
生成器 = （表达式 for 变量 in 序列 if 条件语句）
a.展开成函数
def 函数名():
for 变量 in 序列：
if 条件语句：
yield 表达式
生成器 = 函数名()
gen2 = (x for x in range(10) if x % 2)
list4 = list(gen2)
print(list4)
补充：python 中的三目运算符
c、java、js等中的三目运算符：变量 = 条件语句？表达式1：表达式2
python 中的三目运算符：变量 = 表达式1 if 条件语句 else 表达式2
功能：判断条件语句是否为True，如果是结果是表达式1，否则结果为表达式2
a = 19
num = '奇数' if a & 1 else '偶数'
print(num)
练习：使用生成式写一个生成器，能够产生1~10中所有的数能否被3整除的结果
ee = ('True' if x % 3 == 0 else 'False' for x in range(1, 11))
print(list(ee))
函数作为变量
python 中所有数据都存在堆里（包括函数）
1.python中声明函数就是声明类型是function的变量，函数名就是变量名
普通变量能做的事函数都能做
a = 12
print(a, type(a))
def f1():
print('====')
print(f1, type(f1), id(f1))
# <function f1 at 0x000001AA6CB63438> <class 'function'> 1831479948344
1）用一个变量给另外一个变量赋值
b = a
print(b)
c = f1
print(c, type(c), id(c))
# <function f1 at 0x000001AA6CB63438> <class 'function'> 1831479948344
c() # 调用函数
2）修改变量的值
a = '123'
# f1 = 100
# # f1() # 给f1赋值为整型之后不能调用 TypeError: 'int' object is not callable
# print(f1)
3)作为序列的元素
list1 = [a, 10]
print(list1)
print(list1[0].rjust(7, '0'))
list2 = [f1, f1(), 10]
print(list2) # [<function f1 at 0x0000012992B13438>, None, 10]
list2[0]() # 列表第一个元素是函数，调用该函数
# ====
print(list2[0]())
# ====
# None
4）作为函数的参数
def f2(x):
print(x)
a = 10
f2(a)
f2(f1) # 实参高阶函数，某一个函数的参数是函数
5）变量作为函数的返回值
def f3(x, y):
num = x + y
return num
print(f3(1, 3))
def f4():
def f5():
print('函数5')
return f5 # 返回值高阶函数：一个函数的返回值是函数
print(f4()) # <function f4.<locals>.f5 at 0x00000213ED7B3828>
f4()() # 函数5
print(f4()())
# 函数5
# None
高阶函数
装饰器 = 实参高阶函数 + 返回值高阶函数 + 糖语法
1.实参高阶函数（一个函数的参数是函数）
python中内置的sorted、max、min、等函数，以及列表的sort方法都是实参高阶函数
这些函数都有一个参数为key，要求传参的时候传一个函数。（这个函数需要一个参数和
一个返回值，参数代表序列中的元素，返回值是返回比较的对象）
nums = [1, 3, 5, 8, 9, 11]
# nums.sort(key=1) # TypeError: 'int' object is not callable
nums.sort()
print(nums) # [1, 3, 5, 8, 9, 11]
问题1：按个位数的大小对nums中的元素从小到大排序
# def f1(item):
# return item % 10
# nums.sort(key=f1)
# print(nums) # [1, 11, 3, 5, 8, 9]
nums.sort(key=lambda item: item % 10)
print(nums) # [1, 11, 3, 5, 8, 9]
问题2：按各个数的所有位数之和从大到小排序
def f2(item):
sum = 0
for x in str(item):
sum += int(x)
return sum
nums.sort(key=f2)
print(nums) # [1, 11, 3, 5, 8, 9]
dicts = [
{'a': 'a', 's': 89},
{'a': 'b', 's': 81},
{'a': 'c', 's': 86},
{'a': 'd', 's': 85},
]
# 按照字典中‘key’ 为‘s’的值从小从小到大排序
dicts.sort(key=lambda item: item['s'])
print(dicts)
# [{'a': 'b', 's': 81}, {'a': 'c', 's': 86}, {'a': 'a', 's': 89}, {'a': 'd', 's': 89}]
nums2 = [1, 78, 90, 23, 74]
print(max(nums2, key=lambda item: item % 10))
print(max(dicts, key=lambda item: item['s']))
# max函数的内部实现
def yt_max(*args, key=None):
if not key:
# print(args)
# 传的是一个序列,想要求序列中元素的最大值
if len(args) <= 1:
seq = list(args[0])
max = seq[0]
for x in seq[1:]:
if x > max:
max = x
return max
# 传的是多个数据，求多个数据中的最大值
else:
max = args[0]
for x in args[1:]:
if x > max:
max = x
return max
else:
if len(args) <= 1:
seq = list(args[0])
max = seq[0]
for x in seq[1:]:
if key(x) > key(max):
max = x
return max
# 传的是多个数据，求多个数据中的最大值
else:
max = args[0]
for x in args[1:]:
if key(x) > key(max):
max = x
return max
print(yt_max(223, 89, 0))
print(yt_max(87, 89, 560, key=lambda x: x % 10))
2.返回值高阶函数
写装饰器或闭包
返回值高阶函数
函数的返回值是一个函数，这样的函数就是返回值高阶函数
返回值高阶函数
def f1():
def f2():
print('f2')
return f2
假的返回值高阶函数
def f3():
print('ss')
def f4():
return f3
练习：声明一个函数operation，要求可以接收一个字符参数，最后根据字符值得不同返回不同功能的函数
def operation(str:str):
if str == '+':
def jia(*args):
sum1 = 0
for i in args:
sum1 += i
return sum1
return jia
if str == '_':
def jian(*args):
temp = args[0]
for i in args[1:]:
temp -= i
return temp
return jian
if str == '*':
def cheng(*args):
count = 1
for i in args:
count *= i
return count
return cheng
print(operation('+')(1, 2, 3, 4))
闭包
写装饰器
闭包
1.什么是闭包
闭包就是一个函数，满足一下两个条件：
a.函数的返回值是声明在这个函数中的函数（内函数）
b.这个内函数必须使用外函数中的临时变量（外函数中的局部变量）
闭包的作用：保存临时变量的值（函数调用结束后，函数中的数据不销毁）
def f1(x):
a = 10
def f2():
print(a + x)
print('内函数')
return f2
f1(12)
装饰器
装饰器是python的三大神器之一
1.什么是装饰器：装饰器本质还是一个函数
装饰器的作用：在不修改函数本省的前提下给函数添加功能
方式1：给函数添加功能需要修改源代码
import time
def sum1(x, y):
start = time.time()
print(x + y)
print('sssssssssssss')
end = time.time()
print('时间：', (end - start))
sum1(1, 2)
方式2：调用函数的时候添加功能
def sum11():
print('sssssssssssss')
print('ssssddddddddddaaaaaaaaa')
def count_time(fn):
start = time.time()
fn()
end = time.time()
print('总时间：', end - start)
count_time(sum11)
def sum11(x, y):
print(x + y)
print('sssssssssssss')
print('ssssddddddddddaaaaaaaaa')
def count_time2(fn, *args, **kwargs):
start = time.time()
fn(*args, **kwargs)
end = time.time()
print('总时间：', end - start)
count_time2(sum11, 1, 2)
方式3：装饰器
语法：
def 函数名1（参数(一个，fn)）：
def 函数名2（*args， *kwargs）：
添加为原函数添加功能的代码
（保证出现：参数1（args， **kwargs）） ###
return 函数2
使用：
@函数名1
声明需要添加功能的函数
print('------------------------')
def count_time3(fn):
def test(*args, **kwargs):
start = time.time()
fn(*args, **kwargs)
end = time.time()
print('shijain:', end - start)
return test
sum11 = count_time3(sum11)
sum11(1, 33)
print()
@count_time3
def pr():
print('pppppppppppp')
pr()
@count_time3 # 糖语法
def jia(x, y):
print(x + y)
jia(1, 2)
练习：写一个装饰器给函数添加权限
def authority(fn):
def test(*args, **kwargs):
a = input('密码：')
if a == '123456':
print('密码正确')
fn(*args, **kwargs)
return test
@authority
def fun3():
print('=========')
fun3()
回调函数
1.什么是回调函数: 函数的调用是在其他函数的内部满足条件的时候自动调用的函数
import itchat
import time
def func1():
print('登录成功')
def func2():
print('退出！')
# itchat.auto_login(loginCallback=func1, exitCallback=func2)
#
# itchat.run()
# 这儿的in_call_back和exit_call_back都是回调函数
def login(in_call_back, exit_call_back):
in_call_back()
time.sleep(3)
exit_call_back()
login(func1, func2)
