python經常使用模塊

時間 2019-11-10

原文原文鏈接

1 time模塊

時間表示形式

在Python中，一般有這三種方式來表示時間：時間戳、元組(struct_time)、格式化的時間字符串：
(1)時間戳(timestamp) ：一般來講，時間戳表示的是從1970年1月1日00:00:00開始按秒計算的偏移量。咱們運行「type(time.time())」，返回的是float類型。html

(2)格式化的時間字符串(Format String)： ‘1988-03-16’python

(3)元組(struct_time) ：struct_time元組共有9個元素共九個元素:(年，月，日，時，分，秒，一年中第幾周，一年中第幾天等）web

# <1> 時間戳

>>> import time
>>> time.time()      #--------------返回當前時間的時間戳

1493136727.099066

# <2> 時間字符串

>>> time.strftime("%Y-%m-%d %X")
'2017-04-26 00:32:18'

# <3> 時間元組

>>> time.localtime()
time.struct_time(tm_year=2017, tm_mon=4, tm_mday=26,
                 tm_hour=0, tm_min=32, tm_sec=42, tm_wday=2,
                 tm_yday=116, tm_isdst=0)

小結：時間戳是計算機可以識別的時間；時間字符串是人可以看懂的時間；元組則是用來操做時間的正則表達式

幾種時間形式的轉換

（1）算法

#一時間戳<－－－－>結構化時間： localtime/gmtime mktimeshell

>>> time.localtime(3600*24)
>>> time.gmtime(3600*24)編程

>>> time.mktime(time.localtime())json

#字符串時間<－－－－>結構化時間： strftime／strptimebash

>>> time.strftime("%Y-%m-%d %X", time.localtime())
>>> time.strptime("2017-03-16","%Y-%m-%d")網絡

（2）

>>> time.asctime(time.localtime(312343423))
'Sun Nov 25 10:03:43 1979'
>>> time.ctime(312343423)
'Sun Nov 25 10:03:43 1979'

#--------------------------其餘方法
# sleep(secs)
# 線程推遲指定的時間運行，單位爲秒。

二 random模塊

import random
 
print(random.random())#(0,1)----float    大於0且小於1之間的小數
 
print(random.randint(1,3))  #[1,3]    大於等於1且小於等於3之間的整數
 
print(random.randrange(1,3)) #[1,3)    大於等於1且小於3之間的整數
 
print(random.choice([1,'23',[4,5]]))#1或者23或者[4,5]，choice()中只能放列表格式
 
print(random.sample([1,'23',[4,5]],2))#列表元素任意2個組合
 
print(random.uniform(1,3))#大於1小於3的小數，如1.927109612082716 
 
 
item=[1,3,5,7,9]
random.shuffle(item) #打亂item的順序,至關於"洗牌"
print(item)

import random

def test():
    s = ""
    for i in range(5):
        r1 = random.randint(0, 9)
        r2 = chr(random.randint(65, 90))   #ASCII表對應A-Z
        r3 = chr(random.randint(97, 122))  #ASCII表對應a-z
        r4 = random.choice([str(r1), r2, r3])   #三選一
        s += r4
    return s

print(test())

實例：5位隨機驗證碼

三hashlib模塊

1.什麼叫hash:hash是一種算法（3.x裏代替了md5模塊和sha模塊，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法），該算法接受傳入的內容，通過運算獲得一串hash值
2.hash值的特色是：
2.1 只要傳入的內容同樣，獲得的hash值必然同樣=====>要用明文傳輸密碼文件完整性校驗
2.2 不能由hash值返解成內容=======》把密碼作成hash值，不該該在網絡傳輸明文密碼
2.3 只要使用的hash算法不變，不管校驗的內容有多大，獲得的hash值長度是固定的

hash算法就像一座工廠，工廠接收你送來的原材料（能夠用m.update()爲工廠運送原材料），通過加工返回的產品就是hash值

import hashlib
 
m=hashlib.md5()# m=hashlib.sha256()
 
m.update('hello'.encode('utf8'))
print(m.hexdigest())  #5d41402abc4b2a76b9719d911017c592
 
m.update('alvin'.encode('utf8'))
 
print(m.hexdigest())  #92a7e713c30abbb0319fa07da2a5c4af
 
m2=hashlib.md5()
m2.update('helloalvin'.encode('utf8'))
print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af

'''
注意：把一段很長的數據update屢次，與一次update這段長數據，獲得的結果同樣
可是update屢次爲校驗大文件提供了可能。
'''

以上加密算法雖然依然很是厲害，但時候存在缺陷，即：經過撞庫能夠反解。因此，有必要對加密算法中添加自定義key再來作加密。

import hashlib
 
# ######## 256 ########
 
hash = hashlib.sha256('898oaFs09f'.encode('utf8'))
hash.update('alvin'.encode('utf8'))
print (hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7

import hashlib
passwds=[
    'alex3714',
    'alex1313',
    'alex94139413',
    'alex123456',
    '123456alex',
    'a123lex',
    ]
def make_passwd_dic(passwds):
    dic={}
    for passwd in passwds:
        m=hashlib.md5()
        m.update(passwd.encode('utf-8'))
        dic[passwd]=m.hexdigest()
    return dic

def break_code(cryptograph,passwd_dic):
    for k,v in passwd_dic.items():
        if v == cryptograph:
            print('密碼是===>\033[46m%s\033[0m' %k)

cryptograph='aee949757a2e698417463d47acac93df'
break_code(cryptograph,make_passwd_dic(passwds))

模擬撞庫破解密碼

四 os模塊

os.getcwd() 獲取當前工做目錄，即當前python腳本工做的目錄路徑
os.chdir("dirname") 改變當前腳本工做目錄；至關於shell下cd
os.curdir 返回當前目錄: ('.')
os.pardir 獲取當前目錄的父目錄字符串名：('..')
os.makedirs('dirname1/dirname2') 可生成多層遞歸目錄
os.removedirs('dirname1') 若目錄爲空，則刪除，並遞歸到上一級目錄，如若也爲空，則刪除，依此類推
os.mkdir('dirname') 生成單級目錄；至關於shell中mkdir dirname
os.rmdir('dirname') 刪除單級空目錄，若目錄不爲空則沒法刪除，報錯；至關於shell中rmdir dirname
os.listdir('dirname') 列出指定目錄下的全部文件和子目錄，包括隱藏文件，並以列表方式打印
os.remove() 刪除一個文件
os.rename("oldname","newname") 重命名文件/目錄
os.stat('path/filename') 獲取文件/目錄信息
os.sep 輸出操做系統特定的路徑分隔符，win下爲"\\",Linux下爲"/"
os.linesep 輸出當前平臺使用的行終止符，win下爲"\t\n",Linux下爲"\n"
os.pathsep 輸出用於分割文件路徑的字符串 win下爲;,Linux下爲:
os.name 輸出字符串指示當前使用平臺。win->'nt'; Linux->'posix'
os.system("bash command") 運行shell命令，直接顯示
os.environ 獲取系統環境變量
os.path.abspath(path) 返回path規範化的絕對路徑
os.path.split(path) 將path分割成目錄和文件名二元組返回
os.path.dirname(path) 返回path的目錄。其實就是os.path.split(path)的第一個元素
os.path.basename(path) 返回path最後的文件名。如何path以／或\結尾，那麼就會返回空值。即os.path.split(path)的第二個元素
os.path.exists(path) 若是path存在，返回True；若是path不存在，返回False
os.path.isabs(path) 若是path是絕對路徑，返回True
os.path.isfile(path) 若是path是一個存在的文件，返回True。不然返回False
os.path.isdir(path) 若是path是一個存在的目錄，則返回True。不然返回False
os.path.join(path1[, path2[, ...]]) 將多個路徑組合後返回，第一個絕對路徑以前的參數將被忽略
os.path.getatime(path) 返回path所指向的文件或者目錄的最後存取時間
os.path.getmtime(path) 返回path所指向的文件或者目錄的最後修改時間
os.path.getsize(path) 返回path的大小

五 sys模塊

sys.argv           命令行參數List，第一個元素是程序自己路徑
sys.exit(n)        退出程序，正常退出時exit(0)
sys.version        獲取Python解釋程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值
sys.platform       返回操做系統平臺名稱

六 logging模塊

6.1 函數式簡單配置

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用戶輸出的消息

6.2 logger對象配置（推薦）

import logging


def test():
    # 一、建立一個logger
    log = logging.getLogger()
    log.setLevel(logging.DEBUG)
    # 2.建立一個handler，用於寫入日誌文件
    file = logging.FileHandler("test.txt")
    file.setLevel(logging.DEBUG)
    # 再建立一個handler，用於輸出到控制檯
    stream = logging.StreamHandler()
    stream.setLevel(logging.DEBUG)
    # 3.定義handler的輸出格式（formatter）
    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
    # 4.給handler添加formatter
    file.setFormatter(formatter) 
    stream.setFormatter(formatter)
    # 5.給logger添加handler
    log.addHandler(file)       # logger對象能夠添加多個file和stream對象
    log.addHandler(stream)
    return log


l = test()
l.debug("debug")
l.info("info")
l.warning("warning")
l.error("error")
l.critical("critical")

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

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

7 序列化模塊

什麼是序列化？

咱們把對象(變量)從內存中變成可存儲或傳輸的過程稱之爲序列化，在Python中叫pickling，在其餘語言中也被稱之爲serialization，marshalling，flattening等等，都是一個意思。序列化以後，就能夠把序列化後的內容寫入磁盤，或者經過網絡傳輸到別的機器上。反過來，把變量內容從序列化的對象從新讀到內存裏稱之爲反序列化，即unpickling。

json模塊

若是咱們要在不一樣的編程語言之間傳遞對象，就必須把對象序列化爲標準格式，好比XML，但更好的方法是序列化爲JSON，由於JSON表示出來就是一個字符串，能夠被全部語言讀取，也能夠方便地存儲到磁盤或者經過網絡傳輸。JSON不只是標準格式，而且比XML更快，並且能夠直接在Web頁面中讀取，很是方便。

JSON表示的對象就是標準的JavaScript語言的對象一個子集，JSON和Python內置的數據類型對應以下：

python在文本中的使用：

#----------------------------序列化
import json

dic={'name':'alvin','age':23,'sex':'male'}
print(type(dic))#<class 'dict'>

data=json.dumps(dic)
print("type",type(data))#<class 'str'>
print("data",data)


f=open('序列化對象','w')
f.write(data)  #-------------------等價於json.dump(dic,f)
f.close()


#-----------------------------反序列化<br>
import json
f=open('序列化對象')
new_data=json.loads(f.read())#  等價於data=json.load(f)

print(type(new_data))

pickle模塊

##----------------------------序列化
import pickle
 
dic={'name':'alvin','age':23,'sex':'male'}
 
print(type(dic))#<class 'dict'>
 
j=pickle.dumps(dic)
print(type(j))#<class 'bytes'>
 
 
f=open('序列化對象_pickle','wb')#注意是w是寫入str,wb是寫入bytes,j是'bytes'
f.write(j)  #-------------------等價於pickle.dump(dic,f)
 
f.close()
#-------------------------反序列化
import pickle
f=open('序列化對象_pickle','rb')
 
data=pickle.loads(f.read())#  等價於data=pickle.load(f)
 
print(data['age'])

Pickle的問題和全部其餘編程語言特有的序列化問題同樣，就是它只能用於Python，而且可能不一樣版本的Python彼此都不兼容，所以，只能用Pickle保存那些不重要的數據，不能成功地反序列化也不要緊。

shelve模塊

shelve模塊比pickle模塊簡單，只有一個open函數，返回相似字典的對象，可讀可寫;key必須爲字符串，而值能夠是python所支持的數據類型

import shelve

f=shelve.open(r'sheve.txt')
# f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']}
# f['stu2_info']={'name':'gangdan','age':53}
# f['school_info']={'website':'http://www.pypy.org','city':'beijing'}

print(f['stu1_info']['hobby'])
f.close()

re模塊

一：什麼是正則？

正則就是用一些具備特殊含義的符號組合到一塊兒（稱爲正則表達式）來描述字符或者字符串的方法。或者說：正則就是用來描述一類事物的規則。（在Python中）它內嵌在Python中，並經過 re 模塊實現。正則表達式模式被編譯成一系列的字節碼，而後由用 C 編寫的匹配引擎執行。

生活中到處都是正則：

好比咱們描述：4條腿

　　你可能會想到的是四條腿的動物或者桌子，椅子等

繼續描述：4條腿，活的

就只剩下四條腿的動物這一類了

二：經常使用匹配模式(元字符)

# =================================匹配模式=================================
#一對一的匹配
# 'hello'.replace(old,new)
# 'hello'.find('pattern')

#正則匹配
import re
#\w與\W
print(re.findall('\w','hello egon 123')) #['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '1', '2', '3']
print(re.findall('\W','hello egon 123')) #[' ', ' ']

#\s與\S
print(re.findall('\s','hello  egon  123')) #[' ', ' ', ' ', ' ']
print(re.findall('\S','hello  egon  123')) #['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '1', '2', '3']

#\n \t都是空,均可以被\s匹配
print(re.findall('\s','hello \n egon \t 123')) #[' ', '\n', ' ', ' ', '\t', ' ']

#\n與\t
print(re.findall(r'\n','hello egon \n123')) #['\n']
print(re.findall(r'\t','hello egon\t123')) #['\n']

#\d與\D
print(re.findall('\d','hello egon 123')) #['1', '2', '3']
print(re.findall('\D','hello egon 123')) #['h', 'e', 'l', 'l', 'o', ' ', 'e', 'g', 'o', 'n', ' ']

#\A與\Z
print(re.findall('\Ahe','hello egon 123')) #['he'],\A==>^
print(re.findall('123\Z','hello egon 123')) #['he'],\Z==>$

#^與$
print(re.findall('^h','hello egon 123')) #['h']
print(re.findall('3$','hello egon 123')) #['3']

# 重複匹配：| . | * | ? | .* | .*? | + | {n,m} |
#.
print(re.findall('a.b','a1b')) #['a1b']
print(re.findall('a.b','a1b a*b a b aaab')) #['a1b', 'a*b', 'a b', 'aab']
print(re.findall('a.b','a\nb')) #[]
print(re.findall('a.b','a\nb',re.S)) #['a\nb']
print(re.findall('a.b','a\nb',re.DOTALL)) #['a\nb']同上一條意思同樣

#*
print(re.findall('ab*','bbbbbbb')) #[]
print(re.findall('ab*','a')) #['a']
print(re.findall('ab*','abbbb')) #['abbbb']

#?
print(re.findall('ab?','a')) #['a']
print(re.findall('ab?','abbb')) #['ab']
#匹配全部包含小數在內的數字
print(re.findall('\d+\.?\d*',"asdfasdf123as1.13dfa12adsf1asdf3")) #['123', '1.13', '12', '1', '3']

#.*默認爲貪婪匹配
print(re.findall('a.*b','a1b22222222b')) #['a1b22222222b']

#.*?爲非貪婪匹配：推薦使用
print(re.findall('a.*?b','a1b22222222b')) #['a1b']

#+
print(re.findall('ab+','a')) #[]
print(re.findall('ab+','abbb')) #['abbb']

#{n,m}
print(re.findall('ab{2}','abbb')) #['abb']
print(re.findall('ab{2,4}','abbb')) #['abb']
print(re.findall('ab{1,}','abbb')) #'ab{1,}' ===> 'ab+'
print(re.findall('ab{0,}','abbb')) #'ab{0,}' ===> 'ab*'

#[]
print(re.findall('a[1*-]b','a1b a*b a-b')) #[]內的都爲普通字符了，且若是-沒有被轉意的話，應該放到[]的開頭或結尾
print(re.findall('a[^1*-]b','a1b a*b a-b a=b')) #[]內的^表明的意思是取反，因此結果爲['a=b']
print(re.findall('a[0-9]b','a1b a*b a-b a=b')) # 結果爲['a1b']
print(re.findall('a[a-z]b','a1b a*b a-b a=b aeb')) # 結果爲['aeb']
print(re.findall('a[a-zA-Z]b','a1b a*b a-b a=b aeb aEb')) # 結果爲['aeb','aEb']

#\# print(re.findall('a\\c','a\c')) #對於正則來講a\\c確實能夠匹配到a\c,可是在python解釋器讀取a\\c時，會發生轉義，而後交給re去執行，因此拋出異常
print(re.findall(r'a\\c','a\c')) #r表明告訴解釋器使用rawstring，即原生字符串，把咱們正則內的全部符號都當普通字符處理，不要轉義
print(re.findall('a\\\\c','a\c')) #同上面的意思同樣，和上面的結果同樣都是['a\\c']

#():分組
print(re.findall('ab+','ababab123')) #['ab', 'ab', 'ab']
print(re.findall('(ab)+123','ababab123')) #['ab']，匹配到末尾的ab123中的ab
print(re.findall('(?:ab)+123','ababab123')) #findall的結果不是匹配的所有內容，而是組內的內容,?:可讓結果爲匹配的所有內容
print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">點擊</a>'))#['http://www.baidu.com']
print(re.findall('href="(?:.*?)"','<a href="http://www.baidu.com">點擊</a>'))#['href="http://www.baidu.com"']
# 給分組加上名字，能夠用名字來取組值
s = re.search('(?P<w>\w+)\.(?P<fuck>\w+)\.(?P<com>\w+)', 'www.buleone.com')
print(s.group('fuck'))
#|
print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))

