人生苦短之我用Python篇（深淺拷貝、經常使用模塊、內置函數）

深淺拷貝

有時候，尤爲是當你在處理可變對象時，你可能想要複製一個對象，而後對其作出一些改變而不但願影響原來的對象。這就是Python的copy所發揮做用的地方。

• 　　定義了當對你的類的實例調用copy.copy()時所產生的行爲。copy.copy()返回了你的對象的一個淺拷貝——這意味着，當實例自己是一個新實例時，它的全部數據都被引用了——例如，當一個對象自己被複制了，它的數據仍然是被引用的（所以，對於淺拷貝中數據的更改仍然可能致使數據在原始對象的中的改變）。
  • 　　定義了當對你的類的實例調用copy.deepcopy()時所產生的行爲。copy.deepcopy()返回了你的對象的一個深拷貝——對象和其數據都被拷貝了。memodict是對以前被拷貝的對象的一個緩存——這優化了拷貝過程而且阻止了對遞歸數據結構拷貝時的無限遞歸。當你想要進行對一個單獨的屬性進行深拷貝時，調用copy.deepcopy()，並以memodict爲第一個參數。

 

思路一：利用切片操做和工廠方法list方法拷貝就叫淺拷貝，只是拷貝了最外圍的對象自己，內部的元素都只是拷貝了一個引用而已。

思路二：利用copy中的deepcopy方法進行拷貝就叫作深拷貝，外圍和內部元素都進行了拷貝對象自己，而不是引用。

可是對於數字，字符串和其餘原子類型對象等，沒有被拷貝的說法，即使是用深拷貝，查看id的話也是同樣的，若是對其從新賦值，也只是新建立一個對象，替換掉舊的而已。

---

 經常使用模塊

getpass模塊

pwd = getpass.getpass("請輸入密碼：")  #輸入密碼不可見

yh = getpass.getuser()                #顯示當前登陸系統用戶名;

getpass.getpass([prompt[, stream]]) 
提示用戶輸入一段密碼，參數 prompt 用於提示用戶開始輸入，默認爲'Password: '。在 Unix 上，該提示符被寫入到類文件對象流中。
參數 stream 默認爲控制終端 (/dev/tty) 或入過前者不可用時爲 sys.stderr (該參數在 Windows 上無效)。
若是無回顯輸入不可用，getpass() 回退並向流 stream 中輸出一個警告消息，
從 sys.stdin 中讀取並拋出異常 GetPassWarning。
適用於： Macintosh, Unix, Windows.

*注：若是你在 IDLE 中調用getpass()，輸入可能會在你啓動 IDLE 的終端中而不是在 IDLE 窗口中完成
 

1 >>> import getpass
2 >>> p=getpass.getpass('input your password')
3 input your password
4 >>> print(p)
5 aaa

 

 exception getpass.GetPassWarning 
　　Python內置異常 UserWarning 的子類，當密碼輸入可能被回顯時拋出。

 getpass.getuser() 
　　返回用戶的登陸名，適用於：Unix, Windows

該函數依次檢測環境變量 LOGNAME、USER、LNAME 和 USERNAME，返回其中第一個非空的值。
若是這些變量都沒有被設置，支持 pwd 模塊的系統會返回密碼數據庫中的登陸名，不然拋出異常。

 

注，此模塊在pycharm中沒法使用。

 

os模塊，

* os，os模塊對通用的操做系統服務提供了可移植的（portable）的接口。os能夠認爲是nt和posix的抽象。nt提供windows的服務接口，posix提供UNIX（Linux，mac）的服務接口。

* os.path，os.path模塊以可移植的方式來處理路徑相關的操做。

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    輸出用於分割文件路徑的字符串
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所指向的文件或者目錄的最後修改時間

 

sys 模塊，sys模塊包含了跟python解析器和環境相關的變量和函數。

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

 

subprocess 模塊：*  執行系統命令，subprocess模塊包含了函數和對象來統一建立新進程，控制新進程的輸入輸出流，處理進程的返回。

import subprocess

