复习：

1.匿名函数

函数名 = lambda 参数列表:返回值
参数列表: 变量名1，变量名2
函数体是一条语句，并这条语句是有结果的
匿名函数也是函数

func1 = lambda a,b: max([a, b])
print(func1(1, 2))


def func1(a, b):

    return max([a, b])

2.变量的作用域

全局变量:	没有声明在函数或者类中的变量。从声明开始到文件结束，任何位置都能用
局部变量:	声明在函数或者类中的变量。从声明开始到函数、类结束
global :	在函数中声明一个全局变量/想要在函数中修改一个全局变量的值
nonlocal :	想要在局部的局部去修改一个局部变量的值

a = 10
def func1():
    global a
    a = 20
    print(a)

    print(a)

func1()
print(a)

3.函数作为变量

声明函数就是在声明一个类型是function的变量。普通变量能做的事情，函数变量都可以做。

函数名 --->	一个函数
函数名() --->	调用函数，拿到的是函数的返回值
函数作为参数 -->	闭包
函数作为返回 -->	装饰器

4.调用过程

函数的调用过程是一个压栈的过程

调用函数的时候系统会自动在栈区间开辟空间存储数据(函数的参数，函数中声明的变量),调用结束后会自动销毁

int a = 10, b = 20;
void func1(int a, int b){
    int t = a;
    a = b
    b = t
}
func1(a, b)
printf(a, b)

a = 10
b = 20

def func1(a, b):
    a, b = b, a

func1(a, b)

print(a, b)

5.递归函数

自己调用自己的函数

循环能做的递归都可以做，但是能用循环的就不要用递归

三个步骤:
a.找临界值，在这儿要让函数结束
b.找出f(n)和f(n-1)的关系
c.使用f(n-1)去实现f(n)的功能

2.模块的使用：

1.导入模块

python中一个py文件就是一个模块。

可以通过import或者from-import在一个模块中去使用另一个模块的内容

import 模块名 ---> 将模块中所有的内容都导入,并且可以在当前模块中通过'模块名.'的方式去使用模块中的所有全局变量

from 模块名 import 变量1, 变量2，.... ---> 将模块中所有的内容都导入。但是只能使用import后面的变量

from 模块名 import * --->将模块中所有的内容都导入， 可以直接使用模块中的所有全局变量

代码执行到import的时候，会将import后面的模块的内容执行一遍

 import test1

 使用test1中的整型变量test_a
 print(test1.test_a + 100)

 使用test1中的函数test1_func1
test1.test1_func1()

 from test1 import test_a, test1_func1
 from test1 import *
 print('当前模块:', test_a)
 print(test1_func1())

 print(name)

name = '张三'

2.重命名：

import 模块名 as 模块的新名字 --> 给模块重命名，使用模块的时候用新的名字来使用

from 模块名 import 变量名1 as 新名1, 变量名2 --> 给部分变量重新命名

import test1 as TS
print(TS.name)

from test1 import name as test1_name, test1_func1 as other_func, test_a
 print(name)  /使用当前模块的name变量
 print(test1_name)  / 使用test1中的name
 other_func()
 print(test_a)

3.import：可以检查被导入的内容之前是否已经导入过，如果导入过，不会再重复导入

导入多次，但是只执行一次。多种导入的效果可以同时生效

import test1
/ import test1
from test1 import test_a as AA
print(test1.test_a, AA)

3.选择性导入;

1.阻止导入的方法：

if __name__ == '__main__':
    代码块 

说明:
if name == 'main': ---> 固定写法
代码块 ---> 直接执行当前模块，代码块会被执行.
如果在别的模块中被导入，代码块不会执行

2.每一个模块都有一个name属性， 这个属性的默认值是当前模块对应py文件的文件名。

!!!当当前模块正被执行(直接)的时候，系统会自动将模块的name属性变成'main'

import test1

3.什么时候使用模块

将具有相同的功能的函数和数据封装到一起

import random
import math

 import random
 (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))

import color

(255, 255, 255)
color.white
color.white
color.red
color.randow_color()

4.迭代器：

1.什么是迭代器（iter）：

迭代器是python中一种容器类的数据类型。属于序列。没有具体的字面量,可以将其他的序列转换成迭代器：iter(序列)

2.迭代器的特点：

只能通过next方法去一个一个按顺序获取迭代器中的元素，取出后迭代器中就不存在这个元素了

iter1 = iter('abcd')
print(iter1)

print(next(iter1))
print(next(iter1))

for x in range(5):
    print(x)

print(next(iter1))
print(next(iter1))
print(next(iter1))  /StopIteration

3.遍历迭代器

iter1 = iter(['abc', 10, 'name'])
print('=====')
for x in iter1:
    print(x)

print('====')

print(next(iter1))

方法：
next(迭代器)
迭代器.next()

