Python之模塊

一 模塊介紹

某個功能相關的代碼集合。主要分爲三種模塊：

自定義模塊、內置標準模塊(標準庫)和開源模塊

 

二 time & datetime 模塊

import time

'''
表示時間的幾種方法
1）時間元組 time.struct_time(time_year=2016,tm_mom=7,tm_day=21,tm_hour)
2) 時間戳距離1970-01-01 00:00:00 此時間的總秒數
3）格式化顯示 ('%Y-%m-%d %X')
4）英文顯示 Mon Apr 17 21:14:36 2017
'''
# 返回本地時間的struct time對象格式
# time.struct_time(tm_year=2017, tm_mon=4, tm_mday=17, tm_hour=21, tm_min=25,tm_sec=18, tm_wday=0, tm_yday=107, tm_isdst=0)
print("localtime=> ",time.localtime())

# 返回UTC時間的struct時間對象格式
# time.struct_time(tm_year=2017, tm_mon=4, tm_mday=17, tm_hour=10, tm_min=41,tm_sec=33, tm_wday=0, tm_yday=107, tm_isdst=0)
print("gmtime=> ",time.gmtime(time.time() - 10000))

# 返回英語表示的時間 Mon Apr 17 21:29:41 2017
print("ctime =>",time.ctime())


#將日期字符串轉成 struct時間對象格式
# time.struct_time(tm_year=2017, tm_mon=4, tm_mday=17, tm_hour=21, tm_min=30,tm_sec=21, tm_wday=0, tm_yday=107, tm_isdst=-1)
string_2_struct = time.strptime("2017-04-17 21:30:21","%Y-%m-%d %H:%M:%S") #將日期字符串轉成 struct時間對象格式
print("日期字符串轉成 struct時間對象格式:strptime=>",string_2_struct)

# 將指定struct_time格式轉成指定的字符串 2017-04-1713:38:46
struct_2_string = time.strftime("%Y-%m-%d %X",time.gmtime())
print("將指定struct_time格式轉成指定的字符串:strftime=>", struct_2_string)

#將struct時間對象轉成時間戳 1492435821.0
struct_2_stamp = time.mktime(string_2_struct)
print("將struct時間對象轉成時間戳:mktime=>", struct_2_stamp)

# 求當前的時間戳
time.time()


'''
時間格式化：

%y 兩位數的年份表示（00-99）
%Y 四位數的年份表示（000-9999）
%m 月份（01-12）
%d 月內中的一天（0-31）
%H 24小時制小時數（0-23）
%I 12小時制小時數（01-12）
%M 分鐘數（00=59）
%S 秒（00-59）

%a 本地簡化星期名稱
%A 本地完整星期名稱
%b 本地簡化的月份名稱
%B 本地完整的月份名稱
%c 本地相應的日期表示和時間表示
%j 年內的一天（001-366）
%p 本地A.M.或P.M.的等價符
%U 一年中的星期數（00-53）星期天爲星期的開始
%w 星期（0-6），星期天爲星期的開始
%W 一年中的星期數（00-53）星期一爲星期的開始
%x 本地相應的日期表示
%X 本地相應的時間表示
%Z 當前時區的名稱
%% %號本身
'''

import _datetime
import time


# 表示當前時間
print(_datetime.datetime.now())

# 時間戳直接轉換成日期格式 2017-04-17
print(_datetime.date.fromtimestamp(time.time()))

# 當前時間+3天
print(_datetime.datetime.now() + _datetime.timedelta(3))

# 當前時間-3天
print(_datetime.datetime.now() - _datetime.timedelta(3))

#當前時間+3小時
print(_datetime.datetime.now() + _datetime.timedelta(hours=3))

#當前時間+30分
print(_datetime.datetime.now() + _datetime.timedelta(minutes=30))

dt = _datetime.datetime(2017,4,18,22,20,34,123)

# 取出年、月、日等信息
print(dt.year,dt.month,dt.day)

# 取出年月日和時間2017-04-17 22:20:34.000123
print(dt.date(),dt.time())

