面向连接的tcp 编程

from socket import *
serverSocket=socket(AF_INET,SOCK_STREAM)
serverSocket.bind(("",8899))
serverSocket.listen(5)
newSocket,clientAddr=serverSocket.accept()     #返回新的套接字和对方的ip地址和端口号
print("有客户端连接")
recvDate=newSocket.revc(1024)
print("%s%s"%(str(clientAddr),recvDate))
newSocket.send("thank you !")
newSocket.close()
serverSocket.close()

from socket import *

# 创建socket
tcpSerSocket = socket(AF_INET, SOCK_STREAM)

# 绑定本地信息
address = ('', 8899)
tcpSerSocket.bind(address)

# 使用socket创建的套接字默认的属性是主动的，使用listen将其变为被动的，这样就可以接收别人的链接了
tcpSerSocket.listen(5)

# 如果有新的客户端来链接服务器，那么就产生一个新的套接字专门为这个客户端服务器
# newSocket用来为这个客户端服务
# tcpSerSocket就可以省下来专门等待其他新客户端的链接
newSocket, clientAddr = tcpSerSocket.accept()

# 接收对方发送过来的数据，最大接收1024个字节
recvData = newSocket.recv(1024)
print('接收到的数据为:%d',recvData.decode("gb2312"))

# 发送一些数据到客户端
newSocket.send("thank you !".encode("gb2312"))

# 关闭为这个客户端服务的套接字，只要关闭了，就意味着为不能再为这个客户端服务了，如果还需要服务，只能再次重新连接
newSocket.close()

# 关闭监听套接字，只要这个套接字关闭了，就意味着整个程序不能再接收任何新的客户端的连接
tcpSerSocket.close()

# 多线程服务器，接收客户机链接

from socket import *
from threading import *

def recv_send_Thread(customer_sock,addr):
    while True:

        str=customer_sock.recv(1024)                                  # 循环接收客户端发来的信息
        customer_sock.send(str)
        print(str.decode("gb2312"))
        if str.decode("gb2312") == 'exit':
            print("关闭套接字")
            customer_sock.close()
            break
    customer_sock.close()
#创建服务器的socket
server_tcp_socket=socket(AF_INET,SOCK_STREAM)

# 解决MSL问题，如果服务器先断开链接，则第四次会后不必等2被时间，即可链接，避免出现等到2倍时间内地址被占用的问题
server_tcp_socket.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)

#bind绑定地址和端口
server_tcp_socket.bind(("",8899))

#设置监听listen
server_tcp_socket.listen(5)

while True:
    new_socket,new_addr=server_tcp_socket.accept()       #等待接受客户端链接
    print(("与客户%s建立链接成功，可以交流" % new_addr[0]))
    new_socket.send(("您好客户%s，已经建立链接，可以交流" % new_addr[0]).encode("gb2312"))           #  链接成功后，发送链接信息
    th=Thread(target=recv_send_Thread,args=(new_socket,new_addr))
    th.start()
    th.join()

#收发信息

#释放链接
server_tcp_socket.close()

#select版本的服务器代码
#轮询的方式检测，效率低；32位最多链接1023个，64位最多链接2045个端口
from socket import *
from select import select
from sys import *

def main():

    server = socket(AF_INET,SOCK_STREAM)
    # 解决MSL问题，如果服务器先断开链接，则第四次会后不必等2被时间，即可链接，避免出现等到2倍时间内地址被占用的问题
    server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
    address = ("",8000)
    server.bind(address)
    server.listen(1024)
    inputs=[server,stdin]
    running = True
    while True:
        readable,writeable,exceptional = select(inputs,[],[])
        for sock in readable:

            if(sock == server):
                s,addr = server.accept()
                print(s)
                inputs.append(s)
                s.send("已经建立好链接".encode("gb2312"))
            elif sock == stdin:
                cmd = stdin.readline()
                running = False
                break
            else:
                msg = sock.recv(1024)
                print(msg.decode("gb2312"))
                sock.send(("服务器收到了客户端发送的：%s"%(msg.decode("gb2312"))).encode("gb2312"))
                if msg.decode("gb2312")=='exit':
                    #sock.send("将要断开链接".encode("gb2312"))
                    sock.close()
                    inputs.remove(sock)
        if running==False:
            break
    server.close()
    print("服务器关闭")
