python基礎之經常使用模塊

一 time模塊

時間表示形式：

在Python中，一般有這三種方式來表示時間：時間戳、元組（struct_time）、格式化的時間字符串：
（1）時間戳（timestamp）:一般來講，時間戳表示的是從1970年1月1日00:00:00開始按秒計算的偏移量。咱們運行「type(time.time())」,返回的是float類型。
（2）格式化的時間字符串（Format String）：'1988-03-16'
（3）元組（struct_time）:struct_time元組共有9個元素共九個元素:(年，月，日，時，分，秒，一年中第幾周，一年中第幾天等)

# <1> 時間戳

import time
print(time.time())    #--------------返回當前時間的時間戳
#1493194473.8422034

# <2> 時間字符串

print(time.strftime("%Y-%m-%d %X"))
#2017-04-26 16:14:33

# <3> 時間元組

print(time.localtime()) #東八區時間。
print(time.gmtime()) #標準時間，格林威治時間。
#time.struct_time(tm_year=2017, tm_mon=4, tm_mday=26, tm_hour=16, tm_min=14, tm_sec=33, tm_wday=2, tm_yday=116, tm_isdst=0)
#time.struct_time(tm_year=2017, tm_mon=4, tm_mday=26, tm_hour=8, tm_min=14, tm_sec=33, tm_wday=2, tm_yday=116, tm_isdst=0)

小結：時間戳是計算機可以識別的時間；時間字符串是人可以看懂的時間；元組則是用來操做時間的

幾種時間形式的轉換：

（1）

　　　　　　　　

#一 時間戳<－－－－>結構化時間：  localtime/gmtime   mktime
print(time.localtime(3600*24))
print(time.gmtime(3600*24))
print(time.mktime(time.localtime()))

#time.struct_time(tm_year=1970, tm_mon=1, tm_mday=2, tm_hour=8, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=2, tm_isdst=0)
#time.struct_time(tm_year=1970, tm_mon=1, tm_mday=2, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=2, tm_isdst=0)
#1493194973.0

#字符串時間<－－－－>結構化時間： strftime／strptime
print(time.strftime("%Y-%m-%d %X",time.localtime()))
print(time.strptime("2017-03-16","%Y-%m-%d"))
print(time.strftime("%Y-%m-%d",time.localtime(time.time()-24*3600)))

#2017-04-26 16:22:53
#time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
#2017-04-25

（2）

　　　　　　　　　

print(time.asctime(time.localtime(312343423)))
#Sun Nov 25 10:03:43 1979
print(time.ctime(312343423))
#Sun Nov 25 10:03:43 1979

#--------------------------其餘方法
# sleep(secs)
# 線程推遲指定的時間運行，單位爲秒。

 2、random模塊

import random

print(random.random()) # 大於0且小於1之間的小數
# 0.8871504125977017

print(random.randint(1,5)) # 大於等於1且小於等於5之間的整數
# 2

print(random.randrange(1,3)) # 大於等於1且小於3之間的整數
# 1

print(random.choice([1,'23',[4,5]])) # #1或者23或者[4,5] (choice 選擇)
# [4, 5]

print(random.sample([1,'23',[4,5]],2)) #列表元素任意2個組合 (sample 取樣)
# [[4, 5], '23']

print(random.uniform(1,3)) #大於1小於3的小數  (uniform  統一的)
# 2.407927435974846

item=[1,3,5,7,9]
random.shuffle(item) # 打亂次序  (shuffle 洗牌)
print(item)
random.shuffle(item)
print(item)

練習：生產驗證碼  (validate 驗證)

def validate():
    s = ''
    for i in range(5):
        num=random.randint(0,9)
        Alf=chr(random.randint(65,90)) #A-Z
        alf=chr(random.randint(97,122)) #a-z
        ret=random.choice([str(num),Alf,alf])
        s="".join([s,ret]) #和下面的字符相加結果同樣
        # s+=ret
    return s

print(validate())