# 取出周幾和日曆 (2017, 16, 2) 哪一年那一週第幾天
print(dt.weekday(), dt.isocalendar())

# 獲取時間戳
print(dt.timestamp())

# 按照自定義格式返回字符串 2017-04-18
print(dt.strftime("%Y-%m-%d"))

# 得到時間元組
print(dt.timetuple())

 

二 OS 和 sys模塊

import os

'''
提供對操作系統進行調用的接口
'''

# 獲取當前工作目錄
print(os.getcwd())

print(os.curdir)

# 返回path所指向的文件或者目錄的最後存取時間
print(os.path.getatime("E:\Java學習筆記\腳本語言\python\python"))

# 反回path所指向的文件或者目錄的最後修改時間
print(os.path.getmtime("E:\Java學習筆記\腳本語言\python\python"))

# 判斷給定的路徑是目錄還是文件
os.path.isdir("E:\Java學習筆記\腳本語言\python\python")

os.path.isfile("E:\Java學習筆記\腳本語言\python\python\文件操作.txt")

# 判斷路徑是否存在
os.path.exists("E:\Java學習筆記\腳本語言\python\python")

# 如果path是絕對路徑，返回True
os.path.isabs("E:\Java學習筆記\腳本語言\python\python")

# 返回指定路徑中最後一層文件或者目錄
print(os.path.basename("E:\Java學習筆記\腳本語言\python\python"))

# 返回當前文件或者目錄位於哪一個目錄下
print(os.path.dirname("E:\Java學習筆記\腳本語言\python\python\文件操作.txt"))

# 將basename和前面的進行分割,元組的形式返回
print(os.path.split("E:\Java學習筆記\腳本語言\python\python\文件操作.txt"))

# 獲取系統環境變量
os.environ

# 重命名文件/目錄
#os.rename("oldname","newname")

'''
獲取文件/目錄信息
st_mode=33206, st_ino=3940649674019449, st_dev=178758312, st_nlink=1,
st_uid=0, st_gid=0, st_size=586, st_atime=1491655549, st_mtime=1491656964, st_ctime=1491655549
'''
print(os.stat("E:\Java學習筆記\腳本語言\python\python\文件操作.txt"))

# 刪除一個文件
# os.remove()

#  列出指定目錄下的所有文件和子目錄，包括隱藏文件，並以列表方式打印
print(os.listdir('E:\Java學習筆記\腳本語言\python\python'))

# 創建和刪除目錄
os.mkdir('E:\Java學習筆記\腳本語言\python\python2')
# 可生成多層遞歸目錄
os.makedirs('E:\Java學習筆記\腳本語言\python\python2\test')

os.rmdir('E:\Java學習筆記\腳本語言\python\python2')
# 若目錄爲空，則刪除，並遞歸到上一級目錄，如若也爲空，則刪除，依此類推
os.removedirs('E:\Java學習筆記\腳本語言\python\python2')

 

 

 

import sys

print(sys.version)
print(sys.maxsize)
print(sys.path )
print(sys.platform)

 

 

三 JSON 和 pickle

'''
json，用於字符串和 python數據類型間進行轉換
'''
import json

data = [
    {"姓名": "nicky", "年齡": 29, "gender": "男", "城市": "成都"},
    {"姓名": "alice", "年齡": 25, "gender": "女", "城市": "北京"},
    {"姓名": "britney", "年齡": 24, "gender": "女", "城市": "舊金山"},
    {"姓名": "houston", "年齡": 39, "gender": "女", "城市": "洛杉磯"},
    {"姓名": "belly", "年齡": 25, "gender": "女", "城市": "倫敦"},
    {"姓名": "mark", "年齡": 28, "gender": "男", "城市": "香港"}
]
# 對數據進行編碼，將python對象轉換成json字符串
json_str = json.dumps(data)

# 將數據轉化爲json字符串，並寫入文件
with open('D:/python/result.json','w') as fp:
    json.dump(data,fp)




# 讀取json串，對數據進行解碼，轉換成python對象
obj = json.loads(json_str)