iter2 = iter((1, 2, 3))
a = iter2.__next__()
print(a)  / 1

list1 = list(iter2)
print(list1)  / [2, 3]

5.生成式和生成器：

1.什么是生成器

生成器就是迭代器，但是迭代器不一定是生成器

生成式就是生成器的一种特殊形式：(变量 for 变量 in 序列)

• 产生一个生成器，生成器中可以生成的数据是数字0~4（每个元素是数字）

ge1 = (x for x in range(5))
print(ge1)

print(next(ge1))
print(next(ge1))

print('=========')
for item in ge1:
    print(item)

ge2 = (x*2 for x in range(5))
print('=========')
for item in ge2:
    print(item)

ge2 = ([x, x*2] for x in 'abc')
print(next(ge2))

print('===========')
ge2 = (x for x in range(5) if x%2)

for item in ge2:
    print(item)

2. 生成器就是函数体中有yield关键字的函数

(函数中只要有yield，那么调用这个函数不再是执行函数体并且获取返回值，而是产生一个生成器)

通过next获取生成器的元素的时候，会去执行生成器对应的函数的函数体，执行到yield为止，并且将yield后面的值作为返回值(元素值)。
然后保存当前结束的位置，下次一获取生成器的元素的时候会接着上次结束位置往后执行，执行到yield.....

生成器可以当成序列来使用

print('============')
def func1(n):
    print('你好，生成器!!')
    for x in range(n+1):
        print(x)
        yield x
        print('yeye')

ge3 = func1(3)
print(ge3)

print('=:',next(ge3))  #    0
print('=:',next(ge3))  # 1
print(next(ge3))  #  2
print(next(ge3))  # 3
 print(next(ge3))

def func2():
    str1 = 'abcdef'
    index = 0
    while index < len(str1):
        yield str1[index]
        index += 1
ge4 = func2()
print(next(ge4))
print(next(ge4))
print(list(ge4))

def func3():
    num = 0
    while True:
        yield num
        num += 1

ge5 = func3()
print(ge5)
print('==:',next(ge5))
print('==:',next(ge5))

print('========')
for _ in range(5, 100):
    print(next(ge5))

print('=======')
print(next(ge5))

• 生成器生成的数据的规律：奇数就返回他本身，偶数就返回它的2倍

def func2(n):
    for x in range(n):
        yield x, 2*x, 3*x
         yield 2*x
         yield 3*x
         if x%2:
             yield x
         else:
            yield x*2

g6 = func2(5)
print(next(g6))
print(next(g6))
print(next(g6))

6.文件的读和写：

使用文件可以做数据的持久化(本地化) ---> 数据库文件

txt、	json，	plist，	二进制文件

1.文件操作 -- 读写操作
读 -> 取出文件中的数据
写 -> 将数据写到文件中

所有文件操作的过程：1.打开文件 -->2. 操作文件 --> 3.关闭文件

2.打开文件和关闭文件：

open(file, mode='r',encoding=None)

1.file -> 文件路径(必须传参)，决定需要打开的是哪个文件
绝对路径（不推荐使用）

相对路径: ./	相对路径 (相对路径是相对当前py文件对应的文件夹)
./	---> 当前文件夹
../	--> 当前文件夹的上层文件夹
.../	--> 当前文件夹的上层文件夹的上层文件夹

2.文件打开：
mode	-> 文件打开方式（不同的操作对应不同的打开方式）
'r'	--> 以只读的形式打开文件, 文本
'rb'/'br'	--> 读操作，读出来的数据是二进制形式的数据
'w'	--> 以写的形式打开文件
'bw'/'wb'	--> 写操作，将二进制数据写入文件
'a'	--> 写操作，追加

3.encoding	文本文件的编码方式
utf-8 :	几乎支持所有的语言文字
gbk :	只支持英文

4.open函数的返回值，就被打开的文件对象

关闭文件:	文件对象.close()

========================文件的读操作=====================

1.打开文件

f1 = open('./test1.txt', 'r', encoding='utf-8')

2.读文件中的内容

文件对象.read()	--> 从文的读写位置读到文件结束,返回读到的结果
文件对象.readline()	--> 读一行
文件对象.readlines()	--> 返回一个列表，列表的元素是文件中每一行的内容

content = f1.read()
print(type(content), content)

 print('==:', f1.read())

 content = f1.readlines()
 print(content)

3.关闭文件

f1.close()

---

---

---

==================文件的写操作==================

1.打开文件

'w'	-> 将字符串写入文件中， 完全覆盖文件原来的内容
'wb'/'bw'	-> 将二进制写入文件中, 完全覆盖文件原来的内容
'a'	-> 追加

f2 = open('./test1.txt', 'w', encoding='utf-8')

2.写入文件

f2.write(content+'hello world')
f2.writelines(['abc\n', '123\n', 'aaaaa\n'])