基于Udp套接字
 服务器端：
udp_server=socket(AF_INET,SOCK_DGRAM)：创建一个服务器的套接字
udp_server.bind(('127.0.0.1',8080))：绑定服务器套接字
 
data,client_addr=udp_server.recvfrom(1024)：接受
udp_server.sendto(data.upper(),client_addr)：发送
 
客户端：
udp_client=socket(AF_INET,SOCK_DGRAM)：创建客户套接字
 
udp_client.sendto(msg.encode('utf-8'),('127.0.0.1',8080))：发送
data,server_addr=udp_client.recvfrom(1024)：接受
 
udp不会粘包：发一条收一条
 
 
 
 
socketserver分为两大类：server类  request类
server类：（与链接有关）
BaseServer：基类
TCPServer      Unixstreamserver
UDPserver      UnixDatagramServer
 
基于多线程实现开发：
ThreadingMixin：链接做成并发
ThreadingTCPserver：并发
ThreadingUDPserver：并发
 
基于多进程实现开发
ForKingMixIn：
ForkingTCPServer：
ForkingUDPServer：
 
 
与通信有关的类：
BaseRequestHandler：
StreamRequestHandler：
DatagramRequestHandler：
 
 
进程
进程：正在进行的一个过程或者说一个任务。而负责执行任务则是cpu
程序仅仅只是一堆代码而已，而进程指的是程序的运行过程。
一 并发：是伪并行，即看起来是同时运行。单个cpu+多道技术就可以实现并发，（并行也属于并发）
二 并行：同时运行，只有具备多个cpu才能实现并行
方式一：
from multiprocessing import Process
import time
def work(name):
    print('task <%s> is runing' %name)
    time.sleep(2)
    print('task <%s> is done' % name)

if __name__ == '__main__':
    # Process(target=work,kwargs={'name':'egon'})
    p1=Process(target=work,args=('egon',))
    p2=Process(target=work,args=('alex',))
    p1.start()
    p2.start()
    print('主')
方式二：
from multiprocessing import Process
import time
class MyProcess(Process):
    def __init__(self,name):
        super().__init__()
        self.name=name

    def run(self):
        print('task <%s> is runing' % self.name)
        time.sleep(2)
        print('task <%s> is done' % self.name)



if __name__ == '__main__':
    p=MyProcess('egon')
    p.start()

    print('主')

守护进程：
from multiprocessing import Process
import time
def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")
if __name__ == '__main__':

    p1=Process(target=foo)
    p2=Process(target=bar)

    p1.daemon=True
    p1.start()
    p2.start()
    print("main-------") #打印该行则主进程代码结束,则守护进程p1应该被终止,可能会有p1任务执行的打印信息123,因为主进程打印main----时,p1也执行了,但是随即被终止

同步锁：
# from multiprocessing import Process,Lock
# import time
# def work(name,mutex):
#     mutex.acquire()
#     print('task <%s> is runing' %name)
#     time.sleep(2)
#     print('task <%s> is done' % name)
#     mutex.release()
#
# if __name__ == '__main__':
#     mutex=Lock()
#     p1=Process(target=work,args=('egon',mutex))
#     p2=Process(target=work,args=('alex',mutex))
#     p1.start()
#     p2.start()
#     print('主')

队列：
from multiprocessing import Queue


# q=Queue(3)
#
# q.put('first')
# q.put('second')
# q.put('third')
# # q.put('fourth')
#
# print(q.get())
# print(q.get())
# print(q.get())
# print(q.get())




了解
q=Queue(3)

q.put('first',block=False)
q.put('second',block=False)
q.put('third',block=False)
# q.put_nowait('fourth') #q.put('fourth',block=False)
q.put('fourth',timeout=3)


paramiko：
import paramiko

transport = paramiko.Transport(('120.92.84.249', 22))
transport.connect(username='root', password='123QWEasd')

sftp = paramiko.SFTPClient.from_transport(transport)
# 将location.py 上传至服务器 /tmp/test.py
sftp.put('id_rsa', '/tmp/test.rsa')
# 将remove_path 下载到本地 local_path
# sftp.get('remove_path', 'local_path')

transport.close()

进程池：
import requests #pip3 install requests
import os,time
from multiprocessing import Pool
def get_page(url):
    print('<%s> get :%s' %(os.getpid(),url))
    respone = requests.get(url)
    if respone.status_code == 200:
        return {'url':url,'text':respone.text}

def parse_page(dic):
    print('<%s> parse :%s' %(os.getpid(),dic['url']))
    time.sleep(0.5)
    res='url:%s size:%s\n' %(dic['url'],len(dic['text'])) #模拟解析网页内容
    with open('db.txt','a') as f:
        f.write(res)


if __name__ == '__main__':
    p=Pool(4)
    urls = [
        'http://www.baidu.com',
        'http://www.baidu.com',
        'http://www.baidu.com',
        'http://www.baidu.com',
        'http://www.baidu.com',
        'http://www.baidu.com',
        'http://www.baidu.com',
    ]


    for url in urls:
        p.apply_async(get_page,args=(url,),callback=parse_page)


    p.close()
    p.join()
    print('主进程pid:',os.getpid())






 


线程




在传统操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程


线程顾名思义，就是一条流水线工作的过程，一条流水线必须属于一个车间，一个车间的工作过程是一个进程






多线程指的是，在一个进程中开启多个线程，简单的讲：如果多个任务共用一块地址空间，那么必须在一个进程内开启多个线程。详细的讲分为4点：


　　1. 多线程共享一个进程的地址空间


      2. 线程比进程更轻量级，线程比进程更容易创建可撤销，在许多操作系统中，创建一个线程比创建一个进程要快10-100倍，在有大量线程需要动态和快速修改时，这一特性很有用


      3. 若多个线程都是cpu密集型的，那么并不能获得性能上的增强，但是如果存在大量的计算和大量的I/O处理，拥有多个线程允许这些活动彼此重叠运行，从而会加快程序执行的速度。


      4. 在多cpu系统中，为了最大限度的利用多核，可以开启多个线程，比开进程开销要小的多。（这一条并不适用于python）