python常用標準庫

純潔的程式碼發表於2020-02-06
Python
-------------------系統內建函式-------------------

1、字串

str='這是一個字串資料測試資料'對應

str[0]：獲取str字串中下標為0的字元。

str[3]：獲取str字串中下標為3的字元。

str[0:3]：獲取到字串中從下標為0到下標為3的字串。


str.find()：返回指定str字串中是否存在指定的字串資料資訊；如果存在則返回字串首字母的下標，如果不存在則返回-1。

str.index()：返回指定str字串中是否存在指定的字串資料資訊；如果存在則返回字串首字母的下標，如果不存在進行錯誤異常處理。

str.count()：返回指定str字串中被查詢字串存在的個數資訊。

len(str)：返回指定str字串的字元總長度；如果字串為空，則返回值為0。

str.replace('替換前字元','替換後字元'，指定替換的次數)：進行指定str字串中指定字元資料的替換操作，並將替換後的資料進行返回。

str.split(" ",切割次數):進行指定字串的切割，返回被切割後的字串列表資料資訊；如果切割次數不填，預設進行最大的切割次數。

str.capitalize()：將指定str字串的第一個字元進行大寫。

str.startswith(匹配字串資料)：返回boolen型別，匹配指定str字串是否以指定字串資料開頭。

str.endswith(匹配字串資料)：返回boolen型別，匹配指定str字串是否以指定字串資料結尾。

str.lower()：將指定的字串資料資訊進行統一的小寫轉換並返回轉換後的資料。

str.upper()：將指定的字串資料資訊進行統一的大寫轉換並返回轉換後的資料。

str.ljust(指定返回的字串長度)：返回一個字串，將指定str進行左對齊，如果str字串長度小於指定的長度，則進行右側的空格補充操作。

str.rjust(指定返回的字串長度)：返回一個字串，將指定str進行右對齊，如果str字串長度小於指定的長度，則進行左側的空格補充操作。

str.center(制定返回的字串長度)：返回一個字串，將制定str進行中間對齊，如果str字串長度小於指定的長度，則進行兩邊的空格的補充操作。

str.lstrip()：返回字串，刪除左側的空格。

str.rstrip()：返回字串，刪除末尾的空格。

str.rfind()：類似find函式，從指定字串的右側開始進行查詢，返回查詢到的字串第一個字元的下標。

str.rindex()：類似index函式，從指定str字串的左側開始進行查詢，返回查詢到的字串第一個字串下標。

str.partition(指定分割的字串)：從指定str字串中，查詢制定分割的字串，返回一個列表包含它的前面部分，它自身和它的後面部分；如果字串的匹配沒有成功，則返回它自身和前後兩個空字元。

str.rpartition(指定分割的字串)：類似partition函式，只是指定的分割字串是從右開始查詢的。

str.splitlines()：進行行分割，返回一個列表，以每行資料作為一個元素進行儲存。

str.isdigit()：返回boolen型別，判斷指定str字串中的資料是否為字母或數字。

str.isalpha()：返回boolen型別，判斷指定str字串中的資料是否為純字母。

str.isalnum()：返回boolen型別，判斷指定str字串中的資料是否為純數字。

str.isspace()：返回boolen型別，判斷指定str字串中的資料是否只包含空格。

str.isupper()：返回boolen型別，判斷指定str字串中的資料是否為純大寫。

str.islower()：返回boolen型別，判斷指定str字串中的資料是否為純小寫。

mystr.join(str)：將類表mystr中的資料，根據指定的str字串進行拼接操作；返回拼接後的字串資料資訊。

print("%0.1f",float(result*1.0))：進行浮點數的轉換，並列印小數點後一位的資料

print("%d*%d=%d"%(j,i,i*j),end=' ')：結束最後的換行


2、檔案流

檔案流對應的基礎操作：

f=open('檔名','訪問模式')；if f：返回boolen型別，判斷檔案是否開啟。

w：開啟一個檔案只用於寫入；如果該檔案已經存在則將其覆蓋；如果該檔案不存在，則建立一個新的檔案。

r：以只讀的方式開啟檔案；檔案的指標將會放在檔案的開頭；這個是預設模式。

