1.函數(shù)調(diào)用過程:

函數(shù)調(diào)用過程又叫壓棧的過程：
每次調(diào)用函數(shù)，系統(tǒng)都會在內(nèi)存的棧區(qū)間自動開辟一個臨時的內(nèi)存空間，
用來保存在函數(shù)中聲明的局部變量(其中形參是也保存在這個區(qū)域中的)，
當函數(shù)調(diào)用結(jié)束，這個內(nèi)存區(qū)域會自動銷毀(這個內(nèi)存中存儲的數(shù)據(jù)也會銷毀)

2.迭代器(iter)

• 1. 什么是迭代器
     迭代器是python提供的容器型數(shù)據(jù)類型。 （可變，有序的）-- 不關(guān)注
     迭代器和之前的列表、字典、集合、元祖等容器不一樣，它只能查看元素，而且看一個對于迭代器來說，里面的元素就會少一個
     迭代器的值：a.將其他的數(shù)據(jù)轉(zhuǎn)換成迭代器 b.生成器
     迭代器的元素: 任何類型的數(shù)據(jù)都可以，可以重復

iter1 = iter('abc')
print(iter1)

iter2 = iter([12, 34, 'abc', [1, 2], {'a': 10}, (1, 2), {1, 3}, lambda x: x])
print(iter2)

• 2. 查 - 獲取元素的值
     注意: 不管以任何形式獲取了迭代器中某個元素的值，這個元素都會從迭代器中消失

 # a.獲取單個元素
 next(迭代器)/ 迭代器.__next__()    -  返回容器中最上面的元素

print(next(iter1))
print(next(iter1))
print(next(iter1))
print(next(iter1))     #  StopIteration

 # b.遍歷取出迭代器中的每個元素

print('=============')
iter3 = iter('abcdef')
next(iter3)
next(iter3)
for item in iter3:
    print(item)
print('=============')
print(next(iter3))   # StopIteration

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

3.生成器

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

• 1）怎么創(chuàng)建生成器
  如果函數(shù)中有yield關(guān)鍵字，那么這個函數(shù)就不再是一個普通的函數(shù)。
  調(diào)用函數(shù)不再是執(zhí)行函數(shù)體，獲取返回值。而是創(chuàng)建這個函數(shù)對應的生成器對象

def nums():
    print('============')
    print(100)
    if False:
        yield
    return 100
gen1 = nums()      # 函數(shù)調(diào)用表達式nums()才是生成器

