AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x

IOError 输入/输出异常；基本上是无法打开文件

ImportError 无法引入模块或包；基本上是路径问题或名称错误

IndentationError 语法错误（的子类） ；代码没有正确对齐

IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]

KeyError 试图访问字典里不存在的键

KeyboardInterrupt Ctrl+C被按下

NameError 使用一个还未被赋予对象的变量

SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）

TypeError 传入对象类型与要求的不符合

UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，

导致你以为正在访问它

ValueError 传入一个调用者不期望的值，即使值的类型是正确的

ArithmeticError

AssertionError

AttributeError

BaseException

BufferError

BytesWarning

DeprecationWarning

EnvironmentError

EOFError

Exception

FloatingPointError

FutureWarning

GeneratorExit

ImportError

ImportWarning

IndentationError

IndexError

IOError

KeyboardInterrupt

KeyError

LookupError

MemoryError

NameError

NotImplementedError

OSError

OverflowError

PendingDeprecationWarning

ReferenceError

RuntimeError

RuntimeWarning

StandardError

StopIteration

SyntaxError

SyntaxWarning

SystemError

SystemExit

TabError

TypeError

UnboundLocalError

UnicodeDecodeError

UnicodeEncodeError

UnicodeError

UnicodeTranslateError

UnicodeWarning

UserWarning

ValueError

Warning

ZeroDivisionError

num1=input('>>: ') #输入一个字符串试试

if num1.isdigit():

    int(num1) #我们的正统程序放到了这里,其余的都属于异常处理范畴

elif num1.isspace():

    print('输入的是空格,就执行我这里的逻辑')

elif len(num1) == 0:

    print('输入的是空,就执行我这里的逻辑')

else:

    print('其他情情况,执行我这里的逻辑')

#第二段代码

# num2=input('>>: ') #输入一个字符串试试

# int(num2)

#第三段代码

# num3=input('>>: ') #输入一个字符串试试

# int(num3)

'''

问题一：

使用if的方式我们只为第一段代码加上了异常处理，针对第二段代码，你得重新写一堆if，elif等

第三段，你还得在写一遍，当然了,你说,可以合在一起啊,没错,你合起来看看,你的代码还能被看懂吗???

而这些if，跟你的代码逻辑并无关系，这就好比你在你心爱的程序中到处拉屎，拉到最后，谁都不爱看你的烂代码，为啥，因为可读性差，看不懂

问题二：

第一段代码和第二段代码实际上是同一种异常，都是ValueError,相同的错误按理说只处理一次就可以了，而用if，由于这二者if的条件不同，这只能逼着你重新写一个新的if来处理第二段代码的异常

第三段也一样

'''

f=open('a.txt')

g=(line.strip() for line in f)

'''

next(g)会触发迭代f，依次next(g)就可以读取文件的一行行内容，无论文件a.txt有多大，同一时刻内存中只有一行内容。

提示：g是基于文件句柄f而存在的，因而只能在next(g)抛出异常StopIteration后才可以执行f.close()

'''

f=open('a.txt')

g=(line.strip() for line in f)

for line in g:

    print(line)

else:

    f.close()

try:

    f=open('a.txt')

    g=(line.strip() for line in f)

    print(next(g))

    print(next(g))

    print(next(g))

    print(next(g))

    print(next(g))

except StopIteration:

    f.close()

s1 = 'hello'

try:

    int(s1)

except Exception,e:

    '丢弃或者执行其他逻辑'

    print(e)

#如果你统一用Exception，没错，是可以捕捉所有异常，但意味着你在处理所有异常时都使用同一个逻辑去处理（这里说的逻辑即当前expect下面跟的代码块）

s1 = 'hello'

try:

    int(s1)

except IndexError as e:

    print(e)

except KeyError as e:

    print(e)

except ValueError as e:

    print(e)

except Exception as e:

    print(e)

>>> mylist = ['qqq']

>>> assert len(mylist) >=1

>>> mylist.pop()

'qqq'

>>> mylist

[]

>>> assert len(mylist) >=1

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

AssertionError　　

from socket import *

from multiprocessing import Process

server = socket(AF_INET,SOCK_STREAM)

server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)

server.bind(('127.0.0.1',9999))

server.listen(5)