a：開啟一個檔案用於追加；如果該檔案已存在，檔案指標將會放在檔案的結尾；也就是說，新的內容將會被寫入到已有內容之後。如果該檔案不存在，建立新檔案進行寫入。


rb：以二進位制格式開啟一個檔案用於只讀，檔案指標將會放在檔案的開頭。這是預設模式。

wb：以二進位制格式開啟一個檔案用於寫入，如果該檔案已存在則將其進行覆蓋。如果該檔案不存在則建立新檔案。

ab：以二進位制格式開啟一個檔案用於追加。如果該檔案已存在，檔案指標將會放在檔案的結尾。也就是說，新的內容將會被寫入到已有內容之後；如果該檔案不存在，建立新檔案進行寫入操作。


r+：開啟一個檔案用於讀寫；檔案指標將會放在檔案的開頭。

w+：開啟一個檔案用於讀寫；如果噶檔案已存在則將其覆蓋。如果該檔案不存在，建立新檔案

a+：開啟一個檔案用於讀寫；如果該檔案存在，檔案指標將會放在檔案的結尾。檔案開啟時會是追加模式。如果該檔案不存在，建立新檔案用於讀寫。


rb+：以二進位制格式開啟一個檔案用於讀寫；檔案指標將會放在檔案的開頭。

wb+：以二進位制格式開啟一個檔案用於讀寫；如果該檔案已存在則將其覆蓋。如果該檔案不存在，建立新檔案。

ab+：以二進位制格式開啟一個檔案用於追加；如果該檔案已存在，檔案指標將會放在檔案的結尾；如果檔案不存在，建立新檔案用於讀寫。



f.close()：檔案流操作結束後進行關閉。

f.wirte(寫入的內容)：開啟檔案後，將指定內容寫入檔案中。

f.read(讀取資料的長度)：使用read可以從檔案中讀取指定長度的資料，並將指標移到這條資料之後；預設讀取全部資料。

f.readline()：讀取檔案中一行資料的資訊，指標移動的下一行。

f.readlines()：讀取整個檔案的資料資訊資訊，返回一個列表，列表中每個元素為一行資料的資訊。

f.tell()：檢視當前位置，就是指標對應的位置。

seek(offset,from)：將指標定位到某個位置

from：方向

0：表示檔案的開頭。

1：表示檔案的當前位置。

2：表示檔案的末尾。

offset：偏移量

測試

f.seek(5,0)：檔案開頭，向後偏移5個位置

f.seek(-3,2)：檔案結尾，向前偏移3個位置


3、列表、字典、元組操作

1、列表:

strList=['']：列表的建立。

str='字串'

newStr='新的字串'。

strList.append：進行列表資料資訊的新增操作。

strList[0]=newStr：根據下標，進行列表指定元素資料資訊的修改操作

str in strLsit：返回boolen型別，指定字串資訊是否在列表中存在。

for item in strList：進行列表資料的遍歷操作，item為元素值

del strList[0]：根據列表下標，刪除指定的列表元素。

strList.pop()：刪除列表最後一個元素的資料資訊。

strList.remove('元素的值')：根據元素的值進行刪除操作。


2、字典：

修改元素：根據Key值進行修改

新增元素：infor['age']=18

刪除元素：del

清空字典中的資料資訊：infor.clear


3、字典的常見操作

dic={1:'xiaohao',2:'xiaodong'}：建立一個字典物件。

dic.keys()：獲取字典所有對應的鍵，以列表的形式進行返回。

dic.valuses()：獲取字典所有對應的值，以列表的形式進行返回。

dic.items()：獲取字典中的鍵值資料，以列表的形式返回，每個元素都一個元組，分別存放著鍵和值。

dic.has_key(1)：返回boolen型別，判斷鍵值是否存在


4、元組：

tuple=(1,2,3,4,5)：建立一個元組。

tuple[2]：根據下標讀取到第三個元素。

tuple[-2]：根據下標讀取到倒數第二個元素。

tuple[1:]：擷取元組第二個元素到最後。

cmp(tuple1,tuple2)：比較兩個元組中的元素。

max(tuple)：返回元組中元素的最大值。

min(tuple)：返回元組中元素的最小值。

