python 创建：udp tcp服务器 线程 进程 进程池 互斥锁 协程

UDP User Datagram Protocol

TCP Transmission Control Protocol

udp

import socket
# 创建udp套接字
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 绑定端口号
udp_socket.bind("", 端口号)
# 发送消息
udp_socket.sendto("发送消息内容", (目的地址，以元祖方式))
# 接收消息
udp_socket.recvfrom(1024)  # 1024代表一次接收数据大小
# 关闭套接字
udp_socket.close()

tcp客户端

import socket
# 创建tcp套接字
tcp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 绑定端口号
tcp_client_socket.bind("", 端口号)
# 链接服务器
tcp_client_socket.connect((目的地址，以元祖方式))
# 接收消息
tcp_client_socket.recv(1024)
# 发送消息
tcp_client_socket.send("消息内容")
# 关闭套接字
tcp_client_socket.close()

tcp服务器

import socket
# 创建tcp套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 绑定端口号
tcp_server_socket.bind("", 端口号)
# 响铃
tcp_server_socket.listen(128)  # 表示最多可以接受128个客户端的链接
# 接受客户端链接,返回链接专用套接字和客户端地址
client_socket, dest_addr = tcp_server_socket.accept()
# 发送消息
client_socket.send()
# 接收消息
client_socket.recv(1024)
# 关闭套接字
client_socket.close()
tcp_server_socket.close()

创建线程

import threading
thread = threading.Thread(target=函数, args=(以元祖方式向函数中传入参数,))
thread.start()  # 调用子线程

创建进程

import multiprocessing
process = multiprocessing.Process(target==函数, args=(以元祖方式向函数中传入参数,))
process.start()  # 调用子进程

进程间通信，队列queue，先进先出

import multiprocessing
queue = multiprocessing.Queue()
queue.put(传入数据)
queue.get()  # 依次取出数据

进程池

import multiprocessing
po = multiprocessing.Pool(3)  # 代表进程池中最多有三个进程
po.apply_async(函数, (以元祖方式向函数中传入参数,))
po.close()  # 关闭进程池，不再接受新任务
po.join()  # 主进程解阻塞

进程池之间的通信

from multiprocessing import manager,pool
queue = Manager().Queue()  # 必须使用multiprocess中的Manager中的Queue创建队列
po = Pool(3)

互斥锁

import threading
# 创建锁
mutex = threading.Lock()
# 锁定
mutex.acquire()
# 释放
mutex.release()

协程

# 实现方法一：
# 例如：两个函数中有yield,在程序中while写入next()，交替切换生成器；属于手动切换

# 实现方法二：
# 例如：在两个函数while True中分别调用对方的g.switch(),
# 这样程序只要执行一个g.switch(),greenlet会自动切换
from greenlet import greenlet
g1 = greenlet(函数名, 传入函数中的参数)
g2 = greenlet(函数名, 传入函数中的参数)
g1.switch()

# 实现方法三：
import gevent
g1 = gevent(函数名, 传入函数中的参数)
g2 = gevent(函数名, 传入函数中的参数)
g1.join()
g2.join()
# 还可以写成gevent.joinall([g1, g2])  # [以列表的形式写入gevent(函数名, 参数)]

# 只要有延时操作，gevent才会自动切换
# gevent 中的延时操作必须用自己的，比如 gevent.sleep(1)
# 若是升级代码，代码中已有time模块，更改会很麻烦，这时就需要打补丁
form gevent import monkey
monkey.patch_all()  # 程序执行到这句话，会分析下面所有代码，把time换成gevent执行
                    # 看到的是time.sleep(1),实际上执行的是gevent.sleep(1)

迭代器Iterator

可迭代对象：有__iter__方法，且返回一个迭代器对象

判断一个对象是否可迭代：
from collections import Iterable
isinstance(判断对象, Iterable)
返回True 则是 False 不是

迭代器：有__iter__方法和__next__方法：

判断一个对象是否是迭代器：
from collections import Iterator
isinstance(判断对象, Iterator)
返回True 则是 False 不是

迭代器I调用方法：
for i in I
next(I)

创建一个迭代器

class Iterator(object):
    def __init__(self):
        xxx

    def __iter__(self):
        return self

    def __next__(self):
        if xxx:
            xxx
        else:
            raise StopIteration  # 超过列表范围，要抛出异常

生成器 generator

调用生成器G的方式：

# list(可迭代对象)
list(i for i in range(10))
list(range(10))
for i in G
    next(G)
    # 另外一种调用生成器的方式
    # G.send(None)  # 如果需要往函数中传入参数，则写，不需要传参，写None

生成器创建方法（一）：
将列表推到式的[]改为()   G = (i for i in range(10))

生成器创建方法（二）：函数中的return换成yield，如果生成器也有return，可以通过try，抛出异常的方式获取return的内容：
例题：生成器打印列表：
def generator(num)
    i = 0
    while i < num:
        i += 1
        yield i-1   # 相当于return 
        # a yield b  可以通过send(a)传入参数，a 和 b 完全没有关系，执行顺序：先b后a
        return None

调用生成器

G = generator(100)
while True:
    try:
        num = G.send(None)  # 如果没有参数传入，要写send(None)
        # 还可以用next(G)调用生成器，取出数据
        print(num)
    except StopIteration as ret:  # 或者用except Exception as ret
        print(ret.value)  # ret.value原因 ret返回的是一个对象，调用value方法返回None
        break