一.函数作为变量

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

1.函数给其他变量赋值
使用一个变量给另外一个变量赋值

def func1():
  print('hello')
c = func1# c也是一个函数
#两种写法相同
func1()
c()

2.函数作为列表的元素

list2 = []
list3 = []
for x in range(10):
  def func2(y):
    print(x+y)
  list2.append(func2)#list2中每个元素都是函数
  list3.append(func2(x))#list3中每个元素都是None

func = list2[0]#list2[0]就是一个函数
print(func(100))#结果是109

3.将函数作为字典的值

def sub(*nums):
    """
    累计求差
    :param nums:求差的数
    :return: 差
    """
  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,1)
print(result)
#输出结果是-11

4.函数作为函数的参数(回调函数)
例:家居服务

#厨房清理服务
def clean_kitchen(time):
  print('在%s,打扫厨房'%time)
  print('收费200元')
  return 200

def call_service(time:str,service):
  service(time)

call_service('上午10点',clean_kitchen)

#输出结果:在上午10点，打扫厨房
收费200元

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

def operation(operator:str):
  if operator == '+':
    def sum1(*nums):
      sum2 = 0
      for item in nums[:]:
        sum2 += item
    print(sum1)
    return sum1#将求和的函数返回
  
operation('+')(1,2,3,4,5)#相当于sum1这个函数,然后调用函数
#输出结果是15

二.生成器和生成式

可以把迭代器看成一种容器,类似列表.生成器就是来生成迭代器
1.生成式(表达式,一个语句)
生成式就是产生一个迭代器的表达式

a=(x for x in range(10))#a是生成器,能够生成0-9中所有的数字.a里面的式子是生成式,结果是生成器
#通过将生成式产生的迭代器转换成了一个列表,迭代器可以看成生成器

注意:列表存数据时,要给每个数据都开辟空间,并且可以重复取数据,生成器存的是数据的产生方式,是一种算法,永远只存一个数据,取数据一个一个取,不能返回

a1 = (char for char in 'hel334lo12'if '0'<=char<='9')
#后面可以加判断条件
print(next(a1))
输出结果是:3

2.生成器和迭代器都是通过next来获取里面的数据

a=(x for x in range(10))
#第一种方式
print(next(a))
#输出结果是0
#第二种方式
for x in a:
  print(x)
#输出结果是1,2,3,4,5,6,7,8,9

3.将生成器转换成列表

list = [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的值.

dict1 = dict((value,key) for key,value in {'a':1,'b':2,'c':3}.items())

三.生成器

1.yield关键字

只要函数中有yield关键字,不管yield会不会执行到,这个函数都会变成一个生成器

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

def func2():
  print('abc')
  for x in range(10):
    yield x 
    print('aaa')

a = func2()

print(next(a))#第一次通过next获取
#结果是abc 0
print(next(a))#第二次通过next获取
#结果是aaa 1
print(next(a))#第三次通过next获取
#结果是aaa 2

print(func2(), type(func2()), type(func2))
#结果是<generator object func2 at 0x027FF690> <class 'generator'> <class 'function'>

def func3(x):
  print('abc')
  if x > 10:
    yield 100
gen2 = func3(1)
print(gen2)
#不管遇没遇到yield,都是生成器,遇到yield,生成器里面的内容不是空.没有遇到yield,生成器里的内容是空,调用next会报错

#结果是<generator object func3 at 0x027FF810>

yield执行多少次,就能产生多少数据,数据具体内看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

2.生成器和生成式产生的对象就是迭代器
例:将列表转换成迭代器(iter)对象

iter1 = iter([1,2,3,4])
print(iter1)
print(next(iter1))
print(next(iter1))
for item in iter1:
  print(item)
#输出结果是:<list_iterator object at 0x01D57390>
1#print(next(iter1))

2#print(next(iter1))

3#for语句
4

四.文件操作

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

做数据持久化、本地化，都要使用文件来保存数据
(数据库文件、txt文档、json文件、plist、xml文件等、二进制文件(图片、视频、音频等)).程序中通过变量、列表、字典等保存的数据，在程序结束后都会被销毁的。

1.打开文件
语法:open(文件地址file,打开方式,encoding=编码方式)
a.文件地址:告诉open函数,要打开的是哪个文件,填文件路径,可以填绝对路径,也可以填相对路径
绝对路径:C:/Users/Administrator/Desktop/a.txt(一般不用)
相对路径:相对于当前文件所在的目录

./相对路径(相对于当前文件所在的目录)
../相对路径(相对于当前文件所在的目录的上一层目录)

b.打开方式:获取文件的内容以读的形式打开,往文件里写内容以写的形式打开
'r'-->读(默认值),读出来的内容以文本(str)的形式返回
'rb'/'br'-->读,读出来的内容以二进制(bytes)的形式返回
'w'--->写,写文本到文件中
'wb'/'bw'-->写,写二进制数据到文件中
'a'-->写,追加

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

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

2.关闭文件
语法: 文件对象.close()

3.操作文件
a.读操作
1)语法: read()---从文件开头读到文件结尾

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

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

f.close()

读完后指针指到最后,下一次开始读是从最后开始读
2)语法:readline()----一行一行读文件

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

练习:读文件的内容,一行一行的读,读完为止

f = open('./test1.text','r',encoding='utf-8')
content = f.readline()
while content:#有内容就是True
  print(content)
  content = f.readline()#读下一行
f.close()

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

4.文件不存在的情况

当以读的形式打开文件的时候，如果文件不存在，程序会崩溃，报：FileNotFoundError
当以写的形式打开一个不存在的文件的时候，会自动创建一个新的文件
练习:统计一个模块执行的次数

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