tuple(seq)：將列表轉換為元組。


5、運算子操作列表、字典、元組的技巧：

1、len((1,2,3,4))：獲取到元組中元素的個數。

2、(1,2,3,4) +(1,2,3,4,5) ；進行兩個元組的合併，獲取到一個新的元組。

3、['Hi']*4：建立一個新的列表，並將列表中的資料進行復制四次。

4、1 in (1,2,3,4)：判斷元素是否存在；返回boolen型別。


4、異常捕獲

定義：某些錯誤操作導致程式無法正常執行

異常捕獲：

try：

except(NameError,IOError),result：

print(result)#返回具體的錯誤資訊

else：

print("我是else")

finally:

print("我是finally")


5、range：獲取

1、help(range):

range(stop) -> list of integers

range(start, stop[, step]) -> list of integers

2、引數分析：

1、start:計數從start開始。預設是從0開始。例如range（5）等價於range（0， 5）。

2、stop:到stop結束，但不包括stop.例如：range（0， 5） 是[0, 1, 2, 3, 4]沒有5。

3、step:每次跳躍的間距，預設為1。例如：range（0， 5） 等價於 range(0, 5, 1)。

3、示例：

a = range(5)

list(a)


6、map：函式

1、help(map):

map(...)

map(function, sequence[, sequence, ...]) -> list

2、引數分析：

1、function:是一個函式

2、sequence:是一個或多個序列,取決於function需要幾個引數

3、返回值是一個list

3、語法：

引數序列中的每一個元素分別呼叫function函式，返回包含每次function函式返回值的list。

4、示例

#函式需要一個引數

map(lambda x: x*x, [1, 2, 3])

[1, 4, 9]


#函式需要兩個引數

map(lambda x, y: x+y, [1, 2, 3], [4, 5, 6])

[5, 7, 9]


#函式為None,相當於合併引數為元祖

map(None, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])

