Python 經常使用模塊介紹

時間 2019-11-17

標籤 python 經常使用模塊介紹欄目 Python 简体版

原文原文鏈接

time模塊

import timepython

time模塊的經常使用方法：程序員

時間戳

從1970年1月1日0：00：00開始按秒計算正則表達式

time.time()算法

格式化時間（顯示當前時間）

time.strftime(%Y-%m-%d %X)編程

%Y 年 -%m月- %d日 %X秒json

datetime模塊

import datetimeapi

返回當前時間

print(datetime.datetime.now())數組

2019-8-19 15:05:30.000000安全

#當前時間
print(datetime.datetime.now())
#當前時間的加減
print(print(datetime.datetime.now() + datetime.timedelta(3)))

2019-8-19 15:05:30.000000dom

2019-8-22 15:05:30.000000

經過datetime.timedelta添加來達到當前日期的加減模式：

默認加減天數，hours加減少時，minutes加減分鐘

random模塊

import random

random模塊方法

random方法：

#大於0且小於1的小數
print(random.random())
#想生成0且小於多少的小數只要在後面乘多少就好啦 
print(random.random()*10)

生成隨機整數

#隨機生成0到4之間的整數
random.randint(0,4)

os模塊

import time

os模塊經常使用方法

import os
#常常用的經常使用方法
res = os.listdir(r'G:\py')#列出該文件夾下的全部文件
res = os.path.join(r'G:\py','guapi.py')#拼接文件夾路徑
#經常使用方法中的不經常使用方法
os.path
os.mkdir('m2') #建立一個叫m2的文件夾
os.rmdir('沒') #刪除一個叫m2的文件加

sys模塊

import sys

#經常使用方法
sys.argv() 經過命令行返回參數
sys.path()返回python的環境變量路徑

json模塊

import json

#json經常使用方法
import json
#序列化
struct_data = {'name': 'json', 'age': 23, 'sex': 'male'}
with open('test.json','w') as fw:
    json.dump(struct_data,fw)
#反序列化
with open('test.json') as fr:
    date = json.load(fr)
    print(date)

json的用途：

在編寫接口傳遞數據時，每每須要使用JSON對數據進行封裝。python和json數據類型的轉換，看做爲編碼與解碼。

pickle模塊

import pickle

pickle用途：

能夠將python全部的數據類型進行序列化和反序列化，經過二進制進行保存

# 序列化(注意：pickle模塊須要使用二進制存儲，即'wb'模式存儲)
with open('Pickle序列化對象.pkl', 'wb') as fw:
    pickle.dump(struct_data, fw)
# 反序列化
with open('Pickle序列化對象.pkl', 'rb') as fr:
    pickle = pickle.load(fr)
print(data)

hashlib模塊

import hashlib

什麼是hash：

用於密碼的加密，是一種加密的方式

特色：1.傳入的內容同樣時，獲得的hash值同樣，用於密碼校驗

2.不能有hash值返解成內容，保證密碼的安全性

3.不管多長，獲得的hash長度時一致的

#hashlib模塊的方法：
import hashlib
m=hashlib.md5()
m.update('hello'.encode('utf8'))
a=hashlib.md5()
a.update('hello'.encode('utf8'))
print(m.hexdigest())
print(a.hexdigest())

5d41402abc4b2a76b9719d911017c592 5d41402abc4b2a76b9719d911017c592

hmac模塊

hamc模塊

import hmac

hmac模塊的使用方法

import hmac

h1=hmac.new(b'hash')
h1.update(b'hello')
h1.update(b'world')
print(h1.hexdigest())
h2 = hmac.new(b'hash')
h2.update(b'helloworld')
print(h2.hexdigest())

logging模塊

import time

logging模塊包含四種角色：logger、Filter、Formatter對象、Handler