# 從文件讀取字符串，對數據解碼，轉換成python對象
with open('D:/python/result.json','r') as fp:
    json.load(fp)

import pickle

filename = "D:/python/result.json"

animals = ['lion','tiger','hadoop','dog','snake','hive']
person = ("nicky",29,"male","chengdu")

data = pickle.dumps(bytes(animals))
print(data)

四 Shutil 模塊 

import shutil
'''
這是一個高級的文件、文件夾、壓縮包處理模塊
'''

# 定義幾個變量
src = "D:\python\src.txt"
dst = "D:\python\dest.txt"
# 將文件內容拷貝到另一個文件中,可以拷貝部分
# shutil.copyfileobj(src,dst)

# copyfile：從源文件拷貝內容到目標文件
# shutil.copyfile(src,dst)

# copymode：只是拷貝源文件權限。不拷貝內容、組、用戶等
# shutil.copymode(src,dst)

# copystat：拷貝文件狀態信息
# shutil.copystat(src, dst)

# 既拷貝文件內容，又拷貝文件權限
# shutil.copy(src, dst)

# 既拷貝文件內容，又拷貝文件狀態
# shutil.copy2(src, dst)

'''
文件夾遞歸拷貝
src => 代表源文件夾
dst => 代表目的地，但是不能存在，存在則會報錯
ignore => 對文件或者文件夾進行過濾，表示拷貝到是時候，哪些可以忽略
'''
# shutil.copytree("D:\python\srcf","D:\python\destf",ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))

'''
遞歸刪除文件夾
src => 代表源文件夾
dst => 代表目的地，但是不能存在，存在則會報錯
ignore_errors => 是否可以忽略錯誤,默認就是False
'''
# shutil.rmtree(src,True)

'''
遞歸移動文件夾
src => 代表源文件夾
dst => 代表目的地
'''
# shutil.move(src,dst)

'''
創建壓縮包，並返回路徑
base_name：壓縮包的文件名，也可以是壓縮包的路徑。只是文件名時，則保存至當前目錄，否則保存至指定路徑，
format：    壓縮包種類，“zip”, “tar”, “bztar”，“gztar”
root_dir：  要壓縮的文件夾路徑（默認當前目錄）
owner：用戶，默認當前用戶
group：組，默認當前組
logger：    用於記錄日誌，通常是logging.Logger對象
'''
# 對D:/python/srcf進行zip壓縮沒然後放到D:/python/target目錄下面
# shutil.make_archive("D:/python/target",'zip',"D:/python/srcf")

'''
shutil 對壓縮包的處理是調用 ZipFile 和 TarFile 兩個模塊來進行的
'''
import zipfile

# 壓縮：產生一個壓縮文件，然後把src 和 dst文件全部壓縮到這個壓縮文件中
z = zipfile.ZipFile('D:/python/tmp.zip', 'w')
z.write(src)
z.write(dst)
z.close()

# 解壓縮
z = zipfile.ZipFile('D:/python/tmp.zip', 'r')
z.extractall()
z.close()


import tarfile

# 壓縮
tar = tarfile.open('your.tar','w')
tar.add('D:/python/1.zip', arcname='1.zip')
tar.add('D:/python/2.zip', arcname='2.zip')
tar.close()

# 解壓
tar = tarfile.open('/opt/tools/3.tar','r')
tar.extractall()  # 可設置解壓地址
tar.close()

五 shelve <k,v>內存數據塊模塊

'''
shelve模塊是一個簡單的k,v將內存數據通過文件持久化的模塊，可以持久化任何pickle可支持的python數據格式
shelve類似於一個key-value數據庫，可以很方便的用來保存Python的內存對象，其內部使用pickle來序列化數據，
簡單來說，使用者可以將一個列表、字典、或者用戶自定義的類實例保存到shelve中，下次需要用的時候直接取出來，
就是一個Python內存對象，不需要像傳統數據庫一樣，先取出數據，然後用這些數據重新構造一遍所需要的對象
'''

import shelve