def talk(conn,client_addr):

    while True:

        try:

            msg = conn.recv(1024)

            if not msg:break

            conn.send(msg.upper())

        except Exception:

            break

if __name__ == '__main__':

    while True:

        conn,client_addr = server.accept()

        p = Process(target=talk,args=(conn,client_addr))

        p.start()

from socket import *

client = socket(AF_INET,SOCK_STREAM)

client.connect(('127.0.0.1',9999))

while True:

    msg = input('--->: ').strip()

    if not msg:continue

    client.send(msg.encode('utf-8'))

    msg = client.recv(1024)

    print(msg.decode('utf-8'))

server端是无限接受socker请求,每启动一个进程都会开辟一块内存空间,如果大量并发请求,server端会出现内存溢出的情况

解决方法:进程池

from multiprocessing import Process

import time

import random

def piao(name):

    print('%s is piaoing' %name)

    time.sleep(random.randint(1,3))

    print('%s is piao end' %name)

p1=Process(target=piao,args=('egon',))

p2=Process(target=piao,args=('alex',))

p3=Process(target=piao,args=('yuanhao',))

p4=Process(target=piao,args=('wupeiqi',))

p1.start()

p2.start()

p3.start()

p4.start()

#有的同学会有疑问:既然join是等待进程结束,那么我像下面这样写,进程不就又变成串行的了吗?

#当然不是了,必须明确：p.join()是让谁等？

#很明显p.join()是让主线程等待p的结束，卡住的是主线程而绝非进程p，

#详细解析如下：

#进程只要start就会在开始运行了,所以p1-p4.start()时,系统中已经有四个并发的进程了

#而我们p1.join()是在等p1结束,没错p1只要不结束主线程就会一直卡在原地,这也是问题的关键

#join是让主线程等,而p1-p4仍然是并发执行的,p1.join的时候,其余p2,p3,p4仍然在运行,等#p1.join结束,可能p2,p3,p4早已经结束了,这样p2.join,p3.join.p4.join直接通过检测，无需等待

# 所以4个join花费的总时间仍然是耗费时间最长的那个进程运行的时间

p1.join()

p2.join()

p3.join()

p4.join()

print('主线程')

#上述启动进程与join进程可以简写为

# p_l=[p1,p2,p3,p4]

#

# for p in p_l:

#     p.start()

#

# for p in p_l:

#     p.join()

#多进程共享一套文件系统

from multiprocessing import Process

def work(f,msg):

    g = open(f, 'a+')

    g.write(msg)

    g.flush()

if __name__ == '__main__':

    for i in range(5):

        p=Process(target=work,args=('a.txt',str(i)))

        p.start()

#文件db的内容为：{"count":1}

#注意一定要用双引号，不然json无法识别

from multiprocessing import Process,Lock

import json

import time

import random

import os

def work(filename,lock): #买票

    # lock.acquire()

    with lock:

        with open(filename,encoding='utf-8') as f:

            dic=json.loads(f.read())

            # print('剩余票数: %s' % dic['count'])

        if dic['count'] > 0:

            dic['count']-=1

            time.sleep(random.randint(1,3)) #模拟网络延迟

            with open(filename,'w',encoding='utf-8') as f:

                f.write(json.dumps(dic))

            print('%s 购票成功' %os.getpid())

        else:

            print('%s 购票失败' %os.getpid())

    # lock.release()

if __name__ == '__main__':

    lock=Lock()

    p_l=[]

    for i in range(100):

        p=Process(target=work,args=('db',lock))

        p_l.append(p)

        p.start()

    for p in p_l:

        p.join()

    print('主线程')

#模拟买票

from multiprocessing import Process,Lock

import json

import time

import random

import os

def work(filename): #查票

    with open(filename,encoding='utf-8') as f:

        dic=json.loads(f.read())

        # print('剩余票数: %s' % dic['count'])

    if dic['count'] > 0:

        time.sleep(random.randint(1,3)) #模拟网络延迟

        print('%s 查票成功 当前余票%s' %(os.getpid(),dic['count']))

    else:

        print('%s 当前无票' %os.getpid())

if __name__ == '__main__':

    p_l=[]

    for i in range(100):

        p=Process(target=work,args=('db',))

        p_l.append(p)

        p.start()

    for p in p_l:

        p.join()

    print('主线程')

