第七章

經常使用模塊二

• hashlib模塊
• configparse模塊
• logging模塊

模塊使用

• import
• from ... import...
• 把模塊當作腳本執行 
• 模塊搜索路徑
• 編譯python文件

內置函數

• isinstance和issubclass

反射

• 　　setattr
• 　　delattr
• 　　getattr
• 　　hasattr
• __str__和__repr__
• __del__
• item系列
• 　　__getitem__
• 　　__setitem__
• 　　__delitem__
• __new__
• __call__
• __len__
• __hash__
• __eq__

 

經常使用模塊二　

hashlib模塊

 

算法介紹

Python的hashlib提供了常見的摘要算法，如MD5，SHA1等等。

什麼是摘要算法呢？摘要算法又稱哈希算法、散列算法。它經過一個函數，把任意長度的數據轉換爲一個長度固定的數據串（一般用16進制的字符串表示）。

摘要算法就是經過摘要函數f()對任意長度的數據data計算出固定長度的摘要digest，目的是爲了發現原始數據是否被人篡改過。

摘要算法之因此能指出數據是否被篡改過，就是由於摘要函數是一個單向函數，計算f(data)很容易，但經過digest反推data卻很是困難。並且，對原始數據作一個bit的修改，都會致使計算出的摘要徹底不一樣。

咱們以常見的摘要算法MD5爲例，計算出一個字符串的MD5值：

import hashlib
 
md5 = hashlib.md5()
md5.update('how to use md5 in python hashlib?')
print md5.hexdigest()

計算結果以下：
d26a53750bc40b38b65a520292f69306

若是數據量很大，能夠分塊屢次調用update()，最後計算的結果是同樣的：

md5 = hashlib.md5()
md5.update('how to use md5 in ')
md5.update('python hashlib?')
print md5.hexdigest()

MD5是最多見的摘要算法，速度很快，生成結果是固定的128 bit字節，一般用一個32位的16進制字符串表示。另外一種常見的摘要算法是SHA1，調用SHA1和調用MD5徹底相似：

import hashlib
 
sha1 = hashlib.sha1()
sha1.update('how to use sha1 in ')
sha1.update('python hashlib?')
print sha1.hexdigest()

SHA1的結果是160 bit字節，一般用一個40位的16進制字符串表示。比SHA1更安全的算法是SHA256和SHA512，不過越安全的算法越慢，並且摘要長度更長。

摘要算法應用

任何容許用戶登陸的網站都會存儲用戶登陸的用戶名和口令。如何存儲用戶名和口令呢？方法是存到數據庫表中：

name    | password
--------+----------
michael | 123456
bob     | abc999
alice   | alice2008

若是以明文保存用戶口令，若是數據庫泄露，全部用戶的口令就落入黑客的手裏。此外，網站運維人員是能夠訪問數據庫的，也就是能獲取到全部用戶的口令。正確的保存口令的方式是不存儲用戶的明文口令，而是存儲用戶口令的摘要，好比MD5：

username | password
---------+---------------------------------
michael  | e10adc3949ba59abbe56e057f20f883e
bob      | 878ef96e86145580c38c87f0410ad153
alice    | 99b1c2188db85afee403b1536010c2c9

考慮這麼個狀況，不少用戶喜歡用123456，888888，password這些簡單的口令，因而，黑客能夠事先計算出這些經常使用口令的MD5值，獲得一個反推表：

'e10adc3949ba59abbe56e057f20f883e': '123456'
'21218cca77804d2ba1922c33e0151105': '888888'
'5f4dcc3b5aa765d61d8327deb882cf99': 'password'

這樣，無需破解，只須要對比數據庫的MD5，黑客就得到了使用經常使用口令的用戶帳號。

對於用戶來說，固然不要使用過於簡單的口令。可是，咱們可否在程序設計上對簡單口令增強保護呢？

因爲經常使用口令的MD5值很容易被計算出來，因此，要確保存儲的用戶口令不是那些已經被計算出來的經常使用口令的MD5，這一方法經過對原始口令加一個複雜字符串來實現，俗稱「加鹽」：

hashlib.md5("salt".encode("utf8"))

通過Salt處理的MD5口令，只要Salt不被黑客知道，即便用戶輸入簡單口令，也很難經過MD5反推明文口令。

可是若是有兩個用戶都使用了相同的簡單口令好比123456，在數據庫中，將存儲兩條相同的MD5值，這說明這兩個用戶的口令是同樣的。有沒有辦法讓使用相同口令的用戶存儲不一樣的MD5呢？

