python 內置模塊

時間 2019-11-12

標籤 python 內置模塊欄目 Python 简体版

原文原文鏈接

1、序列號模塊(*****)

　　1.1 什麼是序列化,反序列化 python

#   序列化: 把內存中的數據轉化成一種中間的格式（json或pickle），而後存放在硬盤中，永久保存
#   反序列化：從硬盤中讀出（json或pickle）格式，而後反解成python 的數據類型

　　1.2 爲何要使用序列化linux

#   一、數據格式的持久化
#   二、跨平臺交互

　　1.3 如何使用序列化git

import json

dict = {'name':'jmz','age':23,'sex':'boy','school':{'small_school':'lala','middle_school':'chajj school'}}


with open('json.txt','w',encoding='utf-8') as f:
    f.write(json.dumps(dict))
    # json.dump(dict,f)     # 這是上面的簡寫


with open('json.txt','r',encoding='utf-8') as f:
    res = json.loads(f.readline())
    # res = json.load(f)        # 上面的簡寫


print(res['name'])

json_mod.py

import pickle               
                            
def func(name):             
    print(name)             
                            
dict = {'name':'jmz','school
                            
with open('pick.pkl','wb') a
    # pickle 只保存 bytes 類型的數據
    f.write(pickle.dumps(dic
    # pickle.dump(dict,f)   
                            
with open('pick.pkl','rb') a
    res = pickle.loads(f.rea
    # res = pickle.load(f)  
                            
print(res)                  
res['func'](res['name'])

pickle_mod

　　1.4 總結算法

# json：
#       優勢：全部的語言都支持json
#       缺點：只支持 部分的python 數據類型

# pickle:
#       優勢：支持全部的python 數據類型
#       缺點：只有python 語言支持

# 注意：
    # pickle 在保存數據時，只保存bytes類型，在轉化成pickle 時已經是bytes類型了

2、hash模塊(*****)

　　2.1 什麼是hashshell

#   hash 是一種算法，該算法是用來效驗數據內容的
#   多數用來加密數據，保證數據的安全。

　　2.2 怎麼使用json

import hashlib

m1= hashlib.md5()                   # 建立 一個md5的工廠
m1.update('中文'.encode('utf-8'))    # 向 工廠中添加內容   # 注意內容必須是 bytes類型
print(m1.hexdigest())               # 獲得hash 結果，md5 是固定32位的 hash算法加密




m2 = hashlib.sha512()
m2.update(b'hello')
m2.update(b'jmz')
m2.update(b'shanghai')
m2.update(b'haha')
print(m2.hexdigest())     # sha512 是可變長的 hash算法加密

hash_mod.py

　　2.3 流程windows

# 流程:
#     一、建立一個hash 工廠(hashlib.XXX())
#     二、向工廠中添加 bytes 數據。 必定要是 bytes 數據類型
#     三、得出hash算法後結果

3、日誌模塊(*****)

　　3.1 錯誤級別安全

# 一、debug   10 調試錯誤
# 二、info    20 提示錯誤
# 三、warning 30 警告錯誤
# 四、error   40 錯誤
# 五、critical 50 致命錯誤

　　3.2 日誌基礎使用(瞭解)bash

import logging
logging.basicConfig(
    filename='access.log',
    format = '%(asctime)s - %(name)s -%(levelname)s -%(module)s:%(message)s',
    datefmt='%Y-%m-%d %X',
    level=10,       # 能夠接受的至少什麼等級的錯誤
)



logging.debug('這是一個調試錯誤')
logging.info('這是一個info錯誤')
logging.warning('這是一個warining錯誤')
logging.error('這是一個error錯誤')
logging.critical('這是一個critical錯誤')


# 中文錯誤在文件的編碼使用的是系統的默認編碼

簡單運用,只作瞭解

　　3.3 日誌原理(項目中不推薦使用,需瞭解)數據結構

#logger：產生日誌的對象

#Filter：過濾日誌的對象

#Handler：接收日誌而後控制打印到不一樣的地方，FileHandler用來打印到文件中，StreamHandler用來打印到終端

#Formatter對象：能夠定製不一樣的日誌格式對象，而後綁定給不一樣的Handler對象使用，以此來控制不一樣的Handler的日誌格式

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmz

import logging

# logger對象： 生成對象，產生atm日誌
logger1=logging.getLogger('atm')


# handle對象, 控制日誌內容的去向，文件or終端
#      FileHandler 文件
#      StreamHandler 終端
a1=logging.FileHandler('a1.log',encoding='utf-8')
a2=logging.FileHandler('a2.log',encoding='utf-8')
ch = logging.StreamHandler()

# 創建 logger 和 handle 之間的綁定關係
logger1.addHandler(a1)
logger1.addHandler(a2)
logger1.addHandler(ch)


# Formatter 對象： 定製日誌格式
format1 = logging.Formatter('%(asctime)s - %(name)s -%(levelname)s -%(module)s:%(message)s',datefmt='%Y-%m-%d %X')
format2 = logging.Formatter('%(asctime)s-%(module)s:%(message)s',datefmt='%Y-%m-%d %X')

# 爲handle對象定製 日誌格式
a1.setFormatter(format1)
a2.setFormatter(format2)


# 設置 保存 錯誤的級別     先 logger  後a1 or a2    # 先頂級過濾 logger 後 纔是handle過濾
logger1.setLevel(10)
a1.setLevel(20)
a2.setLevel(30)




# 輸出錯誤
logger1.debug('這是一個bug錯誤')
logger1.error('這是一個error錯誤')
logger1.info('這是一個info錯誤')

企業項目中通常不使用,但須知原理

format參數中可能用到的格式化串：
%(name)s Logger的名字
%(levelno)s 數字形式的日誌級別
%(levelname)s 文本形式的日誌級別
%(pathname)s 調用日誌輸出函數的模塊的完整路徑名，可能沒有
%(filename)s 調用日誌輸出函數的模塊的文件名
%(module)s 調用日誌輸出函數的模塊名
%(funcName)s 調用日誌輸出函數的函數名
%(lineno)d 調用日誌輸出函數的語句所在的代碼行
%(created)f 當前時間，用UNIX標準的表示時間的浮 點數表示
%(relativeCreated)d 輸出日誌信息時的，自Logger建立以 來的毫秒數
%(asctime)s 字符串形式的當前時間。默認格式是 「2003-07-08 16:49:45,896」。逗號後面的是毫秒
%(thread)d 線程ID。可能沒有
%(threadName)s 線程名。可能沒有
%(process)d 進程ID。可能沒有
%(message)s用戶輸出的消息

日誌格式化串

　　原理圖

　　3.4 日誌記錄,公司經常使用

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmz

"""
logging配置
"""

import os
import logging.config

# 定義三種日誌輸出格式 開始

standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
                  '[%(levelname)s][%(message)s]' #其中name爲getlogger指定的名字

simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'

id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'

# 定義日誌輸出格式 結束

logfile_dir = os.path.dirname(os.path.abspath(__file__))  # log文件的目錄

logfile_name = 'all2.log'  # log文件名

# 若是不存在定義的日誌目錄就建立一個
if not os.path.isdir(logfile_dir):
    os.mkdir(logfile_dir)

# log文件的全路徑
logfile_path = os.path.join(logfile_dir, logfile_name)

# log配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},
    'handlers': {
        #打印到終端的日誌
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        #打印到文件的日誌,收集info及以上的日誌
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': logfile_path,  # 日誌文件
            'maxBytes': 1024*1024*5,  # 日誌大小 5M
            'backupCount': 5,
            'encoding': 'utf-8',  # 日誌文件的編碼，不再用擔憂中文log亂碼了
        },
    },
    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置
        '': {
            'handlers': ['default', 'console'],  # 這裏把上面定義的兩個handler都加上，即log數據既寫入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）傳遞
        },
    },
}


def load_my_logging_cfg():
    logging.config.dictConfig(LOGGING_DIC)  # 導入上面定義的logging配置
    logger = logging.getLogger(__name__)  # 生成一個log實例
    logger.info('It works!')  # 記錄該文件的運行狀態

if __name__ == '__main__':
    load_my_logging_cfg()

經過配置,設置日誌

4、正則模塊(*****)

　　4.1 正則方法

_compile(pattern, flags)           # 匹配正則

search(pattern,[string,],flags=0)  ===> _compile(pattern, flags).search(string)
    # 查找符合正則規則的pattern的string,
    # 存在返回 匹配對象，不存在返回None
re.search(pattern,string).group()  # 返回第一個匹配到的結果，沒有匹配則報錯

split(pattern,string,maxsplit=0)   # 以pattern 分割 string,並確認分割maxsplit份。默認分割所有，返回分割後的新列表

sub(pattern,repl,string)      # 在string 將匹配(pattern)到的內容替換成repl 返回替換後的結果

findall(pattern,string)    # 在 string 在 匹配到全部的pattern ，返回 列表

match(pattern,string)      # 在string的起始位置開始匹配pattern，存在返回對象，不存在，返回None
re.match(pattern,string).group(1)   # 返回匹配到的下標爲1的結果，下標爲0則爲自己

　　4.2 舉例使用方式

import re
content = 'asd3fdsjk43dsndf'
print(re.findall('\d',content))
# ['3', '4', '3']

findall.py

import re

test = '+-dsad-+dsa--dd++'
print(re.sub('\+\-','-',test))
# -dsad-+dsa--dd++

sub.py

import re

a = '23dasd2321dasdf3'

# search().group() 只取都第一個
print(re.search('\d',a).group())
# 2

#單純使用search 能夠確認是否存在值,存在爲真 不存在爲假
if re.search('\d',a):
    print('ok')
else:
    print('no')
# ok

search.py

import re

a = 'sda123dsa432'

# 已什麼做爲分割點，分割，  1 別是分割1次
res = re.split('\d',a,1)
print(res)
# ['sda', '23dsa432']

split.py

import re
content = 'jmz3s4[22],[3],[dsada]'

res = re.match('.*?\[(.*?)\].*?\[(.*?)\].*?\[(.*?)\]',content)

print(res.group())    # jmz3s4[22],[3],[dsada]
print(res.group(1))   # 22
print(res.group(2))   # 3
print(res.group(3))   # dsada

match.py

5、os模塊(*****)

　　os模塊是與操做系統交互的一個接口

os.getcwd() 獲取當前工做目錄，即當前python腳本工做的目錄路徑
os.chdir("dirname")  改變當前腳本工做目錄；至關於shell下cd
os.curdir  返回當前目錄: ('.')
os.pardir  獲取當前目錄的父目錄字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多層遞歸目錄
os.removedirs('dirname1')    若目錄爲空，則刪除，並遞歸到上一級目錄，如若也爲空，則刪除，依此類推
os.mkdir('dirname')    生成單級目錄；至關於shell中mkdir dirname
os.rmdir('dirname')    刪除單級空目錄，若目錄不爲空則沒法刪除，報錯；至關於shell中rmdir dirname
os.listdir('dirname')    列出指定目錄下的全部文件和子目錄，包括隱藏文件，並以列表方式打印
os.remove()  刪除一個文件
os.rename("oldname","newname")  重命名文件/目錄
os.stat('path/filename')  獲取文件/目錄信息
os.sep    輸出操做系統特定的路徑分隔符，win下爲"\\",Linux下爲"/"
os.linesep    輸出當前平臺使用的行終止符，win下爲"\t\n",Linux下爲"\n"
os.pathsep    輸出用於分割文件路徑的字符串 win下爲;,Linux下爲:
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所指向的文件或者目錄的最後修改時間
os.path.getsize(path) 返回path的大小

os模塊的方法

在Linux和Mac平臺上，該函數會原樣返回path，在windows平臺上會將路徑中全部字符轉換爲小寫，並將全部斜槓轉換爲飯斜槓。
>>> os.path.normcase('c:/windows\\system32\\')   
'c:\\windows\\system32\\'   
   

規範化路徑，如..和/
>>> os.path.normpath('c://windows\\System32\\../Temp/')   
'c:\\windows\\Temp'   

>>> a='/Users/jieli/test1/\\\a1/\\\\aa.py/../..'
>>> print(os.path.normpath(a))
/Users/jieli/test1

os路徑處理
#方式一：推薦使用
import os
#具體應用
import os,sys
possible_topdir = os.path.normpath(os.path.join(
    os.path.abspath(__file__),
    os.pardir, #上一級
    os.pardir,
    os.pardir
))
sys.path.insert(0,possible_topdir)


#方式二：不推薦使用
os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

6、sys模塊(****)

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

import time

# print('\r[#          ]',end='')
# time.sleep(0.3)
# print('\r[###        ]',end='')
# time.sleep(0.3)
# print('\r[#######    ]',end='')
# time.sleep(0.3)
# print('\r[###########]',end='')

# x = 0
# while x <= 50:
#     print('\r[%-50s] %d%%'%(x*'#',x//50*100),end='')    # %-50s  表示總共50個字符，不足以空格補充
#     x+=10
#     time.sleep(0.3)


def proccess(x,width=40):
    if x > 1:
        x =1
    pro_format = ('[%%-%ds]'%width) %(int(x*width)*'#')  # '%%' 表示%
    res = '%s %d%%'%(pro_format,int(x*100))
    print('\r %s'%res,end='')

start =0
total = 10484
while start <= total:
    start += 1024
    proccess(start/total)
    time.sleep(0.3)



# 補充知識點 1
#   在windows 中 \r 表示光標移動至行首， \n 跳到下一行，光標不變
#   linux \n 表示就是\r\n


# 補充知識點2
#   %-30s 表示共30個字符，不足以空格補充
#   %% 表示%， 由於格式化操做 % 有特殊意義
#   ('[%%-%ds]'%10)%('###')   ===> '[%-10s]'%('###')   ===> [###       ]

打印進度條

7、random 隨機模塊(*****)

1 random.random()      # (0,1)     0-1 之間取不到0和1
2 random.randint(2,5)   # [2,5]    取2與5之間的整數
3 random.choice([1,2,['jmz','ggf'],'aa'])  # 在 [1,2,['jmz','ggf'],'aa'] 列表 中隨機取一個返回
4 random.sample([1,2,['jmz','ggf'],'aa'],2)  # 在 [1,2,['jmz','ggf'],'aa'] 列表中 隨機取2個組成新的列表
5 random.shuffle([1,2,['jmz','ggf'],'aa'])  # 將列表的下標打亂。
6 random.uniform(4,6)        # （4,6） 取大於4小於6的小數

方法

import random
print(random.random())       # (0,1)  去小數
# 0.644271281361324

print(random.randint(2,4))   # [2,4]
# 4

print(random.choice([1,2,3,['a','jmz']]))     # 在[1,2,3,['a','jmz']] 中隨機取一個
# 2

print(random.sample([1,2,3,['a','jmz']],2))   # [1,2,3,['a','jmz']] 中取兩個 組成 新歷史列表
# [3, 2]

print(random.uniform(2,5))
# 4.7414246822271595

l = ['a','d',3,4,5]
print(random.shuffle(l))   # None
print(l)                   # ['d', 'a', 3, 5, 4]

具體用法

# ascii編碼表 十進制數與字符的轉化
# chr()   ord()

#  十進制 轉 字符
print(chr(43))

# 字符裝 十進制數
print(ord('+'))

import random
def make_code_one():
    '''
    隨機生成覺得字符
    a-z A-Z 0-9
    :return:
    '''
    s1 = random.randint(ord('a'),ord('z'))
    s2 = random.randint(ord('A'),ord('Z'))
    s3 = random.randint(ord('0'),ord('9'))
    res = random.choice([s1,s2,s3])
    return chr(res)

def make_code(n):
    res = ''
    for i in range(n):
        res = res + make_code_one()
    return res

print(make_code(4))

隨機驗證碼生成

8、time模塊(*****)

　　8.1 時間戳,結構化時間,格式化時間

import time

# 一、時間戳 以unix元年（1970-01-01 00:00:00）開始計算一直到當前時間的秒數
print(time.time())
# 1526911211.354357


# 二、結構化時間
print(time.localtime())  # 本地的結構化時間
# time.struct_time(tm_year=2018, tm_mon=5, tm_mday=21, tm_hour=22, tm_min=0, tm_sec=11, tm_wday=0, tm_yday=141, tm_isdst=0)
print(time.localtime().tm_year)
# 2018
print(time.gmtime())     # 世界的結構化時間
# time.struct_time(tm_year=2018, tm_mon=5, tm_mday=21, tm_hour=14, tm_min=0, tm_sec=11, tm_wday=0, tm_yday=141, tm_isdst=0)


# 三、格式化時間
print(time.strftime('%Y-%m-%d %X'))
# 2018-05-21 22:00:11

　　8.2時間戳,結構化時間與格式化時間之間的相互轉化

# 一、時間戳  結構化時間  相互轉化
print(time.localtime(1526911211.354357))     # 時間戳轉結構化時間
# time.struct_time(tm_year=2018, tm_mon=5, tm_mday=21, tm_hour=22, tm_min=0, tm_sec=11, tm_wday=0, tm_yday=141, tm_isdst=0)

print(time.mktime((2009, 2, 17, 17, 3, 38, 1, 48, 0)))    # 格式化時間轉 時間戳
# 1234861418.0

# 二、結構化時間 格式化時間 相互轉化
print(time.strftime('%Y-%m-%d %X',(2009, 2, 17, 17, 3, 38, 1, 48, 0)))  # 結構化時間轉 格式化時間
# 2009-02-17 17:03:38
print(time.strptime('2018-04-09 14:23:14','%Y-%m-%d %H:%M:%S'))   # 格式化時間轉 結構化時間

# 1.1   時間戳轉結構化時間  ===> localtime,gmtime
# 1.2   結構化時間轉時間戳  ===> mktime

# 2.1   結構化時間轉格式化時間 ===> strftime
# 2.2   格式化時間轉結構化時間 ===> strptime

　　圖解

# time 模塊沒有之間進行時間戳與格式化時間的轉換,但能夠本身手寫一個

import time

# 格式化時間轉 時間戳
def mktime(string,format):
    return time.mktime(time.strptime(string,format))

# 時間戳轉 格式化時間
def date(format,strtime=time.time()):
    struct_time = time.localtime(strtime)
    return time.strftime(format,struct_time)

print(mktime('2017-08-09 14:13:34','%Y-%m-%d %H:%M:%S'))
# 1502259214.0


print(date('%Y-%m-%d'))
# 2018-05-21

時間戳與格式化時間的轉化

%a    Locale’s abbreviated weekday name.     
%A    Locale’s full weekday name.     
%b    Locale’s abbreviated month name.     
%B    Locale’s full month name.     
%c    Locale’s appropriate date and time representation.     
%d    Day of the month as a decimal number [01,31].     
%H    Hour (24-hour clock) as a decimal number [00,23].     
%I    Hour (12-hour clock) as a decimal number [01,12].     
%j    Day of the year as a decimal number [001,366].     
%m    Month as a decimal number [01,12].     
%M    Minute as a decimal number [00,59].     
%p    Locale’s equivalent of either AM or PM.    (1)
%S    Second as a decimal number [00,61].    (2)
%U    Week number of the year (Sunday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Sunday are considered to be in week 0.    (3)
%w    Weekday as a decimal number [0(Sunday),6].     
%W    Week number of the year (Monday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Monday are considered to be in week 0.    (3)
%x    Locale’s appropriate date representation.     
%X    Locale’s appropriate time representation.     
%y    Year without century as a decimal number [00,99].     
%Y    Year with century as a decimal number.     
%z    Time zone offset indicating a positive or negative time difference from UTC/GMT of the form +HHMM or -HHMM, where H represents decimal hour digits and M represents decimal minute digits [-23:59, +23:59].     
%Z    Time zone name (no characters if no time zone exists).     
%%    A literal '%' character.

時間格式

9、datetime模塊(*****)

# datetime 就是基於time 模塊發展而來，到用法更簡單

import datetime,time
print(datetime.datetime.now())
# 2018-05-21 22:52:39.542560

print(datetime.date.fromtimestamp((time.time())))
# 2018-05-21  時間轉日期

print(datetime.datetime.now() + datetime.timedelta(-3))
print(datetime.datetime.now() - datetime.timedelta(3))
# 2018-05-18 22:56:21.981011  上面兩個的效果是 同樣的  都是 在當天的基礎上減3天

print(datetime.datetime.now() + datetime.timedelta(hours=-3))
print(datetime.datetime.now() - datetime.timedelta(hours=3))
# 2018-05-21 19:58:22.163141   上面兩個的效果是 同樣的  都是 在當天的基礎上減3小時

print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #當前時間+30分
# 2018-05-21 23:29:06.690998

c_time = datetime.datetime.now()
print(c_time.replace(minute=30,hour=2,day=19))
# 2018-05-19 02:30:19.485846

10、configparser 模塊(***)

# 用戶對 ini 一類文件的讀寫操做
# 通常使用與 對環境，或系統 配置文件的 讀寫操做

import configparser
config = configparser.ConfigParser()    #  生成object 對象
config["DEFAULT"] = {'ServerAliveInterval': '45',
                     'Compression': 'yes',
                     'CompressionLevel': '9',
                     'time' : 12.34}

config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'
config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
topsecret['Host Port'] = '50022'  # mutates the parser
topsecret['ForwardX11'] = 'no'  # same here
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:
    config.write(configfile)

寫一個example.ini 的配置文件

res = configparser.ConfigParser()
res.read('example.ini')

print(res.sections())
print(res.options('topsecret.server.com'))

print(res.get('bitbucket.org','forwardx11'))
print(res.getint('bitbucket.org','CompressionLevel'))
print(res.getfloat('bitbucket.org','time'))

讀 example.ini 配置文件

11、subprocess 模塊(*****)

# 看名字即知 和 子進程有關。
# 主要使用：
#     執行命令獲取進程執行的結果保存。


# 注意
#       os模塊 也能夠執行命令 開啓了一個進程，可是沒法保存結果。

import subprocess,time
# 開啓子進程執行
res = subprocess.Popen('tasklist'
                       ,shell=True
                       # ,stdout=subprocess.PIPE          # 標準化輸出
                       # ,stderr=subprocess.PIPE          # 錯誤輸出
)
time.sleep(1)
print(res)
print(res.stdout.read().decode('gbk'))           # res.stdout.read() 拿到的是一個utf-8或者gbk的16進制碼，這個是操做系統默認字符編碼有關


# 在沒有stdout=subprocess.PIPE的狀況下，子進程命令結果或直接輸入到終端，可否正常顯示，取決於該程序的結束時間是否大於子進程的結束時間，大於則顯示，小於則來不急顯示
# 在有stdout=subprocess.PIPE的狀況下，只有須要（res.stdout.read()）是纔會顯示

12、shutil模塊(***)

# 高級的 文件、文件夾、壓縮包 處理模塊

# 一、shutil.copyfileobj(fsrc, fdst[, length])
# 將文件內容拷貝到另外一個文件中
#  shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))

# 二、shutil.copyfile(src, dst) #拷貝文件

# 三、shutil.copymode(src, dst) # 僅拷貝權限。內容、組、用戶均不變

# 四、shutil.copystat(src, dst) # 僅拷貝狀態的信息，包括：mode bits, atime, mtime, flags

# 五、shutil.copy(src, dst) # 拷貝文件和權限

# 六、 shutil.copy2(src, dst) # 拷貝文件和狀態信息

# 七、shutil.copytree(src, dst, symlinks=False, ignore=None) #遞歸的去拷貝文件夾
#   shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
# #目標目錄不能存在，注意對folder2目錄父級目錄要有可寫權限，ignore的意思是排除


# 八、shutil.rmtree(path[, ignore_errors[, onerror]]) # 遞歸的去刪除文件

# 九、shutil.move(src, dst) # mv 遞歸的去移動文件，它相似mv命令，其實就是重命名。

# 十、shutil.make_archive(base_name, format,...)
#    base_name： 壓縮包的文件名，也能夠是壓縮包的路徑。只是文件名時，則保存至當前目錄，不然保存至指定路徑，
#    如 data_bak                       =>保存至當前路徑
#    如：/tmp/data_bak =>保存至/tmp/
#    format：    壓縮包種類，「zip」, 「tar」, 「bztar」，「gztar」
#    root_dir：    要壓縮的文件夾路徑（默認當前目錄）
#    owner：    用戶，默認當前用戶
#    group：    組，默認當前組
#    logger：    用於記錄日誌，一般是logging.Logger對象

# 壓縮
import shutil
res =shutil.make_archive('a',format='zip')
print(res)

壓縮

# 解壓
import zipfile
z= zipfile.ZipFile('a.zip','r')
z.extractall('./a')
z.close()

解壓

shutil 壓縮的原理就是經過zipfile,tarfile 進行壓縮

import zipfile

# zip 壓縮
z = zipfile.ZipFile('a.zip','w')
z.write('a.txt')
z.write('index.py')
z.close()


# zip解壓
z = zipfile.ZipFile('a.zip','r')
z.extractall('./a')
z.close()

zipfile

import tarfile,os

# 壓縮
t = tarfile.TarFile('a.tar','w')
t.add('a.txt')
t.close()

# 解壓
t= tarfile.TarFile('a.tar','r')
t.extractall('./a')
t.close()

tarfile

十3、shelve模塊(***)

import shelve
# shelve 比 pickle 更簡單

# 添加數據
f= shelve.open(r'test')
f['jmz'] = {'name':'jmz','age':25,'weight':175.3}
f['jly'] = {'name':'jly','age':27,'weight':165.3}
f.close()


# 讀和改
f= shelve.open(r'test',writeback=True)         # 改變數據必需要加writeback=True，添加則不須要
f['jmz']['age'] =35    # 改數據
print(f['jmz'])
f.close()

十4、xml 模塊(***)

xml是實現不一樣語言或程序之間進行數據交換的協議，跟json差很少，但json使用起來更簡單，不過，古時候，在json還沒誕生的黑暗年代，你們只能選擇用xml呀，至今不少傳統公司如金融行業的不少系統的接口還主要是xml。

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

<?xml version="1.0"?>
<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 數據結構

xml協議在各個語言裏的都是支持的，在python中能夠用如下模塊操做xml：

import xml.etree.ElementTree as ET

tree = ET.parse('b.xml')
root = tree.getroot()           # 獲取內容主體
print(root)

print(tree.find('country'))         # 返回第一個country子節點元素
print(tree.findall('country'))      # 返回全部的country子節點元素
print(tree.iter('year'))            # 返回全部的 year 元素

# 遍歷
for country in tree.findall('country'):
    rank = country.find('rank')
    print('%s-->%s-->%s'%(rank.tag,rank.attrib,rank.text))

# tag 標籤
# attrib 獲取的是元素的屬性
# text 獲取元素的文本內容
# {'updated': 'yes'}---->2
# {'updated': 'yes'}---->5
# {'updated': 'yes'}---->69





# 增長元素
country2 = ET.Element('country')    # 建立一個新元素
country2.text='jmz'
country2.attrib = {'updated':'yes','version':'1.0'}
root.append(country2)     # 主體部分 添加一個新元素

tree.write('new.xml',encoding='utf-8')    # tree



# 修改
for year in tree.iter('year'):
    year.text = str(2016)    # xml 必須是str類型
    year.set('updated','yes')
    year.set('version','1.0')

tree.write('b.bat.xml')

xml 操做

import xml.etree.ElementTree as ET

new_xml = ET.Element('namelist')
name = ET.SubElement(new_xml,'jmz',attrib={'updated':'yes'})   # 建立子節點
age = ET.SubElement(name,'age',attrib={'year':'1994'})
age.text = 'jmz'
sex = ET.SubElement(name,'sex',text='男')
sex.text = '男'

name2 = ET.SubElement(new_xml,'jly',attrib={'updated':'yes'})
age2 = ET.SubElement(name2,'age',attrib={'year':'1994'})
age2.text = 'jly'
sex2 = ET.SubElement(name2,'sex')
sex2.text = '女'

object = ET.Element('object')
object.text = 'oldboy'
object.attrib={'addr':'shanghai','time':'2018-01-01'}


et=ET.ElementTree(new_xml)
et.write('namelist.xml',encoding='utf-8',xml_declaration=True)

ET.dump(new_xml)