一、生成式
生成式就是生成器的简写
1、语法一
(表达式 for 变量 in 序列)
说明：
表达式 —— 任何有结果的语句，具体的数据，赋值过的变量，非赋值的运算表达式等 ...展开成生成器：
def 函数名():
for 变量 in 序列:
yield 表达式
生成器 = 函数名
- 用法：
# 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
print(sum(gen))
gen = (x*2 for x in 'hello')
print(max(gen))
# 2. 列表生成式
list1 = list(x for x in range(5))
print('list1: ', list1)
list2 = [x for x in 'abc']
print('list2: ', list2)
gen2 = (x*10 for x in range(5))
list2 = list(gen2)
# print(list2)
# print(next(gen2)) # StopIteration
# 3.字典生成式
dict1 = dict((x, x*2) for x in range(5))
print(dict1)
gen = ((x, x*2) for x in range(5))
print(dict(gen))
2.语法二
生成器 = (表达式 for 变量 in 序列 if 条件语句)
- 展开成生成器
def 函数名():
for 变量 in 序列:
if 条件语句:
yield 表达式
生成器 = 函数名()
- 用法：
gen3 = (x for x in range(10) if x % 2)
"""
def func():
for x in range(10):
if x % 2:
yield x
gen3 = func()
"""
print(list(gen3))
补充：
C、java、js等中的三目运算符：
变量 = 条件语句?表达式1:表达式2
python中的三目运算符：
变量 = 表达式1 if 条件语句 else 表达式2
三目运算符的功能：判断条件语句是否为True，如果是结果是表达式1，否则是表达式2
a = 10
num = '奇数' if a & 1 else '偶数'
print(num)
# 练习：用生成式写一个生成器，能够产生1~10中所有的书能否被3整除的结果
# 1 -> False, 2 -> True, 3-> True, 4 -> False, ...
res = (False if x % 3 else True for x in range(1, 11))
print(list(res))
二、函数作为变量
内存（运行内存），分为两个区，即栈区间和堆区间
在python中所有的数据都存在“堆”里面，“所有python皆对象”
如a=10, 10在“堆”里面(0xff)，a:0xff在“栈”里面，a=10称为引用
name:func1在“堆”里面(0xee)，func1: 0xee在“栈”里面
1.python中声明函数
python中声明函数就是声明类型是function的变量，函数名就是变量名
普通函数能做的事情，函数都可以做
a = 10
print(a, type(a))
# 10 <class 'int'>
def func1():
print('======')
print(func1, type(func1), id(func1))
# <function func1 at 0x00000000025C4C18> <class 'function'> 39603224
1）用一个变量给另一个变量赋值
b = a
print(b, b+20*2)
c = func1
c()
2）修改变量的值
a = 'abc'
print(b, a+'hello')
# func1 = 100
print(c)
# func1() # TypeError: 'int' object is not callable
3）变量作为序列的元素
list1 = [a, 10]
print(list1)
print(list1[0].rjust(7, '0'))
list2 = [func1, func1(), 10]
print(list2)
print('~~~~~~~~~~~~~~~')
print(list2[0]())
a = 2
b = a
print(a, b)
a += 2
print(a, b)
b += 4
print(a, b)
4）作为函数的参数 —— 实参高阶函数
def func2(x):
print('函数里面：', x)
a = 10
func2(a)
func2(func1)
5）变量作为函数的返回值 —— 返回值高阶函数
def func3(x, y):
num = x + y
return num
print(func3(1, 2))
def func4():
def func5():
print('函数5')
return func5
print(func4()) # <function func4.<locals>.func5 at 0x000000000279E0D8>
func4()()
三、高阶函数
装饰器 = 实参高阶函数 + 返回值高阶函数 + 糖语法
1.实参高阶函数
实参高阶函数 —— 参数是函数的函数（装饰器，sorted，max，min）
python中内置的sorted、max、min等函数，以及列表的sort方法都是实参高阶函数。这些函数中都有一个参数key，要求传参的时候传一个函数。
这个参数需要一个参数和一个返回值，参数表示序列中的元素，返回值是比较对象
nums = [1, 78, 90, 23, 74, 90]
# nums.sort(key=100) # TypeError: 'int' object is not callable
nums.sort() # sort(self, key, reverse)
nums1 = sorted(nums) # sorted(iterate, key, reverse)
# 问题1：按个位数的大小对num中的元素从小到大排序
# [90, 90, 1, 23, 74, 78]
# 方法1
# def func1(item):
# return item % 10
#
#
# nums.sort(key=func1)
# 方法2
# nums.sort(key=lambda x: x % 10) #按照个位数排序
print(nums)
# 问题2：按各位数之和从大到小排序
# 1, 15, 9, 5, 11, 9 -> [78, 74, 90, 90, 23, 1]
nums = [1, 78, 90, 23, 74, 90]
def func2(item):
sum1 = 0
for x in str(item):
sum1 += int(x)
return sum1
nums.sort(reverse=True, key=func2)
print(nums)
# 按照字典中key为'score'的值从小到大排序
dict1 = [
{'name': '小明1', 'score': 45},
{'name': '小明2', 'score': 98},
{'name': '小明3', 'score': 67},
{'name': '小明4', 'score': 77}
]
dict2 = sorted(dict1, key=lambda s: s['score'])
print(dict2)
nums = [1, 78, 90, 23, 74, 90]
print(max(nums))
print(max(nums, key=lambda x: x % 10))
print(max(dict1, key=lambda s: s['score']))
# max函数的内部实现
def ly_max(*args, key=None):
# print(args)
# 传的是一个序列，想要求序列中元素的最大值
if not key:
if len(args) == 1:
seq = list(args[0])
max1 = seq[0]
for x in seq[1:]:
if x > max1:
max1 = x
return max1
# 传的是多个数据，求多个数据中的最大值
else:
max1 = args[0]
for x in args[1:]:
if x > max1:
max1 = x
return max1
else:
if len(args) == 1:
seq = list(args[0])
max1 = seq[0]
for x in seq[1:]:
if key(x) > key(max1):
max1 = x
return max1
# 传的是多个数据，求多个数据中的最大值
else:
max1 = args[0]
for x in args[1:]:
if key(x) > key(max1):
max1 = x
return max1
print(ly_max(23, 89, 0))
print(ly_max(87, 82, 56, key=lambda x: x % 10))
四、返回值高阶函数
1.返回值高阶函数
返回值高阶函数 —— 函数的返回是一个函数
- 情况一：真正的返回值高阶函数
def func1():
def func2():
print('函数2')
return func2
- 情况二：假的返回值高阶函数
def func3():
print('函数3')
def func4():
return func3
练习：声明一个函数operation，要求可以接受一个字符参数，最后根据值的不同，返回不同功能的函数
# + -> 求和功能的函数， - -> 求多个数差的功能，* -> 求多个数的乘积的功能
# operation('+')(1, 2, 4, 5) -> 12
# operation('-')(1, 2, 4, 5) -> -10
# operation('*')(1, 2, 4, 5) -> 40
def operation(str0):
if str0 == '+':
def sum0(*args):
sum1 = 0
for x in args:
sum1 += x
return sum1
return sum0
elif str0 == '-':
def diff0(*args):
diff1 = args[0]
for x in args[1:]:
diff1 -= x
return diff1
return diff0
elif str0 == '*':
def multiplication0(*args):
multiplication1 = args[0]
for x in args[1:]:
multiplication1 *= x
return multiplication1
return multiplication0
print(operation('+')(1, 2, 4, 5))
print(operation('-')(1, 2, 4, 5))
print(operation('*')(1, 2, 4, 5))
五、闭包
1.什么是闭包
闭包 就是一个函数，这个函数需要满足一下两个条件：
a. 函数的返回值是声明在这个函数中的函数（内函数）
b. 这个内函数必须使用外函数中的临时变量（外函数中的局部变量）
闭包的作用：保存临时变量（函数调用结束后，函数中的数据不能销毁）
普通函数
def func11(x):
a = 10 + x
return a
func11(1)
闭包函数
def func1(x):
a = 10
def func2():
print(a+x)
print('内函数')
return func2
六、装饰器
装饰器是python的三大神器（迭代器、生成器、装饰器）之一
1.什么是装饰器
- 装饰器本质还是一个函数
- 装饰器的作用：在不改函数本身的前提下给函数添加功能
方式一：给函数添加功能需要修改代码
import time
def sum1(x, y):
start = time.time()
print('和: ', x+y)
# time.sleep(2)
end = time.time()
print('总时间：', end-start)
sum1(100, 200)
方式二：在调用函数的基础上去添加功能
import time
def sum1(x, y):
sum2 = x + y
# sum2 = 100 + 200
print(sum2)
def func1(z):
print('++++')
print('------')
print(z)
def count_time(fn, *args, **kwargs):
start = time.time()
fn(*args, **kwargs)
time.sleep(1)
end = time.time()
print('总时间：', end - start)
count_time(sum1, 111, 222)
count_time(func1, 'abc')
方式三：装饰器
语法：
def 函数名1(参数1):
def 函数名2(*args, **kwargs):
体现为原函数添加功能的代码
(保证出现：参数1(*args, **kwargs))
return 函数名2
@函数名1
声明需要添加功能的函数
def count_time(fn):
def test(*args, **kwargs):
start = time.time()
fn(*args, **kwargs)
time.sleep(1)
end = time.time()
print('总时间：', end - start)
return test
# count_time(sum1)(100, 200)
@count_time
def func1():
print('==========')
func1()
@count_time
def func2(x, y):
print('x+y = ', x+y)
func2(300, 3)
练习：写一个装饰器，给函数添加权限
def password(fn):
def root(*args, **kwargs):
psw = input('请输入密码：')
if psw == '321':
fn(*args, **kwargs)
else:
print('密码错误')
return root
@password
def print_ok():
print('============')
print('ok')
print('============')
print_ok()
七、回调函数
回调函数 —— 在其他函数的内部满足条件的时候自动调用的函数
def func1():
print('ok')
def func2():
print('exit.........')
# 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(in_call_back=func1, exit_call_back=func2)