subprocess.call("ping", shell=True) #執行命令，返回狀態碼
subprocess.check_call("ipconfig", shell=True)#執行命令，若是執行狀態碼是 0 ，則返回0，不然拋異常
subprocess.check_output("ipconfig", shell=True)#執行命令，若是狀態碼是 0 ，則返回執行結果，不然拋異常
subprocess.Popen("mkdir t2", shell=True)

 

shutil\shelve\itertools 模塊

shutil.make_archive(base_name, format,...)

建立壓縮包並返回文件路徑，例如：zip、tar

base_name： 壓縮包的文件名，也能夠是壓縮包的路徑。只是文件名時，則保存至當前目錄，不然保存至指定路徑，

如：www                        =>保存至當前路徑

如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/

format： 壓縮包種類，「zip」, 「tar」, 「bztar」，「gztar」

root_dir： 要壓縮的文件夾路徑（默認當前目錄）

owner： 用戶，默認當前用戶

group： 組，默認當前組

logger： 用於記錄日誌，一般是logging.Logger對象

 

#將 /Users/wupeiqi/Downloads/test 下的文件打包放置當前程序目錄

 

import shutil

ret = shutil.make_archive("wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test')

 

 

#將 /mnt下的文件打包放置 /tmp目錄

import shutil

ret = shutil.make_archive("/tmp/www", 'gztar', root_dir='/mnt')  #2.6用不了，2.7或許能夠

相似於高級API，並且主要強大之處在於其對文件的複製與刪除操做更是比較支持好。

相關API介紹

copyfile(src, dst)

從源src複製到dst中去。固然前提是目標地址是具有可寫權限。拋出的異常信息爲

IOException. 若是當前的dst已存在的話就會被覆蓋掉。

 copyfile( src, dst)    從源src複製到dst中去。固然前提是目標地址是具有可寫權限。拋出的異常信息爲IOException. 若是當前的dst已存在的話就會被覆蓋掉

 copymode( src, dst)    只是會複製其權限其餘的東西是不會被複制的

 copystat( src, dst)    複製權限、最後訪問時間、最後修改時間

 copy( src, dst)       複製一個文件到一個文件或一個目錄

 copy2( src, dst)     在copy上的基礎上再複製文件最後訪問時間與修改時間也複製過來了，相似於cp –p的東西

 copy2( src, dst)     若是兩個位置的文件系統是同樣的話至關因而rename操做，只是更名；若是是不在相同的文件系統的話就是作move操做

 copytree(olddir,newdir,True/Flase)    把olddir拷貝一份newdir，若是第3個參數是True，則複製目錄時將保持文件夾下的符號鏈接，若是第3個參數是False，則將在複製的目錄下生成物理副原本替代符號鏈接

 shutil.rmtree("te")      刪除一個目錄

import shutil

shutil.copyfile('f:/temp.txt', 'f:/os.txt') #複製文件

shutil.copytree('f:/temp', 'f:/os')  #複製目錄

# ######## zip的用法 ########

shutil 對壓縮包的處理是調用 ZipFile 和 TarFile 兩個模塊來進行的，詳細：

import zipfile

# 壓縮

z = zipfile.ZipFile('laxi.zip', 'w')

z.write('a.log')        #壓縮包寫入a.log

z.write('data.data')    #寫入data文件

z.close()

# 解壓

z = zipfile.ZipFile('laxi.zip', 'r')

z.extractall()

z.close()

View Code

 

 

 

 

hashlib 模塊:用於加密相關的操做，代替了md5模塊和sha模塊，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

import hashlib
m = hashlib.md5()
m.update(b"Nobody inspects the spammish repetition") #參數必須是byte類型，不然報Unicode-objects must be encoded before hashing錯誤
md5value=m.hexdigest()
print(md5value)  #bb649c83dd1ea5c9d9dec9a18df0ffe9 

##############################################

import hashlib
data = '我是'
m = hashlib.md5(data.encode(encoding='gb2312'))
print(m.hexdigest())  

##############################################


import hmac
h = hmac.new(b'ccccccc')   #自定義key
h.update(b'hellowo')       #對內容加密   
print( h.hexdigest())                

 

logging日誌模塊， logging模塊靈活方便地對應用程序記錄events，errors，warnings，和debuging 信息。這些log信息能夠被收集，過濾，寫到文件或系統log，甚至經過網絡發送到遠程的機器上。

不少程序都有記錄日誌的需求，而且日誌中包含的信息即有正常的程序訪問日誌，還可能有錯誤、警告等信息輸出，python的logging模塊提供了標準的日誌接口，你能夠經過它存儲各類格式的日誌，logging的日誌能夠分爲 debug(), info(), warning(), error() and critical() 5個級別，下面咱們看一下怎麼用。

import logging
 
logging.warning("user [admin] attempted wrong password more than 3 times")
logging.critical("server is down")
 
#輸出
WARNING:root:user [admin] attempted wrong password more than 3 times
CRITICAL:root:server is down

看一下這幾個日誌級別分別表明什麼意思

Level	When it’s used
DEBUG	Detailed information, typically of interest only when diagnosing problems.
INFO	Confirmation that things are working as expected.
WARNING	An indication that something unexpected happened, or indicative of some problem in the near future (e.g. ‘disk space low’). The software is still working as expected.
ERROR	Due to a more serious problem, the software has not been able to perform some function.
CRITICAL	A serious error, indicating that the program itself may be unable to continue running.

把日誌寫到文件裏

import logging

logging.basicConfig(filename='example.log', level=logging.INFO,format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')     #level=loggin.INFO意思是，把日誌紀錄級別設置爲INFO，也就是說，只有比日誌是INFO或比INFO級別更高的日誌纔會被紀錄到文件裏，
logging.debug('This message should go to the log file')   #在這個例子， 第一條日誌是不會被紀錄的，若是但願紀錄debug的日誌，那把日誌級別改爲DEBUG就好了。
logging.info('So should this')  
logging.warning('And this, too')

日誌格式

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

Python 使用logging模塊記錄日誌涉及四個主要類，使用官方文檔中的歸納最爲合適：

logger提供了應用程序能夠直接使用的接口；

handler將(logger建立的)日誌記錄發送到合適的目的輸出；

filter提供了細度設備來決定輸出哪條日誌記錄；

formatter決定日誌記錄的最終輸出格式。

logger
每一個程序在輸出信息以前都要得到一個Logger。Logger一般對應了程序的模塊名，好比聊天工具的圖形界面模塊能夠這樣得到它的Logger：
LOG=logging.getLogger(」chat.gui」)
而核心模塊能夠這樣：
LOG=logging.getLogger(」chat.kernel」)

Logger.setLevel(lel):指定最低的日誌級別，低於lel的級別將被忽略。debug是最低的內置級別，critical爲最高
Logger.addFilter(filt)、Logger.removeFilter(filt):添加或刪除指定的filter
Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)：增長或刪除指定的handler
Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()：能夠設置的日誌級別

 

handler

handler對象負責發送相關的信息到指定目的地。Python的日誌系統有多種Handler可使用。有些Handler能夠把信息輸出到控制檯，有些Logger能夠把信息輸出到文件，還有些 Handler能夠把信息發送到網絡上。若是以爲不夠用，還能夠編寫本身的Handler。能夠經過addHandler()方法添加多個多handler
Handler.setLevel(lel):指定被處理的信息級別，低於lel級別的信息將被忽略
Handler.setFormatter()：給這個handler選擇一個格式
Handler.addFilter(filt)、Handler.removeFilter(filt)：新增或刪除一個filter對象


每一個Logger能夠附加多個Handler。接下來咱們就來介紹一些經常使用的Handler：
1) logging.StreamHandler
使用這個Handler能夠向相似與sys.stdout或者sys.stderr的任何文件對象(file object)輸出信息。它的構造函數是：
StreamHandler([strm])
其中strm參數是一個文件對象。默認是sys.stderr


