1 函数作为变量
python中声明函数其实就是声明一个类型是function的变量, 函数名就是变量名
普通变量能做的事情函数都可以做
1.1 一个变量可以给另外一个变量赋值
def func1():
print('这是一个函数')
return 100
c = func1 # 将函数名作为变量，给另一个变量赋值
print(c())
func1 = 12.5
print(func1)
print(func1()) # TypeError: 'float' object is not callable
1.2 一个变量可以作为容器的元素
a = 10
def func2(n):
return n * a
a = 20
print(func2(2)) # 40
def func2():
print('这是函数2')
return 100
print(type(func2)) #类型是function
list1 = [a, func2, func2()]
print(list1)
print('0:', list1[0] // 3)
print('1:', list1[1]()) # print('1:', func2()) -> print('1:', 100)
list2 = []
for i in range(5):
def func(n):
return i * 2
list2.append(func)
print(list2[0](3), list2[1](3), list2[2](3)) # 8， 8， 8
list3 = []
for i in range(5):
list3.append(lambda x: x*i)
print(list3[0](2), list3[1](2), list3[2](2)) # 8， 8， 8
1.3 变量可以作为函数的参数
函数作为函数的参数(实参高阶函数)
def func1(fn, fn2):
# fn = func11
# fn2 = func12
fn() # func11(), None
print(fn2(3) / 4) # print(9/4)
def func11():
print('这是一个函数')
def func12(n):
# n = 3
return n**2
print(func1(func11, func12)) # 结果如下
这是一个函数
2.25
None
应用: sort函数
序列.sort函数中有个参数key，这个参数要求传一个函数，并且函数有一个参数和一个返回值
参数就是序列中的元素, 返回值就是排序比较的对象
all_students = [
{'name': '小明', 'age': 19, 'score': 89},
{'name': '熊大', 'age': 20, 'score': 90},
{'name': '熊二', 'age': 17, 'score': 70},
{'name': '光头强', 'age': 21, 'score': 40}
]
def compare(item):
return item['age']
all_students.sort(key=compare)
all_students.sort(key=lambda item: item['age'])
print(all_students)
练习，将all_message中的元祖按照第二个元素从大到小排序。然后再按照学号的最后一位从小到大排序
all_messsage = [
("张三", "python1902004"),
("李四", "python1902007"),
("陈六", "python1902101")
]
all_messsage.sort(reverse=True,key=lambda item:item[1])
print("***按照第二个元素从大到小排序***")
print(all_messsage)
all_messsage.sort(key=lambda item:item[1][-1])
print("***按照第二个元素最后一位从小到大排序***")
print(all_messsage)
#用冒泡排序法实现sort内部 key函数作为参数功能
def sort1(seq, key=None, reverse=False):
if key:
length = len(seq)
for x in range(length - 1):
for y in range(length - 1 - x):
if key(seq[y]) > key(seq[y + 1]):
seq[y], seq[y + 1] = seq[y + 1], seq[y]
else:
length = len(seq)
for x in range(length - 1):
for y in range(length - 1 - x):
if seq[y] > seq[y + 1]:
seq[y], seq[y + 1] = seq[y + 1], seq[y]
nums = [23, 45, 89, 9, 21]
sort1(nums)
print((nums) ) #[9, 21, 23, 45, 89]
all_students = [
{'name': '小明', 'age': 19, 'score': 89},
{'name': '熊大', 'age': 20, 'score': 90},
{'name': '熊二', 'age': 17, 'score': 70},
{'name': '光头强', 'age': 21, 'score': 40}
]
# all_students.sort(key=lambda x: x['age'])
yt_sort(all_students, key=lambda x: x['age'])
print(all_students)
all_students = [
{'name': '小明', 'age': 19, 'score': 89},
{'name': '熊大', 'age': 20, 'score': 90},
{'name': '熊二', 'age': 17, 'score': 70},
{'name': '光头强', 'age': 21, 'score': 40}
]
print(max(all_students, key=lambda x: x['score']))
1.4 变量作为返回值
将一个函数作为函数的返回值(返回值高阶函数)
def func1():
def temp(*nums):
return sum(nums)
return temp
print(func1()(1, 3, 5, 9)) # print(temp(1,3,5,9)) ,-> print(18)->18
2 迭代器(iter)
2.1 什么是迭代器
迭代器是容器型数据类型(可以同时存储多个数据), 但是想要获取/查看迭代器中元素的值，只能将元素取出来。
取出来的元素在迭代器中就不存在了，取的时候只能从前往后一个一个的取，不能跳着取。
2.2 迭代器中的元素
迭代器的元素只能通过类型转换，将其他容器转换成迭代器； 或者通过生成器去生成
转换 - 所有序列都可以转换成迭代器。 迭代器中的元素可以是任何类型的数据
iter1 = iter([10, [1, 3]])
2.3 获取元素:
迭代器获取元素，不管以什么样的方式获取，获取后，这个元素在迭代器中就不存在了
next(迭代器) - 获取迭代器顶部数据(最上面的数据) 取完后再取会返回StopIteration
iter2 = iter('hello')
print(next(iter2))
print(next(iter2))
print(next(iter2))
print(next(iter2))
print(next(iter2))
print(next(iter2)) #StopIteration
遍历获取每个元素
iter2 = iter('hello')
next(iter2)
next(iter2)
for x in iter2:
print('x:', x)# l l o
3 生成器
3.1 什么是生成器
生成器就是迭代器, 迭代器不一定是生成器
调用一个带有yield关键字的函数就能得到一个生成器。(yield只能出现在函数体中)
def func1():
print('=====')
return 100
yield
gen1 = func1()
gen2 = func1()
print(gen1, gen2) #两个生成器对象
3.2 生成器的元素
生成器获取元素的方式和迭代器一样： next()和循环遍历
生成器元素的个数: 看执行完生成器对应的函数会遇到几次yield
元素的值: 看yield后表达式的值
···python
def func2():
print('函数')
for x in range(10):
yield x
gen3 = func2()
print('next:', next(gen3))
print('next:', next(gen3))
print('next:', next(gen3))
for x in gen3:
print('x:', x)
···
3.3 生成器产生数据的原理
当获取生成的元素的是，会执行生成器对应的函数，从开始执行到yield为止,将yield后面的数据作为元素返回并且记录结束位置；下次获取元素的时候，从上次结束的位置接着往后执行，直到遇yield, 将yield后面的数据作为元素返回并且记录结束位置；以此类推， 如果从开始执行到函数结束，没有遇到yield，那么就获取不到元素
def func3():
print('第一次')
yield 1
print('第二次')
yield 2
print('第三次')
yield 3
gen4 = func3()
print('next1:', next(gen4))
for x in range(100):
print('+++++++++++++')
print('next2:', next(gen4))
print('next3:', next(gen4))
def func5():
for x in range(1, 6):
yield str(x).rjust(3, '0')
nums2 = func5()
print(next(nums2)) # 001
print(next(nums2)) #002
能够产生无限数字的生成器
def func6():
num = 0
while True:
yield num
num += 1
gen5 = func6()
