Python經常使用模塊

時間  2019-12-01
標籤 python 經常 使用 模塊 欄目 Python 简体版
原文   原文鏈接

本節目錄

  • 模塊相關介紹

  • time

  • random

  • os

  • sys

  • json & pickle

  • shelve

  • xml

  • configparser

  • hashlib

  • subprocess

  • optparse

  • struct

  • 所述一些模塊方法並不完善,只是簡單性的學習,或有錯誤,敬請指正

  • 未完待續......

 爲何要有模塊：node

　　　　在計算機程序的開發過程當中，程序代碼越寫越多，在一個py文件中會愈來愈多，變得不容易維護python

　　　　爲了編寫易維護的代碼，將不少函數分組，分別放入不一樣的py文件中，每一個文件包含的代碼就會相對減小，諸多編程語言都這樣作web

　　　　在python中，一個.py文件中就能夠稱之爲一個模塊(moudle)算法

　　　　使用模塊有什麼好處：大大提升了代碼的可維護性，也可區分邏輯shell

　　　　其次，在編寫好一個模塊，就能夠在其它地方進行引用，沒必要從0開始編程

模塊有三種：json

  • python標準庫
  • 第三方模塊
  • 應用程序自定義模塊　　

模塊的引用方式:小程序

　　一、import語句　　1）執行對應文件　　2）引入變量名windows

?
1
import time    　　　　 # 導入時間模塊    也能夠同時導入多個模塊，用逗號隔開

　　二、from....import 模塊名bash

?
1
from my_moudle import main

　　三、from....import *

　　　　　　引入一切，即導入模塊中全部的項目，不推薦使用。由於引入的其它來源的命名，極可能覆蓋了已有的定義。

　　四、運行本質

?
1
2
#1 import test
#2 from test import add　

那麼，python中是如何找到這些模塊呢?

　　sys.path，存放的是執行文件的搜索路徑(環境變量)。然而模塊就是經過環境變量去找的.

一個目錄中帶__iter__.py的文件成爲包(package)

　　一、用來組織模塊　　二、避免相同模塊名的衝突

　　注意，每個包目錄下面都會有一個__init__.py的文件，這個文件是必須存在的，不然，Python就把這個目錄當成普通目錄(文件夾)，而不是一個包。__init__.py能夠是空文件，也能夠有Python代碼，由於__init__.py自己就是一個模塊，而它的模塊名就是對應包的名字。

 

                           

 

這裏介紹一下__name__的屬性

　　一個模塊被另外一個程序第一次引入時，其主程序將運行。若是咱們想在模塊被引入時，模塊中的某一程序塊不執行，咱們能夠用__name__屬性來使該程序塊僅在該模塊自身運行時執行。

?
1
2
3
4
5
6
7
8
9
10
if __name__ = = '__main__' :
    print ( '程序自身在運行' )
else :
    print ( '我來自另外一模塊' )
 
python using_name.py
程序自身在運行
 
import using_name
我來自另外一模塊

　　說明： 每一個模塊都有一個__name__屬性，當其值是'__main__'時，代表該模塊自身在運行，不然是被引入。

time

 　　時間相關的操做，時間有三種表示方式：　　　　

　　　　　　時間戳               1970年1月1日以後的秒，即：time.time(),只有時間戳參數才能進行加減

　　　　　　格式化的字符串    2014-11-11 11:11，    即：time.strftime('%Y-%m-%d')