2) logging.FileHandler
和StreamHandler相似，用於向一個文件輸出日誌信息。不過FileHandler會幫你打開這個文件。它的構造函數是：
FileHandler(filename[,mode])
filename是文件名，必須指定一個文件名。
mode是文件的打開方式。參見Python內置函數open()的用法。默認是’a'，即添加到文件末尾。

3) logging.handlers.RotatingFileHandler
這個Handler相似於上面的FileHandler，可是它能夠管理文件大小。當文件達到必定大小以後，它會自動將當前日誌文件更名，而後建立 一個新的同名日誌文件繼續輸出。好比日誌文件是chat.log。當chat.log達到指定的大小以後，RotatingFileHandler自動把 文件更名爲chat.log.1。不過，若是chat.log.1已經存在，會先把chat.log.1重命名爲chat.log.2。。。最後從新建立 chat.log，繼續輸出日誌信息。它的構造函數是：
RotatingFileHandler( filename[, mode[, maxBytes[, backupCount]]])
其中filename和mode兩個參數和FileHandler同樣。
maxBytes用於指定日誌文件的最大文件大小。若是maxBytes爲0，意味着日誌文件能夠無限大，這時上面描述的重命名過程就不會發生。
backupCount用於指定保留的備份文件的個數。好比，若是指定爲2，當上面描述的重命名過程發生時，原有的chat.log.2並不會被改名，而是被刪除。


