01 - 生成式
生成式就是生成器的简写
1)语法一
生成器 = （表达式 for 变量 in 序列）
a.说明：
表达式 - 任何有结果的语句：数据，赋值后的变量，非赋值的运算表达式等...
b.展开成生成器:
def 函数名():
for 变量 in 序列：
yield 表达式
生成器 = 函数名（）
1.用生成式创建生成器
gen = (x*2 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
2.列表生成器:
list1 = list(x for x in range(5))
print(list1)
list2 = [x for x in range(5)]
print(list2)
gen2 = (x*10 for x in range(5))
list2 = list(gen2)
print(list2)
# print(next(gen2)) # StopIteration
def yt_list(seq):
temp = []
for item in seq:
temp.append(item)
return temp
3.字典生成式
dict1 = dict((x, x*2) for x in range(5))
print(dict1) # {0: 0, 1: 2, 2: 4, 3: 6, 4: 8}
2）语法二：
生成器 = （表达式 for 变量 in 序列 if 条件语句）
a.展开成函数
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))
补充：python中的三目运算符
C，java，js等中的三目运算符：变量 = 条件语句？表达式1：表达式2
python中的三目运算符: 变量 = 表达式1 if 条件语句 else 表达式2
三目运算符的功能：判断条件语句是否为True，如果是结果是表达式1，否则结果是表达式2
a = 19
num = None
if a & 1:
num = "奇数"
else:
num = "偶数"
num = "奇数" if a & 1 else "偶数"
print（num）
02 - 函数作为变量
1.python中声明函数就是声明类型是function的变量，函数名就是变量名
普通变量能做的事情，函数都可以做
a = 10
print(a, type(a), id(a))
def func1():
print("=======")
print(func1, type(func1), id(func1))
# 1) 用一个变量给另外一个变量赋值
b = a
print(b, b+20 * 2)
c = func1
c()
# 2)修改变量的值
a = "abc"
print(a + "hello")
# func1 = 100
# func1() # TypeError: 'int' object is not callable
# 3）变量作为序列的元素
list = [a, 10]
print(list1)
print(list[0], rjust(7, "0"))
list2 = [func1, func1(), 10]
print(list2)
# 4)变量作为函数的参数
deef func2(x)
print("函数里面:", x)
a = 10
func2(a)
func2(func1)
# 5）变量作为函数的返回值
def func3(x, y)
num = x + y
return num
print(func3(1, 2))
ef func4():
def func5():
print('函数5')
return func5
print(func4())
func4()()
03 - 高阶函数
装饰器 = 实参高阶函数 + 返回值高阶函数 + 糖语法
1.实参高阶函数
有一个参数是函数的函数就是实参高阶函数
python中内置的sorted，max，min等函数，以及列表的sort方法都是实参高阶函数
这些函数中都有一个参数key，要求传参的时候传一个函数。
这个函数需要一个参数和一个返回值，参数代表序列中的元素，返回值是比较对象
num = [1, 78, 90, 23, 74, 90]
num.sort()
print(num)
# 问题1： 按个位数的大小对num中的元素从小到大排序
# [90, 90, 1, 23, 74, 78]
def func1(item):
return item % 10
num = [1, 78, 90, 23, 74, 90]
num.sort(key=func1)
num.sort(key=lambda item: item % 10)
print(num)
# 问题2： 按各位数之和从大到小排序
# 1, 15, 9, 5, 11, 9 -> [78, 74, 90, 90, 23, 1]
num = [1, 78, 90, 23, 74, 90]
def func2(item):
sum = 0
for x in str(item):
sum += int(x)
return sum
num.sort(reverse=True, key=func2)
print(num)
# 问题3：按照字典中key为'score'的值从小到大排序
dicts = [
{'name': '小明1', 'score': 98},
{'name': '小明2', 'score': 40},
{'name': '小明3', 'score': 67},
{'name': '小明4', 'score': 89}
]
dicts.sort(key=lambda item: item['score'])
print(dicts)
num = [1, 78, 90, 23, 74, 90]
print(max(num, key=lambda item: item % 10))
print(max(dicts, key=lambda item: item['score']))
print(max(90, 89))
# 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))
04 - 返回值高阶函数
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(char):
# char = '+'
if char == '+':
def sum(*args):
# args = (1, 2, 4, 5)
temp = 0
for x in args:
temp += x
return temp
return sum
elif char == '-':
def diff(*args):
temp = args[0]
for x in args[1:]:
temp -= x
return temp
return diff
print(operation('+')(1, 2, 4, 5))
"""
print(sum(1, 2, 4, 5))
print(12)
"""
print(operation('-')(1, 2, 4, 5))
05 - 闭包
1.什么是闭包
闭包就是一个函数，这个函数需要满足以下两个条件
1.函数的返回值是声明在这个函数中的函数（内函数）
2.这个内函数必须使用外函数中的临时变量（外函数中的局部变量）
闭包的作用：保存临时变量的值（函数调用结束后，函数中的数据不销毁）
def func11(x):
a = 10
func11(100)
def func1(x):
a = 10
def func2():
print(a+x)
print('内函数')
return func2
func1(10)
06 - 装饰器
装饰器是python的三大神器之一
1.什么是装饰器：装饰器本质还是一个函数
装饰器的作用哦：在不修改函数本身的前提下给函数添加功能
# 方式一： 给函数添加功能需要修改原代码
def sum1(x, y):
start = time.time()
print('和:', x+y)
end = time.time()
print('总时间:', end-start)
sum1(100, 200)
方式二: 调用函数的基础上添加新的功能
def sum11(x, y):
sum = 100 + 200
print('x, y:', x, y)
print('和:', sum)
def func1(x):
print('+++++')
print('-----')
print(x)
def count_time(fn, *args, **kwargs):
start = time.time()
fn(*args, **kwargs)
end = time.time()
print('总时间:', end - start)
count_time(sum11, 111, 222)
count_time(func1, 'abc')
print('=============')
sum11(100, 200)
方法三:装饰器
语法：
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)
end = time.time()
print('总时间:', end - start)
return test
@count_time # 糖语法
def func1():
print('======')
func1()
@count_time
def func2(x, y):
print(x+y)
func2(1, 2)
# 练习: 写一个装饰器，给函数添加权限, 密码是:'321'
def password(fn):
def test(*args, **kwargs):
ps = input('请输入密码:')
if ps == '321':
fn(*args, **kwargs)
return test
@password
def func3():
print('函数3')
func3()
@password
def func4(x, y):
print('函数4:', x+y)
func4(10, 20)
07 - 回调函数
import itchat
import time
# 1.什么是回调函数: 函数的调用是在其他函数的内部满足条件的时候自动调用的函数
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)