logger：產生日誌的對象
Filter：過濾日誌的對象
Formatter對象：能夠定製不一樣的日誌格式對象，而後綁定給不一樣的Handler對象使用，以此來控制不一樣的Handler的日誌格式
Handler：接收日誌而後控制打印到不一樣的地方，FileHandler用來打印到文件中，StreamHandler用來打印到終端

numpy模塊

import numpy as np

numpy經常使用方法

import numpy as np
arr1 = np.array([[1,2,3],[4,5,6]])
print(arr1) #輸出arr1的數組


print(arr1.T)#數組的轉置
arr2 = np.array([[7,8,9],[10,11,12]])
print(arr1*arr2) #數組的算法

print(np.hstack((arr1,arr2)))   #行合併
print(np.vstack((arr1,arr2)))   列合併

arr = np.hstack((arr1,arr2))
print(arr[:,:]) #取全部
# print(arr[:1,:])    #取第一行全部元素
# print(arr[:,:1])    #取第一列

經過函數生成numpy數組

方法	詳解
array()	將列表轉換爲數組，可選擇顯式指定dtype
arange()	range的numpy版，支持浮點數
linspace()	相似arange()，第三個參數爲數組長度
zeros()	根據指定形狀和dtype建立全0數組
ones()	根據指定形狀和dtype建立全1數組
eye()	建立單位矩陣
empty()	建立一個元素全隨機的數組
reshape()	重塑形狀

arange生成

import numpy as np
print(np.arange(5))     #生成0-4的一維數組
print(np.arange(5),np.arange(5))    #生成0-4的二維數組

zeros()/noes()生成

import numpy as np
print(np.zeros((3,4)))  #生成一個3行4列全是0的二維數組
print(np.ones((3,4)))   #生成一個3行4列全是1的二維數組
print(np.ones((5,6))*5) #生成5行6列全是5的二維數組

numpy數組運算函數

numpy數組函數	詳解
np.sin(arr)	對numpy數組arr中每一個元素取正弦，sin(x)sin(x)
np.cos(arr)	對numpy數組arr中每一個元素取餘弦，cos(x)cos(x)
np.tan(arr)	對numpy數組arr中每一個元素取正切，tan(x)tan(x)
np.arcsin(arr)	對numpy數組arr中每一個元素取反正弦，arcsin(x)arcsin(x)
np.arccos(arr)	對numpy數組arr中每一個元素取反餘弦，arccos(x)arccos(x)
np.arctan(arr)	對numpy數組arr中每一個元素取反正切，arctan(x)arctan(x)
np.exp(arr)	對numpy數組arr中每一個元素取指數函數，exex
np.sqrt(arr)	對numpy數組arr中每一個元素開根號x−−√

pandas模塊

import numpy as np

常與numpy連用

import pandas as pd
import numpy as np

arr =np.array([1,2,3,4,np.nan]) 生成一個列表，np.nan表示空值
print(arr)
df=pd.Series(arr,index=['a','b','c','d','e'])   #根據索引建立表格
print(type(df))

pandas經常使用屬性方法 dateframe屬性

屬性	詳解
dtype是	查看數據類型
index	查看行序列或者索引
columns	查看各列的標籤
values	查看數據框內的數據，也即不含表頭索引的數據
describe	查看數據每一列的極值，均值，中位數，只可用於數值型數據
transpose	轉置，也可用Ｔ來操做
sort_index	排序，可按行或列index排序輸出
sort_values	按數據值來排序

matplotlib模塊

1、條形圖

[0, 1, 2, 3]
student_amounts = [66, 55, 45, 70]

# 畫布設置
fig = plt.figure()
# 1,1,1表示一張畫布切割成1行1列共一張圖的第1個；2,2,1表示一張畫布切割成2行2列共4張圖的第一個（左上角）
ax1 = fig.add_subplot(1, 1, 1)
ax1.bar(classes_index, student_amounts, align='center', color='darkblue')
ax1.xaxis.set_ticks_position('bottom')
ax1.yaxis.set_ticks_position('left')

plt.xticks(classes_index,
           classes,
           rotation=0,
           fontsize=13,
           fontproperties=font)