4) logging.handlers.TimedRotatingFileHandler
這個Handler和RotatingFileHandler相似，不過，它沒有經過判斷文件大小來決定什麼時候從新建立日誌文件，而是間隔必定時間就 自動建立新的日誌文件。重命名的過程與RotatingFileHandler相似，不過新的文件不是附加數字，而是當前時間。它的構造函數是：
TimedRotatingFileHandler( filename [,when [,interval [,backupCount]]])
其中filename參數和backupCount參數和RotatingFileHandler具備相同的意義。
interval是時間間隔。
when參數是一個字符串。表示時間間隔的單位，不區分大小寫。它有如下取值：
S 秒
M 分
H 小時
D 天
W 每星期（interval==0時表明星期一）
midnight 天天凌晨

View Code

import logging
 
#create logger
logger = logging.getLogger('TEST-LOG')
logger.setLevel(logging.DEBUG)
 
 
# create console handler and set level to debug
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
 
# create file handler and set level to warning
fh = logging.FileHandler("access.log")
fh.setLevel(logging.WARNING)
# create formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 
# add formatter to ch and fh
ch.setFormatter(formatter)
fh.setFormatter(formatter)
 
# add ch and fh to logger
logger.addHandler(ch)
logger.addHandler(fh)
 
# 'application' code
logger.debug('debug message')
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')

代碼

import logging

from logging import handlers

logger = logging.getLogger(__name__)

log_file = "timelog.log"
#fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=3)
fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3)


formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s')

fh.setFormatter(formatter)

logger.addHandler(fh)


logger.warning("test1")
logger.warning("test12")
logger.warning("test13")
logger.warning("test14")

文件自動截斷例子

 

time\datetime\traceback模塊

三種表示主式：

一、時間戳 1970年1月1往後的秒

二、元組包含了：年、日、星期等...time.struct_time

三、格式化的字符串 2014-11-11 11:11 print time.time()

 * time，time模塊提供了各類時間相關的函數。經常使用的time.sleep().

import time
# 時間戳形式存在
print (time.time())
print(time.mktime(time.localtime()))  #print (time.localtime())

# 元組形式存在
print (time.gmtime()) #可加時間戳參數
print (time.localtime()) #可加時間戳參數
print (time.strptime('2014-11-11','%Y-%m-%d')) #字符串形式轉換成元組形式

# 字符串形式存在
print (time.strftime('%Y-%m-%d'))  #默認當前時間，必須記住，工做中用得最多
print (time.strftime('%Y-%m-%d',time.localtime()))  #默認當前時間
print (time.asctime())
print (time.asctime(time.localtime()))
print (time.ctime(time.time()))

# 時間的三種表示方式演示
import time
print (time.time())  #秒，時間戳的方式,1488459426.7593124
print (time.gmtime())#元組方式，time.struct_time(tm_year=2017, tm_mon=3, tm_mday=2, tm_hour=12, tm_min=57, tm_sec=6, tm_wday=3, tm_yday=61, tm_isdst=0)
print (time.strftime('%Y-%m-%d %H:%M:%S'))#字符串方式，2017-03-02 20:57:06

 

datetime類定義的類屬性與方法：

• datetime.min、datetime.max：datetime所能表示的最小值與最大值；
  
• datetime.resolution：datetime最小單位；
  
• datetime.today()：返回一個表示當前本地時間的datetime對象；
  
