1.函数作为变量
1)函数就是变量
python中声明函数其实就是声明一个类型是function的变量，函数名就是变量名；变量能做的函数都能做
a = 10
def func1():
return '=='
def func2():
return '====='
print(id(a), id(func1))
print(type(a), type(func1))
# 1.变量可以给别的变量赋值
b = a
c = func1
print(c())
# 2.重新给变量赋值
a = 'abc'
func1 = 100
print(func1*2)
func1 = func2
# 3.变量作为容器类型数据的元素
list1 = [a, 10, func1]
print(list1)
print(list1[-1]())
# 4.变量作为函数的参数
def func3(num):
sum1 = num ** num
return sum1
print(func3(3))
a = 4
print(func3(a))
# 函数作为函数的参数 - 实参高阶函数
def func4(fn):
fn()
def func5(x=10):
print(x)
func4(func5)
2)系统实参高阶函数：列表.sort\sorted\max\min...中有个参数key,类型就是function。
key的用法：
key是一个函数，必须有且只有一个参数(代表序列中的元素)，还有一个返回值(返回值就是比较标准)
students = [
{'name': 'a', 'age': 22, 'score': 99},
{'name': 'b', 'age': 20, 'score': 29},
{'name': 'c', 'age': 24, 'score': 86},
{'name': 'd', 'age': 17, 'score': 44}
]
def test(x):
print(x)
return x['age']
students.sort(key=test)
print(students)
# 练习：将列表nums中所有元素按各位数的和从小到大排序
nums = [19, 29, 54, 81, 75, 23]
def test1(item):
print(item)
sum1 = 0
for x in str(item):
sum1 += int(x)
return sum1
nums.sort(key=test1)
print(nums)
# max的原理
def ysy_max(seq, key=None):
if key:
list1 = list(seq)
max1 = list1[0]
for item in list1[1:]:
if key(item) > key(max1):
max1 = item
return max1
else:
list1 = list(seq)
max1 = list1[0]
for item in list1[1:]:
if item > max1:
max1 = item
return max1
print(ysy_max([12, 34, 52]))
print(ysy_max('1d2s1'))
print(ysy_max({'name': 'a', 'age': 12}))
print(ysy_max([13, 12, 44], key=lambda item: item % 10))
# 5.变量作为函数的返回值
# 函数作为函数的返回值(返回值高阶函数)
def operation(char):
if char == '+':
def sum1(*nums):
x = 0
for num in nums:
x += num
return x
return sum1
elif char == '*':
def sum2(*nums):
x = 1
for num in nums:
x *= num
return x
return sum2
print(operation('+')(12, 90, 22))
2.装饰器
1)什么是装饰器
装饰器的本质就是函数，是用来给函数添加功能用的
装饰器 = 实参高阶函数 + 返回值高阶函数 + 糖语法
# 实例一：给函数添加功能（统计执行时间的功能）
def func1(x, y):
print(x + y)
func1(10, 20)
def func2():
print(' *')
print('====')
func2()
# 实例二：用实参高阶函数给不同的函数添加相同功能
def statistics_time(fn, *args, **wkargs):
t1 = time.time()
fn(*args, **wkargs)
t2 = time.time()
print('时间:{}s'.format(t2 - t1))
statistics_time(func1, y=1, x=2)
# 实例三：无参装饰器
"""
a.语法
def 函数1(fn):
def 函数2(*args, **kwargs):
实现添加功能的代码
fn(*args, **kwargs)
return 函数2
b.说明：
函数名1 - 装饰器的名字（根据添加的功能来命名）
fn - 类型是函数，指向的是需要添加功能的函数
函数名2 - 实现添加功能的函数，名字随便命名，一般为test
"""
def add_time(fn):
def test(*args, **kwargs):
t1 = time.time()
fn(*args, **kwargs)
t2 = time.time()
print(t2-t1)
return test
@add_time
def func5():
print('5')
func5()
# 实例四：有参装饰器
"""
有参装饰器的写法：
def 装饰器名（参数列表）：
def 函数名1（fn）:
def test(*args,**kwargs):
fn(*args,**kwargs)
添加新功能
return test
return 函数1
说明：参数列表 - 装饰器添加功能的时候变化的部分通过参数列表来确定
"""
def tag(name):
def func11(fn):
def test(*args, **kwargs):
re_str = fn(*args, **kwargs)
new_str1 = '<%s>' % name + re_str + '<%s>' % name
return new_str1
return test
return func11
@tag(name='p')
def render(text):
# 执行其他操作
return text
练习1：写一些装饰器，实现函数结束调用结束后打印‘调用完成’
def add_print(fn):
def test(*args, **kwargs):
fn(*args, **kwargs)
print('调用完成')
return test
@add_print
def func6(m):
print(m**2)
func6(8)
练习2：写一个装饰器，实现将返回值是整数的函数的返回值以十六进制的形式返回
def hex_result(fn):
def test(*args, **kwargs):
re = fn(*args, **kwargs)
return hex(re)
return test
@hex_result
def func7(m):
return m ** 2
print(func7(2))
3.迭代器
1)什么是迭代器(iter)
迭代器是容器型数据类型(序列)，迭代器中的元素只能通过将其他序列转换成迭代器或者创建生成器
迭代器中的元素：如果需要查看元素，需要将元素从迭代器取出，而且一旦取出就不能再放回去
2)创建迭代器
iter(序列) - 将序列转换成迭代器并返回
iter1 = iter('akq')
print(iter1)
iter2 = iter({'name': 'a', 'age': 19})
print(iter2)
3)获取元素
1)获取单个元素
next(迭代器) / 迭代器.next()
item = next(iter2)
print(item) # name
item = next(iter2)
print(item) # age
# item = next(iter2)
# print(item) # 报错：StopIteration
2)遍历迭代器
print('======')
for x in iter1:
print('x:', x)
# 练习：
iter1 = iter('hello')
list1 = list(iter1)
print(list1) # ['h', 'e', 'l', 'l', 'o']
# print(next(iter1)) # 报错：StopIteration
4.生成器
1)什么是生成器
生成器就是迭代器，容器有产生数据的能力。
1)怎么创建生成器：调用一个带有yield关键字的函数，就可以得到一个生成器对象
2)生成器产生数据的原理：
当调用一个带有yield关键字函数的时候，不会执行函数体，也不会获取返回值，而是创建一个生成器；
生成器能产生多少个数据，以及每个数据的值，看执行完函数体会遇到几次yield生成器就可以产生几个数据，
yield后面的数据就是会产生的数据
每次获取生成器的元素的时候，都会去执行相应的函数的函数体，执行到yield为止，取下一个元素，
从上次结束的位置接着往后执行
def func1():
print('=====')
print('+++++')
yield [8, 9]
print('----')
yield 4
re = func1()
print('re:', re)
print(next(re))
print('第一次结束')
print(next(re))
练习：写一个学号生成器，能够产生的学号的范围和学号的前缀创建生成器的时候自己决定
def creat_id(pre, num):
length = len(str(num))
for x in range(num):
yield pre+str(x).zfill(length)
py_creater = creat_id('python', 200)
print(next(py_creater))
5.生成式
1)什么是生成式
生成式就是生成器的一种简写方式
1)形式一：
(表达式 for 变量 in 序列) - 序列有多少个元素，生成器就能产生多少个数据，每次循环表达式的值就是产生数据的值
相当于：
def func1():
for 变量 in 序列:
yield 表达式
2)形式二：
(表达式 for 变量 in 序列 if 条件语句)
def func1():
for 变量 in 序列:
if 条件语句：
yield 表达式
gen1 = (x*2 for x in range(5))
print(gen1)
print(next(gen1), next(gen1))
gen2 = (x*2 for x in range(5) if x % 2)
print(next(gen2))
2)变形
1)列表生成式
[表达式 for 变量 in 序列] 相当于 list((表达式 for 变量 in 序列))
[表达式 for 变量 in 序列 if 条件语句]
2)集合生成式
{表达式 for 变量 in 序列} 相当于 set((表达式 for 变量 in 序列))
{表达式 for 变量 in 序列 if 条件语句}
3)生成式转字典
dict(表达式 for 变量 in 序列)
list1 = [x*2 for x in range(5)]
print(list1)
list2 = [x*2 for x in range(5) if x % 2]
print(list2)
set2 = {x*2 for x in range(5) if x % 2}
print(set2)
dict1 = dict((x*2, x) for x in range(5) if x % 2)
print(dict1)
练习：用一行代码实现交换一个字典的键对，产生新的字典
dict2 = {'a': 1, 'b': 2, 'c': 3}
new_dict2 = dict((dict2[key], key) for key in dict2)
print(new_dict2)