from multiprocessing import Queue,Process

import time,os,random

def producer(seq,q):

    for i in seq:

        time.sleep(random.randint(1,3))

        print('\033[46m生产者生产了：%s\033[0m' %i)

        q.put(i)

def consume(q):

    while True:

        time.sleep(random.randint(1,3))

        res = q.get()

        if res == 'full': break

        print('\033[45m消费者拿到了：%s\033[0m' % res)

if __name__ == '__main__':

    p = Queue()

    seq  = ['乐虎%s' %i for i in range(10)]

    c = Process(target=consume,args=(p,))

    c.start()

    producer(seq, p)

    p.put('full')

    c.join()

    print('主进程')

from multiprocessing import Process,JoinableQueue

import time,random

def consumer(q):

    while True:

        time.sleep(random.randint(1,2))

        res=q.get()

        print('消费者拿到了 %s' %res)

        q.task_done()

def producer(seq,q):

    for item in seq:

        time.sleep(random.randrange(1,2))

        q.put(item)

        print('生产者做好了 %s' %item)

    q.join()

if __name__ == '__main__':

    q=JoinableQueue()

    seq=('包子%s' %i for i in range(10))

    p=Process(target=consumer,args=(q,))

    p.daemon=True #设置为守护进程，在主线程停止时p也停止，但是不用担心，producer内调用q.join保证了consumer已经处理完队列中的所有元素

    p.start()

    producer(seq,q)

    print('主线程')

joinables

from multiprocessing import Process,JoinableQueue

import time,random

def consumer(name,q):

    while True:

        time.sleep(random.randint(1,2))

        res=q.get()

        print('%s拿到了 %s' %(name,res))

        q.task_done()

def producer(seq,q):

    for item in seq:

        time.sleep(random.randrange(1,2))

        q.put(item)

        print('生产者做好了 %s' %item)

    q.join()

if __name__ == '__main__':

    q=JoinableQueue()

    seq=('包子%s' %i for i in range(10))

    p=Process(target=consumer,args=('消费者1',q))

    p1 = Process(target=consumer, args=('消费者2',q))

    p2 = Process(target=consumer, args=('消费者3',q))

    p.daemon=True #设置为守护进程，在主线程停止时p也停止，但是不用担心，producer内调用q.join保证了consumer已经处理完队列中的所有元素

    p1.daemon=True

    p2.daemon=True

    p.start()

    p1.start()

    p2.start()

    producer(seq,q)

    print('主线程')

一个生产者多个消费者模式

from multiprocessing import Process,JoinableQueue

import time,random

def consumer(name,q):

    while True:

        time.sleep(random.randint(1,2))

        res=q.get()

        print('%s拿到了 %s' %(name,res))

        q.task_done()

def producer(seq,q):

    for item in seq:

        time.sleep(random.randrange(1,2))

        q.put(item)

        print('生产者做好了 %s' %item)

    q.join()

if __name__ == '__main__':

    q=JoinableQueue()

    seq=['包子%s' %i for i in range(10)]

    p=Process(target=consumer,args=('消费者1',q))

    p1 = Process(target=consumer, args=('消费者2',q))

    p2 = Process(target=consumer, args=('消费者3',q))

    p.daemon=True #设置为守护进程，在主线程停止时p也停止，但是不用担心，producer内调用q.join保证了consumer已经处理完队列中的所有元素

    p1.daemon=True

    p2.daemon=True

    p.start()

    p1.start()

    p2.start()

    p4=Process(target=producer,args=(seq,q))

    p4.start()

    p4.join()

    print('主线程')

将生产者放到子进程里进行生产,多消费者消费

Pipe([duplex]):在进程之间创建一条管道，并返回元组（conn1,conn2）,其中conn1，conn2表示管道两端的连接对象，强调一点：必须在产生Process对象之前产生管道

dumplex:默认管道是全双工的，如果将duplex射成False，conn1只能用于接收，conn2只能用于发送.

conn1.close():关闭连接。如果conn1被垃圾回收，将自动调用此方法

conn1.fileno():返回连接使用的整数文件描述符

conn1.poll([timeout]):如果连接上的数据可用，返回True。timeout指定等待的最长时限。如果省略此参数，方法将立即返回结果。如果将timeout射成None，操作将无限期地等待数据到达。