• datetime.now([tz])：返回一個表示當前本地時間的datetime對象，若是提供了參數tz，則獲取tz參數所指時區的本地時間；
  
• datetime.utcnow()：返回一個當前utc時間的datetime對象；
  
• datetime.fromtimestamp(timestamp[, tz])：根據時間戮建立一個datetime對象，參數tz指定時區信息；
  
• datetime.utcfromtimestamp(timestamp)：根據時間戮建立一個datetime對象；
  
• datetime.combine(date, time)：根據date和time，建立一個datetime對象；
  
• datetime.strptime(date_string, format)：將格式字符串轉換爲datetime對象；

 

from datetime import *
import time

print('datetime.max:', datetime.max)
print('datetime.min:', datetime.min)
print('datetime.resolution:', datetime.resolution)
print('today():', datetime.today())
print('now():', datetime.now())
print('utcnow():', datetime.utcnow())
print('fromtimestamp(tmstmp):', datetime.fromtimestamp(time.time()))
print('utcfromtimestamp(tmstmp):', datetime.utcfromtimestamp(time.time()) )

輸出結果：
datetime.max: 9999-12-31 23:59:59.999999
datetime.min: 0001-01-01 00:00:00
datetime.resolution: 0:00:00.000001
today(): 2017-03-02 21:22:09.304740
now(): 2017-03-02 21:22:09.304739
utcnow(): 2017-03-02 13:22:09.304739
fromtimestamp(tmstmp): 2017-03-02 21:22:09.304740
utcfromtimestamp(tmstmp): 2017-03-02 13:22:09.304740

 

 

json\pickle\模塊

• json，用於字符串 和 python數據類型間進行轉換
• pickle，用於python特有的類型 和 python的數據類型間進行轉換

json:
    dumps:　　將對象序列化
    dump:　　將對象序列化並保存到文件
    loads:　　將序列化字符串反序列化
    load:　　將序列化字符串從文件讀取並反序列化

pickle:基本上和json同樣，pickle： pickle模塊被用來序列化python的對象到bytes流，從而適合存儲到文件，網絡傳輸，或數據庫存儲。
（pickle的過程也被稱serializing,marshalling或者flattening，pickle同時能夠用來將bytes流反序列化爲python的對象）。

那pickle和json有什麼區別呢？
在上面兩段代碼中，pickle寫入和讀取文件時，用的是 ‘b’模式，而json沒有。
json是能夠在不一樣語言之間交換數據的，而pickle只在python之間使用。
json只能序列化最基本的數據類型，而pickle能夠序列化全部的數據類型，包括類，函數均可以序列化。

import json
data = {'k1':123, 'k2':123}
j_dumps = json.dumps(data)
print(j_dumps,type(j_dumps))
j_loads = json.loads(j_dumps)
print(j_loads,type(j_loads))

#打開文件，而後將data寫入
with open('data.txt', 'w') as f:
    json.dump(data, f)
#一樣讀取的時候也須要打開文件
with open('data.txt', 'r') as f:
    data_1 = json.load(f)
print(type(data_1) )


#######################################

import pickle
data = {'k1':123, 'k2':123}
p_dumps = pickle.dumps(data)
print(p_dumps,type(p_dumps))
p_loads = pickle.loads(p_dumps)
print(p_loads,type(p_loads))

#打開文件，而後將data寫入
with open('data.txt', 'wb') as f:
    pickle.dump(data, f)
#一樣讀取的時候也須要打開文件
with open('data.txt', 'rb') as f:
    data_1 = pickle.load(f)
print(type(data_1) )

 

re 正則模塊

'.'     默認匹配除\n以外的任意一個字符，若指定flag DOTALL,則匹配任意字符，包括換行
'^'     匹配字符開頭，若指定flags MULTILINE,這種也能夠匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
'$'     匹配字符結尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也能夠
'*'     匹配*號前的字符0次或屢次，re.findall("ab*","cabb3abcbbac")  結果爲['abb', 'ab', 'a']
'+'     匹配前一個字符1次或屢次，re.findall("ab+","ab+cd+abb+bba") 結果['ab', 'abb']
'?'     匹配前一個字符1次或0次
'{m}'   匹配前一個字符m次
'{n,m}' 匹配前一個字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 結果'abb', 'ab', 'abb']
'|'     匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 結果'ABC'
'(...)' 分組匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 結果 abcabca456c
 
 
'\A'    只從字符開頭匹配，re.search("\Aabc","alexabc") 是匹配不到的
'\Z'    匹配字符結尾，同$
'\d'    匹配數字0-9
'\D'    匹配非數字
'\w'    匹配[A-Za-z0-9]
'\W'    匹配非[A-Za-z0-9]
's'     匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 結果 '\t'
 
