1. recode

1. 匿名函數(shù)

格式：
lambda 參數(shù)列表: 返回值 常用情況：函數(shù)名 = lambda 參數(shù)列表: 返回值

匿名函數(shù)也是函數(shù)

2. 變量的作用域

全局變量：沒(méi)有聲明在函數(shù)或者類中的變量都是全局變量
作用域從聲明開(kāi)始到py文件結(jié)束

局部變量：聲明在函數(shù)和類中的變量
作用域從聲明開(kāi)始到函數(shù)或類結(jié)束

關(guān)鍵字:
global: 在函數(shù)中聲明一個(gè)全局變量/或者想要在函數(shù)中修改全局變量的值
nonlocal: 想要在局部的局部去修改一個(gè)局部變量的值拳喻，我們就使用nonlacal

3. 函數(shù)作為變量

聲明函數(shù)就是在聲明一個(gè)類型是function的變量。普通變量能做的事情，函數(shù)都能做

函數(shù)名 ---> 一個(gè)函數(shù)
函數(shù)名() ---> 調(diào)用函數(shù)闷祥，拿到的是函數(shù)的返回值

函數(shù)作為參數(shù) ---> 閉包的概念(以后會(huì)講)
函數(shù)作為返回值 ---> 裝飾器(以后會(huì)講)

4. 函數(shù)的調(diào)用過(guò)程

函數(shù)的調(diào)用過(guò)程是一個(gè)壓棧的過(guò)程(適用于所有語(yǔ)言)
調(diào)用函數(shù)時(shí)亚再，系統(tǒng)會(huì)自動(dòng)在棧區(qū)間開(kāi)辟空間存儲(chǔ)數(shù)據(jù)(函數(shù)的參數(shù)艰猬，函數(shù)中聲明的變量)社牲， 調(diào)用結(jié)束后內(nèi)存和數(shù)據(jù)會(huì)自動(dòng)銷毀

a = 10
b = 20


def func_a (a, b):
    a, b = b, a
    print(a, b)


func_a(a, b)
print(a, b)

5. 遞歸函數(shù) ---> 自己調(diào)用自己

循環(huán)能做的遞歸都能做肝谭，但是能用循環(huán)的就不要用遞歸(短時(shí)間內(nèi)會(huì)進(jìn)行內(nèi)存的大量開(kāi)辟和釋放， 會(huì)消耗cpu)

步驟：
第一: 找臨界值(找出循環(huán)結(jié)束的條件穴肘，這兒要讓函數(shù)結(jié)束)
第二: 找當(dāng)次循環(huán)( f(n) )和上次循環(huán)( f(n-1) )的關(guān)系
第三: 用f(n-1)去實(shí)現(xiàn)f(n)的功能

2. 模塊的使用

1. 什么是模塊

python中一個(gè)py文件就是一個(gè)模塊,可以通過(guò)import 模塊或者from-import在一個(gè)模塊中去使用另一個(gè)模塊

2. 導(dǎo)入模塊

import 模塊名 ---> 導(dǎo)入模塊中所有內(nèi)容,并且在當(dāng)前模塊中通過(guò)"模塊名."的方式去使用模塊中的所有全局變量
from 模塊名 import 變量1, 變量2…… ---> 將模塊中的所有內(nèi)容都導(dǎo)入抱冷，但是只能使用import后導(dǎo)入的變量
from 模塊名 import* ---> 將模塊中所有內(nèi)容導(dǎo)入，可以直接使用模塊中的全局變量

代碼執(zhí)行到import的時(shí)候梢褐，會(huì)講import模塊中的代碼內(nèi)容執(zhí)行一遍

# import ey_module
#
# # 使用test1 中的整型變量
# print(ey_module.ey_test + 100)



# # 使用eryang_module中的函數(shù)eryang_func
# ey_module.ey_func()
# print("當(dāng)前模塊", ey_test)
# print(ey_func())

# # 使用*
# from ey_module import *
# print("當(dāng)前模塊", ey_test)
# print(ey_func())

3. 重命名