plt.xlabel('班級', fontproperties=font, fontsize=15)
plt.ylabel('學生人數', fontproperties=font, fontsize=15)
plt.title('班級-學生人數', fontproperties=font, fontsize=20)
# 保存圖片，bbox_inches='tight'去掉圖形四周的空白
# plt.savefig('classes_students.png?x-oss-process=style/watermark', dpi=400, bbox_inches='tight')
plt.show()

2、直方圖

[59.00855949 43.16272141 48.77109774 ... 57.94645859 54.70312714
 58.94125528]
# 構造均值爲100的符合正態分佈的數據
x2 = mu2 + sigma * np.random.randn(10000)
print(x2)
[115.19915511  82.09208214 110.88092454 ...  95.0872103  104.21549068
 133.36025251]
fig = plt.figure()
ax1 = fig.add_subplot(121)
# bins=50表示每一個變量的值分紅50份，即會有50根柱子
ax1.hist(x1, bins=50, color='darkgreen')

ax2 = fig.add_subplot(122)
ax2.hist(x2, bins=50, color='orange')

fig.suptitle('兩個正態分佈', fontproperties=font, fontweight='bold', fontsize=15)
ax1.set_title('綠色的正態分佈', fontproperties=font)
ax2.set_title('橙色的正態分佈', fontproperties=font)
plt.show()

3、折線圖

[ 1.62434536  1.01258895  0.4844172  -0.58855142  0.2768562  -2.02468249
 -0.27987073 -1.04107763 -0.72203853 -0.97140891  0.49069903 -1.56944168
 -1.89185888 -2.27591324 -1.1421438  -2.24203506 -2.41446327 -3.29232169
 -3.25010794 -2.66729273 -3.76791191 -2.6231882  -1.72159748 -1.21910314
 -0.31824719 -1.00197505 -1.12486527 -2.06063471 -2.32852279 -1.79816732
 -2.48982807 -2.8865816  -3.5737543  -4.41895994 -5.09020607 -5.10287067
 -6.22018102 -5.98576532 -4.32596314 -3.58391898]
plot_data2 = randn(40).cumsum()
plot_data3 = randn(40).cumsum()
plot_data4 = randn(40).cumsum()

plt.plot(plot_data1, marker='o', color='red', linestyle='-', label='紅實線')
plt.plot(plot_data2, marker='x', color='orange', linestyle='--', label='橙虛線')
plt.plot(plot_data3, marker='*', color='yellow', linestyle='-.', label='黃點線')
plt.plot(plot_data4, marker='s', color='green', linestyle=':', label='綠點圖')

# loc='best'給label自動選擇最好的位置
plt.legend(loc='best', prop=font)
plt.show()

4、散點圖+直線圖

