迭代器

在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)

可以把迭代器看成一种容器，类似列表
生成器就是用来生成迭代器

1. 生成式----产生一个迭代器的表达式
   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()