re模塊提供的方法介紹

import re
#1
print(re.findall('e','alex make love') )   #['e', 'e', 'e'],返回全部知足匹配條件的結果,放在列表裏
#2
print(re.search('e','alex make love').group()) #e,只到找到第一個匹配而後返回一個包含匹配信息的對象,該對象能夠經過調用group()方法獲得匹配的字符串,若是字符串沒有匹配，則返回None。

#3
print(re.match('e','alex make love'))    #None,同search,不過在字符串開始處進行匹配,徹底能夠用search+^代替match

#4
print(re.split('[ab]','abcd'))     #['', '', 'cd']，先按'a'分割獲得''和'bcd',再對''和'bcd'分別按'b'分割

#5
print('===>',re.sub('a','A','alex make love')) #===> Alex mAke love，不指定n，默認替換全部
print('===>',re.sub('a','A','alex make love',1)) #===> Alex make love
print('===>',re.sub('a','A','alex make love',2)) #===> Alex mAke love
print('===>',re.sub('^(\w+)(.*?\s)(\w+)(.*?\s)(\w+)(.*?)$',r'\5\2\3\4\1','alex make love')) #===> love make alex

print('===>',re.subn('a','A','alex make love')) #===> ('Alex mAke love', 2),結果帶有總共替換的個數


#6
obj=re.compile('\d{2}')

print(obj.search('abc123eeee').group()) #12
print(obj.findall('abc123eeee')) #['12'],重用了obj