若是假定用戶沒法修改登陸名，就能夠經過把登陸名做爲Salt的一部分來計算MD5，從而實現相同口令的用戶也存儲不一樣的MD5。

摘要算法在不少地方都有普遍的應用。要注意摘要算法不是加密算法，不能用於加密（由於沒法經過摘要反推明文），只能用於防篡改，可是它的單向計算特性決定了能夠在不存儲明文口令的狀況下驗證用戶口令。

 

configparser模塊

 

該模塊適用於配置文件的格式與windows ini文件相似，能夠包含一個或多個節（section），每一個節能夠有多個參數（鍵=值）。

建立文件

來看一個好多軟件的常見文檔格式以下：

[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes
  
[bitbucket.org]
User = hg
  
[topsecret.server.com]
Port = 50022
ForwardX11 = no

若是想用python生成一個這樣的文檔怎麼作呢？

import configparser

config = configparser.ConfigParser()

config["DEFAULT"] = {'ServerAliveInterval': '45',
                      'Compression': 'yes',
                     'CompressionLevel': '9',
                     'ForwardX11':'yes'
                     }

config['bitbucket.org'] = {'User':'hg'}

config['topsecret.server.com'] = {'Host Port':'50022','ForwardX11':'no'}

with open('example.ini', 'w') as configfile:

   config.write(configfile)

查找文件

import configparser

config = configparser.ConfigParser()

#---------------------------查找文件內容,基於字典的形式

print(config.sections())        #  []

config.read('example.ini')

print(config.sections())        #   ['bitbucket.org', 'topsecret.server.com']

print('bytebong.com' in config) # False
print('bitbucket.org' in config) # True


print(config['bitbucket.org']["user"])  # hg

print(config['DEFAULT']['Compression']) #yes

print(config['topsecret.server.com']['ForwardX11'])  #no


print(config['bitbucket.org'])          #<Section: bitbucket.org>

for key in config['bitbucket.org']:     # 注意,有default會默認default的鍵
    print(key)

print(config.options('bitbucket.org'))  # 同for循環,找到'bitbucket.org'下全部鍵

print(config.items('bitbucket.org'))    #找到'bitbucket.org'下全部鍵值對

print(config.get('bitbucket.org','compression')) # yes       get方法Section下的key對應的value

增刪改操做

import configparser

config = configparser.ConfigParser()

config.read('example.ini')

config.add_section('yuan')



config.remove_section('bitbucket.org')
config.remove_option('topsecret.server.com',"forwardx11")


config.set('topsecret.server.com','k1','11111')
config.set('yuan','k2','22222')

config.write(open('new2.ini', "w"))

 

logging模塊

 

函數式簡單配置

import logging  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message') 

默認狀況下Python的logging模塊將日誌打印到了標準輸出中，且只顯示了大於等於WARNING級別的日誌，這說明默認的日誌級別設置爲WARNING（日誌級別等級CRITICAL > ERROR > WARNING > INFO > DEBUG），默認的日誌格式爲日誌級別：Logger名稱：用戶輸出消息。

靈活配置日誌級別，日誌格式，輸出位置:

import logging  
logging.basicConfig(level=logging.DEBUG,  
                    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',  
                    datefmt='%a, %d %b %Y %H:%M:%S',  
                    filename='/tmp/test.log',  
                    filemode='w')  
  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message')

配置參數：

logging.basicConfig()函數中可經過具體參數來更改logging模塊默認行爲，可用參數有：

filename：用指定的文件名建立FiledHandler，這樣日誌會被存儲在指定的文件中。
filemode：文件打開方式，在指定了filename時使用這個參數，默認值爲「a」還可指定爲「w」。
format：指定handler使用的日誌顯示格式。
datefmt：指定日期時間格式。
level：設置rootlogger（後邊會講解具體概念）的日誌級別
stream：用指定的stream建立StreamHandler。能夠指定輸出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’))，默認爲sys.stderr。若同時列出了filename和stream兩個參數，則stream參數會被忽略。