View Code

3、hashlib

算法介紹：

python的hashlib提供了常見的摘要算法，如MD5，SHA1等等。

什麼是摘要算法呢？摘要算法又稱哈希算法、散列算法。它經過一個函數，把任意長度的數據轉換爲一個長度固定的數據串（一般用16進制的字符串表示）。

摘要算法就是經過摘要函數f()對任意長度的數據data計算出固定長度的摘要digest,目的是爲了發現原始數據是否被人篡改過。

摘要算法之因此能指出數據是否被篡改過，就是由於摘要函數是一個單向函數，計算f(data)很容易，但經過digest反推data卻很是困難。並且，對原始數據作一個bit的修改，都會致使計算出的摘要徹底不一樣。

咱們以常見的摘要算法MD5爲例，計算出一個字符串的MD5值：

import hashlib
 
md5 = hashlib.md5()
md5.update('how to use md5 in python hashlib?')
print(md5.hexdigest())

計算結果以下：
d26a53750bc40b38b65a520292f69306

若是數據量很大，能夠分塊屢次調用update()，最後計算的結果是同樣的：

md5 = hashlib.md5()
md5.update('how to use md5 in ')
md5.update('python hashlib?')
print(md5.hexdigest())

MD5是最多見的摘要算法，速度很快，生成結果是固定的128 bit字節，一般用一個32位的16進制字符串表示。另外一種常見的摘要算法是SHA1，調用SHA1和調用MD5徹底相似：

import hashlib
 
sha1 = hashlib.sha1()
sha1.update('how to use sha1 in ')
sha1.update('python hashlib?')
print sha1.hexdigest()

SHA1的結果是160 bit字節，一般用一個40位的16進制字符串表示。比SHA1更安全的算法是SHA256和SHA512，不過越安全的算法越慢，並且摘要長度更長。

摘要算法應用：

任何容許用戶登陸的網站都會存儲用戶登陸的用戶名和口令。如何存儲用戶名和口令呢？方法是存到數據庫表中：

name    | password
--------+----------
michael | 123456
bob     | abc999
alice   | alice2008

若是以明文保存用戶口令，若是數據庫泄露，全部用戶的口令就落入黑客的手裏。此外，網站運維人員是能夠訪問數據庫的，也就是能獲取到全部用戶的口令。正確的保存口令的方式是不存儲用戶的明文口令，而是存儲用戶口令的摘要，好比MD5：

username | password
---------+---------------------------------
michael  | e10adc3949ba59abbe56e057f20f883e
bob      | 878ef96e86145580c38c87f0410ad153
alice    | 99b1c2188db85afee403b1536010c2c9

考慮這麼個狀況，不少用戶喜歡用123456，888888，password這些簡單的口令，因而，黑客能夠事先計算出這些經常使用口令的MD5值，獲得一個反推表：

'e10adc3949ba59abbe56e057f20f883e': '123456'
'21218cca77804d2ba1922c33e0151105': '888888'
'5f4dcc3b5aa765d61d8327deb882cf99': 'password'

這樣，無需破解，只須要對比數據庫的MD5，黑客就得到了使用經常使用口令的用戶帳號。

對於用戶來說，固然不要使用過於簡單的口令。可是，咱們可否在程序設計上對簡單口令增強保護呢？

因爲經常使用口令的MD5值很容易被計算出來，因此，要確保存儲的用戶口令不是那些已經被計算出來的經常使用口令的MD5，這一方法經過對原始口令加一個複雜字符串來實現，俗稱「加鹽」：

hashlib.md5("salt".encode("utf8"))

通過Salt處理的MD5口令，只要Salt不被黑客知道，即便用戶輸入簡單口令，也很難經過MD5反推明文口令。

可是若是有兩個用戶都使用了相同的簡單口令好比123456，在數據庫中，將存儲兩條相同的MD5值，這說明這兩個用戶的口令是同樣的。有沒有辦法讓使用相同口令的用戶存儲不一樣的MD5呢？