import 模塊 as 模塊新的名字 
from 模塊 import 變量名1 as 新的名字, 變量名2 as 新的名字 ……
"""
er_tese = "name"
# import ey_module as aa
# print(aa.ey_test)

# from ey_module import ey_test as a
# print(er_tese)      # 使用當(dāng)前模塊的 ey_test
# print(a)        # 使用ey_module中的 ey_test

import: 可以檢查被導(dǎo)入的內(nèi)容之前是否已經(jīng)導(dǎo)入過(guò)，如果導(dǎo)入過(guò)赵讯，不會(huì)再重復(fù)導(dǎo)入
導(dǎo)入多次盈咳，但是只執(zhí)行一次。多種導(dǎo)入只執(zhí)行一次

3. 選擇性導(dǎo)入

1. 阻止導(dǎo)入的方法

if __name__ == "__main__":
    代碼塊 

說(shuō)明：
if name =="main": ---> 固定寫法
代碼塊 ---> 在當(dāng)前模塊直接執(zhí)行边翼，代碼塊會(huì)被執(zhí)行鱼响，如果被別的模塊導(dǎo)入，這個(gè)代碼塊不會(huì)執(zhí)行

2. 每一個(gè)模塊都有一個(gè)name屬性组底，這個(gè)屬性的默認(rèn)值是當(dāng)前模塊對(duì)應(yīng)的py文件的文件名

當(dāng)當(dāng)前模塊正在被直接執(zhí)行的時(shí)候丈积，系統(tǒng)會(huì)自動(dòng)將模塊的name屬性變成main

3. 什么時(shí)候使用模塊

將具有相似或相同的功能的函數(shù)和數(shù)據(jù)封裝到一起

函數(shù)時(shí)將多個(gè)代碼塊封裝
模塊是將多個(gè)函數(shù)數(shù)據(jù)封裝到一起

4. 迭代器

1. 什么是迭代器(iter)

迭代器是python中的一種容器類的數(shù)據(jù)類型，屬于序列债鸡，沒(méi)有具體的字面量,可以將其他的序列轉(zhuǎn)換為迭代器

iter(序列)

2. 迭代器的特點(diǎn)

只能通過(guò)next()或者 迭代器.next() 方法去一個(gè)一個(gè)按順序的獲取迭代器中的元素江滨，而且一旦元素被取出,迭代器中就不存在這個(gè)元素

iter1 = iter("abcd")
print(iter1)
print(next(iter1))
print(next(iter1))
print(next(iter1))
print(next(iter1))
# print(next(iter1))        報(bào)錯(cuò)：StopIteration

3. 遍歷迭代器：

iter2 = iter("abcde")

print("=====")
for x in iter2:
    print(x)
print("+++++")
# print(next(iter2))   # 取不到元素 因?yàn)樯厦嬉呀?jīng)取完


iter3 = iter("abcd")
print(iter3.__next__())
print(next(iter3))

生成器和生成式

1. 什么是生成器

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

生成式就是生成器的一種特俗形式: (變量 for 變量 in 序列)
特點(diǎn)：
需要數(shù)據(jù)的時(shí)候根據(jù)算法去一次生成一個(gè)數(shù)據(jù)

# 產(chǎn)生一個(gè)生成器厌均，生成器中可以生成的數(shù)據(jù)是數(shù)字0~4 (每個(gè)元素是數(shù)字)
generator1 = (x for x in range(5))
print(generator1)

print(next(generator1))
print(next(generator1))
print("===========")
for item in generator1:
    print(item)


print("++++++++++++")
generator2 = (x*2 for x in range(5))
for item2 in generator2:
    print(item2)


generator3 = ([y, y*2] for y in "abc")
print(next(generator3))


print("========")
generator4 = (x for x in range(5) if x%2)
for item4 in generator4:
    print(item4)

2. 生成器就是函數(shù)體中有yield關(guān)鍵字的函數(shù) ---> 函數(shù)中只要有yield,那么調(diào)用函數(shù)不再是執(zhí)行函數(shù)體

獲取返回值唬滑，而是產(chǎn)生一個(gè)生成器

通過(guò)next獲取生成器的元素的時(shí)候，會(huì)去執(zhí)行生成器對(duì)應(yīng)的函數(shù)的函數(shù)體，執(zhí)行到y(tǒng)ield位置晶密，并且將yield
后面的值產(chǎn)生(生成)擒悬，然后保存當(dāng)前結(jié)束的位置。下一次獲取生成器元素的時(shí)候會(huì)接著上次結(jié)束的位置往后執(zhí)行

生成器可以當(dāng)做序列來(lái)使用

print("**********************")


def function1(n):
    print("你好生成器")
    for x in range(n+1):
        print(x)
        yield x     # 生成x的值稻艰，調(diào)用next函數(shù)的時(shí)候取出來(lái)


g4 = function1(10)
print(g4)
print("=:", next(g4))       # 你好生成器  0  =: 0
print("=:", next(g4), type(g4))       # 1  =: 1

文件的讀和寫

文件用來(lái)干嘛懂牧？
使用本地文件可以做數(shù)據(jù)的持久化(本地化) ---> 常用二進(jìn)制文件 數(shù)據(jù)庫(kù)文件 txt文件 json文件 plist文件

1. 文件操作 --> 讀寫操作(二進(jìn)制不能設(shè)置編碼方式，編碼方式是對(duì)應(yīng)文本來(lái)講的)

讀 ---> 取出文件中的數(shù)據(jù)
寫 ---> 將數(shù)據(jù)寫到文件中

所有文件操作基本過(guò)程: 先要打開(kāi)文件 --> 操作文件 --> 關(guān)閉文件

2. 打開(kāi)文件和關(guān)閉文件

• 打開(kāi)文件: open(file, mode="r", encoding=None)

a. file: 文件路徑(必須傳參),決定需要打開(kāi)的是哪個(gè)文件
絕對(duì)路徑(不推薦): 完整文件路徑
相對(duì)路徑:

./相對(duì)路徑 (相對(duì)路徑是相對(duì)當(dāng)前py文件對(duì)應(yīng)的文件夾)
../ ---> 當(dāng)前文件夾上層文件夾
.../ ---> 當(dāng)前文件夾上層文件夾的上層文件夾

b. mode: 決定文件打開(kāi)方式(決定打開(kāi)文件后是讀還是寫還是改……,不同操作對(duì)應(yīng)不同打開(kāi)方式)
"r" --> read 以只讀的形式打開(kāi)尊勿，讀文本文件
"rb" / "br" --> 讀操作僧凤，讀出來(lái)的數(shù)據(jù)是二進(jìn)制形式的數(shù)據(jù)
"w" --> write 以寫的方式打開(kāi)文件
"wb" / "bw" --> 寫操作，將二進(jìn)制數(shù)據(jù)寫入文件
"a" --> 寫操作运怖，追加

c. encoding: 文本文件的編碼方式
utf-8: 幾乎支持所有的語(yǔ)言文字
gbk: 只支持英文

d. open()函數(shù)的返回值拼弃，就是被打開(kāi)的文件對(duì)象

• 關(guān)閉文件: 文件對(duì)象.close()

# # 在此文件絕對(duì)路徑打開(kāi)test.txt文件
# a = open(r"D:\Study\phase 1\Day11_文件操作\test.txt")

# # 在此文件相對(duì)路徑打開(kāi)test.txt, 文件操作.txt, 文件操作2.py文件
# b = open("./test.txt")
# c = open("./files/文件操作.txt")
# d = open("./files/files2/文件操作2.py")
#
# # 在文件操作2中，相對(duì)路徑打開(kāi)test.txt, 文件操作.txt
# e = open("../文件操作.txt")
# f = open(".../test.txt")

讀文件

# 1. 打開(kāi)文件
f1 = open("./test.txt", mode="r", encoding="utf-8")

# 2. 讀文件中的內(nèi)容(每次讀是按照上次讀到的位置往下面讀)
"""
文件對(duì)象.read() ---> 從文件開(kāi)始讀到文件結(jié)束摇展，返回讀到的結(jié)果
文件對(duì)象.readline() ---> 讀一行
文件對(duì)象.readlines() ---> 一行一行讀完吻氧，每一行作為列表元素，返回列表
"""
content2 = f1.read()
print("=: ", content2)
# content = f1.readline()
# print(type(content), content, sep="\n")


# 關(guān)閉文件
f1.close()

寫文件一般先把原來(lái)的內(nèi)容讀出來(lái)咏连，然后再寫文件的時(shí)候用原來(lái)的內(nèi)容加上添加的內(nèi)容
一般不用"a"去寫文件盯孙，因?yàn)橐话汩_(kāi)發(fā)文件為json文件，使用"a"可能會(huì)導(dǎo)致文件被破壞
"w" ---> 將字符串寫入文件中祟滴，完全覆蓋文件原來(lái)的內(nèi)容
"wb" / "bw" ---> 將二進(jìn)制寫入文件中振惰，完全覆蓋文件原來(lái)的內(nèi)容
"a" ---> 在文件的最后面去寫內(nèi)容

# 1. 打開(kāi)文件
f2 = open("./test.txt", mode="w", encoding="utf-8")

# 2. 寫入文件
f2.write(content2 + "我是被寫入的hello python\n")
# f2.writelines(["hahah, ", "我也被寫進(jìn)來(lái)了\n"])

# 3. 關(guān)閉文件
f2.close()