函数作为变量

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__':