1.匿名函数
函数名 = lambda 参数列表：返回值
函数名（实参）
sum1 = lambda x, y:x*y
def sum1_a(x, y):
return x*y
2.作用域
函数的调用过程是一个全栈的过程
全局变量：函数和类外面声明的变量都是全局变量，作用域：从声明到程序结束
局部变量：在函数/类里面声明的变量时局部变量，作用域：从声明到函数结束
3.递归函数（能不用就不用）
a.找临界值（结束循环）
b.找关系（上次循环和本次循环的关系f（n）和f（n-1）的关系）
c.根据f（n-1）实现f（n）的功能
4.模块的使用
一个py文件就是一个模块
2.函数作为变量
在python中，函数就是一种特殊的类型。声明函数的时候其实就是在声明类型是function个的变量
变量能做的事情，函数都可以做
1.函数给其他变量赋值
def func1():
print('hello python')
c = func1 #c也是一个函数
2.函数作为列表的函数
list1 = ['a', '0, 100]
list2 = []
list3 = []
for x in range(10):
def func2():
print(x+y, end=' ')
return x+y
list2.append(func2)
list3.append(func2(2))
#list2中每个元素的值都是函数
print(list2)
print(list3)
list2[0]就是一个函数
func = list2[0]
print(func(100))
直接将函数作为列表的元素
funcs = [func1]
funcs[0]()
3.将函数作为字典的值
operation = {'+':lambda x, y:x+y, '-':lambda x, y:x-y}
result = operation['*'](10, 20)
print(result)
4.函数作为函数的参数（回调函数）
def cleac_kitchen(time):
print('%s,打扫厨房' % time)
print('收费200')
return 200
def clean_floor(time):
print('在%s,做地板清洁服务' % time)
print('收费100元')
return 100
#在指定的时间叫指定的服务
def call_service(time, service):
service(time)
#将函数作为参数，传给其他函数
call_service('上午十点', cleac_kitchen)
5.函数作为函数的返回值
def operation(operetor:str):
if operetor == '+':
def my_sum(*nums):
sum1 = 0
for num in nums:
sum1+=num
print(sum1)
#将求和的函数返回
return my_sum()
#operation（'+'）函数
operation('+')(1, 3)
3.生成器和生成式
1.可以吧迭代器看成一种容器，类似于列表。生成器就是来生成迭代器。
a是生成器，能够生成0-9中的所有数字
a = (x for x in range(10))
print(a,type(a))
2.生成器和迭代器都是通过next来获取里面的数据
print(next(a))
生成式：产生一个迭代器的表达式
3.通过键生成式产生的迭代器转换成一个列表。
a = (char for char in 'hello python')
a = (char for char in 'he123llo python' if '0'<char<'9' )
print(next(a))
print(next(a))
list1 = [x for x in range(10)]
print(list1, type(list1))
4.将生成器转化成列表
list1 = [(x for x in range(10))]
print(list1)
5.将生成器转换成字典
注意：容器类型的元素是元祖，并且元祖中有且只有两个元素，才能转换成元祖
dict1 =dict([(x, x*2) for x in range(10)])
print(dict1)
练习：用一句代码实现交换一个字典中的key和value的值
dict3 = {'a':1, 'b':2}
dict2 = ((dict3[key],key) for key in {'a':1, 'b':2})
print(dic2)
4.生成器
1.只要函数中有yield关键字，那么这个函数就会变成一个生成器。
a.有yield的函数，在调用函数的时候不再是获取返回值，而是产生一个生成器的对象，生成器对象中保留的是函数体。
b.当通过next获取生成器中的数据的时候，才会执行函数体，执行到yield并且将yield后面的结果作为生成的数据返回。同时记录结束的位置，下次调用next的时候，从上次结束的位置接着往后执行。
def func2():
print('abc')
for x in range(10):
yield x
print('aaa')
# 注意：函数中只要有yield，不管函数的调用结果，都是生成器
def func3(x):
print('abc')
if x > 10:
yield 100
return 20
print(func2(), type(func2()), type(func2()))
#这儿的func2（）是一个生成器
gen = (func2())
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))
gen2 = func3(1000)
print(gen2)
练习：写一个生成器，可以产生斐波那契数列
def fei_bo(n):
yield 1
yield 1
f1 = 1
f2 = 1
while True:
yield f1+f2
f1,f2 = f2, f1+f2
fei = fei_bo()
for _ in range(6):
print(next(fei))
生成器和生成式产生的对象就是迭代器
- 将列表转换成迭代器对象
迭代器（iter）
iter1 = iter([1, 2, 3, 4])
print(iter1)
print(next(iter1))
print(next(iter1))
for item in iter1:
print(item)
5.文件操作
1.程序中不管操作任何文件，不管怎么操作，过程都是：打开文件，然后再操作（读，写） _>关闭文件
2.做数据持久化，本地化，都要使用文件来保存数据。（数据库文件、txt文档、json文件、plist/xml、二进制文件（图片，视频等））。程序中通过变量、列表、字典等保存的数据，在程序结束后都会被销毁
打开文件(open)
open(文件地址，打开方式，encoding=编码方式)
a.文件地址：告诉open函数要打开的是哪个文件，填文件路径（可以填绝对路径，也可以填相对路径）
绝对路径：(一般不用)
相对路径;./相对路径（相对于当前文件所在的目录）
../相对路径（相对于当前文件所在目录的上一级）
b.打开方式：获取文件内容以读的形式打开，往文件中写内容就以写的形式打开
'r'-->读（默认值），读出来的内容以文本（str）的形式返回
'rb/br'-->读，读出来的内容（bytes）以二进制的形式返回。
'w'-->写，写文本到文件中
'wb/bw'-->写，写二进制数据到文件中
'a'-->写，追加
c.编码方式：以文本的 形式读和写的时候才需要设置编码方式。
utf-8：万国码
gbk：只支持中文
d.open函数的返回值是被打开的文件对象
2.关闭文件
文件对象.close()
打开文件，f就是被打开的文件对象
f = open('./files/test2.txt', 'r', encoding='utf-8')
# 获取文件中的所有的内容，将结果返回给content保存
content = f.read()
print(content)
f.close()
# readline 就是读一行
f1 = open('./files/test2.txt', 'r', encoding='utf-8')
# 从文件开始读到第一行结束
content = f1.readline()
print(content)
# 从第二行开始，读到第二行结束
print(f1.readline())
# 从第三上开始，读到第三行结束
print(f1.read())
f1.close()
b.写操作
'w'-->写操作，完全覆盖文件的内容
'a'-->写操作，在原文件的内容后去追加新的内容
f = open('./files/test2.txt', 'w', encoding='utf-8')
f.write('程序员的诗词')
f.close
4.文件不存在的情况
当以读的形式打开文件的时候，如果文件不存在，程序会崩溃。
当以写的形式打开文件时候，如果不存在，系统不会报错，会创建这个文件，并且将内容存在新建的文件里面。```
