1、网络编程一

# 客户端属性
connect(address)：连接到address处的套接字，address格式为元组(hostname,port)，如果连接出错抛出socket.error异常；
connect_ex(address)：同上，只不过connect_ex有返回值，连接成功返回 0 ，连接失败时候返回编码，例如：10061；
# 服务端属性
bind(address)：将套接字绑定到地址，address地址的格式取决于地址族，在AF_INET下为元组以(host,port)的形式表示；
listen(backlog)：开始监听客户端连接。backlog表示的是服务器拒绝(超过/proc/sys/net/core/somaxconn限制的数量)连接之前，操作系统可以挂起的最大连接数量，backlog也可以看作是排队的数量；
accept()：接受连接并返回(conn,address),其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址；
sendfile(file,offset=0,count=None)：表示是否需要在用户空间和内核空间来回拷贝，因为代码进入到内核态之后，需要先从磁盘上读到内核的内存空间，再从内核空间搬到应用程序的内存空间才能使用，因为内核空间是普通指令不能操作的，所以数据就从磁盘上，搬到内核的内存空间，然后又从内核内存空间复制到用户的内存空间，然后程序又要发送出去，然后用户内存空间的数据，又得复制到内核空间，然后通过缓冲区发送出去，这里面就来回好几次拷贝过程，如果设置sendfile，就可以直接将从磁盘上读取到的数据，直接发送出去，减少复制的过程，大大提高效率，但是windows不支持；
fileno()：套接字的文件描述符；
recv(bufsize[,flag])：接受套接字的数据，默认阻塞。数据以编码后的字符串形式返回，bufsize指定最多可以接收多大的数量；
recvfrom(bufsize[.flag])：与recv()类似，但返回值是(data,address)。其中data是包含接收数据的字符串，address是发送数据的套接字地址；
send(string[,flag])：将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小，可能未将指定内容全部发送；
sendall(string[,flag])：将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常，内部通过递归调用send，将所有内容发送出去；
sendto(string[,flag],address)：将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议；
close()：关闭套接字；
# socket工作模式设定
getpeername()：返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）；
getsockname()：返回套接字自己的地址。通常是一个元组(ipaddr,port)；
setblocking(flag)：如果flag为0，则将套接字设置为非阻塞模式，否则为阻塞模式(默认值)，非阻塞模式下，如果调用recv()没有发现任何数据，或者send()调用，无法立即发送数据，那么将引起socket.error异常；
settimeout(flag)：设置套接字操作的超时期，timeout是一个浮点数，单位是秒，值为None表示没有超时时间，一般超时时间应该在刚创建套接字时设置；
setsocketopt(level,optname,value)：设置套接字选项的值，比如缓冲区大小，等，不同操作系统都有不同版本；

import socket
server=socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM) # 创建Socket对象
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # socket重用
server.bind(("127.0.0.1",8083))
server.listen()
new_socket,client_info=server.accept() # 返回一个新的socket对象和客户端信息
new_socket.send("我是你大爷".encode("utf8")) # 发送数据
result=new_socket.recv(1024).decode("gbk") # 接受数据
new_socket.close() # 关闭链接
print(result) # 你大爷
server.close()

import socket

class Server():
    def __init__(self,bind_ip="127.0.0.1",bind_port=8083):
        self.address=(bind_ip,bind_port)
        self.server=socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
    def start(self):
        self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # socket重用,解决地址被占用问题
        self.server.bind(self.address) # 监听在指定的IP和端口之上
        self.server.listen(5) # 最大并发连接数为5
        new_socket,client_info=self.server.accept() # 阻塞，直至用户链接
        while True: # 循环收发消息
            message=new_socket.recv(1024).decode("gbk").rstrip() # 阻塞，等待信息
            if message:
                print(message)
            else: # 如果消息为空，就关闭通信链接
                new_socket.close()
                break
    def __exit__(self, exc_type, exc_val, exc_tb): # 退出时关闭socket server主链接
        self.server.close()
s1=Server()
s1.start()

import socket,threading

class Server():
    def __init__(self,bind_ip="127.0.0.1",bind_port=8083):
        self.address=(bind_ip,bind_port)
        self.server=socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
    def create_conn(self,socket_channel):
        while True: # 循环收发消息
            message=socket_channel.recv(1024).decode("gbk").rstrip() # 阻塞，等待信息
            if message:
                print(message)
            else:
                socket_channel.close()
                break
    def start(self):
        self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # socket重用
        self.server.bind(self.address)
        self.server.listen()
        new_socket,client_info=self.server.accept()
        threading.Thread(target=self.create_conn,args=(new_socket,)).start()
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.server.close()
s1=Server()
s1.start()

import socket,threading,multiprocessing

