函数作为变量
1.函数调用表达式
函数调用表达式 - 调用函数的语句
普通值能做的事情函数调用表达式都可以做
2.函数作为变量
!!python中声明函数本质就是声明一个类型是function的变量，函数名就是变量名
变量能做的事情，函数都可以做
a = lambda x: x * 2
print(a(4))
1）一个变量可以给另外一个复制
def func4(x):
print('这是一个函数;', x)
c = func4
c(10)
2)给变量重新复制
def func4(x):
print('这是一个函数;', x)
c = func4
c(10)
func4 = 444
print(func4)
c(10)
3)变量作为容器的元素
a = 10
list1 = [a, 10]
print(list1[0] / 2)
def func4(x):
print('这是一个函数;', x)
list1 = [func4, func4(20)]
print(list1[0](9))
4)变量作为函数的参数
一个函数可以作为另外一个函数的实参，
如果一个函数的参数也是函数，这种函数叫实参高阶函数
def func6(x):
print(x)
func6(func4)
listn = []
for x in range(5):
listn.append(lambda i: i * x)
print(listn[0](2)) # listn[8, 8, 8, 8, 8]
实参高阶函数：列表.sort()、sorted()、max()、min()
sort()、sorted()
这两个函数是实参高阶函数，里面有个参数key要求传一个参数
key参数对应的函数是用来决定排序规则：函数需要一个参数和一个返回值，
他的参数代表需要排序的的序列的元素，返回值是比较对象**
数字列表，排序规则发生改变：按照数字的个位数熊小到大排序**
nums = [1, 78, 9, 79, 67, 100]
nums.sort(key=lambda item: item)
print(nums)
按照元素个位数的大小排序
nums = [21, 1, 378, 69, 9, 79, 67, 100]
def func1(item):
return item % 10
nums.sort(key=func1)
print(nums)
按照元素最高位的大小排序
nums = [21, 1, 8, 378, 69, 9, 79, 67, 100]
def func1(item):
return int(str(item)[0])
nums.sort(key=func1)
print(nums)
练习：给一个数字列表，按照各位数的和的大小从小到大排序
nums = [12, 67, 18, 90, 890, 123, 99]
def func2(item):
sum1 = 0
for ch in str(item):
sum1 += int(ch)
return sum1
nums.sort(key=func2)
print(nums)
练习：
all_students = [
{'name': '小明1', 'age': 23, 'score': 50, 'id': 'stu001'},
{'name': '小明2', 'age': 20, 'score': 87, 'id': 'stu041'},
{'name': '小明3', 'age': 19, 'score': 74, 'id': 'stu061'},
{'name': '小明4', 'age': 78, 'score': 90, 'id': 'stu023'}
]
#学生成绩从小到大排序
def func4(item):
return item['score']
all_students.sort(key=func4)
print(all_students)
#按成绩排序
print(max(all_students, key=lambda item:item['score']))
nums = [12, 39, 56]
print(max(nums, key=lambda item: item%10))
5）变量作为函数的返回值
一个函数的返回值如果也是一个函数，那么这个函数就是返回值高阶函数
def func1():
def func11():
return 10
return func11
print(func1()())
迭代器
1.什么是迭代器（iter)
迭代器是容器型数据类型（序列），可变（不支持增删改），有序（不支持下标操作）
保存在迭代器中的元素，只能够取，并且取出来之后就不再保存，也不可以再往迭代器中添加元素。
迭代器没有对应的格式数据，迭代器只能通过将其他序列转换成迭代器，或者是生成器
iter1 = iter([10, 20, 30])
print(iter1)
iter2 = iter('abc')
print(iter2)
2.获取迭代器中的元素
不管用什么样的方式去获取迭代器中的元素，获取一个就会少一个
1）获取单个元素：next(迭代器) - 获取迭代器顶部的元素
iter2 = iter('abc')
print(next(iter2))
print(next(iter2))
print(next(iter2))
2)遍历
iter2 = iter('abc')
print(next(iter2))
for x in iter2:
print('===', x)
生成器
1.什么是生成器
生成器就是迭代器 - 获取元素金和迭代器一样（只能一个一个取，取一个少一个）
调用函数体有yield关键字的函数，就可以得到一个生成器
2.yield
yield只能出现在函数体中
调用yield关键字的函数，不会执行函数体，也不会获取返回值，而是得到一个生成器。
3.生成器怎么产生数据
看一个生成器能够产生几个数据，看执行完生成器对应的函数会遇到几次yield；
yield后面的值就是生成器能够产生的数据
def func2():
yield 100
yield 'abc'
for x in range(5):
yield x
gen1 = func2()
print(gen1)
print(next(gen1))
print(next(gen1))
print(next(gen1))
for x in gen1:
print('====', x)
4.生成器生成数据的原理
生成器不会同时将所有的元素保存起来，而是需要数据的时候临时产生数据。
获取生成器元素的时候，就会执行生成器对应的函数体，从前往后执行，
直到遇到yield为止，并且将yield后面的值作为结果；同时保存结束位置；
下次获取下一个元素的时候，接着上次结束的位置往后执行，直到遇到下一个yield；
以此类推
如果执行到函数结束都没有遇到yield，next函数就会报StopIteration错误
def func3():
print('=====第一个数据======')
yield 1
print('======第二个数据=====')
yield 2
print('=====第三个数据======')
yield 3
print('end')
gen2 = func3()
print(next(gen2))
写一个产生学号的生成器
def creat_id():
num = 1
while True:
yield 'stu' + str(num)
num += 1
nums = creat_id()
print(next(nums))
print(next(nums))
for _ in range(10):
print('=====:', next(nums))
生成式
1.什么是生成式
生成式本质就是生成器
1）语法1
（表达式 for 变量 in 序列） - 创建一个生成器
展开成生成器：
def func1():
for 变量 in 序列:
yield 表达式
[表达式 for 变量 in 序列] - 将生成式对应的生成器转换为列表
2)语法2
（表达式 for 变量 in 序列 if 条件语句） - 创建一个生成器
展开生成器：
def func1():
for 变量 in 序列:
if 条件语句:
yield 表达式
gen1 = (x*2 for x in range(10))
```
def func():
for x in range(10):
yield x*2
gen1 = func()
```
print(next(gen1))
print(next(gen1))
print(next(gen1))
print(next(gen1))
list1 = list(gen1)
print(list1)
print(next(gen1)) #StopIteration
list2 = [x*x for x in range(1, 10)]
print(list2)
list3 = list(x*x for x in range(1, 10))
print(list3)
dict1 = dict((x, x*2) for x in range(5))
print(dict1)
list4 = ['stu' + str(x) for x in range(10) if x%2]
print(list4)
list5 = ['%d*2=%d' % (x, x*2) for x in range(5)]
print(list5)
模块
在实际开发的时候，一个项目会分成多个模块
1.什么是模块：一个py文件就是模块
2.多模块怎么协作
1) import 模块名 - 在当前模块在中导入指定模块，导入后可以使用指定模块所有的全局变量
以'模块名.变量'的方式去使用
from 模块名 import 全局变量1，全局变量2，...
- 导入指定模块中指定的模块变量；被导入的全局变量在当前模块中直接使用
3）重命名
import 模块名 as 新模块名
from 模块名 import 变量1 as 新变量1, 变量2 as 新变量2, ...
- 变量重命名，通过新变量去使用变量
4）通配符
**from 模块名 import *** - 导入模块中所有的全局变量，全局变量直接拿来用
3.导入模块的原理
当执行导入模块的代码的时候，实质会执行被导入的模块对应的py文件
将不希望别人执行的代码模块放在下面的if语句中
if __name__ == '__main__':
