目錄

• Python - 模塊(一)
  • 模塊的引用方式
  • 常用模塊
    • random(隨機模塊)
    • os模塊
    • sys
    • 序列化模塊
    • hashlib
    • subprocess
    • optparse
    • struct

Python - 模塊(一)

模塊的引用方式

1. import 語句

   執行對應文件

   引入變量名

   import time #導入時間模塊,也可以同時導入多個模塊,用逗號隔開

2. from ... import 模塊名

    from my_model import main

3. from ... import *

    引入一切，即導入模塊中所有的項目，不推薦使用。因為引入的其它來源的命名，很可能覆蓋了已有的定義。

常用模塊

### time ###

時間相關的操作, 時間有三種表示方法:

• 時間戳(timestamp): 時間戳使用的是從1970年1月1日00點00分00秒得到現在一共經過了多少秒..用float表示.

• 格式化的字符串(strftime): 這個時間可以根據我們的需要對時間進行任意的格式化.

• 結構化時間(struct_time): 這個時間主要可以把時間進行分類規劃,比如,1970年01月01日 00點00分00秒 這個時間可以被細分為年,月,日..

生成時間戳

1. time.time()
輸出 1515137389.69163

生成格式化的時間字符串

1. time.ctime()
輸出 Fri Jan  5 15:34:00 2018
=============================
2. time.strftime("%Y-%m-%d %H:%M:%S")
輸出 2018-01-05 15:34:27
========================

生成結構化時間

1. time.gmtime()
輸出 time.struct_time(tm_year=2018, tm_mon=1, tm_mday=5, tm_hour=7, tm_min=34, tm_sec=57, tm_wday=4, tm_yday=5, tm_isdst=0)
===========================================================================================================================
2. time.localtime()
輸出 time.struct_time(tm_year=2018, tm_mon=1, tm_mday=5, tm_hour=15, tm_min=35, tm_sec=59, tm_wday=4, tm_yday=5, tm_isdst=0)
============================================================================================================================
 

時間戳轉格式化時間

t = time.localtime(188888888)   # 結構化時間
s = time.strftime("%Y-%m-%d %H:%M:%S", t)   # 格式化這個時間
print(s)

格式化時間轉化為時間戳

s = "2020-10-01 12:18:12"
t = time.strptime(s, "%Y-%m-%d %H:%M:%S")   # 轉化成結構化時間
print(time.mktime(t))   # 轉化成時間戳

計算時間差

import time
ture_time=time.mktime(time.strptime('2017-09-11 08:30:00'), "%Y-%m-%d %H:%M:%S")

time_now=time.mktime(time.strptime('2017-11-11 08:30:00'), "%Y-%m-%d %H:%M:%S")
dif_time=time_now-treu_time
stuct_time=time.localtime(dif_time)

datetime

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(隨機模塊)

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.choise([num, alf]) # 基於上面的可叠代對象選擇一個
        checkcode += str(add) # 將他們變成字符串,加到空字符串裏面
    return checkcode
if __name__ == "__main__":
    print(v_code())

os模塊

用於提供系統級別的操作

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解釋器相關的操作

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       錯誤相關

簡單的進度條

    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

json: 用於【字符串】和 【python基本數據類型】 間進行轉換,
(數據交互)，可以進行多種語言的數據交互

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

json用法
import json

1. 字典 -> 字符串 系列化

    dic = {"a":"模特", "b":"蘿莉", "c": "小清新"}
    json.dumps(dic, ensure_ascii=False)

2. 字符串 -> 字典 反序列化

    str = {"a":"模特", "b":"蘿莉", "c": "小清新"}
    json .loads(str)

3. 把序列化的結果寫入到文件中

    dic = {"a":"模特", "b":"蘿莉", "c": "小清新"}
    f = open("test.json", mode="w", encoding="utf-8")
    json.dump(dic, f, ensure_ascii=False) # 把對象打散成json寫入到文件中
    f.close()

4. 從文件件中讀取一個json
   f = open("test.json", mode="w", encoding="utf-8")
   dic = json.load(f)
   f.close()

pickle用法

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()

shelve

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

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'])k

hashlib

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

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

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 組成的列表。

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

unpack

# 反解
struct.unpack('i',l)
(12313123,)

# 查看類型
l=struct.pack('i',1)
type(l)
<class 'bytes'>  # bytes類型

Python - 模塊(一)