class Server():
    def __init__(self,bind_ip="127.0.0.1",bind_port=8083):
        self.address=(bind_ip,bind_port)
        self.server=socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
    def socket_accept(self):
        while True: # 不断接受用户的链接
            new_socket,client_info=self.server.accept()
            threading.Thread(target=self.create_conn,args=(new_socket,client_info)).start()
    def create_conn(self,socket_channel,client):
        while True: # 循环收发消息
            message=socket_channel.recv(1024).decode("gbk").rstrip() # 阻塞，等待信息
            if message:
                print("%s:%s：%s"%(*client,message))
            else:
                socket_channel.close()
                break
    def start(self):
        self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # socket重用
        self.server.bind(self.address)
        self.server.listen()
        return multiprocessing.Process(target=self.socket_accept).start()
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.server.close()
s1=Server()
s1.start()

import socket, threading, multiprocessing

class Server():
    def __init__(self, bind_ip="127.0.0.1", bind_port=8083):
        self.address = (bind_ip, bind_port)
        self.server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
        self.clients = [] # 该列表主要用于实现群聊，存储已建立链接的所有客户端
    def socket_accept(self):
        while True:  # 不断接受用户的链接
            new_socket, client_info = self.server.accept()
            self.clients.append(new_socket)
            threading.Thread(target=self.create_conn, args=(new_socket, client_info)).start()

    def create_conn(self, socket_channel, client):
        while True:  # 循环收发消息
            message = socket_channel.recv(1024).decode("gbk").rstrip()  # 阻塞，等待信息
            self.group_recv(message) # 一旦有人发送消息，就调用群聊方法
            if message: # 判断是否异常断开，异常断开message为空
                print("%s:%s：%s" % (*client, message))
            else:
                socket_channel.close()
                self.clients.remove(socket_channel) # 如果socket通道已关闭，需要及时将它移除
                break

    def group_recv(self, message):
        for sock in self.clients: # 给所有的已建立链接的客户端发送群聊信息
            sock.send(message.encode())

    def start(self):
        self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  # socket重用
        self.server.bind(self.address)
        self.server.listen()
        return multiprocessing.Process(target=self.socket_accept).start()

    def __exit__(self, exc_type, exc_val, exc_tb):
        for client_socket in self.clients:
            client_socket.close()
        self.server.close()

s1 = Server()
s1.start()

import socket, threading, multiprocessing

class Server():
    def __init__(self, bind_ip="127.0.0.1", bind_port=8083):
        self.address = (bind_ip, bind_port)
        self.server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
        self.clients = {}  # 线程不安全
        self.lock = threading.Lock() # 加锁，对self.clients加入线程安全

    def socket_accept(self):
        while True: # 循环等待客户链接
            new_socket, client_info = self.server.accept()
            with self.lock:
                self.clients[client_info] = new_socket
            threading.Thread(target=self.create_conn, args=(new_socket, client_info)).start()

    def create_conn(self, socket_channel, client):
        while True:  # 循环收发消息
            message = socket_channel.recv(1024).decode("gbk").rstrip()
            self.group_recv(message)
            if message:
                print("%s:%s：%s" % (*client, message))
            else:
                socket_channel.close()
                with self.lock: # 加锁，对self.clients加入线程安全
                    self.clients.pop(client)  # 当当前客户端断开时，从容器中移除
                break

    def group_recv(self, message):
        with self.lock: # 加锁，对self.clients加入线程安全
            for sock in self.clients.values():
                sock.send(message.encode())

    def start(self):
        self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  # socket重用
        self.server.bind(self.address)
        self.server.listen()
        threading.Thread(target=self.socket_accept).start()

    def stop(self):
        with self.lock: # 加锁，对self.clients加入线程安全
            for client_socket in self.clients.values(): # 迭代或者close可能会有点慢，所以我们其实也可以先在加锁之前先拿到所有的values，然后再遍历
                client_socket.close()
            self.clients.clear()
        self.server.close()

s1 = Server()
s1.start()

while True:
    choice=input("a: ").rstrip()
    if choice == 'q':
        s1.stop()
        break

import socket,threading

class client():
    def __init__(self,server_ip="127.0.0.1",server_port=8083):
        self.client=socket.socket()
        self.address=server_ip,server_port
        self.event=threading.Event()
    def send(self,messgae):
        self.client.send(messgae.encode())
    def recv(self):
        while not self.event.is_set(): # 默认为False
            try:
                data=self.client.recv(1024).decode()
                if data:
                    print("\n%s"%data)
                else:
                    break
            except Exception as e:
                print(e)
                break
    def interaction(self):
        while True:
            message=input("请输入消息：")
            if message.lower() == "q" or message == "quit":
                self.stop()
                break
            self.send(message)
    def start(self):
        self.client.connect(self.address)
        self.send("hello server")
        threading.Thread(target=self.recv).start()
    def stop(self):
        self.send("q")
        self.event.set()
        self.client.close()
c1=client()
c1.start()
c1.interaction()