• 2）生成器怎么產(chǎn)生數(shù)據(jù)
  一個生成器能夠產(chǎn)生多少個數(shù)據(jù)，就看執(zhí)行完生成器對應的函數(shù)體會遇到幾次yield關(guān)鍵字
  生成器是在獲取數(shù)據(jù)的時候才會產(chǎn)生數(shù)據(jù)，執(zhí)行生成器對應的函數(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('取第一個值')
print(next(gen2))
print('取第二個值')
print(next(gen2))
print('取第三個值')
print(next(gen2))
def nums2():
    index = 0
    while True:
        yield index
        index += 2
gen3 = nums2()
for _ in range(10):
    print(next(gen3))
print(next(gen3))
print(next(gen3))

練習: 寫一個生產(chǎn)器，能夠產(chǎn)生'stuXXXX'的學號， stu0000 ~ stu9999

def stu_num_creater(count, width=0):
    for num in range(count):
        if width == 0:
            width = len(str(count))
        num_str = 'stu' + str(num).zfill(width)
        yield num_str


creater = stu_num_creater(100, 4)
print(next(creater))
for num in creater:
    print(num)

4.生成式

• 生成式是生成器的另外一種寫法（簡寫）

• a.語法1：
  生成器變量 = (表達式 for 變量 in 序列) -- 結(jié)果是生成器
  列表變量 = [表達式 for 變量 in 序列] -- 結(jié)果是列表

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

• c.展開
  def 函數(shù)名():
  for 變量 in 序列:
  yield 表達式

gen1 = (x*2 for x in range(5))
print(gen1)
for num in gen1:
    print(num)

• a.語法2：
  生成器變量 = (表達式 for 變量 in 序列 if 條件語句)

• b.展開
  def 函數(shù)名():
  for 變量 in 序列:
  if 條件語句:
  yield 表達式

gen2 = (x for x in range(10) if x % 2)
# 5個  1，3，5，7，9
for num in gen2:
    print(num)
gen2 = ((x, x*2) for x in range(10) if x % 2)
for num in gen2:
    print(num)
gen2 = ((x, x*2) for x in range(10) if x % 2)
list2 = list(gen2)
print(list2)
# next(gen2)
gen2 = ['num%d' % x for x in range(10) if x % 2]
print(gen2)

5.模塊

python中一個py文件就是一個模塊
從封裝的角度看：
函數(shù)是對功能的封裝

模塊可以通過多個函數(shù)對不同的功能進行封裝，還可以通過全局變量對數(shù)據(jù)進行封裝

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

• 1.模塊的導入
  a.import 模塊名 / import 模塊名 as 新的模塊名 --- 可以通過'模塊名.'的方式去使用這個模塊中所有的全局變量
  b.from 模塊名 import 全局變量1 as 新名1,全局變量2 as 新名2,... --- 帶入指定模塊中指定的全局變量，導入后直接使用全局變量

• 注意: 重命名后，原名不能使用

# ===========導入方式1===========
# import keyword
# import random
# import math
# import test
#
# print(test.test1_a * 3)
# test.test1_a = 200
# print(test.test1_a)
#
# test.test1_func1()

# ============導入方式2==========
# from random import randint
# print(randint(10, 30))
#
# from test import test1_func1, test1_a
# test1_func1()
#
# print(test1_a)

# ============導入模塊并重命名==========
# import test as TS
# print(TS.test1_a)
# TS.test1_func1()

# b = 'python'
# from test import b as t_b, test1_a as t_a
#
# print(b, t_b, t_a)

• 3.導入模塊的原理：當代碼執(zhí)行到import或者from - import的時候，會自動將對應的模塊中的代碼全部執(zhí)行一遍
  同一個模塊導入多次不會執(zhí)行多次(放心的導入!)

# print('++++++++++++++')
# import test
# import test
# from test import test1_a
# import test2
#
# print(test1_a, test.test1_func1())
# print('++++++++++++++')
print('mudule:', __name__)
from test2 import yt_sum
print(yt_sum(1, 1))

import PIL
import requests

• 4.阻止導入： 將需要阻止被別的模塊導入的代碼放到以下if語句中
  if name == 'main':
  需要阻止導入的代碼段

• 原理: 每個模塊都有一個屬于自己的name屬性，用來保存當前模塊的模塊名。默認情況下name的值就模塊對應的py文件
  的文件名。當我們直接運行某個模塊的時候，對應的模塊的name會自動變成'main',其他模塊是默認值。

6.異常 ：

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

• 1.異常捕獲：程序出現(xiàn)異常的時候，程序不崩潰
  1）方式一： 捕獲所有類型的異常
  a.語法
  try:
  代碼段1
  except:
  代碼段2
  finally:
  代碼段N

其他語句

b.說明：先執(zhí)行代碼段1，如果代碼段1不出現(xiàn)異常，直接執(zhí)行后面的其他語句；
如果出現(xiàn)異常不崩潰直接執(zhí)行代碼段2，然后再接著其他語句

list1 = [1, 2, 3]

try:
    print(list1[10])
    print({'a': 10}['b'])
    print('~~~~')
except:
    print('出現(xiàn)異常')

print('======================')

2 ) 方式2：捕獲指定的一個或者多個異常，做相同的處理
try:
代碼段1
except 異常類型:
代碼段2
finally:
代碼段N

其他語句

try:
代碼段1
except (異常類型1,異常類型2,...):
代碼段2
finally:
代碼段N

其他語句

先執(zhí)行代碼段1，如果代碼1沒有出現(xiàn)異常，直接執(zhí)行后面的其他語句；
如果代碼段1出現(xiàn)異常，如果這個異常的類型和需要捕獲的異常類型一致，程序不崩潰，直接執(zhí)行代碼段2，然后再執(zhí)行其他語句；
如果代碼段出現(xiàn)異常，異常類型和需要捕獲的異常類型不一致，程序直接崩潰

注意：異常類型要求必須是直接或者間接繼承Exception類的子類
SyntaxError 不能捕獲

print('==============方式二===============')
try:
    # print({'a': 10}['n'])
    # print([1, 2, 3][10])
    print('======')
    print(int('abc'))
except (KeyError, IndexError):
    print('出現(xiàn)異常!')
finally:
    print('寫遺書！')

3)方式3：捕獲不同類型的異常，并且可以對不同的異常做不同的處理
try:
代碼段1
except 異常類型1:
代碼段2
except 異常類型2:
代碼段3
finally:
代碼段N

print('==============方式3===============')
try:
    print({'a': 10}['b'])
    print([1, 2, 3][10])
except IndexError:
    print('下標越界')
except KeyError:
    print('key不存在')

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