函數回調

提前寫出函數的調用，再去考慮函數體的實現  
　　怎麽樣提前寫出函數的調用：在另一個函數中寫出函數的調用 
　　再去考慮函數體的實現：根據實際的需求

def my_sleep(sec):
    import time
    current_time = time.time()
    while time.time() - current_time < sec:
        pass


def download(fn=None):
    print(‘開始下載‘)
    my_sleep(1)
    data = ‘下載得到的信息‘
    print
 
(‘下載完成‘)
    if fn:  # 如果外界提供了回調函數的實現體，再去調用，否則就只完成默認下載的功能
        res = fn(data)  # 下載成功的回調函數，具體完成什麽事之後決定
        if res:
            print(‘操作成功‘)
            return True
        print(‘操作失敗‘)
        return False
    return data  # 沒有外界具體操作下載結果的功能代碼，就將下載結果直接返回

# res = download()
# print(res)
 


def download_action(data):
    print(‘往文件中寫‘)
    with open(‘1.txt‘, ‘w‘, encoding=‘utf-8‘) as f:
        f.write(data)
        return True
    return False

res = download(download_action)
print(res)

# 下載成功後的動作可以多樣化
def download_action1(data):
    print(data)
    return True
res 
 
= download(download_action1)
print(res)


# 補充：
# 自定義sleep
def my_sleep(sec):
    import time
    current_time = time.time()
    while time.time() - current_time < sec:
        pass
print(000)

模塊

模塊：一系列功能的集合體
定義模塊：創建一個py文件就是一個模塊，該py文件名就是模塊名 
使用模塊：在要使用該模塊功能的文件中導入模塊，通過import關鍵字導入模塊名

要求：

1.了解什麽是模塊 
2.為什麽要使用模塊 
3.import導入模塊：名稱空間 
4.起別名：原名與別名 
5.from導入方式 
6.*的知識點 
7.查詢順序 
8.自啟文件與模塊的區別
難點：循環導入

模塊的四種存在方式： ①
　　1.使用python編寫的.py文件（任何一個py文件都可以作為模塊） 
　　2.包:一堆py文件的集合體 
　　3.使用C編寫並鏈接到python解釋器的內置模塊 
　　4.已被編譯為共享庫或DLL的C或C++擴展

優點：②
1.從文件級別組織代碼，是同特性的功能能統一管理
2.可以使用系統或第三方模塊(拿來主義)，來提高開發效率

module.py文件內容：
# 每一個py文件都是一個模塊，py文件名module就是模塊名
a = 100
# print(a)


def b():
    print(a)  # 局部中沒有a，只能從全局或內置找
    # 註：如果自身文件的全局中有，就找自身的，否則就找內置，不會找導入它的文件全局中的名字


def c():
    global a
    a = 300
---------------------------module.py  內容結束-------------------------------

import module 
# 導入模塊，會編譯執行成一個pyc文件,該pyc文件就是該模塊的執行文件
# print(module)

# 再次導入，module該模塊不會被執行了
import module
import module
import module
import module

# 導入模塊: import module ③
# 1.編譯執行模塊所對應的py文件，形成對應的pyc文件
# 2.產生該模塊自己的全局名稱空間
# 3.在使用該模塊的全局名稱空間中產生一個名字(導入的模塊名)
import module
aaaaa = module
import module
a = 888
module.b()

module.c()

print(aaaaa.a)

print(a)
# 註：④
# 1.每一個文件都會產生自己的全局名稱空間，且相互不影響
# 2.多次導入，只會編譯執行模塊一次，將其加載到內存，之後的都是直接對名字的引用

起別名

通過as關鍵字可以給模塊起別名: 模塊名一旦起別名，原模塊名就不能再使用

　　1.簡化模塊名字

　　2.統一功能

　　from 模板名 import 名字1 as 別名1, ..., 名字n as 別名n

#
import mmmmmmmmmmmmmmmmmm3 as my_m3
print(my_m3.num)

cmd = input(‘數據庫選擇 1:mysql | 2:oracle：‘)
if cmd == ‘1‘:
    import mysql as db
    # mysql.excuse()
else:
    import oracle as db
    # oracle.excuse()
db.excuse()

在任何地方都可以導入模塊
def fn():
    global m3
    import m3  # 就是普通的名字，只是該名字執行的是一個py文件(全局名稱空間)
    print(‘>>>‘, m3.num)
fn()
print(m3.num)

from導入

from 模塊名 import 名字1, 名字2, ..., 名字n

　　可以指名道姓導入模板中所有想導入的名字

from 模塊名 import *

　　導入的是模塊中的__all__這個列表
　　1、系統默認該列表不會收錄_開頭的名字
　　2、可以自定義__all__列表來規定外界通過*可以導入的名字

　　不建議直接導入 *，因為可讀性差，且極容易出現變量重名
　　模塊中有 名字a
　　可以使用模塊中的a
　　a = 20
　　模塊中的a就被覆蓋了，且在代碼上還不能直接看出

import m3, m4
import m3
import m4

# 在import後的名字才會在該文件的名稱空間中產生
# from m4 import a, b, _c  # 指名道姓的可以導入_開頭的名字

# 通過*導入: 可以將導入模塊中的(除了以_開頭的)名字一並導入
from m4 import *
# 通常不建議導入*，當需要使用模塊中絕大部分名字時，才考慮導入*

print(a)
a()

# 兩個py文件中的名字a都合理存在，
# 但import後的名字a和a=20，在一個名稱空間中，只會保留最後一次值
a = 20
# a()
b()
print(a)

# _c()
print(_c)
# print(c)

# 一旦起別名，原名字就不能再用 
from m5 import aaaaa as a, bbbbb as b, ccccc as c 
print(a) 
print(b) 
print(c)

自執行與模塊區別

__name__：
1.在py文件作為模塊被使用時，__name__為模塊名
2.在py文件自執行時，__name__為字符串 ‘__main__‘

print("共有邏輯")
if __name__ == ‘__main__‘:
    # 所有自執行的邏輯
    print("m6: 我是自執行的")
    a = 10  # 產生的是全局的名字
else:
    # 所有模塊的邏輯
    print("m6: 我被導入執行的")
    print(a)  # 會報錯：走else就不可能走if，所以a壓根沒產生

大總結

模塊的概念：一系列功能的集合體
為什麽要使用模塊：使用模塊後的優點：1文件角度考慮代碼，2拿來主義，提供開發效率
py中實現模塊的方式：4種，重點：py文件


定義模塊：新建一個py文件：文件名就是模塊名，盡量采用全英文，可以結合數字與下劃線
使用模塊：可以不用起別名，但一旦起別名，原名字就不能再使用了
    -- import 模塊名 as 別名
    -- from 模塊名 import 名字 as 別名
    
自執行文件與模塊區分：__name__

15 函數回調 模塊