〖Python〗-- 模塊系列(一)

【模塊】

本節目錄

• 模塊相關介紹

• time

• random

• os

• sys

• json & pickle

• shelve

• xml

• configparser

• hashlib

• subprocess

• optparse

• struct

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

• 未完待續......

 爲何要有模塊：

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

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

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

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

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

模塊有三種：

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

模塊的引用方式:

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

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

　　二、from....import 模塊名

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)

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

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

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

 

格式

　　

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

　　一、獲取全部節點 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, 表示不作重定向，管道能夠用來接收數據。

把標準輸出放入管道中，屏幕上就不會輸出內容。
res=subprocess.Popen("dir", shell=True,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)   #執行dir命令，交給shell解釋器執行，經過標準類型和subprocess.PIPE放入管道中。
 
>>> res.stdout.read()  #讀取管道里面的數據，在程序中，讀取也不會輸出到屏幕上。
 
>>> res.stdout.read()   #再read一次，內容就爲空，說明讀取完成.
b''  #顯示爲：bytes類型

View Code

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類型