[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
# 擬合一條水平散點線
np.random.seed(1)
y_linear = x + 10 * np.random.randn(19)
print(y_linear)
[ 17.24345364  -4.11756414  -2.28171752  -6.72968622  13.65407629
 -17.01538697  24.44811764   0.38793099  12.19039096   7.50629625
  25.62107937  -8.60140709   9.77582796  10.15945645  26.33769442
   5.00108733  15.27571792   9.22141582  19.42213747]
# 擬合一條x²的散點線
y_quad = x**2 + 10 * np.random.randn(19)
print(y_quad)
[  6.82815214  -7.00619177  20.4472371   25.01590721  30.02494339
  45.00855949  42.16272141  62.77109774  71.64230566  97.3211192
 126.30355467 137.08339248 165.03246473 189.128273   216.54794359
 249.28753869 288.87335401 312.82689651 363.34415698]
# s是散點大小
fig = plt.figure()
ax1 = fig.add_subplot(121)
plt.scatter(x, y_linear, s=30, color='r', label='藍點')
plt.scatter(x, y_quad, s=100, color='b', label='紅點')

ax2 = fig.add_subplot(122)
plt.plot(x, y_linear, color='r')
plt.plot(x, y_quad, color='b')

# 限制x軸和y軸的範圍取值
plt.xlim(min(x) - 1, max(x) + 1)
plt.ylim(min(y_quad) - 10, max(y_quad) + 10)
fig.suptitle('散點圖+直線圖', fontproperties=font, fontsize=20)
ax1.set_title('散點圖', fontproperties=font)
ax1.legend(prop=font)
ax2.set_title('直線圖', fontproperties=font)
plt.show()

re模塊

正則表達式

什麼是正則表達式

正則表達式自己是一種小型的、高度專業化的編程語言，它並非Python的一部分。正則表達式是用於處理字符串的強大工具，擁有本身獨特的語法以及一個獨立的處理引擎，效率上可能不如str自帶的方法，但功能十分強大。得益於這一點，在提供了正則表達式的語言裏，正則表達式的語法都是同樣的，區別只在於不一樣的編程語言實現支持的語法數量不一樣；但不用擔憂，不被支持的語法一般是不經常使用的部分。若是已經在其餘語言裏使用過正則表達式，只須要簡單看一看就能夠上手了。而在python中，經過內嵌集成re模塊，程序員們能夠直接調用來實現正則匹配。正則表達式模式被編譯成一系列的字節碼，而後由用C編寫的匹配引擎執行。

正則表達式用途

用於對字符串或者數據進行篩選，也能夠連用requests模塊來進行爬蟲

re模塊得基本使用

正則表達式是用來匹配處理字符串的 python 中使用正則表達式須要引入re模塊

import re  # 第一步，要引入re模塊
a = re.findall("匹配規則", "這個字符串是否有匹配規則的字符")  # 第二步，調用模塊函數
print(a)  # 以列表形式返回匹配到的字符串
['匹配規則']

^元字符

字符串開始位置與匹配規則符合就匹配，不然不匹配

匹配字符串開頭。在多行模式中匹配每一行的開頭（Python3+已經失效，配合compile使用）

^元字符若是寫到[]字符集裏就是反取

import re
a = re.findall("^匹配規則", "匹配規則這個字符串是否匹配")  # 字符串開始位置與匹配規則符合就匹配，不然不匹配
print(a)
#打印出 ['匹配規則']
['匹配規則']

[^a-z]反取

匹配出除字母外的字符，^元字符若是寫到字符集裏就是反取

import re
a = re.findall("[^a-z]", "匹配s規則這s個字符串是否s匹配f規則則re則則則")  # 反取，匹配出除字母外的字符
print(a)
['匹', '配', '規', '則', '這', '個', '字', '符', '串', '是', '否', '匹', '配', '規', '則', '則', '則', '則', '則']

$元字符

字符串結束位置與匹配規則符合就匹配，不然不匹配

匹配字符串末尾，在多行模式中匹配每一行的末尾

import re
a = re.findall("匹配規則$", "這個字符串是否匹配規則")  # 字符串結束位置與匹配規則符合就匹配，不然不匹配
print(a)
['匹配規則']

*元字符

須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的*元字符）前面的一個字符能夠是0個或多個本來字符

匹配前一個字符0或屢次，貪婪匹配前導字符有多少個就匹配多少個很貪婪

若是規則裏只有一個分組，儘可能避免用*不然會有可能匹配出空字符串

import re
# 須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的*元字符）前面的一個字符能夠是0或多個本來字符
a = re.findall("匹配規則*", "這個字符串是否匹配規則則則則則")
print(a)
['匹配規則則則則則']

+元字符

須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的+元字符）前面的一個字符能夠是1個或多個本來字符

匹配前一個字符1次或無限次，貪婪匹配前導字符有多少個就匹配多少個很貪婪

import re
# 須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的+元字符）前面的一個字符能夠是1個或多個本來字符
a = re.findall("匹配+", "匹配配配配配規則這個字符串是否匹配規則則則則則")
print(a)
['匹配配配配配', '匹配']

?元字符(防止貪婪匹配)

須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的?元字符）前面的一個字符能夠是0個或1個本來字符

匹配一個字符0次或1次

還有一個功能是能夠防止貪婪匹配，詳情見防貪婪匹配

import re
# 須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的?元字符）前面的一個字符能夠是0個或1個本來字符
a = re.findall("匹配規則?", "匹配規這個字符串是否匹配規則則則則則")
print(a)
['匹配規', '匹配規則']

{}元字符(範圍)

須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的 {} 元字符）前面的一個字符，是自定義字符數，位數的本來字符

{m}匹配前一個字符m次，{m,n}匹配前一個字符m至n次，若省略n，則匹配m至無限次

{0,}匹配前一個字符0或屢次,等同於*元字符
{+,}匹配前一個字符1次或無限次,等同於+元字符
{0,1}匹配前一個字符0次或1次,等同於?元字符

import re
# {m}匹配前一個字符m次，{m,n}匹配前一個字符m至n次，若省略n，則匹配m至無限次
a = re.findall("匹配規則{3}", "匹配規這個字符串是否匹配規則則則則則")
print(a)
['匹配規則則則']

[]元字符(字符集)

須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的 [] 元字符）對應位置是[]裏的任意一個字符就匹配

字符集。對應的位置能夠是字符集中任意字符。字符集中的字符能夠逐個列出，也能夠給出範圍，如[abc]或[a-c]。[^abc]表示取反，即非abc。
全部特殊字符在字符集中都失去其原有的特殊含義。用\反斜槓轉義恢復特殊字符的特殊含義。

import re
# 須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的 [] 元字符）對應位置是[]裏的任意一個字符就匹配
a = re.findall("匹配[a,b,c]規則", "匹配a規則這個字符串是否匹配b規則則則則則")
print(a)
['匹配a規則', '匹配b規則']

[^]

非，反取，匹配出除[^]裏面的字符，^元字符若是寫到字符集裏就是反取

import re
a = re.findall("[^a-z]", "匹配s規則這s個字符串是否s匹配f規則則re則則則")  # 反取，匹配出除字母外的字符
print(a)
['匹', '配', '規', '則', '這', '個', '字', '符', '串', '是', '否', '匹', '配', '規', '則', '則', '則', '則', '則']

反斜槓後邊跟普通字符實現特殊功能(預約義字符)

預約義字符是在字符集和組裏都是有用的

\d匹配任何十進制數，它至關於類[0-9]

import re
a = re.findall("\d", "匹配規則這2個字符串3是否匹配規則5則則則7則")  # \d匹配任何十進制數，它至關於類[0-9]
print(a)
['2', '3', '5', '7']

\d+

匹配一位或者多位數的數字時用

import re
a = re.findall("\d+", "匹配規則這2個字符串134444是否匹配規則5則則則7則")  # \d+若是須要匹配一位或者多位數的數字時用
print(a)
['2', '134444', '5', '7']

匹配任何非數字字符，它至關於類[^0-9]

import re
a = re.findall("\D", "匹配規則這2個字符串3是否匹配規則5則則則7則")  # \D匹配任何非數字字符，它至關於類[^0-9]
print(a)
['匹', '配', '規', '則', '這', '個', '字', '符', '串', '是', '否', '匹', '配', '規', '則', '則', '則', '則', '則']

匹配任何空白字符，它至關於類[\t\n\r\f\v]

import re
# \s匹配任何空白字符，它至關於類[\t\n\r\f\v]
a = re.findall("\s", "匹配規則   這2個字符串3是否匹\n配規則5則則則7則")
print(a)
[' ', ' ', ' ', '\n']

匹配任何非空白字符，它至關於類[^\t\n\r\f\v]

import re
# \S匹配任何非空白字符，它至關於類[^\t\n\r\f\v]
a = re.findall("\S", "匹配規則   這2個字符串3是否匹\n配規則5則則則7則")
print(a)
['匹', '配', '規', '則', '這', '2', '個', '字', '符', '串', '3', '是', '否', '匹', '配', '規', '則', '5', '則', '則', '則', '7', '則']

匹配包括下劃線在內任何字母數字字符，它至關於類[a-zA-Z0-9_]

import re
# \w匹配包括下劃線在內任何字母數字字符，它至關於類[a-zA-Z0-9_]
a = re.findall('\w', "https://www.cnblogs.com/")
print(a)
['h', 't', 't', 'p', 's', 'w', 'w', 'w', 'c', 'n', 'b', 'l', 'o', 'g', 's', 'c', 'o', 'm']

匹配非任何字母數字字符包括下劃線在內，它至關於類[^a-zA-Z0-9_]

import re
# \w匹配包括下劃線在內任何字母數字字符，它至關於類[a-zA-Z0-9_]
a = re.findall('\W', "https://www.cnblogs.com/")
print(a)
[':', '/', '/', '.', '.', '/']

()元字符(分組)

也就是分組匹配，()裏面的爲一個組也能夠理解成一個總體

若是()後面跟的是特殊元字符如 (adc)* 那麼*控制的前導字符就是()裏的總體內容，再也不是前導一個字符

import re
# 也就是分組匹配，()裏面的爲一個組也能夠理解成一個總體
a = re.search("(a4)+", "a4a4a4a4a4dg4g654gb")  # 匹配一個或多個a4
b = a.group()
print(b)
a4a4a4a4a4
import re
# 也就是分組匹配，()裏面的爲一個組也能夠理解成一個總體
# 匹配 (a) (\d0-9的數字) (+能夠是1個到多個0-9的數字)
a = re.search("a(\d+)", "a466666664a4a4a4dg4g654gb")
b = a.group()
print(b)
a466666664

|元字符(或)

|或，或就是先後其中一個符合就匹配

import re
a = re.findall(r"你|好", "a4a4a你4aabc4a4dgg好dg4g654g")  # |或，或就是先後其中一個符合就匹配
print(a)

re模塊的方法

re.S

在Python的正則表達式中，有一個參數爲re.S。它表示「.」的做用擴展到整個字符串，包括「\n」。看以下代碼：

import re
a = '''asdfhellopass:
    worldaf
    '''
b = re.findall('hello(.*?)world', a)
c = re.findall('hello(.*?)world', a, re.S)
print('b is ', b)
print('c is ', c)
b is  []
c is  ['pass:\n    ']

正則表達式中，「.」的做用是匹配除「\n」之外的任何字符，也就是說，它是在一行中進行匹配。這裏的「行」是以「\n」進行區分的。a字符串有每行的末尾有一個「\n」，不過它不可見。

若是不使用re.S參數，則只在每一行內進行匹配，若是一行沒有，就換下一行從新開始，不會跨行。而使用re.S參數之後，正則表達式會將這個字符串做爲一個總體，將「\n」當作一個普通的字符加入到這個字符串中，在總體中進行匹配。

re.I

不區分大小寫

res = re.findall(r"A", "abc", re.I)
print(res)
['a']

re.sub

# 要求結果：['12', '23', '34']
l = ['1 2 ', '2   3', '  3 4']
import re
print(eval(re.sub(r'\s*', '', str

typing模塊

typing模塊的使用：

from typing import List, Tuple, Dict

typing模塊的用途

類型檢查，防止運行時出現參數和返回值類型不符合。
做爲開發文檔附加說明，方便使用者調用時傳入和返回參數類型。
該模塊加入後並不會影響程序的運行，不會報正式的錯誤，只有提醒。

注意：typing模塊只有在python3.5以上的版本中才可使用,pycharm目前支持typing檢查

from typing import List, Tuple, Dict


def add(a: int, string: str, f: float,
        b: bool) -> Tuple[List, Tuple, Dict, bool]:
    list1 = list(range(a))
    tup = (string, string, string)
    d = {"a": f}
    bl = b
    return list1, tup, d, bl


print(add(5, "hhhh", 2.3, False))