01-record

• 1.匿名函数
  函数名 = lambda 参数列表：返回值
  函数名（实参）
• 2.作用域
  函数的调用过程是一个压栈的过程
  全局变量：不在函数或类外面声明的变量
  从声明开始到文件结束
  局部变量：在函数和类里面声明的变量
  从声明开始到函数结束
  global的使用
  nonlocal的使用：局部中给变量赋值
• 3.递归函数（能不用就不用）
  a.找临界（结束循环/让函数结束）
  b.假设函数功能已经实现，找关系
  c.通过f(n-1)实现f(n)的功能
• 4.模块使用
  一个py文件就是一个模块
  import
  form-import
  当程序执行导入模块的代码的时候，会进入模块中，将模块里面的代码全部执行一遍

sum1 = lambda x,y:x*y

def sum1_1(x,y):
    '''
    函数功能的描述
    :param x:
    :param y:
    :return:
    '''
    return x*y

sum1 = sum1_1(2,3)
if __name__ == '__main__':
    print(sum1)

02-函数作为变量

在python中，函数就是一种特殊的类型，声明函数的时候，其实就是在声明类型是function的变量
变量能做的事情，函数都可以做

if __name__ == '__main__':
    # 1.使用一个变量给另一个变量赋值
    a = 10
    b = a
    # 声明一个函数func1(声明了一个变量func1，func1就是一个变量）
    def func1():
        print('hello python')

    # c也是一个函数
    c = func1
    func1()
    c()

2.函数作为列表的元素

    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]就是一个函数
    list2[0]
    func = list2[0]
    print(func(100))

    list2[1](10)

    # 直接将函数作为列表的元素
    funcs = [func1]
    funcs[0]()

3.将函数作为字典的值

    def sub(*nums):
        '''
        累计求差
        :param nums: 求差的数
        :return: 差
        '''
        if not nums:
            return 0
        # 默认是第一个数
        sum1 = nums[0]
        for item in nums[1:]:
            sum1 -= item
        return sum1
    operation ={'+':lambda x,y:x+y,'-':lambda x,y:x-y,'*':lambda x,y:x*y}
    result = operation['*'](10,20)
    print(result)

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

    def clean_kitchen(time):
        print('在%s,打扫厨房' % time)
        print('收费200元')
    def clean_floor(time):
        print('在%s,清洁地板' % time)
        print('收费100元')
    # 在指定的时间，叫指定的服务
    def call_service(time,service):
        service(time)
    # 将函数作为参数，传给其他函数使用
    call_service('上午10点',clean_kitchen)
    print('===============')
    # 函数作为函数的返回值
    def operation(operator:str):
        if operator == '+':
            def my_sum (*nums):
                sum1 = 0
                for num in nums:
                    sum += num
            # 将求和的函数返回
            return my_sum()
        elif operator == '*':
            def my_sum(*nums):
                sum1 = 1
                for num in nums:
                    sum1 *= num
                print(sum1)
            # 将求乘的函数返回
            return my_sum
    # operation('*')的结果是函数
    operation('*')(1,2,3)

03-生成器和生成式

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

1.生成式-----产生一个迭代器的表达方式

a.是生成器，能够保存生成0-9中所有数字的算法

a = (x for x in range (10))
    print(a,type(a))
    a = (x*2 for x in range(10))
    a = (char for char in 'a1b0cd1' if '0' <= char <= '9')
2.生成器和迭代器都是通过next来获取里面的数据
    print(next(a))
    print(next(a))
    print(next(a))

3.将生成器转换成列表

通过将生成式产生的迭代器转换成了一个列表

list1 = [x for x in range(10)]
    print(list1)

4.将生成器转换成字典

注意：容器类型的元素是元组，并且元素中有且只有2个元素，才能转换成字典

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

• 用一句代码转换一个字典中的key和value的值.{'a';1,'b';2}

方法一：
    dict2 = dict((value,key) for key,value in {'a':1,'b':2}.items())
    print(dict2)
方法二：
    old = {'a':1,'b':2}
    dict3 = dict((old[key],key) for key in old )
    print(dict3)