conn1.recv_bytes([maxlength]):接收c.send_bytes()方法发送的一条完整的字节消息。maxlength指定要接收的最大字节数。如果进入的消息，超过了这个最大值，将引发IOError异常，并且在连接上无法进行进一步读取。如果连接的另外一端已经关闭，再也不存在任何数据，将引发EOFError异常。

conn.send_bytes(buffer [, offset [, size]])：通过连接发送字节数据缓冲区，buffer是支持缓冲区接口的任意对象，offset是缓冲区中的字节偏移量，而size是要发送字节数。结果数据以单条消息的形式发出，然后调用c.recv_bytes()函数进行接收    

conn1.recv_bytes_into(buffer [, offset]):接收一条完整的字节消息，并把它保存在buffer对象中，该对象支持可写入的缓冲区接口（即bytearray对象或类似的对象）。offset指定缓冲区中放置消息处的字节位移。返回值是收到的字节数。如果消息长度大于可用的缓冲区空间，将引发BufferTooShort异常。

　　　　基于管道实现进程间通信（与队列的方式是类似的，队列就是管道加锁实现的）：

from multiprocessing import Process,Pipe

import time,os

def consumer(p,name):

    left,right = p

    left.close()

    while True:

        try:

            baozi = right.recv()

            print('%s 收到包子:%s' % (name, baozi))

        except EOFError:

            right.close()

            break

def producer(seq,p):

    left,right = p

    right.close() #将管道对象的左右都传入,但是只有left去生产,所以直接将right关闭

    for i in seq:

        left.send(i)

        print('生产了包子%s' %(i))

    else:

        left.close()

if __name__ == '__main__':

    left,right = Pipe()

    c1 = Process(target=consumer,args=((left,right),'xiaoming'))

    c1.start()

    seq = [i for i in range(10)]

    producer(seq,(left,right)) #拿主进程当做一个进程去执行生产者

    right.close()

    left.close()

    c1.join()

    print('主进程')

　　　　注意：生产者和消费者都没有使用管道的某个端点，就应该将其关闭，如在生产者中关闭管道的右端，在消费者中关闭管道的左端。如果忘记执行这些步骤，程序可能再消费者中的recv()操作上挂起。管道是由操作系统进行引用计数的,必须在所有进程中关闭管道后才能生产EOFError异常。因此在生产者中关闭管道不会有任何效果，付费消费者中也关闭了相同的管道端点。 ----> 生产者开启left管道,就必须关闭right管道，消费者开启right管道，就必须关闭 left管道

　　　　管道可以用于双向通信，利用通常在客户端/服务器中使用的请求／响应模型或远程过程调用，就可以使用管道编写与进程交互的程序，如下　

from multiprocessing import Process,Pipe

import time,os

def adder(p,name):

    server,client=p

    client.close()

    while True:

        try:

            x,y=server.recv()

        except EOFError:

            server.close()

            break

        res=x+y

        server.send(res)

    print('server done')

if __name__ == '__main__':

    server,client=Pipe()

    c1=Process(target=adder,args=((server,client),'c1'))

    c1.start()

    server.close()

    client.send((10,20))   #用主进程当做一个进程与新建进程进行交互

    print(client.recv())

    client.close()

    c1.join()

    print('主进程')

'''

30

server done

主进程

'''

python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。

    事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，那么event.wait 方法时便不再阻塞。

clear：将“Flag”设置为False

set：将“Flag”设置为True

#_*_coding:utf-8_*_

#!/usr/bin/env python

from multiprocessing import Process,Event

import time,random

def car(e,n):

    while True:

        if not e.is_set(): #Flase

            print('\033[31m红灯亮\033[0m，car%s等着' %n)

            e.wait()

            print('\033[32m车%s 看见绿灯亮了\033[0m' %n)

            time.sleep(random.randint(3,6))

            if not e.is_set():

                continue

            print('走你,car', n)

            break

def police_car(e,n):

    while True:

        if not e.is_set():

            print('\033[31m红灯亮\033[0m，car%s等着' % n)

            e.wait(1)

            print('灯的是%s，警车走了,car %s' %(e.is_set(),n))

            break

