"""author = 陈俊龙"""
============函数作为变量=============
1.函数调用表达式：调用函数的语句
普通值能做的事情函数调用表达式都可以做
2.函数作为变量：
python中声明函数本质就是声明一个类型是function的变量，函数名就是变量名
def func4(x):
return x*2
func4 = lambda x: x*2
变量能做的事情函数都能做：
1）一个变量可以给另一个变量赋值:
c = func4
c(2) # 4
2）给变量从新赋值:
3)变量作为容器的元素:
4)变量可以作为函数的参数，那么函数也可以作为其他函数的参数，这种其他函数叫实参高阶函数
def func5(y):
print(y)
def func6(x):
print(x)
func6(func5(1)) # 1 None!!!注意结果
3.实参高阶函数的应用：
列表.sort(),max(),min(),sorted()
什么时候使用：
1）数字列表，排序规则发生改变：按照数字的个位数从小到大排序
sort()和sorted()里面的参数key要求传一个函数，key参数对应的参数是用来决定排序规则：函数需要一个参数和一个返回值，他的参数代表需要排序的序列元素，返回值是比较对象
num = [1, 78, 9, 78, 67, 100]
def func(item):
return item
按照元素本身排序:
num.sort(key=func)
# 或者
num.sort(key=lambda item: item)
按照元素的个位数来排序:
def func(item):
return item % 10
num.sort(key=func)
# 或者
num.sort(key=lambda item: item % 10)
按照元素的首位大小排序:
def func(item):
return int(str(item)[0])
num.sort(key=func)
# 或者
#num.sort(key=lambda item: int(str(item)[0])
练习：
给出一个列表，按照各位数的和的大小从小到大排序:
num1 = [12, 67, 18, 90, 890, 123, 99]
def func1(item):
sum1 = 0
for x in str(item):
sum1 += int(x)
return sum1
num1.sort(key=func1)
print(num1)
根据学生成绩排序：
all_student = [{'name': 'alice', 'age': 20, 'score':90,'id': 'stu001'},
{'name': 'alic1', 'age': 20, 'score':60,'id': 'stu002'},
{'name': 'alice2', 'age': 20, 'score':70,'id': 'stu003'},
{'name': 'alice2', 'age': 20, 'score':80,'id': 'stu004'}
]
def func4(item):
return item['score']
all_student.sort(key=func4)
print(all_student)
4.变量作为函数的返回值
一个函数的返回值如果也是一个函数，那么这个函数就是返回值高阶函数
def func1():
def func11():
return 10
return func11
print(func1()())
================迭代器===============
1.什么是迭代器(iter):
迭代器是容器型数据类型（序列），可变（不支持增删改），有序（不支持下标操作）
保存在迭代器中的元素，只能一个一个取，并且取出来后，迭代器中就不再保存，也不可以再往迭代器中添加元素
迭代器没有具体格式的数据，只能用别的序列转换而来，或者通过生成器去产生
iter1 = iter([1, 2, 3])
print(iter1) #
iter2 = iter('abc')
print(iter2) #
2.获取迭代器中的元素：
不管用什么样的方式去获取迭代器中的元素，获取一个就会少一个
1）获取单个元素：next(迭代器) - 获取迭代器中最顶部（第一个）的元素
print(next(iter1)) # 1
print(next(iter1)) # 2
print(next(iter1)) # 3
# print(next(iter1)) # StopIteration
2)遍历(for in 遍历）
iter1 = iter([1, 2, 3])
for x in iter1:
print(x)
================生成器===============
1.什么是生成器：
生成器就是迭代器 - 获取元素和迭代器相同
调用函数体中！有！yield的关键字的函数，就可以得到一个生成器
2.yield：
yield只能出现在函数体中
调用有yield关键字的函数，不会执行函数体，也不会获取返回值，而是得到一个生成器
def func():
if False:
yield
print('我是一个函数')
return 100
print(func()) #
3.如何用生成器产生数据
一个生成器能产生几个数据，看执行完生成器对应的函数会遇到几次yield,yield后面的值就是生成器产生的数据
def func2():
yield 'abc'
yield 123
gen1 = func2()
print(gen1)
print(next(gen1)) # abc
print(next(gen1)) # 123
产生多个数据:
def func2():
for x in range(10):
yield x
gen1 = func2()
print(gen1)
for x in gen1:
print("===", x)
4.生成数据的原理：
生成器不会同时将所以的元素保存起来，而是需要数据的时候临时产生数据。
每次获取生成器元素的时候，就去执行生成器对应的函数的函数体，从前往后执行，直到遇到yield，并把yield后面的数据作为结果，同时保存结束的位置，下次获取元素时，接着上次结束位置开始执行，直到遇到下一个yield，以此类推
如果执行到函数结束都没有再遇到yield，程序就会报错(StopIteration)
def func3():
print('start')
print('第一个数据')
yield 1
print('第二个数据')
yield 2
print('第三个数据')
yield 3
print('end')
gen2 = func3()
print(next(gen2))
print(next(gen2))
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 x in range(100):
print(next(nums))
！注意return在yield前面的情况 ！遇到return，数据就不会往下再产生了 ！重点理解并区别！
def func():
yield 1
return
yield 2
yield 3
print(next(func())) # 1
print(next(func())) # 1
print(next(func())) # 1
print(next(func())) # 1
def func():
yield 1
return
yield 2
yield 3
func1 = func()
print(next(func1)) # 1
print(next(func1)) # StopIteration
================生成式===============
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))
print(next(gen1)) # 0
print(next(gen1)) # 2
list1 = list(gen1) # [4, 6, 8, 10, 12, 14, 16, 18]
print(list1)
gen1 = [x*2 for x in range(10)]
print(gen1) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
list4 = [x for x in range(10) if x % 2]
print(list4)
===============模块的使用===============
在实际开发的时候，一个项目会分为多个模块
1.什么是模块：一个py文件就是一个模块
2.怎么协作：导入模块(import)
方式：
1）import 模块名 （注意：没有后缀）
在当前模块中带入指定模块，导入后可以使用指定模块中所以的全局变量。 以 模块名.变量 的方式去使用
2）from 模块名 import 全局变量1，全局变量2.....
导入指定模块中指定的全局变量，被导入的变量可以！直接使用！
3）import 模块名 as 新模块名
通过新模块名去使用模块
对模块中的变量进行重命名：
from 模块名 import 全局变量1，全局变量2 as 新变量名 后面通过新变量去使用变量
4）通配符
from 模块名 import * - 导入模块中所以的全局变量，方便在于使用的时候都可以直接用，缺点是不能重命名。
3.导入模块的原理：
在执行导入模块代码时，系统会回到模块位置，会把被导入的模块的代码执行一遍，通过from导也会全部都执行
如果希望不全部执行：就将不希望被别的模块执行的代码放到if语句中
'可以被别人导入的代码'
if __name__ == '__main__':
'不希望被别人执行的代码'