if __name__ =="__main__":
    main()

# epool 方式实现服务器
# epool是没有套接字上限，是时间通知机制。     pool是轮询机制,解决了套接字有上限的问题。

from socket import *
from select import *

s = socket(AF_INET,SOCK_STREAM)
# 解决MSL问题，如果服务器先断开链接，则第四次会后不必等2被时间，即可链接，避免出现等到2倍时间内地址被占用的问题
s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
addr=("",8000)
s.bind(addr)
s.listen(10)
epoll_l = epoll()
epoll_l.register(s.fileno(),EPOLLIN|EPOLLET)

connections={}
addresses={}

while True:
    epoll_list = epoll_l.poll()

    for fd,events in epoll_list:
        if fd == s.fileno():
            soc,addres = s.accept()
            soc.send("已经链接链接".encode("gb2312"))
            connections[soc.fileno()] = soc
            addresses[soc.fileno()] = addres

            epoll_l.register(soc.fileno(), EPOLLIN|EPOLLET)
        elif events == EPOLLIN:

            msg = connections[fd].recv(1024)
            print(msg.decode("gb2312"))
            connections[fd].send(("收到了客户端的%s"%msg.decode("gb2312")).encode("gb2312"))
            if msg.decode("gb2312") == "exit":
                epoll_l.unregister(fd)
                connections[fd].close()
                print()
        else:
            pass

# 协程,生成器版本

import time

def A():
    while True:
        print("----a----")
        yield
        time.sleep(1)

def B(c):
    while True:
        print("----b----")
        c.__next__()
        time.sleep(1)

a=A()
print(a.__next__())
b=B(a)

# 协程，greenlet版本

from greenlet import greenlet
import time

def test1():
    while True:
        print("A")
        gr2.switch()
        time.sleep(1)

def test2():
    while True:
        print("B")
        gr1.switch()
        time.sleep(1)

gr1=greenlet(test1)
gr2=greenlet(test2)

gr1.switch()

#  gevent版本的服务器

import gevent
#from socket import *
from gevent import socket,monkey
monkey.patch_all()

def handle_request(conn):
    while True:
        data=conn.recv(1024)
        if not data:
            conn.close()
            break
        print("recv:%s"%data.decode("gb2312"))
        conn.send(data)

def server(port):
    s=socket.socket()
    # 解决MSL问题，如果服务器先断开链接，则第四次会后不必等2被时间，即可链接，避免出现等到2倍时间内地址被占用的问题
    #s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
    s.bind(("",port))
    s.listen(5)
    while True:
        cli,addr = s.accept()
        cli.send("已经连接成功".encode("gb2312"))
        gevent.spawn(handle_request,cli)

if __name__=="__main__":
    server(8000)

客户端程序：

# 客户端程序
from socket import *

# 创建socket
tcpClientSocket = socket(AF_INET, SOCK_STREAM)

# 链接服务器
serAddr = ('192.168.249.210', 8000)
tcpClientSocket.connect(serAddr)                                          # 建立连接
recvData = tcpClientSocket.recv(1024)                                     # 接收数据
print('接收到的数据为:'+recvData.decode("gb2312"))
while True:
    # 提示用户输入数据
    sendData = input("请输入要发送的数据：")
    tcpClientSocket.send(sendData.encode("gb2312"))                      # 循环发送数据
    if sendData == "exit":
        break
        # 接收对方发送过来的数据，最大接收1024个字节
    recvData = tcpClientSocket.recv(1024)                                # 循环接收数据
    print('接收到的数据为:'+recvData.decode("gb2312"))

# 关闭套接字
tcpClientSocket.close()