format參數中可能用到的格式化串：
%(name)s Logger的名字
%(levelno)s 數字形式的日誌級別
%(levelname)s 文本形式的日誌級別
%(pathname)s 調用日誌輸出函數的模塊的完整路徑名，可能沒有
%(filename)s 調用日誌輸出函數的模塊的文件名
%(module)s 調用日誌輸出函數的模塊名
%(funcName)s 調用日誌輸出函數的函數名
%(lineno)d 調用日誌輸出函數的語句所在的代碼行
%(created)f 當前時間，用UNIX標準的表示時間的浮 點數表示
%(relativeCreated)d 輸出日誌信息時的，自Logger建立以 來的毫秒數
%(asctime)s 字符串形式的當前時間。默認格式是 「2003-07-08 16:49:45,896」。逗號後面的是毫秒
%(thread)d 線程ID。可能沒有
%(threadName)s 線程名。可能沒有
%(process)d 進程ID。可能沒有
%(message)s用戶輸出的消息

logger對象配置

import logging

logger = logging.getLogger()
# 建立一個handler，用於寫入日誌文件
fh = logging.FileHandler('test.log',encoding='utf-8') 

# 再建立一個handler，用於輸出到控制檯 
ch = logging.StreamHandler() 
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

fh.setLevel(logging.DEBUG)

fh.setFormatter(formatter) 
ch.setFormatter(formatter) 

logger.addHandler(fh) #logger對象能夠添加多個fh和ch對象 
logger.addHandler(ch) 

logger.debug('logger debug message') 
logger.info('logger info message') 
logger.warning('logger warning message') 
logger.error('logger error message') 
logger.critical('logger critical message')

logging庫提供了多個組件：Logger、Handler、Filter、Formatter。Logger對象提供應用程序可直接使用的接口，Handler發送日誌到適當的目的地，Filter提供了過濾日誌信息的方法，Formatter指定日誌顯示格式。另外，能夠經過：logger.setLevel(logging.Debug)設置級別,固然，也能夠經過

fh.setLevel(logging.Debug)單對文件流設置某個級別。

 

模塊

1 什麼是模塊？

   常見的場景：一個模塊就是一個包含了python定義和聲明的文件，文件名就是模塊名字加上.py的後綴。

   但其實import加載的模塊分爲四個通用類別：　

　　1 使用python編寫的代碼（.py文件）

　　2 已被編譯爲共享庫或DLL的C或C++擴展

　　3 包好一組模塊的包

　　4 使用C編寫並連接到python解釋器的內置模塊

2 爲什麼要使用模塊？

    若是你退出python解釋器而後從新進入，那麼你以前定義的函數或者變量都將丟失，所以咱們一般將程序寫到文件中以便永久保存下來，須要時就經過python test.py方式去執行，此時test.py被稱爲腳本script。

    隨着程序的發展，功能愈來愈多，爲了方便管理，咱們一般將程序分紅一個個的文件，這樣作程序的結構更清晰，方便管理。這時咱們不只僅能夠把這些文件當作腳本去執行，還能夠把他們當作模塊來導入到其餘的模塊中，實現了功能的重複利用，

3.如何使用模塊？

3.1 import

示例文件：自定義模塊my_module.py，文件名my_module.py,模塊名my_module

#my_module.py
print('from the my_module.py')

money=1000

def read1():
    print('my_module->read1->money',money)

def read2():
    print('my_module->read2 calling read1')
    read1()

def change():
    global money
    money=0

 

3.1.1

模塊能夠包含可執行的語句和函數的定義，這些語句的目的是初始化模塊，它們只在模塊名第一次遇到導入import語句時才執行（import語句是能夠在程序中的任意位置使用的,且針對同一個模塊很import屢次,爲了防止你重複導入，python的優化手段是：第一次導入後就將模塊名加載到內存了，後續的import語句僅是對已經加載大內存中的模塊對象增長了一次引用，不會從新執行模塊內的語句），以下 

#demo.py
import my_module #只在第一次導入時才執行my_module.py內代碼,此處的顯式效果是隻打印一次'from the my_module.py',固然其餘的頂級代碼也都被執行了,只不過沒有顯示效果.
import my_module
import my_module
import my_module

'''
執行結果：
from the my_module.py
'''

 

咱們能夠從sys.modules中找到當前已經加載的模塊，sys.modules是一個字典，內部包含模塊名與模塊對象的映射，該字典決定了導入模塊時是否須要從新導入。

 

3.1.2 

每一個模塊都是一個獨立的名稱空間，定義在這個模塊中的函數，把這個模塊的名稱空間當作全局名稱空間，這樣咱們在編寫本身的模塊時，就不用擔憂咱們定義在本身模塊中全局變量會在被導入時，與使用者的全局變量衝突

#測試一:money與my_module.money不衝突
#demo.py
import my_module
money=10
print(my_module.money)

'''
執行結果：
from the my_module.py
1000
'''

