函数作为变量

在python中，函数就是一种特殊的类型。声明函数的时候，其实就是在声明类型是function的变量，变量能做的事，函数都可以做
1######.函数给其他变量赋值

#使用一个变量给另一个变量赋值
a = 10
b = a
#声明一个函数func1(声明了一个函数变量func1，func1就是一个变量)
def func1():
      print('hello python')
# c也是一个函数
c = func1
func1()
c()
输出：
hello python
hello python

2.######2.函数作为列表的元素

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

# 调用list2中下标是1对应的函数，并且传参为10
x = 10
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 *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

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)
输出:
在上午10点，打扫厨房
收费200元
在下午2点，做地板清洁服务
收费100元

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)
输出：
6
24

生成器和生成式

可以把迭代器看成一种容器，类似列表，生成器就是来生成迭代器
1.生成式-----产生一个迭代器的表达式
例如：a是生成器，生成0-9中的所有数字

a = (x for x in range(10))
print(a,type(a))
输出：
<generator object <genexpr> at 0x02171690> <class 'generator'>

a0 = (x*2 for x in range(10))

a1 = (char for char in 'hello world')

a2 = (char for char in 'sa2dr4f453' if '0'<=char<='9')
#生成器和迭代器都是通过next来获取里面的数据
print(next(a))
print(next(a))
print(next(a))
print(next(a))
print('========')
for x in a:
    print(x)
输出：
0
1
2
3
=======
4
5
6
7
8
9

将生成器转换成列表

#通过将生成式产生的迭代器转换成一个列表
list1 = [x for x in range(10)]
print(list1)
输出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

将生成器转换成字典

注意：容器类型的元素是元组，并且元素中有且只有两个元素的，才能转换成字典
dict1 = dict((x,x*2) for x in range(10))
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}.items())


#能够实现同样的效果
old = {'a':1,'b':2}
dict2 = dict((old[key],key) for key in old)
print(dict2)
输出：
{1: 'a', 2: 'b'}

生成器

只要函数中有yield关键字，那么这个函数就会变成一个生成器
a.函数中有yield的函数，在调用函数的时候不再是获取返回值，而是产生一个生成器，生成器对象中保留的是函数体
b.当通过next获取生成器的数据的时候，才会执行函数体，执行到yield为止，并且将yield后面的结果作为生成的数据返回，同时记录结束的位置，下次再调用的时候，从上次结束的位置接着往后执行

def func2():
    print('abc')
    for x in range(10):
        yield x
        print('aaa')
#这的func2()是一个生成器
gen = func2()
print(next(gen))
print(next(gen))
print(next(gen))
输出:
abc
0
aaa
1
aaa
2

注意：函数中只要有yield不管yield会不会执行到，函数的调用结果都是生成器

def func3(x):
    print('asd')
    if  x > 10:
        yield 100
    return 20
print(func2(),type(func2()),type(func2))
输出:
<generator object func2 at 0x00931690> <class 'generator'> <class 'function'>

练习：写一个生成器，可以产生斐波那契数列（可以无限生成）
(1,1,2,3,5,8,13,21,34....)

def fei():
    yield 1
    yield 1
    a = 1
    b = 1
    while True:
        yield a+b
        a,b = b,a+b

gen = fei()
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))
输出:
1
1
2
3
5

生成器和生成式产生的对象就是迭代器

#将列表转换成迭代器对象
iter1 = iter([1,2,3,4])
print(iter1)

print(next(iter1))
print(next(iter1))
for item in iter1:
    print(item)
输出：
<list_iterator object at 0x00927DB0>
1
2
3
4

文件操作

1.程序中不管操作任何文件，不管怎么操作，过程都是：打开文件-->操作（读/写）-->关闭文件
2.2.做数据持久化，本地化，都要使用文件来保存数据（数据库文件，txt文档，json文件，plist,xml文件等，二进制文件（图片，视频，音频等））
程序中通过变量，列表，字典等保存的数据，在程序结束后都会被销毁的

1.打开文件

open(文件地址，打开方式，encoding=编码方式)
文件地址：告诉open函数要打开的是哪个文件，填文件路径，可以填绝对路径，也可以填相对路径
绝对路径：/Users/Administrator/Desktop/a.txt
相对路径：./相对路径（相对于当前文件所在的目录）
../相对路径（相对于当前文件所在的目录的上一层目录）
b.打开方式，获取文件的内容以读的形式打开，往文件中写内容就以写的内容打开
'r' ---> 读（默认值）,读出来的内容以文本形式返回
'rb' /'br' ---> 读，读出来的内容以二进制（bytes）的形式返回
'w'--> 写，写文本到文件中
'wb'/'bw'--> 写，写二进制数据到文件中
'a' ---> 写 追加

c.编码方式：以文本的形式读和写的时候才需要设置编码方式
utf-8:万国码
gbk:只支持中文

d.open函数的返回值是被打开的文件对象

文件对象.close()
打开文件

f1 = open('/Users/Administrator/Desktop/a.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 = open('./test.txt', 'r', encoding='utf-8')
# 获取文件中的所有内容，将结果返回给content保存
content = f.read()
print(content)

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

f.close()

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

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

#读文件中的内容，一行一行读写，读完为止
f = open('./test.txt','r',encoding='utf-8')
content = f.readline()
while content:
    print('line',content)
    content = f.readline()

f.close()
输出:
line 少时狂发编程想，无畏赴身IT行。纵使荣华未可近，我自coding又何妨！

line 老夫聊发少年狂，不小心，选错行。误入IT，两眼泪茫茫

line 日撸代码三千行，疯狂、疯狂，人未老，珠已黄。

line 日出东隅照我床，悠悠青龙倚斜阳。陋室区区徒四壁，代码行行正铿锵

b.写操作

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

f = open('./test.txt','w',encoding='utf8')
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()
执行一次，输出的值加1