'(?P<name>...)' 分組匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 結果{'province': '3714', 'city': '81', 'birthday': '1993'}

 最經常使用的匹配語法

re.match 　　  從頭開始匹配

re.search 　　　匹配包含

re.findall   把全部匹配到的字符放到以列表中的元素返回

re.splitall 　　以匹配到的字符當作列表分隔符

re.sub     匹配字符並替換

 反斜槓的困擾
與大多數編程語言相同，正則表達式裏使用"\"做爲轉義字符，這就可能形成反斜槓困擾。假如你須要匹配文本中的字符"\"，那麼使用編程語言表示的正則表達式裏將須要4個反斜槓"\\\\"：前兩個和後兩個分別用於在編程語言裏轉義成反斜槓，轉換成兩個反斜槓後再在正則表達式裏轉義成一個反斜槓。Python裏的原生字符串很好地解決了這個問題，這個例子中的正則表達式可使用r"\\"表示。一樣，匹配一個數字的"\\d"能夠寫成r"\d"。有了原生字符串，你不再用擔憂是否是漏寫了反斜槓，寫出來的表達式也更直觀。

僅需輕輕知道的幾個匹配模式
re.I(re.IGNORECASE): 忽略大小寫（括號內是完整寫法，下同）
M(MULTILINE): 多行模式，改變'^'和'$'的行爲（參見上圖）
S(DOTALL): 點任意匹配模式，改變'.'的行爲

 

 

 

---

---

 

內置函數

 

 

enumerate：遍歷，返回序號和值

seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
    print(i,seq[i])
    print(i,element)

filter和map函數：

def f1(a):
    if a>22:
        return True

def f2(a):
    if a>22:
        return a+100

li = [11,22,33,44,55,66,77]
ret = filter(f1,li) #fliter(函數，可迭代的對象)
print(list(ret))
print(ret)

result = map(f2,li) #fliter(函數，可迭代的對象)
print(list(result))
print(result)

輸出結果：
[33, 44, 55, 66, 77]
<filter object at 0x000001BE9C03B198>
[None, None, 133, 144, 155, 166, 177]
<map object at 0x000001BE9C03B278>

#fliter() 將li中的每一個值執行函數，將函數返回值爲TRUE的添加到列表中 #map() 將li中的每一個值執行函數，將函數返回值爲TRUE的添加到列表中,返回值爲FLASE的用NONE代替

關於計算的:

# abs()　　#求絕對值
abs(11)
# pow()　　#求X方，即冪的次數
pow(3,6)
# round()　　#返回浮點數x的四捨五入值,能夠指定返回的小數點位數
round(1.5)
# divmod()　　#求商和餘數(地板除)
divmod(5,3)

類型轉換：

# int()
print(int(123.1))
# complex()
print(complex(12))
# float()
print(float(55.22))
# bool()
print(bool(0))

輸出結果：
123
(12+0j)
55.22
False

進制轉換:

bin()#將十進制的數轉換成二進制的數

oct()#將十進制的數轉換成八進制的數

hex()#將十進制的數轉換成十六進制的數


例子：
print(hex(10))
print(oct(10))
print(bin(255))
輸出結果：
0xa
0o12
0b11111111

ASCII轉換:

ord()#將ascii碼轉成整數

chr()#將整數轉成ascii碼

print(ord('A'))
print(chr(65))
輸出結果：
65
A

數學函數:

import math

math.sin()

math.tan()

math.cos()

隨機數函數：

import random
random.uniform(1,10)#返回1-10間的一個浮點數
random.choice([1,2,3,4,5,6,7,8,9])#返回其中一個數
random.randint(50,60)#　#返回一個整數
random.randrange(10,100,2)#從指定範圍內，按指定基數遞增的集合中 獲取一個隨機數。