#測試二：read1與my_module.read1不衝突
#demo.py
import my_module
def read1():
    print('========')
my_module.read1()

'''
執行結果:
from the my_module.py
my_module->read1->money 1000
'''

#測試三：執行my_module.change()操做的全局變量money仍然是my_module中的
#demo.py
import my_module
money=1
my_module.change()
print(money)

'''
執行結果：
from the my_module.py
1
'''

 

3.1.3

總結：首次導入模塊my_module時會作三件事：

1.爲源文件(my_module模塊)建立新的名稱空間，在my_module中定義的函數和方法如果使用到了global時訪問的就是這個名稱空間。

2.在新建立的命名空間中執行模塊中包含的代碼，見初始導入import my_module

1 提示:導入模塊時到底執行了什麼？
2 
3 In fact function definitions are also ‘statements’ that are ‘executed’; the execution of a module-level function definition enters the function name in the module’s global symbol table.
4 事實上函數定義也是「被執行」的語句，模塊級別函數定義的執行將函數名放入模塊全局名稱空間表，用globals()能夠查看

3.建立名字my_module來引用該命名空間

1 這個名字和變量名沒什麼區別，都是‘第一類的’，且使用my_module.名字的方式能夠訪問my_module.py文件中定義的名字，my_module.名字與test.py中的名字來自兩個徹底不一樣的地方。

 

 3.1.4

爲模塊名起別名，至關於m1=1;m2=m1 

1 import my_module as sm
2 print(sm.money)

 

示範用法一：

有兩中sql模塊mysql和oracle，根據用戶的輸入，選擇不一樣的sql功能

#mysql.py
def sqlparse():
    print('from mysql sqlparse')
#oracle.py
def sqlparse():
    print('from oracle sqlparse')

#test.py
db_type=input('>>: ')
if db_type == 'mysql':
    import mysql as db
elif db_type == 'oracle':
    import oracle as db

db.sqlparse()

 

示範用法二： 

爲已經導入的模塊起別名的方式對編寫可擴展的代碼頗有用，假設有兩個模塊xmlreader.py和csvreader.py，它們都定義了函數read_data(filename):用來從文件中讀取一些數據，但採用不一樣的輸入格式。能夠編寫代碼來選擇性地挑選讀取模塊，例如

if file_format == 'xml':
     import xmlreader as reader
elif file_format == 'csv':
     import csvreader as reader
data=reader.read_date(filename)

3.1.5

在一行導入多個模塊

1 import sys,os,re

 

3.2 from ... import...

3.2.1

對比import my_module，會將源文件的名稱空間'my_module'帶到當前名稱空間中，使用時必須是my_module.名字的方式

而from 語句至關於import，也會建立新的名稱空間，可是將my_module中的名字直接導入到當前的名稱空間中，在當前名稱空間中，直接使用名字就能夠了、

 1 from my_module import read1,read2

這樣在當前位置直接使用read1和read2就行了，執行時，仍然以my_module.py文件全局名稱空間

#測試一：導入的函數read1，執行時仍然回到my_module.py中尋找全局變量money
#demo.py
from my_module import read1
money=1000
read1()
'''
執行結果:
from the my_module.py
spam->read1->money 1000
'''

#測試二:導入的函數read2，執行時須要調用read1(),仍然回到my_module.py中找read1()
#demo.py
from my_module import read2
def read1():
    print('==========')
read2()

'''
執行結果:
from the my_module.py
my_module->read2 calling read1
my_module->read1->money 1000
'''

 

若是當前有重名read1或者read2，那麼會有覆蓋效果。

#測試三:導入的函數read1，被當前位置定義的read1覆蓋掉了
#demo.py
from my_module import read1
def read1():
    print('==========')
read1()
'''
執行結果:
from the my_module.py
==========
'''

 

須要特別強調的一點是：python中的變量賦值不是一種存儲操做，而只是一種綁定關係，以下：

from my_module import money,read1
money=100 #將當前位置的名字money綁定到了100
print(money) #打印當前的名字
read1() #讀取my_module.py中的名字money,仍然爲1000

'''
from the my_module.py
100
my_module->read1->money 1000
'''

3.2.2

也支持as

1 from my_module import read1 as read

3.2.3

也支持導入多行

1 from my_module import (read1,
2                   read2,
3                   money)

3.2.4

from my_module import * 把my_module中全部的不是如下劃線(_)開頭的名字都導入到當前位置，大部分狀況下咱們的python程序不該該使用這種導入方式，由於*你不知道你導入什麼名字，頗有可能會覆蓋掉你以前已經定義的名字。並且可讀性極其的差，在交互式環境中導入時沒有問題。