def traffic_lights(e,inverval):

    while True:

        time.sleep(inverval)

        if e.is_set():

            e.clear() #e.is_set() ---->False

        else:

            e.set()

if __name__ == '__main__':

    e=Event()

    # for i in range(10):

    #     p=Process(target=car,args=(e,i,))

    #     p.start()

    for i in range(5):

        p = Process(target=police_car, args=(e, i,))

        p.start()

    t=Process(target=traffic_lights,args=(e,10))

    t.start()

    print('============》')

#一：使用进程池（非阻塞,apply_async）

#coding: utf-8

from multiprocessing import Process,Pool

import time

def func(msg):

    print( "msg:", msg)

    time.sleep(1)

    return msg

if __name__ == "__main__":

    pool = Pool(processes = 3)

    res_l=[]

    for i in range(10):

        msg = "hello %d" %(i)

        res=pool.apply_async(func, (msg, ))   #维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去

        res_l.append(res)

    print("==============================>") #没有后面的join，或get，则程序整体结束，进程池中的任务还没来得及全部执行完也都跟着主进程一起结束了

    pool.close() #关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成

    pool.join()   #调用join之前，先调用close函数，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束

    print(res_l) #看到的是<multiprocessing.pool.ApplyResult object at 0x10357c4e0>对象组成的列表,而非最终的结果,但这一步是在join后执行的,证明结果已经计算完毕,剩下的事情就是调用每个对象下的get方法去获取结果

    for i in res_l:

        print(i.get()) #使用get来获取apply_aync的结果,如果是apply,则没有get方法,因为apply是同步执行,立刻获取结果,也根本无需get

#二：使用进程池（阻塞,apply）

#coding: utf-8

from multiprocessing import Process,Pool

import time

def func(msg):

    print( "msg:", msg)

    time.sleep(0.1)

    return msg

if __name__ == "__main__":

    pool = Pool(processes = 3)

    res_l=[]

    for i in range(10):

        msg = "hello %d" %(i)

        res=pool.apply(func, (msg, ))   #维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去

        res_l.append(res) #同步执行，即执行完一个拿到结果，再去执行另外一个

    print("==============================>")

    pool.close()

    pool.join()   #调用join之前，先调用close函数，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束

    print(res_l) #看到的就是最终的结果组成的列表

    for i in res_l: #apply是同步的，所以直接得到结果，没有get()方法

        print(i)

#coding: utf-8

import multiprocessing

import os, time, random

def Lee():

    print("\nRun task Lee-%s" %(os.getpid())) #os.getpid()获取当前的进程的ID

    start = time.time()

    time.sleep(random.random() * 10) #random.random()随机生成0-1之间的小数

    end = time.time()

    print('Task Lee, runs %0.2f seconds.' %(end - start))

def Marlon():

    print("\nRun task Marlon-%s" %(os.getpid()))

    start = time.time()

    time.sleep(random.random() * 40)

    end=time.time()

    print('Task Marlon runs %0.2f seconds.' %(end - start))

def Allen():

    print("\nRun task Allen-%s" %(os.getpid()))

    start = time.time()

    time.sleep(random.random() * 30)

    end = time.time()

    print('Task Allen runs %0.2f seconds.' %(end - start))

def Frank():

    print("\nRun task Frank-%s" %(os.getpid()))

    start = time.time()

    time.sleep(random.random() * 20)

    end = time.time()

    print('Task Frank runs %0.2f seconds.' %(end - start))

def Egon():

    print("\nRun task Egon-%s" %(os.getpid()))

    start = time.time()

    time.sleep(random.random() * 20)

    end = time.time()

    print('Task Egon runs %0.2f seconds.' %(end - start))

def Lily():

    print("\nRun task Lily-%s" %(os.getpid()))

    start = time.time()

    time.sleep(random.random() * 20)

    end = time.time()

    print('Task Lily runs %0.2f seconds.' %(end - start))

if __name__=='__main__':

    function_list=  [Lee, Marlon, Allen, Frank, Egon, Lily]

    print("parent process %s" %(os.getpid()))

    pool=multiprocessing.Pool(4)

    for func in function_list:

        pool.apply_async(func)     #Pool执行函数，apply执行函数,当有一个进程执行完毕后，会添加一个新的进程到pool中

    print('Waiting for all subprocesses done...')

    pool.close()

    pool.join()    #调用join之前，一定要先调用close() 函数，否则会出错, close()执行后不会有新的进程加入到pool,join函数等待素有子进程结束

    print('All subprocesses done.')