判斷函數:

******

格式函數：

#只有字符串纔有這個屬性，int沒有
s_num = 'aba'
a = s_num.center(10,'*')#AttributeError: 'int' object has no attribute 'center'
b = s_num.ljust(10,'*')#AttributeError: 'int' object has no attribute 'ljust'
print(a,b)

format()　　#這個方法會把字符串看成一個模版，經過傳入的參數進行格式化。這個用來格式化的模版使用大括號({,})做爲特殊字符

搜素函數:

num = '123as113f1a6f5a32f1sa5f1as3f51as23s1a5613b1351u35131f3a'
# count()
print(num.count('a'))
# find()
print(num.find('3'))
# index()
print(num.index('u'))
# rfind()
print(num.rfind('a'))

輸出結果：
8
2
46
54

替換函數:

基本用法：對象.replace(rgExp,replaceText,max)
其中，rgExp和replaceText是必需要有的，max是可選的參數，能夠不加。
rgExp是指正則表達式模式或可用標誌的正則表達式對象，也能夠是 String 對象或文字；replaceText是一個String 對象或字符串文字；max是一個數字。
對於一個對象，在對象的每一個rgExp都替換成replaceText，從左到右最多max次。
num = '123as113f1a6f5a32f1sa5f1as3f51as23s1a5613b1351u35131f3a'
new_num = num.replace('1','*',3)
print(num)
print(new_num)

輸出結果：
123as113f1a6f5a32f1sa5f1as3f51as23s1a5613b1351u35131f3a
*23as**3f1a6f5a32f1sa5f1as3f51as23s1a5613b1351u35131f3a
======================================================================================
str.expandtabs(tabsize=8)
參數:tabsize — 指定轉換字符串中的 tab 符號(‘\t’)轉爲空格的字符數。
返回值:該方法返回字符串中的 tab 符號(‘\t’)轉爲空格後生成的新字符串。
實例
如下實例展現了expandtabs()方法的實例：
#!/usr/bin/python3

str = "this is\tstring example....wow!!!"

print ("原始字符串: " + str)
print ("替換 \\t 符號: " +  str.expandtabs())
print ("使用16個空格替換 \\t 符號: " +  str.expandtabs(16))

輸出結果：
原始字符串: this is    string example....wow!!!
替換 \t 符號: this is string example....wow!!!
使用16個空格替換 \t 符號: this is         string example....wow!!!

拆分函數:

str = 'abc.' \
      '123.def.456.ghi.789.jkl'
# partition('.')
#根據指定的分隔符將字符串進行分割。若是字符串包含指定的分隔符，
#則返回一個3元的元組，第一個爲分隔符左邊的子串，第二個爲分隔符自己，第三個爲分隔符右邊的子串
print(str.partition('.'))#輸出結果：('abc', '.', '123.def.456.ghi.789.jkl')
# split('.')#經過指定分隔符對字符串進行切片，若是參數num 有指定值，則僅分隔 num 個子字符串
print(str.split('.'))#輸出結果：['abc', '123', 'def', '456', 'ghi', '789', 'jkl']
# splitlines()#照行('\r', '\r\n', \n')分隔，返回一個包含各行做爲元素的列表，若是參數 keepends 爲 False，不包含換行符，若是爲 True，則保留換行符。
print(str.splitlines())#輸出結果：['abc.123.def.456.ghi.789.jkl']
#

# 剝離函數
# strip()#用於移除字符串頭尾指定的字符（默認爲空格）
# lstrip()#用於截掉字符串左邊的空格或指定字符
# rstrip()##用於截掉字符串右邊的空格或指定字符
#
str = '*      abc.123.456.dff ' \
      'safafsfa156165.saa,14           *'
print(str)
print(str.strip('*'))
print(str.lstrip('*'))
print(str.rstrip('*'))

輸出結果：
*      abc.123.456.dff safafsfa156165.saa,14           *
      abc.123.456.dff safafsfa156165.saa,14           
      abc.123.456.dff safafsfa156165.saa,14           *
*      abc.123.456.dff safafsfa156165.saa,14           

len()  #3.5中按字符計算，2.7中按字節計算json()　　#變量裏面的字符必須使用雙引號