1.复习：

匿名函数
匿名函数 = lambda 参数列表 ：返回值
函数名（实参）

2.作用域
函数调用过程是一个压栈的过程

全局变量：在函数/类外面声明的变量是全局变量，从声明开始到文件结束

局部变量：在函数/类里面声明的变量是局部变量，从声明开始到函数/类结束

global使用
nonlocal的使用
3.*递归函数（能不用就尽量不用）
a.找临界值（结束循环/让函数结束）
b.假设函数功能已经实现，找关系（找上次循环和本次循环的关系f(n)和f（n-1）的关系）
c.通过f(n-1)实现f(n）的功能

4.模块的使用
一个py文件就是一个模块

import
form-import
当程序执行到导入模块的代码的时候，会进入模块中，将模块里面的代码全部执行一遍

import random #引入模块
import math  #引入模块

import otherModel #引入模块
print(otherModel.a) #将a值带入模块中
print(otherModel.test（）) #将test带入模块中

global和nonlocal的用法：

n = 100
def func1():
      global  # 在函数中引入global让局部改变全局变量的值
      n = 200
    
      nn =10
      def func2():
            nonlocal nn  #在函数中引入nonlocal,在函数的函数中改变函数中的变量
            nn = 100
       func2()
       print(nn) #100
func1(）
print(n) #200

匿名函数：

sum1 = lambda x,y：x*y
print(sum1(10,20)

对应的普通函数：

def sum1_1(x,y)
      ''""
      函数功能的描述
      ：param x:
        :param y:
        :return:
       """
        return   x*y
print(sum1_1(10,20)) #20

5.如果不想被封装就将代码写在if后面
规则：
if name=='main':
pass

2.函数作为变量：

在python 中，函数就是一种特殊的类型。声明函数的时候，
其实就是声明类型是function的变量。
变量能做的事，函数都可以做
1.函数给其他变量赋值
if name == 'main':
(使用一个变量给另一个变量赋值）
a = 10
b = a
/声明一个函数func1（声明了一个函数变量func1,func1就是一个变量）

def  func1():
      print('hello  python')
/c也是一个函数
c = func1
print(c)

2.函数作为列表的元素

list2 = []
list3 = []
 for x in range(10):
         def func2(y):
                print(x+y)
list2.append(func2)
list3.append(func2(x)) # x--->0~9
/list2中每个元素的值都是函数
print(list2)  #func2 的地址
print(list2)   # 没有return ,所有返回值是None组成的列表

/list2 [0]就是一个函数
func1 = list2[0]
print(func（100）)

/调用list2中下标是1对应的函数，并且传参为10
x = 10
list2[1]（10）

/直接将函数作为列表元素
funcs = [func1]
funcs0

3.将函数做为字典的值

def sub(*nums):
          '''
          累计求差
         ：param nums: 求差的数
          ：return:差
          '''
            if not nums:# 不是空，代表num是空
                    return 0
              /默认是第一个数
             sum1 = nums[0]
              for item in nums[1:]：
                sum1    -=    item
              return sum1

operation = {'+'：lambda *nums：sum(nums)，'-':sub,'*':lambdax,y:x*y}  #operation代表一个字典

result = operation['-'](10,20,30,-100)  #字典通过key 值取sub,就相当于sub(10,20,30,-100)

print(result)# 60

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)      /service相当于clean_kitchen，time就是下面传上来的值，再传给clean_kitchen(time)或clean_floor(time)再执行

     #将函数作为参数，传给其他函数
 call_service('上午10点', clean_kitchen)   /将值传给time和service
 call_service('下午2点', clean_floor)    /将值传给time和service

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

def operation(operator):  #1  ,12
    if operator == '+':         # 3


        def my_sum(*nums):  #6
            sum1 = 0                #7
            for num in nums:    #8
                sum1 += num     #9
            print(sum1)            #10

         将求和的函数返回
        return my_sum     #4

    elif operator == '*':    #13
        def my_sum(*nums):    #16
            sum1 = 1          #17
            for num in nums:     #18
                sum1 *= num      #19
            print(sum1)               #20
         将求乘积的函数返回
        return my_sum       #14

operation('+')的结果是函数
operation('+')(1, 2, 3)          #2,  5
operation('*')(2, 3, 4)           #11, 15,最后

 ```

3.生成器和生成式：

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

if __name__ == '__main__':

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

    print('=======')
    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))  # {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)

4.生成器

if __name__ == '__main__':

    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():
     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

     print(func2(), type(func2()), type(func2))

这儿的func2()是一个生成器

    gen = func2()
    print(next(gen))
    print(next(gen))
    print(next(gen))

    gen2 = func3(1)
    print(gen2)

练习：写一个生成器，可以产生斐波那契数列（可以无限生成）
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)

5.文件操作：

程序中不管操作任何文件，不管怎么操作，过程都是: 打开文件 -> 操作(读/写) -> 关闭文件

做数据持久化、本地化，都要使用文件来保存数据
(数据库文件、txt文档、json文件、plist、xml文件等、二进制文件(图片、视频、音频等))

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

if __name__ == '__main__':

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)

前面已经读完了，接着往后读，读不到内容
print('!!!:',f.readline())

f.close()

print('================')

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

  从第三行开始，读到文件结束
    print(f1.read())
    f1.close()

练习：读文件中的内容，一行一行的读，读完为止
print('~~~~~~~~~~~~~~~~')

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