'''
創建數據庫
flag取值範圍
'r' => 只讀打開
'w' => 讀寫訪問
'c' => 讀寫訪問，如果不存在則創建
'n' => 讀寫訪問，總是創建新的、空的數據庫文件

writeback：爲True時，當數據發生變化會回寫，不過會導致內存開銷比較大
'''

db = shelve.open("D:/python/shelve/shelve.db",flag='c',writeback=True)

# 插入數據
db['abc'] = {'name':['a','b']}
db.sync()
print(type(db['abc']))

# writeback是False，因此對value進行修改是不起作用的
db['abc']['name'] = ['a','b','c']
print(db['abc'])
# 此時打印的還是{'name':['a','b']}
# 如果writeback是True,這時候就打印{'name': ['a', 'b', 'c']}

db['con'] = [1,2,3,4]
db['con'].append(5)
print(db['con']) # [1, 2, 3, 4] ? 在內存緩存中
'''
是把open方法的writeback參數的值賦爲True，這樣的話，
你open後所有的內容都將在cache中，當你close的時候，
將全部一次性寫到硬盤裏面。如果數據量不是很大的時候，建議這麼做。
'''
# 關閉數據庫
db.close()

六 XML 模塊

from xml.etree import ElementTree as ET

# 解析xml文件生成一個樹
tree = ET.parse("D:/python/data.xml")

# 獲取root節點
root = tree.getroot()


#遍歷xml文檔
for child in root:
    print(child.tag,child.attrib)
    for i in child:
        print(i.tag,i.text)


#只遍歷year 節點
for node in root.iter('year'):
    print(node.tag,node.text)

# 修改和刪除xml文檔內容
for node in root.iter('year'):
    new_year = int(node.text) + 1
    node.text = str(new_year)
    node.set("updated", "yes")

tree.write("D:/python/data_update.xml")

# 刪除node
for country in root.findall('country'):
    rank = int(country.find('rank').text)
    if rank > 50:
        root.remove(country)

tree.write("D:/python/data_delete.xml")

# 創建xml文檔
new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml, "name", attrib={"enrolled": "yes"})
age = ET.SubElement(name, "age", attrib={"checked": "no"})
sex = ET.SubElement(name, "sex")
sex.text = '33'
name2 = ET.SubElement(new_xml, "name", attrib={"enrolled": "no"})
age = ET.SubElement(name2, "age")
age.text = '19'

et = ET.ElementTree(new_xml)  # 生成文檔對象
et.write("D:/python/data_create.xml", encoding="utf-8", xml_declaration=True)

ET.dump(new_xml)  # 打印生成的格式

七 logging模塊

'''
很多程序都有記錄日誌的需求，並且日誌中包含的信息即有正常的程序訪問日誌，
還可能有錯誤、警告等信息輸出，python的logging模塊提供了標準的日誌接口，
你可以通過它存儲各種格式的日誌，logging的日誌可以分爲 debug(), info()
, warning(), error() and critical() 5個級別，下面我們看一下怎麼用。
'''

import logging

'''
level=loggin.INFO意思是，把日誌紀錄級別設置爲INFO，也就是說，只有比日誌是INFO
或比INFO級別更高的日誌纔會被紀錄到文件裏，在這個例子，第一條日誌是不會被紀錄的，
如果希望紀錄debug的日誌，那把日誌級別改成DEBUG就行了。
日誌級別的優先級從低到高
DEBUG
INFO
WARNING
ERROR
CRITICAL
'''

# logging.basicConfig(filename='D:/python/run.log',level=logging.DEBUG)
# logging.debug('This message should go to the log file')
# logging.info('So should this')
# logging.warning('And this, too')

