1.函数

声明函数的时候其实就是申明一个数据类型为function的变量，变量能做的事情函数变量都可以做

1.1 函数给另一个变量赋值

    def func1():
        print('hello python')

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

1.2函数作为列表的元素

list1=[]
list2=[]
for x in range(10):
  def func(y):
    print(x+y)
list1.append(func)    #list1的每个元素都是函数
list2.append(func())    #list2的每一个元素都是func的返回值

print(list[2](3))----->func(3)
print(list[2])----->None

###1.3函数作为字典的值
  

# sub(10,2,3) -- 10-2-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 *nums: sum(nums), '-': sub, '*': lambda x, y: x*y}

result = operation['-'](10, 20, 30, -100)
print(result)

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

# 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: str, service):
    service(time)


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

1.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)
    operation('*')(2, 3, 4)

2.生成式，生成器，迭代器

a=x for x in range(10)

• a:生成器/迭代器
• x for x in range(10)：生成式
• （x for x in range(10)）：生成器/迭代器

2.1.写法：

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.2获取生成器/迭代器的值

a.使用next(生成器)获取

• print（next（a0））
  a=next(a0)来获取
  b.通过遍历来获取

注意：
1.生成器在计算机内存中存的是地址，地址指向的内存区域存的是生成式，而不是像序列一样存的是多个元素，它只存一个当前值

2.不管用next（生成器）还是遍历来获取生成器的值，只能依次取，每次只能取一个值，每个值也只能取一次，取完为止

2.3生成器的转化

2.3.1生成器转化为列表

• 将 生成式产生的生成器转化为列表

gen=(x for x in range(10))

• list1=[gen] :list1表示只有一个元素，元素是生成器的列表

• list2=[(x for x in range(10))]: list2跟list1一样，指向的不是同一个地址

• list3=[x for x in range(10)]:表示[0,1,2,3,4,5,6,7,8,9]

• list4=list(gen)或list(x for x in range(10)) 表示[0,1,2,3...,9]

2.3.2.将生成器转换成字典

• 不能用{生成式}的方式，它生成的是一个集合
• 能转换成字典的容器，其每一个元素必须是元祖，并且元祖的长度是2
• dict（生成器）

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

练习:一句代码实现交换一个字典中的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)

复习：遍历字典
**for key in dict:** 只能遍历字典key值
**for key，value in dict.items**:同时遍历key和value

3 yield 关键字

3.1只要函数中有yield关键字，那么这个函数就会变成一个生成器。

def func2():   #func2是一个生成器对象
    print('abc')
    for x in range(10):
        yield x
        print('aaa')    

• 有yield的函数，在调用函数的时候不再是获取返回值， 而是产生一个生成器对象，生成器对象中保留的是函数体。

• 当通过next获取生成器中的数据的时候，才会去执行函数体，执行到yield为止， 并且将yield后面的结果作为生成的数据返回。同时记录结束的位置，下次再调用next的时候， 从上次结束的位置接着往后执行。

说明
申明函数时，只要函数中有yield，不管能不能执行到yield，都是一个生成器

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

3.2

• 迭代器(iter)
• iter(列表)

    iter1 = iter([1, 2, 3, 4])
    print(iter1)    #生成器，存的是地址
    print(next(iter1))  #取生成器第1个值
    print(next(iter1))  #取生成器第2个值
    for item in iter1:
        print(item)   #从第三个值开始遍历

4文件操作

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

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

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

4.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函数的返回值是被打开的文件对象

4.2.关闭文件

文件对象.close()

4.3操作文件

a. 读操作

• read(): 从文件的开头读到文件结果
• readline(): 读一行内容

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

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

    f.close()   #关闭文件

4.4a. 写操作

write(写的内容)

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

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

4.5文件不存在的情况

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