#Pool内的进程数默认是cpu核数，假设为4（查看方法os.cpu_count()）

#开启6个客户端，会发现2个客户端处于等待状态

#在每个进程内查看pid，会发现pid使用为4个，即多个客户端公用4个进程

from socket import *

from multiprocessing import Pool

import os

server=socket(AF_INET,SOCK_STREAM)

server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)

server.bind(('127.0.0.1',8080))

server.listen(5)

def talk(conn,client_addr):

    print('进程pid: %s' %os.getpid())

    while True:

        try:

            msg=conn.recv(1024)

            if not msg:break

            conn.send(msg.upper())

        except Exception:

            break

if __name__ == '__main__':

    p=Pool()

    while True:

        conn,client_addr=server.accept()

        p.apply_async(talk,args=(conn,client_addr))

        # p.apply(talk,args=(conn,client_addr)) #同步的话，则同一时间只有一个客户端能访问

from multiprocessing import Pool

import time,random

import requests

import re

def get_page(url,pattern):

    headers = {'content-type': 'application/json',

               'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:22.0) Gecko/20100101 Firefox/22.0'}

    response=requests.get(url,headers=headers)

    if response.status_code == 200:

        print(response.text)

        return (response.text,pattern)

def parse_page(info):

    page_content,pattern=info

    res=re.findall(pattern,page_content)

    for item in res:

        dic={

            'index':item[0],

            'title':item[1],

            'actor':item[2].strip()[3:],

            'time':item[3][5:],

            'score':item[4]+item[5]

        }

        print(dic)

if __name__ == '__main__':

    pattern1=re.compile(r'<dd>.*?board-index.*?>(\d+)<.*?title="(.*?)".*?star.*?>(.*?)<.*?releasetime.*?>(.*?)<.*?integer.*?>(.*?)<.*?fraction.*?>(.*?)<',re.S)

    url_dic={

        'http://maoyan.com/board/7':pattern1,

    }

    p=Pool()

    res_l=[]

    for url,pattern in url_dic.items():

        res=p.apply_async(get_page,args=(url,pattern),callback=parse_page)

        res_l.append(res)

    for i in res_l:

        i.get()

'''

{'index': '1', 'title': '摔跤吧！爸爸', 'actor': '阿米尔·汗,萨卡诗·泰瓦,法缇玛·萨那·纱卡', 'time': '2017-05-05', 'score': '9.8'}

{'index': '2', 'title': '重返·狼群', 'actor': '李微漪,亦风', 'time': '2017-06-16', 'score': '9.3'}

{'index': '3', 'title': '忠爱无言', 'actor': '高强,于月仙,李玉峰', 'time': '2017-06-09', 'score': '9.2'}

{'index': '4', 'title': '冈仁波齐', 'actor': '杨培,尼玛扎堆,斯朗卓嘎', 'time': '2017-06-20', 'score': '9.0'}

{'index': '5', 'title': '雄狮', 'actor': '戴夫·帕特尔,鲁妮·玛拉,大卫·文翰', 'time': '2017-06-22', 'score': '8.8'}

{'index': '6', 'title': '原谅他77次', 'actor': '蔡卓妍,周柏豪,钟欣潼', 'time': '2017-06-23', 'score': '8.6'}

{'index': '7', 'title': '神奇女侠', 'actor': '盖尔·加朵,克里斯·派恩,罗宾·怀特', 'time': '2017-06-02', 'score': '8.6'}

{'index': '8', 'title': '哆啦A梦：大雄的南极冰冰凉大冒险', 'actor': '水田山葵,山新,大原惠美', 'time': '2017-05-30', 'score': '8.6'}

{'index': '9', 'title': '潜艇总动员之时光宝盒', 'actor': '范楚绒,洪海天,谢元真', 'time': '2015-05-29', 'score': '8.5'}

{'index': '10', 'title': '六人晚餐', 'actor': '窦骁,张钧甯,邬君梅', 'time': '2017-06-16', 'score': '8.2'}

'''

#!/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', '')

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='')

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='')

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