from my_module import * #將模塊my_module中全部的名字都導入到當前名稱空間
print(money)
print(read1)
print(read2)
print(change)

'''
執行結果:
from the my_module.py
1000
<function read1 at 0x1012e8158>
<function read2 at 0x1012e81e0>
<function change at 0x1012e8268>
'''

 

在my_module.py中新增一行

__all__=['money','read1'] #這樣在另一個文件中用from my_module import *就這能導入列表中規定的兩個名字

 

*若是my_module.py中的名字前加_,即_money，則from my_module import *,則_money不能被導入

3.2.5 模塊的循環引用問題

思考：假若有兩個模塊a，b。我可不能夠在a模塊中import b ，再在b模塊中import a？

3.2.6 模塊的加載與修改

考慮到性能的緣由，每一個模塊只被導入一次,放入字典sys.modules中，若是你改變了模塊的內容，你必須重啓程序，python不支持從新加載或卸載以前導入的模塊，

有的同窗可能會想到直接從sys.modules中刪除一個模塊不就能夠卸載了嗎，注意了，你刪了sys.modules中的模塊對象仍然可能被其餘程序的組件所引用，於是不會被清除。

特別的對於咱們引用了這個模塊中的一個類，用這個類產生了不少對象，於是這些對象都有關於這個模塊的引用。

若是隻是你想交互測試的一個模塊，使用 importlib.reload(), e.g. import importlib; importlib.reload(modulename)，這隻能用於測試環境。

def func1():
    print('func1')

import time,importlib
import aa
 
time.sleep(20)
# importlib.reload(aa)
aa.func1()

在20秒的等待時間裏，修改aa.py中func1的內容，等待test.py的結果。

打開importlib註釋，從新測試

 

3.3 把模塊當作腳本執行 

咱們能夠經過模塊的全局變量__name__來查看模塊名：
當作腳本運行：
__name__ 等於'__main__'

當作模塊導入：
__name__= 模塊名

做用：用來控制.py文件在不一樣的應用場景下執行不一樣的邏輯
if __name__ == '__main__':

def fib(n):   
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
    print()

if __name__ == "__main__":
    print(__name__)
    num = input('num :')
    fib(int(num))

 

3.4 模塊搜索路徑

python解釋器在啓動時會自動加載一些模塊，可使用sys.modules查看

在第一次導入某個模塊時（好比my_module），會先檢查該模塊是否已經被加載到內存中（當前執行文件的名稱空間對應的內存），若是有則直接引用

若是沒有，解釋器則會查找同名的內建模塊，若是尚未找到就從sys.path給出的目錄列表中依次尋找my_module.py文件。

因此總結模塊的查找順序是：內存中已經加載的模塊->內置模塊->sys.path路徑中包含的模塊

sys.path的初始化的值來自於：

The directory containing the input script (or the current directory when no file is specified).
PYTHONPATH (a list of directory names, with the same syntax as the shell variable PATH).
The installation-dependent default.

須要特別注意的是：咱們自定義的模塊名不該該與系統內置模塊重名。雖然每次都說，可是仍然會有人不停的犯錯。 

在初始化後，python程序能夠修改sys.path,路徑放到前面的優先於標準庫被加載。

1 >>> import sys
2 >>> sys.path.append('/a/b/c/d')
3 >>> sys.path.insert(0,'/x/y/z') #排在前的目錄，優先被搜索

注意：搜索時按照sys.path中從左到右的順序查找，位於前的優先被查找，sys.path中還可能包含.zip歸檔文件和.egg文件，python會把.zip歸檔文件當成一個目錄去處理。

#首先製做歸檔文件：zip module.zip foo.py bar.py

import sys
sys.path.append('module.zip')
import foo,bar

#也可使用zip中目錄結構的具體位置
sys.path.append('module.zip/lib/python')

#windows下的路徑不加r開頭，會語法錯誤
sys.path.insert(0,r'C:\Users\Administrator\PycharmProjects\a')

 

至於.egg文件是由setuptools建立的包，這是按照第三方python庫和擴展時使用的一種常見格式，.egg文件實際上只是添加了額外元數據(如版本號，依賴項等)的.zip文件。

須要強調的一點是：只能從.zip文件中導入.py，.pyc等文件。使用C編寫的共享庫和擴展塊沒法直接從.zip文件中加載（此時setuptools等打包系統有時能提供一種規避方法），且從.zip中加載文件不會建立.pyc或者.pyo文件，所以必定要事先建立他們，來避免加載模塊是性能降低。

 