　　　　　　結構化時間          元組包含了：年、日、星期等... time.struct_time    即：time.localtime()

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
print time.time()
print time.mktime(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 datetime
'''
datetime.date：表示日期的類。經常使用的屬性有year, month, day
datetime.time：表示時間的類。經常使用的屬性有hour, minute, second, microsecond
datetime.datetime：表示日期時間
datetime.timedelta：表示時間間隔，即兩個時間點之間的長度
timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])
strftime("%Y-%m-%d")
'''
import datetime
print datetime.datetime.now()
print datetime.datetime.now() - datetime.timedelta(days = 5 )

  　

random(隨機模塊)

?
1
2
3
4
5
6
7
8
9
10
import random                 
print (random.random())         # 0到1的隨機浮點數
print (random.randint( 1 , 3 ))     # 整形 閉區間 [1,3]
print (random.randrange( 1 , 3 ))   # 整形，開區間 [1,3)
li = [ 11 , 22 , 33 , 44 , 55 ]
print (random.choice(li))       # 基於可迭代對象隨機
print (random.sample(li, 2 ))     # 隨機選定多個
print (random.uniform( 1 , 2 ))     # 任意範圍的浮點型
random.shuffle(li)             # 隨機打亂次序
print (li)

　　經過隨機模塊能夠製做一個隨機驗證碼

 1 def v_code():  
 2     checkcode = "" # 定義一個空字符串
 3     for i in range(4): # 遍歷四次
 4         num = random.randint(0,9) # 隨機選擇0到9的整形
 5         alf = chr(random.randint(65,90)) # 隨機選擇chr對應的字母
 6         add = random.choice([num,alf]) # 基於上面的可迭代對象選擇一個
 7         checkcode += str(add) # 將它們變爲字符串，加到空字符串裏面
 8     return checkcode
 9 if __name__ == "__main__":
10     print(v_code())
隨機驗證碼

 os

 　　用於提供系統級別的操做

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
os.getcwd()                 獲取當前工做目錄，即當前python腳本工做的目錄路徑
os.chdir( "dirname" )         改變當前腳本工做目錄；至關於shell下cd
os.curdir                   返回當前目錄: ( '.' )
os.pardir                   獲取當前目錄的父目錄字符串名：( '..' )
os.makedirs( 'dir1/dir2' )    可生成多層遞歸目錄
os.removedirs( 'dirname1' )   若目錄爲空，則刪除，並遞歸到上一級目錄，如若也爲空，則刪除，依此類推
os.mkdir( 'dirname' )         生成單級目錄；至關於shell中mkdir dirname
os.rmdir( 'dirname' )         刪除單級空目錄，若目錄不爲空則沒法刪除，報錯；至關於shell中rmdir dirname
os.listdir( 'dirname' )       列出指定目錄下的全部文件和子目錄，包括隱藏文件，並以列表方式打印 * * *
os.remove()                 刪除一個文件
os.rename( "oldname" , "new" )  重命名文件 / 目錄 * * *
os.stat( 'path/filename' )    獲取文件 / 目錄信息，相關信息的介紹 size 文件大小 atime 上次訪問時間 mtime 上次修改時間 ctime 查看建立時間
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

 　　提供對Python解釋器相關的操做：

?
1
2
3
4
5
6
7
8
9
sys.argv           命令行參數 List ，第一個元素是程序自己路徑  * * * * *
sys.exit(n)        退出程序，正常退出時exit( 0 )
sys.version        獲取Python解釋程序的版本信息
sys.maxint         最大的 Int 值
sys.path           返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值
sys.platform       返回操做系統平臺名稱
sys.stdin          輸入相關
sys.stdout         輸出相關
sys.stderror       錯誤相關

　　經過sys模塊能夠作個簡單的進度的小程序

import sys
import time
def view_bar(num, total):
    rate = float(num) / float(total)
    rate_num = int(rate * 100)
    r = '\r%d%%' % (rate_num, )
    sys.stdout.write(r)
    sys.stdout.flush()
if __name__ == '__main__':
    for i in range(0, 101):
        time.sleep(0.1)
        view_bar(i, 100)
# 未研究

import sys
import time
for i in range(10):
    sys.stdout.write("#")
    sys.stdout.flush()
    time.sleep(1)
進度條顯示

json & pickle

 　　這是倆個用做於序列化的模塊

　　　　json   用於【字符串】和 【python基本數據類型】 間進行轉換  *****

　　　　　　　(數據交互)，能夠進行多種語言的數據交互 

　　　　pickle 用於【python特有的類型】 和 【python基本數據類型】間進行轉換　　

　　　　　　　　Json模塊提供了四個功能：dumps、dump、loads、load   無s的區別，應用於文件的操做

 

　　　　　　　　pickle模塊提供了四個功能：dumps、dump、loads、load

import json
# json的用法
dic = {"name":"alex"}
data = json.dumps(dic)
print(data)
print(type(data))
with open("hello","w") as f:
    f.write(data)


with open("hello","r") as new_f:
    i = new_f.read()
    a = json.loads(i)
    print(type(i))
    print(type(a))

{"name": "alex"}
<class 'str'>
<class 'str'>
<class 'dict'>
json

　　　　json裏面都會變爲雙引號的字符串

　　  # dct="{'1':111}"#json 不認單引號

　　　  只要符合json字符串，則直接能夠locals

import pickle                # 和json的方法的相同,序列化對象
dic = {"name":"alex"}
# data = pickle.dumps(dic)   # 轉化爲字節類型
# print(data)                # ---><class 'bytes'>

f = open("hello","wb")
f.write(pickle.dumps(dic))   #
f.close()

f = open("hello","rb")      # 反序列化
data = pickle.loads(f.read())# 至關於data = pickle.load(f)
print(data)
f.close()
pickle

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

shelve

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

?
1
2
3
4
5
6
7
8
9
10
11
12
import shelve
  
f = shelve. open (r 'shelve.txt' )
  
# f['stu1_info']={'name':'alex','age':'18'}
# f['stu2_info']={'name':'alvin','age':'20'}
# f['school_info']={'website':'oldboyedu.com','city':'beijing'}
#
#
# f.close()
  
print (f.get( 'stu_info' )[ 'age' ])

xml

　　跟json差很少，用做實現不一樣語言之間的數據交互，可是json使用起來更簡單。

　　至今不少傳統和金融行業的系統的接口仍是用的xml

　　xml的格式以下，就是經過<>節點來區別數據結構的:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<data>
     <country name = "Liechtenstein" >
         <rank updated = "yes" > 2 < / rank>
         <year> 2008 < / year>
         <gdppc> 141100 < / gdppc>
         <neighbor name = "Austria" direction = "E" / >
         <neighbor name = "Switzerland" direction = "W" / >
     < / country>
     <country name = "Singapore" >
         <rank updated = "yes" > 5 < / rank>
         <year> 2011 < / year>
         <gdppc> 59900 < / gdppc>
         <neighbor name = "Malaysia" direction = "N" / >
     < / country>
     <country name = "Panama" >
         <rank updated = "yes" > 69 < / rank>
         <year> 2011 < / year>
         <gdppc> 13600 < / gdppc>
         <neighbor name = "Costa Rica" direction = "W" / >
         <neighbor name = "Colombia" direction = "E" / >
     < / country>
< / data>                                                  # 有一個xml的數據

 　　接下來咱們能夠進行對它操做

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import xml.etree.ElementTree as ET
tree = ET.parse( "xml_t" )  # 解析(打開)xml文件
root = tree.getroot() #
print (root.tag) # .tag是取第一層的標籤
# 遍歷root文檔
for child in root:
     print (child.tag,child.attrib) # 取每條的標籤名，還有每條標籤的屬性值(是字典)
     for i in child:
         print (i.tag,i.text) # 取子標籤下的標籤名，還有每條標籤下的內容
# 只遍歷yaer的節點
for node in root. iter ( "year" ):
     print (node.tag,node.text) # 取出year的標籤名，還有year標籤名下的內容
#---------------------------------------
import xml.etree.ElementTree as ET
tree = ET.parse( "xmltest.xml" )
root = tree.getroot()
# 修改
for node in root. iter ( 'year' ):   # 只遍歷yaer的節點
     new_year = int (node.text) + 1 # 將每一個year標籤下的內容整形並+1
     node.text = str (new_year)
     node. set ( "updated" , "yes" )    # 添加。set(標籤名，屬性值)
tree.write( "xmltest.xml" )        # 寫入新的修改的xml文件
# 刪除
for country in root.findall( 'country' ): # 遍歷標籤名爲country下的東西
     rank = int (country.find( 'rank' ).text) # 找到country下的子標籤爲rank 取出它的內容，並複製
     if rank > 50 : # 若是大於50
      root.remove(country) # 則刪除country這個標籤
 
tree.write( 'output.xml' )

configarser

 　　其實就是配置解析文件，有固定的格式

1 # 註釋1
2 ;  註釋2
3  
4 [section1] # 節點
5 k1 = v1    # 值
6 k2:v2       # 值
7  
8 [section2] # 節點
9 k1 = v1    # 值
格式

　　

　　例若有個簡單的文件，如上咱們能夠對這個相應格式的文件進行一些操做

　　一、獲取全部節點 sections

?
1
2
3
4
5
6
import configparser
xx = configparser.ConfigParser()   # 建立一個對象
xx.read( "ini" ,encoding = "utf8" )     # 讀取相應文件
 
result = xx.sections()             # 獲取全部節點
print (result)

　　二、獲取指定節點下全部的鍵 options

?
1
2
3
4
5
6
7
import configparser
xx = configparser.ConfigParser()  # 建立一個對象
# xx的對象的read功能，打開讀取文件，放進內容
xx.read( "ini" ,encoding = "utf8" )    # 讀取相應文件
 
result = xx.options( "kaixin" )     # 獲取指定節點下全部的鍵
print (result)

　 三、獲取指定節點下全部的鍵值對 items

?
1
2
3
4
5
6
7
import configparser
xx = configparser.ConfigParser()  # 建立一個對象
# xx的對象的read功能，打開讀取文件，放進內容
xx.read( "ini" ,encoding = "utf8" )    # 讀取相應文件
 
result = xx.items( "kaixin" )       # 獲取指定節點下的全部鍵值對
print (result)

　　四、獲取指定節點下指定key的值

?
1
2
result = xx.get( "kaixin" , "age" )
print (result)

　　五、檢查，添加，刪除節點

?
1
2
3
4
5
6
7
8
9
10
11
# 檢查節點是否存在,返回的是布爾值
has_sec = xx.has_section( "kaixin" )
print (has_sec)
 
# 添加節點
xx.add_section( "Tom" )
xx.write( open ( "ini" , "w" ))
 
# 刪除節點
xx.remove_section( "Tom" )
xx.write( open ( "ini" , "w" ))

　　六、檢查、刪除、設置指定組內的鍵值對

?
1
2
3
4
5
6
7
8
9
10
11
# 檢查節點下的key值是否存在，返回的是布爾值
has_opt = xx.has_option( "kaixin" , "age" )
print (has_opt)
 
# 刪除鍵值對
xx.remove_option( "kaixin" , "money" )
xx.write( open ( "ini" , "w" ))
 
# 設置鍵值對
xx. set ( "tony" , "money" , "10000" )
xx.write( open ( "ini" , "w" ))

hashlib

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

?
1
2
3
4
5
import hashlib
 
hash = hashlib.md5(bytes( "bingdu" ,encoding = "utf8" )) # 建立md5對象,並額外加密
hash .update(bytes( "123" ,encoding = "utf8" )) # 對字符串加密
print ( hash .hexdigest()) # 取到密文

subprocess

 　　能夠執行shell命令的相關模塊和函數有

  • os.system
  • os.spawn*
  • os.popen*    —廢棄
  • popen2.*　　—廢棄
  • commands.* —廢棄,3.x中被移除

　　以上執行shell命令的相關的模塊和函數的功能均在 subprocess 模塊中實現，並提供了更豐富的功能。

subprocess.Popen(...)

用於執行復雜的系統命令

參數：

  • args：shell命令，能夠是字符串或者序列類型（如：list，元組）
  • bufsize：指定緩衝。0 無緩衝,1 行緩衝,其餘 緩衝區大小,負值 系統緩衝
  • stdin, stdout, stderr：分別表示程序的標準輸入、輸出、錯誤句柄
  • preexec_fn：只在Unix平臺下有效，用於指定一個可執行對象（callable object），它將在子進程運行以前被調用
  • close_sfs：在windows平臺下，若是close_fds被設置爲True，則新建立的子進程將不會繼承父進程的輸入、輸出、錯誤管道。
  • 因此不能將close_fds設置爲True同時重定向子進程的標準輸入、輸出與錯誤(stdin, stdout, stderr)。
  • shell：同上
  • cwd：用於設置子進程的當前目錄
  • env：用於指定子進程的環境變量。若是env = None，子進程的環境變量將從父進程中繼承。
  • universal_newlines：不一樣系統的換行符不一樣，True -> 贊成使用 \n
  • startupinfo與createionflags只在windows下有效
  • 將被傳遞給底層的CreateProcess()函數，用於設置子進程的一些屬性，如：主窗口的外觀，進程的優先級等等 
  • shell=True:  指定的命令行會經過shell來執行
  • stdin :   標準輸入
  • stdout : 標準輸出
  • stderr :  標準錯誤的文件句柄
  • PIPE :    管道 ,默認值 爲: None, 表示不作重定向，管道能夠用來接收數據。

optparse

Python 有兩個內建的模塊用於處理命令行參數：

一個是 getopt，《Deep in python》一書中也有提到，只能簡單處理 命令行參數；

另外一個是 optparse，它功能強大，並且易於使用，能夠方便地生成標準的、符合Unix/Posix 規範的命令行說明。

簡單流程

首先必須導入模塊optparse(這個很少說)

import optparse
# 建立OptionParser類對象
parser = optparse.OptionParser()
# 而後,使用add_option來定義命令行參數(僞代碼)
# parser.add_option(opt_str, ...
#                   attr= value,...)
# 每一個命令行參數就是由參數名字符串和參數屬性組成的。如 -f 或者 –file 分別是長短參數名：
parser.add_option("-f","--file",dest = "filename")
# 最後，一旦你已經定義好了全部的命令行參數，調用 parse_args() 來解析程序的命令行：
options,args = parser.parse_args()

注： 你也能夠傳遞一個命令行參數列表到 parse_args()；不然，默認使用 sys.argv[:1]。
parse_args() 返回的兩個值：
options，它是一個對象（optpars.Values），保存有命令行參數值。只要知道命令行參數名，如 file，就能夠訪問其對應的值： options.file 。
args，它是一個由 positional arguments 組成的列表。
View Code

struct

學習到socket網絡編程這裏,對struct有了認識,如今對它進行一些闡釋,也能夠較爲有效的解決粘包問題

struct模塊做用：解決bytes和其餘二進制數據類型的轉換

示例用法：
struct.pack('i',12)

參數說明：

pack函數做用：把任意數據類型變成bytes

i 表示4字節無符號整數。

複製代碼 
import struct
struct.pack('i',12) # 用方法pack進行打包,把後面的整形數據，封裝成一個bytes類型
b'\x0c\x00\x00\x00' # 長度就是4

l=struct.pack('i',12313123)
len(l)
4 #長度就是4
複製代碼

uppack

複製代碼 
# 反解
struct.unpack('i',l)
(12313123,)

# 查看類型
l=struct.pack('i',1)
type(l)
<class 'bytes'>  # bytes類型
複製代碼
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程