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