若是假定用戶沒法修改登陸名，就能夠經過把登陸名做爲Salt的一部分來計算MD5，從而實現相同口令的用戶也存儲不一樣的MD5。

摘要算法在不少地方都有普遍的應用。要注意摘要算法不是加密算法，不能用於加密（由於沒法經過摘要反推明文），只能用於防篡改，可是它的單向計算特性決定了能夠在不存儲明文口令的狀況下驗證用戶口令。

注：Ftp中傳文件用得校驗機制就是hashlib的update原理，傳一行校驗一次。

import hashlib

m =hashlib.md5()
l =hashlib.md5()
m.update("37142343".encode("utf8"))
l.update("37142343".encode("utf8"))
print(m.hexdigest())
print(l.hexdigest())

m=hashlib.md5()
m.update("luchuan".encode("utf8"))
print(m.hexdigest()) #luchuan
m.update("luchuan".encode("utf8"))
#上面校驗的是:luchuanluchuan,以前作過update，以後的update值會相加到一塊兒校驗
print(m.hexdigest())

#加鹽
n = hashlib.md5("salt".encode('utf8'))
n.update(b"luchuan")
print(n.hexdigest())

磨刀霍霍

4、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的大小
'''

import os
print(os.getcwd()) #獲取當前目錄
f=open("test.txt","w")
os.chdir(r"C:\Users\Administrator\PycharmProjects\untitled\day32") #切換當前目錄
print(os.getcwd()) #獲取當前目錄
f=open("test2.txt","w") #建立文件
print(os.getcwd()) #獲取當前目錄

print(os.curdir) #獲取當前目錄.
print(os.pardir) #獲取當前目錄的父目錄

os.makedirs("aaa/bbb") #可生成多層遞歸目錄

os.removedirs("aaa/bbb") #若目錄爲空，可遞歸刪除目錄

print(os.listdir(r"C:\Users\Administrator\PycharmProjects\untitled\day31"))
列出指定目錄下的全部文件和子目錄
print(os.stat(r"C:\Users\Administrator\PycharmProjects\untitled\day32\b.txt"))
獲取文件或目錄信息

print("yuan"+os.sep+"image") #指定操做系統的路徑分隔符，使程序可跨平臺執行
print(os.pathsep) #輸出用於分割文件路徑的字符串
print(os.name) #輸出字符串指示當前使用平臺
print(os.system("dir")) #運行命令
print(os.environ) #獲取系統環境變量
print(os.path.abspath("test.txt")) #返回path規範化的絕對路徑

abs=os.path.abspath("test.txt")
print(os.path.basename(abs)) #返回path最後的文件名
print(os.path.dirname(abs)) #返回path的目錄

print(os.path.exists("test.txt")) #若是path存在，返回True，不然返回False
print(os.path.isfile("test.txt")) #若是path是一個存在的文件，返回True，不然返回False

s1=r"C:\Users\Administrator\PycharmProjects\untitled" # r 表示原生字符
s2=r"練習\test.txt"
print(s1+os.sep+s2)
ret=os.path.join(s1,s2)
print(ret)

print(os.path.getatime('test.txt'))
print(os.path.getmtime('test.txt'))
print(os.path.getsize('test.txt'))

九陰真經

5、sys模塊

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

 sys.argv應用：

C:\Users\Administrator\PycharmProjects\untitled\day33>python test.py luchuan 123
['test.py', 'luchuan', '123']
luchuan
123
['C:\\Users\\Administrator\\PycharmProjects\\untitled\\day33', 'C:\\Python36\\py
thon36.zip', 'C:\\Python36\\DLLs', 'C:\\Python36\\lib', 'C:\\Python36', 'C:\\Pyt
hon36\\lib\\site-packages']

print(sys.argv)
username=sys.argv[1]
password=sys.argv[2]
print(username)
print(password)
print(sys.path)

test.py

6、logging模塊

區別：一、config不能打印到屏幕上 二、logger對象的方式

 一、函數式簡單配置

import logging  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message')  

默認狀況下Python的logging模塊將日誌打印到了標準輸出中，且只顯示了大於等於WARNING級別的日誌，這說明默認的日誌級別設置爲WARNING（日誌級別等級CRITICAL > ERROR > WARNING > INFO > DEBUG），默認的日誌格式爲日誌級別：Logger名稱：用戶輸出消息。

critical : 危險性的

靈活配置日誌級別，日誌格式，輸出位置:

import logging  
logging.basicConfig(level=logging.DEBUG,  
                    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',  
                    datefmt='%a, %d %b %Y %H:%M:%S',  
                    filename='/tmp/test.log',  
                    filemode='w')  
  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message')

配置參數：

logging.basicConfig()函數中可經過具體參數來更改logging模塊默認行爲，可用參數有：

filename：用指定的文件名建立FiledHandler，這樣日誌會被存儲在指定的文件中。
filemode：文件打開方式，在指定了filename時使用這個參數，默認值爲「a」還可指定爲「w」。
format：指定handler使用的日誌顯示格式。
datefmt：指定日期時間格式。
level：設置rootlogger（後邊會講解具體概念）的日誌級別
stream：用指定的stream建立StreamHandler。能夠指定輸出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’))，默認爲sys.stderr。若同時列出了filename和stream兩個參數，則stream參數會被忽略。

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用戶輸出的消息

二、logger對象配置

import logging

logger = logging.getLogger()
# 建立一個handler，用於寫入日誌文件
fh = logging.FileHandler('test.log')

# 再建立一個handler，用於輸出到控制檯
ch = logging.StreamHandler()

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

fh.setFormatter(formatter)
ch.setFormatter(formatter)

logger.addHandler(fh) #logger對象能夠添加多個fh和ch對象
logger.addHandler(ch)

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

logging庫提供了多個組件：Logger、Handler、Filter、Formatter。Logger對象提供應用程序可直接使用的接口，Handler發送日誌到適當的目的地，Filter提供了過濾日誌信息的方法，Formatter指定日誌顯示格式。另外，能夠經過：logger.setLevel(logging.Debug)設置級別。

def get_logger():
    logger=logging.getLogger()

    fh=logging.FileHandler("logger2") # 建立一個handler，用於寫入日誌文件
    sh=logging.StreamHandler() # 再建立一個handler，用於輸出到控制檯

    logger.setLevel(logging.DEBUG)
    fm = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') # 格式化輸出

    logger.addHandler(fh) #logger對象能夠添加多個fh和ch對象
    logger.addHandler(sh)

    fh.setFormatter(fm)
    sh.setFormatter(fm)
    return logger

Logger=get_logger()

Logger.debug('logger debug message')
Logger.info('logger info message')
Logger.warning('logger warning message')
Logger.error('logger error message')
Logger.critical('logger critical 中文')  

高潮部分

注意：若是輸入到文件裏有中文字符，須要以下操做：

7、序列號模塊

以前咱們學習過用eval內置方法能夠將一個字符串轉成python對象，不過，eval方法是有侷限性的，對於普通的數據類型，json.loads和eval都能用，但遇到特殊類型的時候，eval就無論用了,因此eval的重點仍是一般用來執行一個字符串表達式，並返回表達式的值。

d={"河北":["邯鄲","雄安"]}
s=str(d)
print(s)
print(type(s))
with open("data","w") as f:
    f.write(s)
with open("data") as f2:
    s2=f2.read()
    d2=eval(s2)
print(d2["河北"])

#計算
print(eval("12*7+5-3"))

前戲部分

什麼是序列化：

咱們把對象(變量)從內存中變成可存儲或傳輸的過程稱之爲序列化，在Python中叫pickling，在其餘語言中也被稱之爲serialization，marshalling，flattening等等，都是一個意思。序列化以後，就能夠把序列化後的內容寫入磁盤，或者經過網絡傳輸到別的機器上。反過來，把變量內容從序列化的對象從新讀到內存裏稱之爲反序列化，即unpickling。

json：

若是咱們要在不一樣的編程語言之間傳遞對象，就必須把對象序列化爲標準格式，好比XML，但更好的方法是序列化爲JSON，由於JSON表示出來就是一個字符串，能夠被全部語言讀取，也能夠方便地存儲到磁盤或者經過網絡傳輸。JSON不只是標準格式，而且比XML更快，並且能夠直接在Web頁面中讀取，很是方便。

JSON表示的對象就是標準的JavaScript語言的對象一個子集，JSON和Python內置的數據類型對應以下：

import json
i=10
s='hello'
t=(1,4,6)
l=[3,5,7]
d={'name':"luchuan"}

json_str1=json.dumps(i)
json_str2=json.dumps(s)
json_str3=json.dumps(t)
json_str4=json.dumps(l)
json_str5=json.dumps(d)

print(json_str1)   #'10'
print(json_str2)   #'"hello"'
print(json_str3)   #'[1, 4, 6]'
print(json_str4)   #'[3, 5, 7]'
print(json_str5)   #'{"name": "luchuan"}'

前戲部分

python在文本中的使用：

#----------------序列化
import json
d={'name':"egon"}
print(type(d)) #<class'dict'>
s=json.dumps(d) #將字典d轉爲json字符串
print(s)
print(type(s)) #<class'str'>

f=open("new",'w')
f.write(s) #-------------等價於json.dump(s,f)
f.close()

#----------------反序列化
import json
f=open("new")
data=f.read()
data2=json.loads(data) #等價於data2=json.load(f)
print(data2["name"])

#-----------------dump方式
d={'name':"luchuan"}
f=open("new2",'w')
json.dump(d,f) #------一、轉成字符串 二、將json字符串寫入f文件
f.close()

import json
f=open("new3")
data=f.read()
#若是文件中是雙引號則可使用打印出來，單引號則不能夠，json不認識單引號
#只要是知足json字符串格式得，無論是從文件中讀取得仍是字符串均可以直接loads
#{'info':{"name":"yuan","age":24}} #會報錯，不能夠
#{"info":{"name":"yuan","age":24}} #知足json字符串的規則

ret=json.loads(data)
print(ret["info"])

高潮部分

pickle:

import pickle

#--------------------序列化

d={"name":"alvin"}
print(type(d)) #<class'dict'>
s=pickle.dumps(d)
print(s)
print(type(s)) #<class'bytes'>

f=open("new5","wb") #注意是w是寫入str,wb是寫入bytes,j是'bytes'
f.write(s) #-------------等價於pickle.dump(d,f)
f.close()

#------------------反序列

import pickle
f=open("new5","rb")
data=pickle.loads(f.read()) #等價於data=pickle.load(f)
print(data["name"])

高潮部分

補充：

import pickle
import json
import datetime

# t=datetime.datetime.now() #時間是數字類型，不能作轉換
# d={"data":t}
# json.dump(d,open("new4","w"))

t=datetime.datetime.now() #時間是數字類型，不能作轉換
d={"data":t}
pickle.dump(d,open("new4","w"))

後戲部分

 

json和pickle的區別：

......

 8、subprocess模塊

subprocess 模塊容許您生成新進程，鏈接到其輸入/輸出/錯誤管道，並獲取其返回碼。

>>> import subprocess
>>> res=subprocess.Popen('dir',shell=True,stdout=subprocess.PIPE) 
>>> res.stdout.read().decode('gbk')


>>> res=subprocess.Popen('diraaaa',shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
>>> res.stderr.read().decode('gbk')
"'diraaaa' 不是內部或外部命令，也不是可運行的程序\r\n或批處理文件。\r\n"

#第一個參數是命令，第二個參數是以shell方式運行，第三個參數是標準輸出，第四個參數是標準錯誤輸出

傳統Shell調用函數：

　　這些操做提供隱式調用系統shell。

• subprocess.getstatusoutput(cmd)，返回在shell中執行 cmd 的 (status, output)。

>>> subprocess.getstatusoutput('ls /bin/ls')
(0, '/bin/ls')
>>> subprocess.getstatusoutput('cat /bin/junk')
(256, 'cat: /bin/junk: No such file or directory')
>>> subprocess.getstatusoutput('/bin/junk')
(256, 'sh: /bin/junk: not found')

• subprocess.getoutput(cmd)，返回在shell中執行 cmd 的輸出（stdout和stderr）。

像 getstatusoutput()，除了退出狀態被忽略，返回值是一個包含命令輸出的字符串。

>>> subprocess.getoutput('ls /bin/ls')
'/bin/ls'

9、paramiko模塊

paramiko是一個用於作遠程控制的模塊，使用該模塊能夠對遠程服務器進行命令或文件操做，值得一說的是，fabric和ansible內部的遠程管理就是使用的paramiko來現實。

一、下載安裝

pip3 install paramiko

或

# pycrypto，因爲 paramiko 模塊內部依賴pycrypto，因此先下載安裝pycrypto
 
# 下載安裝 pycrypto
wget http://files.cnblogs.com/files/wupeiqi/pycrypto-2.6.1.tar.gz
tar -xvf pycrypto-2.6.1.tar.gz
cd pycrypto-2.6.1
python setup.py build
python setup.py install
 
# 進入python環境，導入Crypto檢查是否安裝成功
 
# 下載安裝 paramiko
wget http://files.cnblogs.com/files/wupeiqi/paramiko-1.10.1.tar.gz
tar -xvf paramiko-1.10.1.tar.gz
cd paramiko-1.10.1
python setup.py build
python setup.py install
 
# 進入python環境，導入paramiko檢查是否安裝成功

二、使用模塊

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

import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('192.168.1.108', 22, 'alex', '123')
stdin, stdout, stderr = ssh.exec_command('df')
print stdout.read()
ssh.close();

執行命令 - 經過用戶名和密碼鏈接服務器

import paramiko

private_key_path = '/home/auto/.ssh/id_rsa'
key = paramiko.RSAKey.from_private_key_file(private_key_path)

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('主機名 ', 端口, '用戶名', key)

stdin, stdout, stderr = ssh.exec_command('df')
print stdout.read()
ssh.close()

執行命令 - 過密鑰連接服務器

import os,sys
import paramiko

t = paramiko.Transport(('182.92.219.86',22))
t.connect(username='wupeiqi',password='123')
sftp = paramiko.SFTPClient.from_transport(t)
sftp.put('/tmp/test.py','/tmp/test.py') 
t.close()


import os,sys
import paramiko

t = paramiko.Transport(('182.92.219.86',22))
t.connect(username='wupeiqi',password='123')
sftp = paramiko.SFTPClient.from_transport(t)
sftp.get('/tmp/test.py','/tmp/test2.py')
t.close()

上傳或者下載文件 - 經過用戶名和密碼

import paramiko

pravie_key_path = '/home/auto/.ssh/id_rsa'
key = paramiko.RSAKey.from_private_key_file(pravie_key_path)

t = paramiko.Transport(('182.92.219.86',22))
t.connect(username='wupeiqi',pkey=key)

sftp = paramiko.SFTPClient.from_transport(t)
sftp.put('/tmp/test3.py','/tmp/test3.py') 

t.close()

import paramiko

pravie_key_path = '/home/auto/.ssh/id_rsa'
key = paramiko.RSAKey.from_private_key_file(pravie_key_path)

t = paramiko.Transport(('182.92.219.86',22))
t.connect(username='wupeiqi',pkey=key)

sftp = paramiko.SFTPClient.from_transport(t)
sftp.get('/tmp/test3.py','/tmp/test4.py') 

t.close()

上傳或下載文件 - 經過密鑰

 

參考wusir