官網解釋

#官網連接：https://docs.python.org/3/tutorial/modules.html#the-module-search-path
搜索路徑：
當一個命名爲my_module的模塊被導入時
    解釋器首先會從內建模塊中尋找該名字
    找不到，則去sys.path中找該名字

sys.path從如下位置初始化
執行文件所在的當前目錄
PTYHONPATH（包含一系列目錄名，與shell變量PATH語法同樣）
依賴安裝時默認指定的

注意：在支持軟鏈接的文件系統中，執行腳本所在的目錄是在軟鏈接以後被計算的，換句話說，包含軟鏈接的目錄不會被添加到模塊的搜索路徑中

在初始化後，咱們也能夠在python程序中修改sys.path,執行文件所在的路徑默認是sys.path的第一個目錄，在全部標準庫路徑的前面。這意味着，當前目錄是優先於標準庫目錄的，須要強調的是：咱們自定義的模塊名不要跟python標準庫的模塊名重複，除非你是故意的，傻叉。

 

3.5 編譯python文件

爲了提升加載模塊的速度，強調強調強調：提升的是加載速度而絕非運行速度。python解釋器會在__pycache__目錄中下緩存每一個模塊編譯後的版本，格式爲：module.version.pyc。一般會包含python的版本號。例如，在CPython3.3版本下，my_module.py模塊會被緩存成__pycache__/my_module.cpython-33.pyc。這種命名規範保證了編譯後的結果多版本共存。

 

Python檢查源文件的修改時間與編譯的版本進行對比，若是過時就須要從新編譯。這是徹底自動的過程。而且編譯的模塊是平臺獨立的，因此相同的庫能夠在不一樣的架構的系統之間共享，即pyc使一種跨平臺的字節碼，相似於JAVA火.NET,是由python虛擬機來執行的，可是pyc的內容跟python的版本相關，不一樣的版本編譯後的pyc文件不一樣，2.5編譯的pyc文件不能到3.5上執行，而且pyc文件是能夠反編譯的，於是它的出現僅僅是用來提高模塊的加載速度的。

 

python解釋器在如下兩種狀況下不檢測緩存
　　1 若是是在命令行中被直接導入模塊，則按照這種方式，每次導入都會從新編譯，而且不會存儲編譯後的結果（python3.3之前的版本應該是這樣）

python -m my_module.py

　　2 若是源文件不存在，那麼緩存的結果也不會被使用，若是想在沒有源文件的狀況下來使用編譯後的結果，則編譯後的結果必須在源目錄下 

提示：

1.模塊名區分大小寫，foo.py與FOO.py表明的是兩個模塊

2.你可使用-O或者-OO轉換python命令來減小編譯模塊的大小

-O轉換會幫你去掉assert語句
-OO轉換會幫你去掉assert語句和__doc__文檔字符串
因爲一些程序可能依賴於assert語句或文檔字符串，你應該在在確認須要的狀況下使用這些選項。

3.在速度上從.pyc文件中讀指令來執行不會比從.py文件中讀指令執行更快，只有在模塊被加載時，.pyc文件纔是更快的

4.只有使用import語句是纔將文件自動編譯爲.pyc文件，在命令行或標準輸入中指定運行腳本則不會生成這類文件，於是咱們可使用compieall模塊爲一個目錄中的全部模塊建立.pyc文件

模塊能夠做爲一個腳本（使用python -m compileall）編譯Python源
 
python -m compileall /module_directory 遞歸着編譯
若是使用python -O -m compileall /module_directory -l則只一層
 
命令行裏使用compile()函數時，自動使用python -O -m compileall
 
詳見：https://docs.python.org/3/library/compileall.html#module-compileall

 

補充:dir()函數

內建函數dir是用來查找模塊中定義的名字，返回一個有序字符串列表

import my_module
dir(my_module)

 

若是沒有參數,dir()列舉出當前定義的名字

dir()不會列舉出內建函數或者變量的名字，它們都被定義到了標準模塊builtin中，能夠列舉出它們，

import builtins
dir(builtins)

 

內置函數

isinstance和issubclass

isinstance(obj,cls)檢查是否obj是不是類 cls 的對象

class Foo(object):
     pass
  
obj = Foo()
  
isinstance(obj, Foo)

issubclass(sub, super)檢查sub類是不是 super 類的派生類 

class Foo(object):
    pass
 
