01.函数作为变量

在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))
    #list2中每个元素的值都是函数
    print(list2)
    print(list3)
    #list2[0]就是一个函数
    func = list2[0]
    print(func(100))
    #调用list2中下标是1对应的函数，并且传参为10
    x=10
    list2[1](10)
    #直接将函数作为列表的元素
    funcs = [func1]
    funcs[0]()

3.将函数作为字典的值

    result = operation['-'](9,9)
    print(result)

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, service):
    service(time)
#将函数作为参数，传给其他函数
call_service('上午10点',clean_kitchen)
call_service('下午2点',clean_floor)

5.函数作为函数的返回值

def operation(operator: str):
    if operator == '+':
        def my_sum(*nums):
            sum1 = 0
            for item in nums:
                sum1 += item
            print(sum1)
# 将求和的函数返回
        return my_sum
    elif operator == '*':
        def my_sum(*nums):
            sum1 = 1
            for item in nums:
                sum1 *= item
            print(sum1)
#将求乘的函数返回
        return my_sum
# operation('*')的结果是函数
operation('*')(1, 2, 3)

02.生成器和生成式

可以把迭代器看成一种容器，类似列表。生成器就是来生成迭代器。
1.生成式----- 产生一个迭代器的表达式

# a是生成器，能够生成0-9中所有的数字
a=(x for x in range(10))
print(a,type(a))
a0=(x*2 for x in range(10))
c='hello python'
a1=(char for char in c)
a2=(char for char in 'hello python999'if '0'<=char<='9')

2.生成器和迭代器都是通过next来获取里面的数据

for x in a:
    print(x)

3.将生成器转换成列表

#通过将生成式产生的迭代式转换成了一个列表
list1=[x for x in range(10)]
print(list1)

4.将生成器装换成字典
注意：容器类型的元素是元祖，并且元素中有且只有两个元素的，才能转换成字典

dict1=dict((x,x*2) for x in range(5))
print(dict1)

练习：一句代码，实现交换一个字典中的key,value的值。{'a':1,'b':2}--->{1：‘a',2:'b'}

ftr=dict((value,key) for key,value in {'a':1,'b':2}.items())
print(ftr)

03.生成器

def func1():
  for x in range(10):
      return x

#0 <class 'int'> <class 'function'>
# print(func1(),type(func1()),type(func1))

1.yield关键字
只要函数中有yield，那么这个函数就会变成一个生成器。
a.有yield的函数，再调用函数的时候不在是获取返回值，
而是生成一个生成器对象，生成器对象中保留的是函数体。
b.当通过next获取声称其中的数据的时候，才会去执行函数体，执行到yield为止，
并且将yield后面的结果作为生成的数据返回。同时记录结束的位置，下次再调用next的时候，
从上次结束的位置接着往后执行。

def func2():
    for x in range(10):
        yield x

注意：函数中只要有yield，不管yield会不会执行到，函数的调用结果
     都是生成器
def func3(x):
    print('abc')
    if x >10:
        yield 100
    return 20
# print(func2(),type(func2()),type(func2))
# 这的func2()是一个生成器
get=func2()

练习：写一个生成器，可以产生斐波那契数列。

def fbnq ():
    yield 1
    yield 1
    x=1
    y=1
    while True:
        yield x+y
        x,y=y,x+y

ftr=fbnq()
print(next(ftr))
print(next(ftr))

注意：
a.生成器和生成式产生的对象就是迭代器
b.将列表转换成迭代器对象
c.迭代器(iter1)

iter1=iter([1,2,3,4])
print(iter1)
print(next(iter1))
print(next(iter1))

for item in iter1:
    print(item)

04.文件操作

1.过程：打开-->操作（读、写）
2.作数据持久化、本地化，都要使用文件来保存数据
（数据库文件、txt文档、json文件、plist、xml文件）
程序中通过变量、列表、字典等保存的数据，在程序
结束后都会被销毁的。

========================================

1.打开文件
open(文件地址，打开方式，encoding=编码方式)
a.文件地址：文件路径，绝对路径和相对路径（./:文件所在目录；../:文件上一层的目录）。
b.打开方式：获取文件的内容以读的形式打开，往文件中写内容就以写的形式开
'r' ---> 读（默认值） 读出来的内容以文本的形式返回
'rb'/'br' --->读，读出来的内容以二进制（）的形式返回
'w' --->写，写文本到文件中
'wb'/'bw' --->写，写二进制数据到文件中
'a' --->写，追加

c.编码方式：以文本的形式读和写的时候才需要设置编码方式。
utf-8：万国码
gbk:只支持中文
d.open函数的返回值是被打开的文件对象
e.关闭文件文件对象.close()
f.文本文件

open('/Users/Desktop/999.txt',encoding='utf-8')
open('./test.txt','rb')
f=open('../')

2.关闭文件
f.close()
3.操作文件
a.读操作
打开文件，f就是被打开的文件对象

f=open('./test.txt','r',encoding='utf-8')
#获取文件中所有的内容，将结果返回给content保存
content=f.read()
print(content)
f.close()

f1=open('./test.txt','r',encoding='utf-8')
#从文件开始读到第一行结束
content=f1.readline()
print(content)
# 从第二行开始，读到第二行结束
print(f1.readline())
# 从第三行开始
f1.close()
ftr=open('./tsxt.txt','r',encoding='utf-8')
content=ftr.readline()
while content:
  print('====================================')
   print(content)
   content=ftr.readline()

ftr.close()

b.写操作
write(写的内容)
'w' -->写操作，完全覆盖原文件的内容
'a' -->写操作，在原文件的内容后去追加新的内容

f=open('./tsxt.txt','a',encoding='utf-8')
f.write('程序员的诗')
f.close()

4.文件不存在的情况
当以读的形式打开文件的时候，如果文件不存在，程序会崩溃。当以写的形式打开一个不存在的文件的时候，会自动创建一个新的文件。

f = open('./test3.txt','w',encoding='utf-8')
f.write('hellollllll')
f.close()

练习：统计一个模块执行的次数。

f1 = open('./test4.txt',encoding='utf-8')
number = int(f1.read())
print(number)
f1.close()
number+=1
f1=open('./test4.txt','w',encoding='utf-8')
f1.write((str(number)))
f1.close()