'''
給日誌格式加上時間

'''
logging.basicConfig(filename='D:/python/run.log',format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
logging.warning('is when this event was logged.')
logging.debug('This message should go to the log file')
logging.info('So should this')
logging.warning('And this, too')

import logging

# 創建Logger
logger = logging.getLogger("MULTI-LOG")
logger.setLevel(logging.DEBUG)

# 創建Console Handler 並且設置日誌級別Debug
ch = logging.StreamHandler


# 創建文件Handlder，設置日誌級別INFO
file = logging.FileHandler("access.log")
file.setLevel(logging.WARNING)

# 創建格式化類
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# 添加formatter to 控制檯和文件

file.setFormatter(formatter)

# 向logger註冊handler

logger.addHandler(file)


logger.debug('debug message')
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')

八  paramiko模塊

Paramiko模塊主要是基於ssh進行遠程的操作

8.1 SSHClient 

連接遠程服務器，並進行操作

HOST_NAME = "hadoop-all-01"
PORT = 22
USERNAME = "hadoop"
PASSWORD = "hadoop"

def sample():
    ssh = paramiko.SSHClient()
    # 允許連接不在know_hosts文件中的主機
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    # 連接服務器
    ssh.connect(hostname=HOST_NAME, port=PORT, username=USERNAME, password=PASSWORD)
    ssh.exec_command("touch /opt/shell/python.sh")
    ssh.exec_command("chmodu+x /opt/shell/python.sh")
    stdin, stdout, stderr = ssh.exec_command("ll /opt/shell")
    #stdout.read(),stderr.read() 可能只有其中一個有值，我麼通過filter,然後利用lambda表達式直接判斷如果不爲空才放入列表
    result = filter(lambda x: x is not None, [stdout.read(),stderr.read()])
    print(result)
    ssh.close()

封裝Transport

# SSHClient 封裝Transport
def getSSHClient(hostname,port,username,password,allow_

missing_host_key_policy):
    address = (hostname,port)
    transport = paramiko.Transport(address)
    transport.connect(username=USERNAME,password=PASSWORD)

    # 創建SSH對象
    client = paramiko.SSHClient()
    client._transport = transport
    if allow_missing_host_key_policy:
        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    return client

# 基於公鑰和密鑰連接
def getSSHClientWithPrivateKey(hostname,port,username,allow_

missing_host_key_policy,private_key):
    address = (hostname,port)
    transport = paramiko.Transport(address)
    transport.connect(username=USERNAME,pkey=private_key)

    # 創建SSH對象
    client = paramiko.SSHClient()
    client._transport = transport
    if allow_missing_host_key_policy:
        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    return client

if __name__ == "__main__":
    private_key = paramiko.RSAKey.from_private_key_file("/home/hadoop/.ssh/id_rsa")
    client = getSSHClientWithPrivateKey(HOST_NAME,PORT,USERNAME,PASSWORD,True,private_key)
    client.close()

8.2 SFTPClient

連接遠程服務器並執行上傳和下載

# 基於用戶名和密碼上傳下載
def getSFTPClient(hostname,port,username,password):
    address = (hostname, port)
    transport = paramiko.Transport(address)
    transport.connect(username=username,password=password)
    sftp = paramiko.SFTPClient.from_transport(transport)
    return sftp

# 基於公鑰密鑰上傳下載
def getSFTPClientWithKey(hostname,port,username,password,key):
    address = (hostname, port)
    transport = paramiko.Transport(address)
    if key:
        transport.connect(username=username,password=password)
    else:
        transport.connect(username=username,pkey=key)
    sftp = paramiko.SFTPClient.from_transport(transport)
    return sftp

def upload(hostname,port,username,password,src,dest):
    print(hostname,username,src,dest)
    sftp = getSFTPClient(hostname,port,username,password)
    print(sftp)
    # 默認情況下，目錄或者文件不能存在，因爲寫文件模式是wb
    sftp.put(src,dest)
    sftp.close()

def download(hostname,port,username,password,src,dest,key):
    sftp = getSFTPClientWithKey(hostname,port,username,

password,key)
    sftp.get(src,dest)
    sftp.close()

if __name__ == "__main__":
    private_key = paramiko.RSAKey.from_private_key_file("/home/hadoop/.ssh/id_rsa")
    src = "/opt/shell/manage.sh"
    dest = "D:/python/manage.sh"
    #upload(HOST_NAME,PORT,USERNAME,PASSWORD,src,dest)
    download(HOST_NAME,PORT,USERNAME,PASSWORD,src,dest,private_key)