class Bar(Foo):
    pass
 
issubclass(Bar, Foo)

 

 

反射

1 什麼是反射

反射的概念是由Smith在1982年首次提出的，主要是指程序能夠訪問、檢測和修改它自己狀態或行爲的一種能力（自省）。這一律唸的提出很快引起了計算機科學領域關於應用反射性的研究。它首先被程序語言的設計領域所採用,並在Lisp和麪向對象方面取得了成績。

 

2 python面向對象中的反射：經過字符串的形式操做對象相關的屬性。python中的一切事物都是對象（均可以使用反射）

四個能夠實現自省的函數

下列方法適用於類和對象（一切皆對象，類自己也是一個對象）

def hasattr(*args, **kwargs): # real signature unknown
    """
    Return whether the object has an attribute with the given name.
    
    This is done by calling getattr(obj, name) and catching AttributeError.
    """
    pass

def getattr(object, name, default=None): # known special case of getattr
    """
    getattr(object, name[, default]) -> value
    
    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
    When a default argument is given, it is returned when the attribute doesn't
    exist; without it, an exception is raised in that case.
    """
    pass

def setattr(x, y, v): # real signature unknown; restored from __doc__
    """
    Sets the named attribute on the given object to the specified value.
    
    setattr(x, 'y', v) is equivalent to ``x.y = v''
    """
    pass

def delattr(x, y): # real signature unknown; restored from __doc__
    """
    Deletes the named attribute from the given object.
    
    delattr(x, 'y') is equivalent to ``del x.y''
    """
    pass

class Foo:
    f = '類的靜態變量'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say_hi(self):
        print('hi,%s'%self.name)

obj=Foo('egon',73)

#檢測是否含有某屬性
print(hasattr(obj,'name'))
print(hasattr(obj,'say_hi'))

#獲取屬性
n=getattr(obj,'name')
print(n)
func=getattr(obj,'say_hi')
func()

print(getattr(obj,'aaaaaaaa','不存在啊')) #報錯

#設置屬性
setattr(obj,'sb',True)
setattr(obj,'show_name',lambda self:self.name+'sb')
print(obj.__dict__)
print(obj.show_name(obj))

#刪除屬性
delattr(obj,'age')
delattr(obj,'show_name')
delattr(obj,'show_name111')#不存在,則報錯

print(obj.__dict__)

 

class Foo(object):
 
    staticField = "old boy"
 
    def __init__(self):
        self.name = 'wupeiqi'
 
    def func(self):
        return 'func'
 
    @staticmethod
    def bar():
        return 'bar'
 
print getattr(Foo, 'staticField')
print getattr(Foo, 'func')
print getattr(Foo, 'bar')

 

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sys


def s1():
    print 's1'


def s2():
    print 's2'


this_module = sys.modules[__name__]

hasattr(this_module, 's1')
getattr(this_module, 's2')

導入其餘模塊，利用反射查找該模塊是否存在某個方法

#!/usr/bin/env python
# -*- coding:utf-8 -*-

def test():
    print('from the test')

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
"""
程序目錄：
    module_test.py
    index.py
 
當前文件：
    index.py
"""

import module_test as obj

#obj.test()

print(hasattr(obj,'test'))

getattr(obj,'test')()

 

__str__和__repr__

改變對象的字符串顯示__str__,__repr__

自定製格式化字符串__format__

#_*_coding:utf-8_*_

format_dict={
    'nat':'{obj.name}-{obj.addr}-{obj.type}',#學校名-學校地址-學校類型
    'tna':'{obj.type}:{obj.name}:{obj.addr}',#學校類型:學校名:學校地址
    'tan':'{obj.type}/{obj.addr}/{obj.name}',#學校類型/學校地址/學校名
}
class School:
    def __init__(self,name,addr,type):
        self.name=name
        self.addr=addr
        self.type=type

    def __repr__(self):
        return 'School(%s,%s)' %(self.name,self.addr)
    def __str__(self):
        return '(%s,%s)' %(self.name,self.addr)

    def __format__(self, format_spec):
        # if format_spec
        if not format_spec or format_spec not in format_dict:
            format_spec='nat'
        fmt=format_dict[format_spec]
        return fmt.format(obj=self)

s1=School('oldboy1','北京','私立')
print('from repr: ',repr(s1))
print('from str: ',str(s1))
print(s1)