04-生成器

 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):
            print('asd')
            yield x
            print('aa')

    # print(func2(), type(func2()), type(func2))
    # 注意：函数中只要有yield，不管yield会不会执行到，函数的结果都是一个生成器
    # 这儿的func2（）是一个生成器
    # gen = func2()
    # print(next(gen))
    # print(next(gen))
    # print(next(gen))

写一个生成器，可以无限产生斐波那契数列

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

    gen = list3()
    print(next(gen))
    print(next(gen))
    print(next(gen))
    print(next(gen))
    print(next(gen))
    print(next(gen))
    print('===============')

写一个生成器，可以产生一个等差数列

 def list4():
        yield 1
        x = 1
        y = 2
        while True:
            yield x + y
            x,y = x + y,y
    Cha = list4()
    print(next(Cha))
    print(next(Cha))
    print(next(Cha))
    print(next(Cha))
    print(next(Cha))
    print(next(Cha))
    print(next(Cha))
    print('===============')

• 2.生成器和生成式产生的对象就是迭代器
  将列表转换成迭代器（iter）

 iter1 = iter([1,2,3,4])
    print(iter1)
    print(next(iter1))
    for item in iter1:
        print(item)

05-文件操作

程序中不管操作任何文件，不管怎么操作，过程都是一样的
过程：打开文件--》操作（读/写）--》关闭文件

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

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

1.打开文件

open(文件地址file,打开方式mode，encoding = 编码方式)

• a.文件地址：告诉open要打开的是哪个文件，填文件路径（可以填绝对路径，也可以填相对路径）
  绝对路径：C:/Users/Administrator/Desktop/txt.txt
  相对路径：./相对路径（相对于当前文件所在的目录） ../相对路径（相对于当前文件所在的目录的上一层目录）
  一次向外扩展
• b.打开方式：获取文件的内容以读的形式打开，往文件中写内容就以写的形式打开
  ‘r’--》读（默认值），读出来的内容以文本（str)的形式返回
  'rb'/'br'--》读，读出来的内容以二进制（bytes)的形式返回
  ‘w'--》写，写文本到文件中
  ‘wb'/'bw'--》写，写二进制数据到文本中
  ‘a'--》写，追加
• c.编码方式：以文本的形式读和写的时候才需要设置编码方式
  utf-8:万国码
  gbk:只支持中文
  d.open函数的返回值是被打开的文件对象

2.关闭文件

文件对象.close

 # 1.打开文件
 # f1 = open('D:/编程Python/Python代码/我的python/08-31函数和文件操作','rb')
    f1= open('./程序员.txt','rb')

2.文件关闭

f1.close()

3.操作文件

a.读操作

    rade():从文件的开头读到文件结束
    readline():读一行
    '''
 # 打开文件，f就是被打开的文件对象
    f = open('./程序员.txt','r',encoding = 'utf-8')
 # 获取文件中所有内容，将结果返回给content保存
    content = f.read()
    print(content)
 # 前面已经读完了，接着往后读，读不到内容
    print('!!!:',f.readline())
    f.close()
    print('=========================')
    f1 = open('./程序员.txt','r',encoding='utf-8')
 # 从文件开始读到第一行结束
    content = f1.readline()
    print(content)
 # 从文件第二行开始，读到第二行结束
    print(f1.readline())
 # 从第三行开始，读到文件结束
    print(f1.read())
    f1.close()

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

print('```````````')
    f2 = open('./程序员.txt', 'r', encoding='utf-8')
    content = f2.readline()
    while content:
        print('line:', content)
        content = f2.readline()
    f2.close()

b.操作

'''
write(写的内容）
'w'-->写操作，完全覆盖原文件的内容
'a'-->写操作，在原文件的内容后去追加新的内容
'''
# f3 = open('./test.txt','a',encoding = 'utf-8')
# f3.write('程序员的诗')
# f3.close()

4.文件不存在的情况

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

# f4 = open('./test2.txt','w',encoding = 'utf-8')
    # f4.write('你好,初次见面请多关照')
    # f4.close()

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

# def num1():
    # while True:
    f5 = open('./test2.txt', 'r', encoding='utf-8')
    content = int(f5.read())
    print(content)
    f5.close()

    f5 = open('./test2.txt', 'w', encoding='utf-8')
    content += 1
    f5.write(str(content))
    print(content)
    f.close()