一、函数作为变量

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

1.函数给其他变量赋值

#1.使用一个变量给另外一个变量赋值
#之前声明变量的方式
a = 10
b = a
#函数变量
#先声明一个函数func1(声明了一个函数变量func1,func1就是一个变量)
def func1()：
    print('Hello,Python')
#c也是一个函数
c = func1
func1()
c()
结果： Hello Python    Hello Python 
#2.函数作为列表的元素
list1 = [a,10,100]
list2 = []
list3 = []
for x in range(10):
    def func2(y):
        print(x+y)  #结果：0,2,4,6,8,10,12,14,16，18
    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.将函数作为字典的值
def sub(*nums):
    if not nums:
       return 0
    sum1 = nums[0]
    for item in nums[1:]:
        sum1 -= item
    return sum1
operation = {'+': lambda *nums: sum(nums), '-': sub, '*': lambda x, y: x*y}
    result = operation['-'](10, 20, 30, -100)
    print(result)  # 结果：60
# 4.函数作为函数的参数（回调函数）
    def clean_kitchen(time):
        print('在%s，打扫厨房' % time)
        print('收费200元')  
        return 200
# 结果：
# 在上午10点，打扫厨房
# 收费200元

    def clean_floor(time):
        print('在%s，做地板清洁服务' % time)
        print('收费100元')
        return 100
# 结果：
# 在下午2点，做地板清洁服务
# 收费100元
    # 在指定的时间，叫指定的服务
    def call_service(time: str, 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 num in nums:
                    sum1 += num
                print(sum1)

            # 将求和的函数返回
            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)  # 结果：6
    operation('*')(2, 3, 4)  # 结果：20

二、生成器和生成式

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

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))  # 0
    print(next(a0))  # 0
    print(next(a1)) # h    
    print(next(a2)) # 0
 
 for x in a:
        print(x)  # 结果：0,1,2,3,4,5,6,7,8,9
    # 3.将生成器转换成列表
    # 通过将生成式产生的迭代器转换成了一个列表
    list1 = [x for x in range(10)]
    print(list1) # 结果：[0,1,2,3,4,5,6,7,8,9]

 # 4.将生成器转换成字典
    # 注意：容器类型的元素是元祖，并且元素中有且只有两个元素的，才能转换成字典
    dict1 = dict((x, x*2) for x in range(5)) 
    print(dict1)  # 结果：{0: 0, 1: 2, 2: 4, 3: 6, 4: 8}

# 练习:一句代码实现交换一个字典中的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)
# 结果：{1: 'a', 2: 'b', 3: 'c'}

三、生成器

if __name__ == '__main__':

    def func1():
        for x in range(10):
            return x
    print(func1(), type(func1()), type(func1))
    #  结果： 0 <class 'int'> < class 'function' >

# 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')  # 结果：abc 
        if x > 10:
            yield 100
        return 20

    # print(func2(), type(func2()), type(func2))
    # 这儿的func2()是一个生成器
    gen = func2()
    print(next(gen)) # 打印0之后继续让下执行打印 aaa
    print(next(gen)) # 打印1之后继续让下执行打印 aaa
    print(next(gen)) # 打印1之后继续让下执行打印 aaa

    gen2 = func3(1)
    print(gen2) # 函数中加入了yield 输出函数就会变成一个生成器，并打印地址

# 练习：写一个生成器，可以产生斐波那契数列（可以无限生成）
    # 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)) 1
    print(next(se)) 1
    print(next(se)) 2
    print(next(se)) 3
    print(next(se)) 5
    print(next(se)) 8
    print(next(se)) 13
    print(next(se)) 21
    print(next(se)) 34
    print(next(se)) 55

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

四、文件操作

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

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

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

打开文件

open（文件地址，打开方式，encoding=编码方式）
a.文件地址：开始open函数要打开的是哪个文件，填文件路径。可以填绝对路径，也可以填相对路径

• 绝对路径：/Users/Administrator/Desktop/weishiqiang.txt（一般不用）
• 相对路径：
  ./相对路径（当前文件所在的目录）
  ../相对路径（当前文件所在的上一级目录）
  .../相对路径（当前文件所在的上上一级目录）
  b.打开方式：获取文件的内容以读的形式打开，往文件中写内容就以写的形式打开
• 'r' ---> 读（默认值），读出来的内容以文本（str）的形式返回
• 'rb'/'br' ---> 读（默认值），读出来的内容以二进制（bytes）的形式返回
• 'w' ---> 写，写文本到文件中
• 'a' ---> 写，追加
  c.编码方式：以文本的形式读和写的时候才需要设置编码方式。
• utf-8：万国码
• gbk：只支持中文
  d.open函数的返回值是被打开的文件对象

关闭文件

文件对象.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()