'''
str函數或者print函數--->obj.__str__()
repr或者交互式解釋器--->obj.__repr__()
若是__str__沒有被定義,那麼就會使用__repr__來代替輸出
注意:這倆方法的返回值必須是字符串,不然拋出異常
'''
print(format(s1,'nat'))
print(format(s1,'tna'))
print(format(s1,'tan'))
print(format(s1,'asfdasdffd'))

class B:

     def __str__(self):
         return 'str : class B'

     def __repr__(self):
         return 'repr : class B'


b=B()
print('%s'%b)
print('%r'%b)

 

__del__

析構方法，當對象在內存中被釋放時，自動觸發執行。

注：此方法通常無須定義，由於Python是一門高級語言，程序員在使用時無需關心內存的分配和釋放，由於此工做都是交給Python解釋器來執行，因此，析構函數的調用是由解釋器在進行垃圾回收時自動觸發執行的。

class Foo:

    def __del__(self):
        print('執行我啦')

f1=Foo()
del f1
print('------->')

#輸出結果
執行我啦
------->

 

item系列

__getitem__\__setitem__\__delitem__

class Foo:
    def __init__(self,name):
        self.name=name

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print('del obj[key]時,我執行')
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print('del obj.key時,我執行')
        self.__dict__.pop(item)

f1=Foo('sb')
f1['age']=18
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alex'
print(f1.__dict__)

class Foo:
    def __init__(self,name):
        self.name=name

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print('del obj[key]時,我執行')
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print('del obj.key時,我執行')
        self.__dict__.pop(item)

f1=Foo('sb')
f1['age']=18
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alex'
print(f1.__dict__)

 

__new__

class A:
    def __init__(self):
        self.x = 1
        print('in init function')
    def __new__(cls, *args, **kwargs):
        print('in new function')
        return object.__new__(A, *args, **kwargs)

a = A()
print(a.x)

class Singleton:
    def __new__(cls, *args, **kw):
        if not hasattr(cls, '_instance'):
            cls._instance = object.__new__(cls, *args, **kw)
        return cls._instance

one = Singleton()
two = Singleton()

two.a = 3
print(one.a)
# 3
# one和two徹底相同,能夠用id(), ==, is檢測
print(id(one))
# 29097904
print(id(two))
# 29097904
print(one == two)
# True
print(one is two)

單例模式

 

__call__

對象後面加括號，觸發執行。

注：構造方法的執行是由建立對象觸發的，即：對象 = 類名() ；而對於 __call__ 方法的執行是由對象後加括號觸發的，即：對象() 或者 類()()

class Foo:

    def __init__(self):
        pass
    
    def __call__(self, *args, **kwargs):

        print('__call__')


obj = Foo() # 執行 __init__
obj()       # 執行 __call__

 

__len__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __len__(self):
        return len(self.__dict__)
a = A()
print(len(a))

 

__hash__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __hash__(self):
        return hash(str(self.a)+str(self.b))
a = A()
print(hash(a))

 

__eq__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __eq__(self,obj):
        if  self.a == obj.a and self.b == obj.b:
            return True
a = A()
b = A()
print(a == b)

 

練習題

紙牌遊戲

class FranchDeck:
    ranks = [str(n) for n in range(2,11)] + list('JQKA')
    suits = ['紅心','方板','梅花','黑桃']

    def __init__(self):
        self._cards = [Card(rank,suit) for rank in FranchDeck.ranks
                                        for suit in FranchDeck.suits]

    def __len__(self):
        return len(self._cards)

    def __getitem__(self, item):
        return self._cards[item]

deck = FranchDeck()
print(deck[0])
from random import choice
print(choice(deck))
print(choice(deck))

紙牌遊戲2

class FranchDeck:
    ranks = [str(n) for n in range(2,11)] + list('JQKA')
    suits = ['紅心','方板','梅花','黑桃']

    def __init__(self):
        self._cards = [Card(rank,suit) for rank in FranchDeck.ranks
                                        for suit in FranchDeck.suits]

    def __len__(self):
        return len(self._cards)

    def __getitem__(self, item):
        return self._cards[item]

    def __setitem__(self, key, value):
        self._cards[key] = value

deck = FranchDeck()
print(deck[0])
from random import choice
print(choice(deck))
print(choice(deck))

from random import shuffle
shuffle(deck)
print(deck[:5])

一道面試題

class Person:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def __hash__(self):
        return hash(self.name+self.sex)

    def __eq__(self, other):
        if self.name == other.name and self.sex == other.sex:return True


p_lst = []
for i in range(84):
    p_lst.append(Person('egon',i,'male'))

print(p_lst)
print(set(p_lst))