一：函数作为变量
在python中，函数就是一种特殊的类型。声明函数的时候，其实就是在声明类型是function的变量。
变量能做的事，函数都可以做
1.函数给其他变量赋值
1.使用一个变量给另外一个变量赋值
a = 10
b = a
声明一个函数func1（声明了一个函数变量func1, func1就是一个变量）
def func1():
print('hello python')
c也是一个函数
c = func1
func1()
c()
2.函数作为列表的元素
list1 = [a, '10', 100]
list2 = []
list3 = []
for x in range(10):
def func2(y):
print(x+y)
list2.append(func2)
list3.append(func2(x))
4.函数作为函数的参数（回调函数）
def clean_kitchen(time):
print('在%s，打扫厨房' % time)
print('收费200元')
return 200
def clean_floor(time):
print('在%s，做地板清洁服务' % time)
print('收费100元')
return 100
# 在指定的时间，叫指定的服务
def call_service(time: str, service):
service(time)
# 将函数作为参数，传给其他函数
call_service('上午10点', clean_kitchen)
call_service('下午2点', clean_floor)
二、生成器和生成式
可以把迭代器看成一种容器，类似列表。生成器就是来生成迭代器。
1.生成式 ---- 产生一个迭代器的表达式
a是生成器，能够生成0-9中的所有的数字
a = (x for x in range(10))
print(a, type(a))
a0 = (x*2 for x in range(10))
a1 = (char for char in 'hello world')
a2 = (char for char in 'h0el761lo p2yt3ho4n902' if '0'<=char<='9')
2.生成器和迭代器都是通过next来获取里面的数据
print(next(a))
print(next(a))
print(next(a))
print(next(a))
3.将生成器转换成列表
通过将生成式产生的迭代器转换成了一个列表
list1 = [x for x in range(10)]
print(list1)
4.将生成器转换成字典
注意：容器类型的元素是元祖，并且元素中有且只有两个元素的，才能转换成字典
dict1 = dict((x, x*2) for x in range(5)) # {0: 0, 1: 2, 2: 4, 3: 6, 4: 8}
print(dict1)
练习:一句代码实现交换一个字典中的key和value的值. {'a':1, 'b':2} --> {1:'a', 2:'b'}
dict2 = dict((value, key) for key,value in {'a': 1, 'b': 2, 'c': 3}.items())
old = {'a': 1, 'b': 2, 'c': 3}
dict3 = dict((old[key], key) for key in old)
print(dict3)
三、生成器
只要函数中有yield关键字，那么这个函数就会变成一个生成器。
a.有yield的函数，在调用函数的时候不再是获取返回值，
而是产生一个生成器对象，生成器对象中保留的是函数体。
b.当通过next获取生成器中的数据的时候，才会去执行函数体，执行到yield为止，
并且将yield后面的结果作为生成的数据返回。同时记录结束的位置，下次再调用next的时候，
从上次结束的位置接着往后执行。
def func2():
print('abc')
for x in range(10):
yield x
print('aaa')
注意：函数中只要有yield，不管yield会不会执行到，函数的调用结果都是生成器
def func3(x):
print('abc')
if x > 10:
yield 100
return 20
练习：写一个生成器，可以产生斐波那契数列（可以无限生成）
# 1,1,2,3,5,8,13,21,34....
def sequence():
yield 1
yield 1
x = 1
y = 1
while True:
yield x + y
x, y = y, x+y
se = sequence()
print(next(se))
print(next(se))
print(next(se))
print(next(se))
print(next(se))
print(next(se))
print(next(se))
print(next(se))
print(next(se))
print(next(se))
2.生成器和生成式产生的对象就是迭代器
将列表转换成迭代器对象
迭代器(iter)
iter1 = iter([1, 2, 3, 4])
print(iter1)
print(next(iter1))
print(next(iter1))
for item in iter1:
print(item)
四：文件操作
程序中不管操作任何文件，不管怎么操作，过程都是: 打开文件 -> 操作(读/写) -> 关闭文件
做数据持久化、本地化，都要使用文件来保存数据
(数据库文件、txt文档、json文件、plist、xml文件等、二进制文件(图片、视频、音频等))
程序中通过变量、列表、字典等保存的数据，在程序结束后都会被销毁的。
1.打开文件
open(文件地址, 打开方式, encoding=编码方式)
a.文件地址：告诉open函数要打开的是哪个文件，填文件路径。可以填绝对路径，也可以填相对路径
绝对路径：/Users/yuting/Desktop/aaa.txt (一般不用)
相对路径：./相对路径（相对于当前文件所在的目录）
../相对路径 （相对于当前文件所在的目录的上一层目录）
.../相对路径 （相对于当前文件所在的目录的上一层的上一层目录）
b.打开方式：获取文件的内容以读的形式打开，往文件中写内容就以写的形式打开
'r' --> 读（默认值）, 读出来的内容以文本(str)的形式返回
'rb'/'br' --> 读，读出来的内容以二进制(bytes)的形式返回
'w' --> 写， 写文本到文件中
'wb'/'bw' --> 写，写二进制数据到文件中
'a' --> 写，追加
c.编码方式：以文本的形式读和写的时候才需要设置编码方式。
utf-8: 万国码
gbk: 只支持中文
d.open函数的返回值是被打开的文件对象
2.关闭文件
文件对象.close()
1.打开文件
f1 = open('/Users/yuting/Desktop/aaa.txt', encoding='utf-8')
f2 = open('./test.txt', 'rb')
f = open('./files/test2.txt', 'w', encoding='utf-8')
2.关闭文件
f1.close()
f2.close()
f.close()
# 3. 操作文件
# a. 读操作
read(): 从文件的开头读到文件结果
readline(): 读一行内容
打开文件, f就是被打开的文件对象
f = open('./test.txt', 'r', encoding='utf-8')
# 获取文件中的所有内容，将结果返回给content保存
content = f.read()
print(content)
前面已经读完了，接着往后读，读不到内容
从文件开始读到第一行结束
content = f1.readline()
print(content)
练习：读文件中的内容，一行一行的读，读完为止
f = open('./test.txt', 'r', encoding='utf-8')
content = f.readline()
while content:
print('line:',content)
content = f.readline()
f.close()
b.写操作
write(写的内容)
'w' --> 写操作，完全覆盖原文件的内容
'a' --> 写操作，在原文件的内容后去追加新的内容
f = open('./test.txt', 'a', encoding='utf-8')
f.write('程序员的诗')
f.close()
4.文件不存在的情况
当以读的形式打开文件的时候，如果文件不存在，程序会崩溃，报：FileNotFoundError
当以写的形式打开一个不存在的文件的时候，会自动创建一个新的文件
f = open('./test3.txt', 'a', encoding='utf-8')
f.write('你好，师姐')
f.close()
练习：统计一个模块执行的次数
f = open('./number', encoding='utf-8')
# 从文件中获取次数
number = int(f.read())
# 打印次数
print(number)
f.close()
次数加1后将新的次数写到文件中
number += 1
f = open('./number', 'w', encoding='utf-8')
f.write(str(number))
f.close()
