迭代器
在python中，函数就是一种特殊类型。声明函数时，其实就是声明function类型的变量，
变量能做的事，函数都可以做
# 1.使用一个变量给另外一个变量赋值
a = 10
b =a
#声明一个函数func1(声明一个函数变量func1，func1就是一个变量)
def func1():
print('hello python')
#c也是一个函数
c = func1
func1()
c()
函数也可以作为一个列表的函数
lst = ['a','10',100]
def fun(lst:list):
lst.remove(100)
return lst
fun(lst)# 将一个列表的地址传给形参，形参也指向这个列表
print(lst)
lst2 = []
lst3 = []
for x in range(10):
def func2(y):
print(x+y)
lst2.append(func2)
lst3.append(func2(x))
func = lst2[0]
调用lst2中下标对应的函数，并传参x = 9(因为在调用的时候，x是指向9)
print(func(100))
operation = {'+':lambda x,y:x+y,'-':lambda x,y:x-y,'*':lambda x,y:x*y}
result = operation['*'](10,20)
print(result)
函数作为函数的参数（回调函数）
def clean_kitchen(time):
print('在{},打扫厨房'.format(time))
print('收费200')
return 200
def clean_floor(time):
print('在{},做地板清洁服务'.format(time))
print('收费100元')
n = 100
return 100
# 在指定的时间，叫指定的服务
def call_service(time,service):
a = service
a(time)
将函数作为参数，传给其他函数使用
call_service('上午10点',clean_kitchen)
call_service('晚上10点',clean_floor)
print('======================')
# 函数作为函数的返回值
def operation(operator:str):
if operator == '+':
def my_sum(*nums):
sum1 = 0
for item in nums:
sum1 += item
print(sum1)
return my_sum
if operator == '*':
def my_sum(*nums):
sum1 = 1
for item in nums:
sum1 *= item
print(sum1)
return my_sum
operation('+')(1,2,3,4,5)
operation('*')(1,2,3,4,5)
可以把迭代器看成一种容器，类似列表
生成器就是用来生成迭代器
- 生成式----产生一个迭代器的表达式
a 是生成器，能够生成0-9所有的数字，一次只产生一个数字，一次取一个数据，取一个数据就不能再取这个数据，只能取下一个数据
a = (x for x in range(10)) # 生成式
print(a,type(a)) # 结果是一个生成器(generator)
a = (char for char in 'hel5lo p4yt6hon'if '0'<=char<='9')
#生成器和迭代器都是通过next来获取里面的数据
print(next(a))
# print(len(a)) 不能使用len判断
print(next(a))
# 通过将生成式产生的迭代器转换成一个列表
list1 = [x for x in range(10)]
print(list1)
print('=======')
for i in a:
print(i)
将生成式转换为字典
容器类型的元素是元组，并且元素中有且有只有两个元素
dict1 = dict((x,x*2) for x in range(10))
print(dict1)
# 一句代码交换字典的key和values
dict2 = {'a':1,'b':2}
dict3 = dict((dict2[key],key) for key in dict2)
print(dict3)
a = [(dict2[key],key) for key in dict2.keys()]
print(a)
def func1():
for x in range(10):
return x
0 <class 'int'> <class 'function'>
print(func1(),type(func1()),type(func1))
def func2():
for x in range(10):
yield x
yield 关键字:
只要函数中有yield关键字，那么这个函数会变为一个生成器
注意：函数中只要有yield，不管yield会不会执行到，函数的调用结果都是生成器
a. 有yield的函数，再调用函数的时候不再是获得返回值，而是产生一个生成器
对象，生成器对象中保留的是函数体
b. 当通过next获取生成器的数据时，才会去执行函数体，执行到yield为止，
并且将yield后面的结果作为生成的数据返回，同时记录结束的位置，下次再调用next的时候
，从上次结束的位置接着往后执行
# func2是一个生成器
print(func2(), type(func2()), type(func2))
gen = func2()
print(next(gen))
print(next(gen))
print(next(gen))
练习：写一个生成器，可以产生斐波那契数列
def func3():
a,b =1,1
while True:
yield a
yield b
a = a + b
b = a + b
f = func3()
print('============')
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
生成器和生成式产生的对象就是迭代器
将列表转换为迭代器对象
iter1 = iter([1,2,3,4,5])
print(iter1)
print(next(iter1))
print(next(iter1))
for item in iter1:
print(item)
程序中不管操作任何文件，不管怎么操作，过程都是：打开文件->操作文件-> 关闭文件
做数据持久化，本地化，都要使用文件来保存数据(数据库文件，txt文件，json文件，plist,xml文件等,二进制文件(图片，音频，视频)
程序通过变量，列表，字典存储的数据都会在程序结束被销毁
文件操作
打开文件
open(文件地址，打开方式，encoding=编码方式)
a. 文件地址：告诉open函数要打开哪个文件，填文件路径，可以填绝对路径，也可以填相对路径
绝对路径：E:\python1806\day10-迭代器和文件操作
相对路径：相对当前的文件所在的目录（./相对路径）
一个点代表当前目录，两个点是当前目录的上一层目录，三个点就是当前当前目录的上一层的上一层目录
b.打开方式：获取文件的内容以读的方式打开，往文件写内容就以写的方式打开
'r' -->读(默认值),读出来的内容是以文本的形式返回
'rb'/'br' --->读，读出来的内容以二进制(bytes)的形式返回
'w' --> 写， 写文本到文件中
'wb'/'bw' -->写二进制数据到文件中
'a' ---> 写，追加
编码方式：以文本的形式读和写的时候才需要设置编码方式.
utf-8:万国码
gbk:只支持中文
d. open函数的返回值是被打开的文件对象
关闭文件：文件对象.close()
'''
#操作文件f 就是被打开的文件对象
read():从文件开头读到文件结尾,如果文件不存在，会报错
'''
f = open('.\open.txt','r',encoding='utf-8')
#读取文件的所有内容，将结果返回给content保存
content = f.read()
print(content)
#关闭文件
f.close()
print('======================')
f1 = open('.\open.txt','r',encoding='utf-8')
#从文件开始读到第一行结束
content = f1.readline()
#从第二行读取到第二行结尾
print(f1.readline())
#从第三行读取到文件结尾
content1 = f1.read()
print(content)
print(content1)
#关闭文件
f1.close()
print('======================')
f2 = open('.\open.txt','r',encoding='utf-8')
while True:
content = f2.readline()
if not len(content):
break
print(content)
f2.close()
"""
当以写的形式打开一个不存在的文件，会自动创建一个文件
"""
f = open('.\open.txt','a',encoding='utf-8')
#f.write('\n程序员的诗')
f.close()
# 统计一个模块执行的次数
f = open('.\open.txt','r',encoding='utf-8')
number = int(f.read())
print(number)
f.close()
number += 1
f = open('.\open.txt','w',encoding='utf-8')
f.write(str(number))
f.close()