[(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]


#兩個序列引數個數不一致時，個數少的補None

map(None, [1, 3, 5, 7, 9], [2, 4, 6])

[(1, 2), (3, 4), (5, 6), (7, None), (9, None)]


7、filter：函式

1、help(filter):

filter(...)

filter(function or None, sequence) -> list, tuple, or string


Return those items of sequence for which function(item) is true. If

function is None, return the items that are true. If sequence is a tuple

or string, return the same type, else return a list.

2、引數分析：

1、function:接受一個引數，返回布林值True或False

2、sequence:序列可以是str，tuple，list

3、語法

filter函式會對序列引數sequence中的每個元素呼叫function函式，最後返回的結果包含呼叫結果為True的元素。返回值的型別和引數sequence的型別相同

4、示例

filter(lambda x: x%2, [1, 2, 3, 4])

[1, 3]


filter(None, "she")

'she'


8、reduce：函式

1、help(reduce):

reduce(...)

reduce(function, sequence[, initial]) -> value


Apply a function of two arguments cumulatively to the items of a sequence,

from left to right, so as to reduce the sequence to a single value.

For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates

((((1+2)+3)+4)+5). If initial is present, it is placed before the items

of the sequence in the calculation, and serves as a default when the

sequence is empty.

2、引數分析：

1、function:該函式有兩個引數

2、sequence:序列可以是str，tuple，list

3、initial:固定初始值


3、語法

reduce依次從sequence中取一個元素，和上一次呼叫function的結果做引數再次呼叫function。 第一次呼叫function時，如果提供initial引數，會以sequence中的第一個元素和initial 作為引數呼叫function，否則會以序列sequence中的前兩個元素做引數呼叫function。 注意function函式不能為None。

4、示例

reduce(lambda x, y: x+y, [1,2,3,4])

10


reduce(lambda x, y: x+y, [1,2,3,4], 5)

15


reduce(lambda x, y: x+y, ['aa', 'bb', 'cc'], 'dd')

'ddaabbcc'


9、sorted：函式

1、help(sorted):

sorted(...)

sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list

2、引數分析：

自定義cmp比較函式，返回三種情況：

x<y 返回-1

x>y 返回1

x==y 返回0

3、示例

def cmp_ignore_case(s1, s2):

u1 = s1.upper()

u2 = s2.upper()

if u1 < u2:

return -1

if u1 > u2:

return 1

return



-------------------系統庫函式，幫助文件查詢-------------------

1、庫函式：print()、raw_input() 系統給的叫庫函式


2、使用者自定義函式：如果系統中，沒有需要的功能，那麼此時就需要自己開發一個，這就是自定義函式


3、ipython下：

dir(包名)：檢視該包下的對應的函式資訊

help(包名)：檢視該包中的分裝的函式資訊

包名.path：可以獲取到指定包對應的檔案路徑



-------------------builtins：內建函式預設載入-------------------



-------------------os：作業系統介面-------------------

import os引用系統的包

os.name()：判斷現在正在使用的平臺，widows返回'nt'；Linux返回'posix'。

os.getcwd()：得到當前工作的目錄。

os.listdir()：指定所有目錄下所有的檔案和目錄名。

os.remove()：刪除指定檔案。

os.rmdir()：刪除指定目錄。

os.mkdir()：建立目錄，只能建立一層。

os.makedirs()：遞迴建立目錄。

os.path.isfile()：判斷制定物件是否為檔案。是返回True，否則False。

os.path.isdir()：判斷指定物件是否為目錄。是True，否則False。

os.path.exists()：檢驗指定的物件是否存在。是True，否則False。

os.path.split()：返回路徑的目錄和檔名。

os.getcwd()：獲得當前工作的目錄。

os.system()：執行shell命令。

os.chdir()：改變目錄到指定目錄。

os.path.getsize()：獲得檔案的大小，如果為目錄，返回0。

os.path.abspath()：獲得絕對路徑。

os.path.join(path,name)：連線目錄和檔名。

os.path.basename(path)：返回檔名。

os.path.dirname(path)：返回檔案路徑。



-------------------sys：Python自身的執行環境-------------------

import sys引用系統的包

sys.stdin

sys.argv：獲取到執行檔案時，對應的引數資訊



-------------------functools：常用的工具-------------------

1、概念：

functools 是python2.5被引人的,一些工具函式放在此包裡。


2、操作：

1、import functools ：引用對應的包

2、dir(functools) ：檢視包中對應的工具函式


1、partial函式（偏函式）：

1、概念：

把一個函式的某些引數設定預設值，返回一個新的函式，呼叫這個新函式會更簡單。

2、示例：

import functools

def showarg(*args, **kw):

print(args)

print(kw)


p1=functools.partial(showarg, 1,2,3)

p1()

p1(4,5,6)

p1(a='python', b='itcast')


p2=functools.partial(showarg, a=3,b='linux')

p2()

p2(1,2)

p2(a='python', b='itcast')


2、wraps函式：

1、概念：

使用裝飾器時，有一些細節需要被注意。例如，被裝飾後的函式其實已經是另外一個函式了（函式名等函式屬性會發生改變）。Python的functools包中提供了一個叫wraps的裝飾器來消除這樣的副作用

2、示例：

import functools

def note(func):

"note function"

@functools.wraps(func)

def wrapper():

"wrapper function"

print('note something')

return func()

return wrapper


@note

def test():

"test function"

print('I am test')


test()

print(test.__doc__)



-------------------json：編碼和解碼 JSON 物件-------------------



-------------------logging：記錄日誌，除錯-------------------



-------------------fork/multiprocessing：多程式-------------------

import os ：


1、pid=os.fork()：程式執行到os.fork()時，作業系統會建立一個新的程式（子程式），然後複製父程式的所有資訊到子程式中；然後父程式和子程式都會從fork()函式中得到一個返回值，其程式中這個值一定是0，而父程式中是子程式的 id號；主：fock()函式只能在Unix/Linux/Mac上執行，windows不可以執行。


import os


# 注意，fork函式，只在Unix/Linux/Mac上執行，windows不可以

pid = os.fork()


if pid == 0:

print('哈哈1')

else:

print('哈哈2')


os.getpid()：獲取到當前程式的PID號

os.getppid()：獲取到父程式的PID號


2、程式建立的第二種方式：

from multiprocessing import Process：引用對應的包。


p=Process(target=run_proc,args=('test',))：呼叫Process類，進行程式物件的建立操作。為引數target賦值程式要實現的方法，為引數args賦值方法中傳入對應的引數。

p.start()：開啟執行對應的程式操作。

p.join()：等待當前程式執行結束，可以等待子程式結束後再繼續向下執行，通常用於程式間的同步。

multiprocessing.cpu_count()：獲取到程式執行的所使用的cpu的核心個數。


pipe=multiprocessing.Pipe()：管道實現程式間的通訊。一個管道有兩個埠，分別為pipe[0]與pipe[1]

pipe[0].send(向管道中新增的資料)：管道的新增操作。

pipe[0].recv()：從管道中取出對應的資料資訊。


3、from multiprocessing import Process,Queue：應用對應的包，為實現程式之間的通訊操作；管道的倆個端一個是負責向裡面寫入資料，一個是負責向外面讀取資料。

q=Queue()：建立一個佇列物件。

q.put(要新增到佇列中的資料資訊)：將制定的資料新增到佇列當中去。

q.get(True)：從佇列中要提取出的佇列資料資訊。

q.empty()：判斷當前佇列是否為空。



-------------------threading：多執行緒-------------------

1、執行緒應用的第一種模式thread模組是比較底層的模組

import thread：引用對應的模組包。


thread.start_new_thread(defName,())建立開啟一個新的執行緒；第一個引數為新執行緒要執行的方法，第二個引數為元組傳遞執行方法對應需要引數；注：python元組為一個時需要(元素,)一個元素加一個'，'進行表示。

thread.exit_thread()：主執行緒呼叫該方法表示所有的執行緒結束操作；子執行緒通過呼叫exit.thread()的方法來表示實現當前子執行緒的結束操作。

thread.join()： python的Thread類中還提供了join()方法，使得一個執行緒可以等待另一個執行緒執行結束後再繼續執行。這個方法還可以設定一個timeout引數，避免無休止的等待。因為兩個執行緒順序完成，看起來象一個執行緒，所以稱為執行緒的合併

thread.setDaemon(True)：預設情況主執行緒退出時會等待子執行緒的結束，如果希望主執行緒不等待子執行緒，可以設定子執行緒為後臺執行緒，主執行緒退出，子執行緒隨即結束。



2、執行緒應用的第二種模式threading模組是對thread模組進行了一定的封裝，可以更方便我們的使用。

import threading：引用對應的模組包。

myThread=threading.Thread(target=defName,args=('Alice',))建立一個執行緒，target賦值要執行執行緒的方法，args複製執行方法需要的引數資訊。

myThread.start()：執行緒開始執行。

num=len(threading.enumerate)：檢視當前執行的執行緒的數量。


3、執行緒的應用的第三種方式建立一個執行緒類，繼承基類threading.Thead；重寫基類的def run(self):方法，將該執行緒要執行的程式寫在該方法中。

class MyThread(threading.Thread)：建立一個執行緒類

進行基類建構函式的建立操作

def __init__(self,name,time):

threading.Thread.__init__(self,name='可以為執行緒的名字進行復制')


myThread=MyThread()：執行緒物件的建立。

myThread.start()：該執行緒執行。


4、threading模組中定義了Lock()類，可以方便的處理鎖定。

mutex=threading.Lock()：互斥鎖物件的建立。

if mutex.acquire([blocking])：進行鎖定，鎖定成功後返回true；鎖定方法acquire()可以有一個blocking引數。如果設定blocking為True，則當前執行緒會堵塞，直到獲取到這個鎖為止（如果沒有指定，那麼預設為True）；如果設定blocking為False，則當前執行緒不會堵塞。

mutex.release()：執行完程式內容後進行鎖的釋放操作。


5、支援同一執行緒多次請求同一資源，python提供了可重入鎖。RLock物件中，同時維護著一個Lock和一個counter變數；counter變數儲存acquire的次數，從而使得資源可以多次被acquire；直到一個執行緒中的所有的acquire被release，其他的執行緒才可以獲得資源

mutex=threading.RLock()：建立可重入鎖物件。

mutex.acquire()：進行上鎖。

mutex.release()：進行釋放。


6、python提供的Condition物件提供了對複雜執行緒同步問題的支援；Condition被稱為條件變數；Condition維護著一個鎖和一個waiting池。

con=threading.Condition()：建立條件變數物件；可以接受一個Lock/RLock物件作為引數，如果沒有指定則內部預設建立一個RLock

con.acquire()：進行加鎖。

con.wait()：執行緒會釋放Condition內部的鎖並進入blocked（堵塞）狀態，同時在waiting池中記錄這個執行緒。

con.notify()：Condition物件會從waiting池中挑選一個執行緒，通知其呼叫acquire方法嘗試取到鎖。

con.notifyAll()：Condition物件通知waiting池中所有的執行緒，嘗試acquire內部鎖。作用防止有的執行緒永遠處於沉默狀態。

con.release()：進行釋放。


threading.Event可以是一個執行緒等待其他執行緒的通知。其內建了一個標誌，初始值為False。執行緒通過wait()方法進入等待狀態，直到另一個執行緒排程set()方法將內建標誌設定為True是，Event通知所有等待狀態的執行緒回覆執行。還可以用isSet()方法查詢Event物件內建狀態的當前值。

event=threading.Event()：進行對應Envent物件的建立。

def __init__(self,threadName,event):

self.threadEvent=event ：重構對應threading.Thread基類中__init__的方法。

self.threadEvent.wait()：使執行緒進入等待狀態。

event.set()：啟動waiting池中等待的執行緒。



-------------------Queue：佇列-------------------

from Queue import Queue：引用對應的模組包。

queue=Queue()：建立一個佇列物件。

queue.qsize()：獲取佇列中元素的數量。

queue.put(向佇列中新增的資料)：想佇列中新增元素。

queue.set()：從佇列中取出元素。

queue.empty()：判斷佇列是否為空。



-------------------copy：拷貝-------------------



-------------------time：時間-------------------



-------------------datetime：日期和時間-------------------



-------------------calendar：日曆-------------------



-------------------hashlib：加密演算法-------------------



-------------------random：生成隨機數-------------------

import random：引用對應的包

random.random()：預設在0到1之間隨機獲取資料資訊。

random.uniform(1,5)：1到5之間隨機獲取對應的數值；包含小數部分。

random.randint(10.50)：10到50之間對應隨機獲取對應的整數

random.randrange(0,51,2)：0到51之間對應隨機獲取對應的3的倍數



-------------------re：字串正則匹配-------------------

import re：引用對應的包

result=re.match(正規表示式，要匹配的字串)：從第一個字元向後依次進行正則匹配操作，匹配出對應的資料資訊。

result.group()：如果上一步匹配到資料的話，可以使用group方法來提取資料。

result=re.search(正規表示式，要匹配的字串)：從匹配到的第一個字元向後依次進行匹配操作。

result==None：判斷獲取的書資料是否為空。

re.search(r'\d+','my hight 177 cm').group()：匹配出指定字串中符合正規表示式的第一條資料（只能匹配一個）。

re.findall(r'\d+','my hight 177 cm my weight 100 kg')：配匹配出指定字串中所有符合正規表示式的有效資料，並以列表的形式進行返回。

re.sub(r'\d+','100','my high 177 cm')：將匹配到的資料進行替換，引數：對應的正規表示式，要替換的資料，匹配出來的資料；


方法一：

#coding=utf-8

import re


ret = re.sub(r"\d+", '998', "python = 997")

print ret


返回結果：998


方法二：

#coding=utf-8

import re


def add(temp):

strNum = temp.group()

num = int(strNum) + 1

return str(num)


ret = re.sub(r"\d+", add, "python = 997")

print ret


ret = re.sub(r"\d+", add, "python = 99")

print ret

返回結果：100


re.split(r':| ','address:beijing xxx@126.com')：根據匹配進行切割字串，並返回一個列表。案例：根據：或空格進行字串的切割操作，結果：['address','beijing','xxx@126.com']



-------------------socket：標準的 BSD Sockets API-------------------



-------------------shutil：檔案和目錄管理-------------------



-------------------glob：基於檔案萬用字元搜尋-------------------



-------------------keyword:關鍵字-------------------

import keyword：引用對應的包

keyword.kwlist()：獲取對應的列表，列表中儲存python中的對應關鍵字




相關文章