recode

1.匿名函數(shù)

lambda 參數(shù)列表:返回值

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

聲明函數(shù)就是聲明類型是function的變量,函數(shù)名就是變量名
函數(shù)作為參數(shù),函數(shù)作為返回值

sort\max\min

3.作用域

全局變量,局部變量,global,nonlocal
"""
global 變量名
變量名 = 值
"""
# 迭代器
## 1.函數(shù)調(diào)用過程:
```python
# 函數(shù)調(diào)用過程又叫壓棧的過程:每次調(diào)用函數(shù),系統(tǒng)都會在內(nèi)存的棧區(qū)間自動開辟一個臨時的內(nèi)存空間
#                            用來保存在函數(shù)中聲明的局部變量(其中形參是也保存在這個區(qū)域中的),
#                            當(dāng)函數(shù)調(diào)用結(jié)束,這個內(nèi)存區(qū)域會自動銷毀(這個內(nèi)存中存儲的數(shù)據(jù)也會銷毀)

2.迭代器(iter)

# 迭代器是python提供的容器型數(shù)據(jù)類型,        ((可變,有序的) --  不關(guān)注)
# 迭代器和之前的列表,字典,集合,元祖等容器不一樣,他只能查看元素,而且看一個元素對于迭代器來說,里面的元素就會少有一個.
# 迭代器的值:a.將其他的數(shù)據(jù)轉(zhuǎn)換成迭代器  b.生成器
# 迭代器的元素:可以是任何類型的數(shù)據(jù)
iter1 = iter('0123')
iter2 = iter([[1, 2], 123, 'asd', [1, 2, 3], [1, 2], lambda x: x])
print(iter2)
# 2) 查 - 或許元素的值
# 注意:不管以任何形式獲取了迭代器中某個元素的值,這個元素都會從迭代器中消失
# a.獲取單獨元素
# next(迭代器)  -  返回容器中最上面的元素
# iter1.__next__()   -  效果同上
print(next(iter1))
print(next(iter1))
print(next(iter1))

# b.遍歷取出迭代器中的每個元素
print('===================')
iter3 = iter('45432dasasd')
for item in iter3:
    print(item)

3)什么時候使用迭代器:多個數(shù)據(jù)中,某個或者某些數(shù)據(jù)使用過了就不需要在保存了,這種數(shù)據(jù)就可以使用迭代器來保存.

生成器

1.什么是生成器

# 生產(chǎn)器就是迭代器,但是迭代器不一定是生成器
# 1)怎么創(chuàng)建生成器
# 如果函數(shù)中有yield關(guān)鍵字,那么這個函數(shù)就不在是一個普通的函數(shù).
# 調(diào)用函數(shù)不在是執(zhí)行函數(shù)體,獲取返回值.而是創(chuàng)建這個函數(shù)對應(yīng)的生成器對象

def nums():
    print(100)
    if False:
        yield
    return 100


gen1 = nums()  #函數(shù)表達(dá)式nums()才是生成器

2)生成器怎么產(chǎn)生數(shù)據(jù)

# 一個生成器能產(chǎn)生多少個數(shù)據(jù),就看執(zhí)行玩生成器對應(yīng)的函數(shù)體會遇到幾次yield關(guān)鍵字
# 生成器是在獲取數(shù)據(jù)的時候才會產(chǎn)生數(shù)據(jù),執(zhí)行生成器對應(yīng)的函數(shù)的函數(shù)體,知道遇到y(tǒng)ield為止,
# 將yield后面的數(shù)據(jù)作為生成器的元素返回,并且會記錄這次產(chǎn)生數(shù)據(jù)函數(shù)體結(jié)束的位置,下次再產(chǎn)生
# 數(shù)據(jù)的時候,會接著上次結(jié)束的位置接著往后執(zhí)行...如果從執(zhí)行開始到函數(shù)結(jié)束,沒有遇到y(tǒng)ield,那么久不會產(chǎn)生數(shù)據(jù).

def nums():
    print('++++++++++')
    yield 'abc'
    print('----------')
    yield '100'
    print('==========')
    for x in range(5):
        yield x

# 創(chuàng)建一個生成器gen2


gen2 = nums()
print(next(gen2))
print(next(gen2))
print(next(gen2))


# 練習(xí):寫一個生成器,產(chǎn)生學(xué)號,'stuXXXX'的學(xué)號

def student_number():
    index = 0
    while index < 10000:
        index += 1
        i = 'stu'+str(index).zfill(4)
        yield i
        int(index)


print('==========================')
i = 0
n = student_number()
for num1 in n:
    i += 1
    print(num1)
    if i ==10:
       break

生成式(簡寫的生成器)

1.生成式

# 生成式是生成器的另一種寫法(簡寫)
"""
a.語法1
表達(dá)式 for 變量 in 序列   -  沒有冒號哦

b. 說明: 表達(dá)式 - 可以是值,變量,運輸表達(dá)式,函數(shù)調(diào)用表達(dá)式等,只要不是賦值語句都可以

c.展開
def 函數(shù)名():
    for 變量 in 序列:
        yield 表達(dá)式
"""
gen1 = (x for x in range(5))
print(next(gen1))
print(next(gen1))
print(next(gen1))
print(next(gen1))
print(next(gen1))

"""
a. 語法2
生成器變量 = (表達(dá)式 for 變量 in 序列 if 條件語句)   -- 結(jié)果是生成器
列表變量 = [表達(dá)式 for 變量 in 序列 if 條件語句]     -- 結(jié)果是列表
b.展開
def 函數(shù)名():
    for 變量 序列:
        yield 表達(dá)式
"""
gen2 = (x for x in range(10) if x % 2)
# 1 3 5 7 9

模塊

什么是模塊

python中一個py文件就是一個模塊

從封裝角度看:
函數(shù)是對功能的封裝
模塊可以通過多個函數(shù)對不同的功能進(jìn)行封裝,還可以通過全局變量對數(shù)據(jù)進(jìn)行封裝

0.模塊的分類:系統(tǒng)模塊(內(nèi)置模塊),第三方庫(別人寫的),自定義模塊

# 1.模塊的導(dǎo)入
# 1)import  模塊名          ---        可以通過'模塊名.'的方式去使用這個模塊中所有的全局變量
# 2)form 模塊名 import 全局變量1,全局變量2,...---  導(dǎo)入指定模塊中指定的全局變量,導(dǎo)入后直接使用全局變量
# 3)重命名
# import 模塊名 as 新的模塊名  ---對導(dǎo)入的模塊名從命名   ---  對模塊重命名
# from 模塊名 import 全局變量1 as 新變量名1 , 全局變量2 as 新變量名...    ---   對全局變量重命名
# !!!注意模塊重命名吼,原名不能使用
# ============== 導(dǎo)入方式1=================
import test

print(test.test1_a)
print(test.test1_a * 3)
# ============== 導(dǎo)入方式2=================
from test import test1_a, test1_func1
print(test1_a + 100)
test1_func1()
# ============== 導(dǎo)入模塊并重命名=================
import test as TS
print(TS.test1_a)

3.導(dǎo)入模塊的原理: 當(dāng)代碼執(zhí)行到 import 或者 from - import 的時候,會自動將對應(yīng)的模塊中的代碼全部執(zhí)行一遍

           同一個模塊導(dǎo)入多次不會執(zhí)行多次

4.阻止導(dǎo)入:將需要阻止的被別的模塊導(dǎo)入的代碼放到以下if語句中

"""
if __name__ == '__main__':
    print('64654654546')
原理:每個模塊都有一個屬于自己的__name__s屬性,用來保存當(dāng)前模塊的模塊名.默認(rèn)情況下__name__的值就是模塊對應(yīng)的py文件
     的文件名.當(dāng)我們直接運行某個某塊的時候,對應(yīng)的模塊的__name__會自動變成 '__main__' ,其他模塊是默認(rèn)值

"""

異常捕獲

1.異常:程序錯誤,程序崩潰.程序中某條語句出現(xiàn)異常,那么從這條語句開始,后面的代碼不會執(zhí)行,程序直接結(jié)束

2.異常捕獲:程序出現(xiàn)異常的時候,程序不崩潰.

# 1)方式一: 捕獲所有類型的異常
"""
try:
    代碼段1
except:
    代碼段2

其他語句

b.說明:先執(zhí)行代碼段1,如果代碼段1不出現(xiàn)異常,直接后面的其他語句;
       如果出現(xiàn)異常,不崩潰,就直接執(zhí)行代碼段2,然后在接著執(zhí)行其他語句
"""
list1 = [1, 2, 3]
try:
    print(list1[10])
except:
    print('出現(xiàn)異常')

# 方式二:捕獲指定的異常然后做相同處理
"""
try:
    代碼段1
except 異常類型:
    代碼段2

其他語句


 
先執(zhí)行代碼段1,如果代碼段1沒有出現(xiàn)異常,直接執(zhí)行后面的其他語句
如果代碼段1出現(xiàn)異常,如果這個異常的類型和需要捕獲的異常類型一致,程序不崩潰,直接執(zhí)行代碼段2,然后在執(zhí)行其他語句
如果代碼段出現(xiàn)的異常,異常類型和需要捕獲的異常類型不一致,程序直接崩潰
!!!注意:異常類型要求必須是直接或者間接繼承Exception

"""

print('========方式二==========')
try:
    print([1, 2, 3][10])
except (KeyError, IndexError):
    print('出現(xiàn)異常')


# 方式3:捕獲不同類型的異常,并且可以對不同的異常做不同的處理
"""
try:
    代碼段1
except 異常類型1:
    代碼段2
except 異常類型2:
    代碼段3
......
"""
print('==============方式三================')
try:
    print([1, 2, 3][10])
    print({'a': 10}['b'])
except IndexError:
    print('下標(biāo)越界')
except KeyError:
    print('key不存在')

3.finally - finally后面的代碼段,不管try中的代碼發(fā)生了什么,都會執(zhí)行

"""
語法:
捕獲異常的代碼任意一種
finally:
    代碼段n
"""
print('=========finally==========')
try:
    print([1, 2, 3][10])
    print({'a': 10}['b'])
except IndexError:
    print('下標(biāo)越界')
except KeyError:
    print('key不存在')
finally:
    print('遺書')

i = True
while i:
    try:
        int(input('請輸入年齡'))
        i = False
    except:
        print('輸入錯請重新輸入')