导入的实质，当程序执行到导入导入模块的代码的时候，会进入到模块，将模块里的代码全部执行一遍

1.在python中，函数就是一种特殊的类型。声明函数的时候，其实就是在声明类型是functiond的变量

变量能做的时，函数都能做
注意:声明函数时，只管声明，不会去执行函数里面的代码

#声明一个函数fun(声明了一个函数变量，fun就是一个变量)
def fun():
    print('hello world')
#a也是一个函数
a = fun
a()

2.函数作为列表的元素

lst2=[]
lst3=[]
for x in range(10):
    def fun2(y):
        print(x+y)
    lst2.append(fun2)
    lst3.append(fun2(x))
print(lst2)
print(lst3)
#lst2就是一个函数
func = lst2[0]
func(100) #输出109

3.将函数作为字典的值

operatin = {'+':lambda x,y:x+y,'-':lambda x,y:x-y,'*':lambda x,y:x*y}
sum=operation['+']
sum(10,20)  #30

4.函数作为函数的参数（回调函数）

def clean_floor(time):
    print('在%s,做地板清洁服务'%time)
    print('收费100元')
    return 100

def clean_kitchen(time):
    print('在%s,打扫厨房'%time)
    print('收费200元')
    return 200
#在指定的时间，叫指定的服务
def call_service(time,service):
    service(time)

#将函数作为参数，传给其他函数
call_service('上午十点'，clean_kitchen)

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

def operation(operator:str):
    if operator =='+':
        def my_sum(*nums):
            sum1 = 0
            for num in nums:
                sum1+=num
            print(sum1)
        return my_sum
    elif operator == '*':
        def my_sum(*nums):
            sum1 = 0
            for num in nums:
                sum1*=num
        return my_sum
operation('+')(1,2,3)

6.生成式和迭代器

'''
可以把迭代器看成一种容器，类似列表。生成器就是来生成迭代器。
'''
#1.生成式---产生一个迭代器的表达式
#a是生成器，能够生成0-9的所有的数字
a=(x for x in range(10))
print(a,type(a))
#2.生成器和迭代器都是通过next来获取里面的数据
print(next(a))

a = (x*2 for x in range(10))
a=(char for char in 'fewfre345465' if '0'<=char<='9')
#3.通过将生成式产生的迭代器转换成一个列表
list1=[x for x in range(10)]
#4.通过生成式产生一个字典
#注意：容器类型的元素是元组，并且元素中有且只有两个元素的，才能转换成字典
dic =dict([(x,x*2) for x in range(10)])
#或者：
dic = dict((x,x*2) for x in range(10))

练习用一句代码实现交换一个字典中的key和value的值{1:'a',2:'b',3:'c'}-->{'a':1,'b':2,'c':3}

dic=dict((value,key) for key,value in dic.items())
dic=dict((dic[key],key) for key in dic)

#两个方法都可以

7、生成器

1.关键字：yield：只要函数中有yield关键字，那么这个函数就会变成一个生成器。
注意:函数中只要有yield，不管yield会不会执行到，函数的调用结果都是生成器
yield后面的结果（相当于作为返回值），每次执行结束后会保留执行的位置，下一次从这儿开始执行
调用函数的时候不执行函数体，每次调用next时候执行函数体

a.有yield的函数，在调用函数的时候不再是获取返回值，而是产生一个生成器对象，生成器对象中保留的是函数体
b.当通过next获取生成器中的数据的时候，才会去执行函数体，执行到yield为止，并且将yield后面的结果作为生成的数据返回，同时记录结束的位置，下次再调用的next的时候，从上次结束的位置接着往后执行。
生成器存的是产生数据的算法
例子：

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

func1()

#这儿的func2()是一个生成器
def func2():
    for x in range(10):
        yield x

gen=func2() #有yield时，这儿保存的是函数体
print(next(gen))    #0
print(next(gen))    #1

def func3(x):
    print('abc')
    if x>10:
        yield 100
    return 20
gen=func3(10)
print(next(gen))

练习：写一个生成器，可以产生斐波那契数列(可以无限生成)

def feibo():
    i = 1
    p1 = 1
    p2 = 1
    while True:
        if i == 1 or i == 2:
            yield p1
            i +=1
        else:
            yield p1+p2
            p1,p2=p2,p1+p2
            i+=1
gen = feibo()
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))

写法二：
def feibo():
    yield 1
    yield 1
    x =1
    y =1
    while True:
        yield x+y
        x,y=y,x+y   
gen = feibo()
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))

#2.生成器和生成式产生的对象就是迭代器
将列表转换为迭代器对象
iter1 = iter([1,2,3,4])
print(next(iter1))
for item in iter1:
    print(item)

8.文件操作

1.程序中不管操作任何文件，不管怎么操作，过程都是：打开一个文件->然后再操作文件（读，写）->关闭文件
2.做数据持久化或者是本地化都要使用文件来保存数据
数据库文件，文本文件（txt文件），json文件，plist，xml文件等等、二进制文件（图片文件，视频，音频）

程序中通过变量，列表、字典等保存的数据，在程序结束后都会被销毁的

1.文本文件的操作：
a.打开文件
open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True)

file:表示文件地址
绝对路径，相对路径都可以，一般不推荐使用绝对路径
相对路径，相对与当前文件所在的目录
./ 相对路径(相对于当前文件文件所在的目录)
../ 相对路径(相对于当前文件上一级文件所在的目录)
.../ 相对于当前文件所在的目录的上一层的上一层的目录
mode:打开方式，默认是r
buffering：文件缓冲区
encodeing:编码方式
errors:错误处理方式，ignore
b.打开方式：获取文件的内容以读的形式打开，往文件中写内容就以写的形式打开
'r' 读（默认值），读出来的内容以文本str的形式返回
'rb/br' 读，读出来的内容以二进制bytes的形式返回
'w' 写，写文本到文件中，没有文件会新建文件，会将有内容的文件清空
'wb/bw' 写，写二进制数据到文件中
'a' 写，追加，

c.编码方式，以文本的形式读和写的时候才需要设置编码方式
utf-8
gbk:只支持中文
d:open函数的返回值是被打开的文件对象

2.关闭文件
文件对象,close()

3.操作文件
a.读操作

file = open(r'D:\迅雷下载\小说.txt'.encode('utf-8').decode('utf-8'),encoding='utf-8',errors='ignore')
for line in file:
    print(line,end=' ')
file.close()

读文件时，会记录文件读取指针，下一次从上一次结束的指针位置开始
读文件中的所有内容:

        content=fileobject.read()//从文件开头读到文件结尾
        lst=fileobject.readliens()

读取文件一行:

        line = fileobject.readline()//读取文件一行

练习：读文件内容，一行一行的读取读完为止

file = open(r'test.txt',encoding='utf-8')
for line in file:
    print(line,end=' ')
file.close()
#方法二
file = open(r'test.txt',encoding='utf-8')
line=file.readline()
while line:
    print(line,end=' ')
    line = file.readline()
file.close()

b.写操作

    f=open('./test.txt','w',encoding='utf-8')
    f.write('哈哈哈哈')
    f.close(）

当以写的形式打开一个不存在的文件的文件的时候，会自动创建一个新的文件
练习:统计一个模块的执行次数

file = open('test04.txt','r',encoding='utf-8')
number = int(file.read())
print(number)
file.close()

file2 = open('test04.txt','w',encoding='utf-8')

file2.write(str(number+1))
file2.close()