python网络编程

import socket
socket.socket(socket_family,socket_type,protocal=0)
socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。获取tcp/ip套接字
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)获取udp/ip套接字
udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)由于 socket 模块中有太多的属性。我们在这里破例使用了'from module import *'语句。使用 'from socket import *',我们就把 socket 模块里的所有属性都带到我们的命名空间里了,这样能 大幅减短我们的代码。
例如tcpSock = socket(AF_INET, SOCK_STREAM)

t_s = socket() #创建服务器套接字
t_s.bind() #把地址绑定到套接字
t_s.listen() #监听连接while True: #服务器无线循环 #这是用来循环接收不同的链接
c_s = t_s.accept() #等待接受客户端连接
while True: #通信循环 #用来基于一次链接的循环的通信
c_s.recv() / c_s.send() #对话（接受与发送）
c_s.close() #关闭客户端的套接字
t_S.close() #关闭服务器的套接字（可选）#这是伪代码，只是了解socket

c_s = socket() #创建客户套接字
c_s.connect() #连接服务器while True:
c_s.send() / cs.recv() #对话（发送/接收）
c_s.close() #关闭客户套接字#这是伪代码

import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #创建基于tcp的网络 套接字 对象
phone.bind(("127.0.0.1",8000)) #把地址和端口号，绑定到套接字对象
print(">>>>>>>>>>>>>")
phone.listen(5)#监听连接
conn,addr = phone.accept() #被动接受TCP客户端连接
msg = conn.recv(1024) #接收TCP数据，
print("客户端发来的消息是>>",msg.decode("utf-8"))
user = input("请给client发送的信息>>>")
conn.send(user.encode("utf-8"))#给client发送TCP数据， 在网络中传输必须是二进制的方式
conn.close()
phone.close() #关闭套接字#注：这是用自已本机做的测试

import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #创建socket对象 tcp方式phone.connect(("127.0.0.1",8000))
a = input(">>>")
phone.send(a.encode("utf-8"))
data = phone.recv(1024)
print("收到服务器发来的消息",data.decode("utf-8"))

第一运行server端，等待client连接>>>>>>>>>>>>>
客户端发来的消息是>> hello
请给client发送的信息>>>收到了第二：连接server 端 相应的ip地址和端口好
给服务发信息>>>hello
收到服务器发来的消息 收到了

from socket import *
address = ("127.0.0.1",5666)
back_log = 5
buffersize = 1024
t_server = socket(AF_INET,SOCK_STREAM)
t_server.bind(address) #这里不能写死了，需要向linux配置文件那样可以随便修改
t_server.listen(back_log)
while True: #循环不同的通讯连接
print("server运行，等待客户端连接")
conn,addr = t_server.accept() #等待客户端连接
print("客户端的链接:>>",conn)
print("客户端的地址:>>",addr)
print("开始聊天".center(50, "#"))
while True:
msg = conn.recv(buffersize) #接收从哪个连接发来的信息，接收的字节大小是buffersize = 1024
if not msg:break #如果不加，正在连接的客户端突然断开，recv便不再阻塞，会触发死循环
print("客户端发来的信息是:》》",msg.decode("utf-8")) #发的什么编码，就用什么编码打开
conn.send(msg.upper())
conn.close()
t_server.close()

from socket import *
address = ("127.0.0.1",5666)
buffersize = 1024
t_client = socket(AF_INET,SOCK_STREAM)
t_client.connect(address)
while True:
msg = input("请给服务端发信息[quit]:》》")
if msg == "quit":break
t_client.send(msg.encode("utf-8"))
data = t_client.recv(buffersize)
print("收到服务端发来的信息是:>>",data.decode("utf-8"))

from socket import *
address = ("127.0.0.1",5666)
back_log = 5
buffersize = 1024
t_server = socket(AF_INET,SOCK_STREAM)
t_server.bind(address) #这里不能写死了，需要向linux配置文件那样可以随便修改
t_server.listen(back_log)
while True: #循环不同通讯连接
print("server运行，等待客户端连接")
conn,addr = t_server.accept() #等待客户端连接
print("客户端的链接:>>",conn)
print("客户端的地址:>>",addr)
print("开始聊天".center(50, "#"))
while True:
try:
msg = conn.recv(buffersize) #接收从哪个连接发来的信息，接收的字节大小是buffersize = 1024
if not msg:break #如果不加，正在连接的客户端突然断开，recv便不再阻塞，会触发死循环
print("客户端发来的信息是:》》",msg.decode("utf-8")) #发的什么编码，就用什么编码打开
conn.send(msg.upper())
except Exception as e:
print("客户端强制断开了连接")
break
conn.close()
t_server.close()#注：只修改了服务端，客户端没动

t_server = socket(AF_INET,SOCK_STREAM)
t_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加,重新使用地址

发现系统存在大量TIME_WAIT状态的连接，通过调整linux内核参数解决，
vi /etc/sysctl.conf编辑文件，加入以下内容：
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30然后执行 /sbin/sysctl -p 让参数生效。net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭；net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭；net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间#这是linux的系统的配置文件

ss = socket() #创建一个服务器的套接字
ss.bind() #绑定服务器套接字
while True: #服务器无限循环
cs = ss.recvfrom()/ss.sendto() # 对话(接收与发送)
ss.close() #伪代码

cs = socket() # 创建客户套接字
while True: # 通讯循环
cs.sendto()/cs.recvfrom() # 对话(发送/接收)
cs.close() # 关闭客户套接字#伪代码

from socket import *address = ("127.0.0.1",9000)
buffersize = 1024
u_server = socket(AF_INET,SOCK_DGRAM) #SOCK_DGRAM 数据报方式 udp
u_server.bind(address)while True: qq_msg,addr = u_server.recvfrom(buffersize)
print('来自[%s:%s]的一条消息:\033[1;33m %s\033[0m' %(addr[0],addr[1],qq_msg.decode('utf-8')))
back_msg = input("回复消息:>>")
u_server.sendto(back_msg.encode("utf-8"),addr)

from socket import *u_client = socket(AF_INET,SOCK_DGRAM)
buffersize = 1024
qq_name_dict = {
'唐僧':('127.0.0.1',9000),
'猪头':('127.0.0.1',9000),
'孙悟空':('127.0.0.1',9000),
'白龙马':('127.0.0.1',9000),
}while True:
for i in qq_name_dict:
print(i)
qq_name = input("请选择聊天对象:>>")
if not qq_name or qq_name not in qq_name_dict:continue
while True:
msg = input("请输入消息，回车发送:>>")
if msg == "quit":break
if not msg:continue
u_client.sendto(msg.encode("utf-8"),qq_name_dict[qq_name]) back_msg,addr = u_client.recvfrom(1024)
# print(back_msg.decode("utf-8"))
# print(addr)
print("来自【%s ：%s】的一条信息\033[1;33m %s \033[0m"%(addr[0],addr[1],back_msg.decode("utf-8")))
u_client.close()

from socket import *
import subprocessip_port = ("127.0.0.1",8000)
buffersize = 1024
back_log = 5
tcp_socket_server = socket(AF_INET,SOCK_STREAM) #创建套接字
tcp_socket_server.bind(ip_port) #绑定套接字
tcp_socket_server.listen(back_log)while True: #循环不同的通讯连接
conn,addr = tcp_socket_server.accept() #等待client连接
print("客户端",addr)
while True: #信息通讯的循序
try: #非常正常关闭
cmd = conn.recv(buffersize) #从client接收的信息
print("客户端发来的信息",cmd)
if len(cmd) == 0:break #如果收到是空消息，继续等待客户端发信息
act_res = subprocess.Popen(cmd.decode("utf-8"),shell=True, #shell=True 表示输入命令通过shell来执行
stdout = subprocess.PIPE, #程序的标准输出句柄，NONE表示不进行重定向，继承父进程，PIPE表示创建管道
stdin = subprocess.PIPE, #程序的标准输入句柄
stderr=subprocess.PIPE) #程序的标准错误句柄
#把得到相应的信息，都放到管道中 err = act_res.stderr.read() ##从错误管道中读取相应信息
if err: #如果有错误信息
ret = err
else: #没有错误信息
ret = act_res.stdout.read()
conn.sendall(ret)#把相应的错误信息或正确信息发送给client端
except Exception:
break conn.close()

import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8000)s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port) #出错时返回出错码,而不是抛出异常while True:
msg=input('>>: ').strip()
if len(msg) == 0:continue
if msg == 'quit':break s.send(msg.encode('utf-8'))
act_res=s.recv(BUFSIZE) print("命令执行的结果是：>>",act_res.decode('gbk'),end='')

from socket import *
import subprocess
ip_port = ("127.0.0.1",8000)
back_log = 5
buffersize = 1024
tcp_server = socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
while True:
conn,addr = tcp_server.accept()
print("新的客户端的链接:》》",addr)
while True:
try:
cmd = conn.recv(buffersize)
if not cmd:break
print("客户端命令是:》》",cmd.decode("utf-8"))
res = subprocess.Popen(cmd.decode("utf-8"),shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE)
err = res.stderr.read()
#发
if err:
ret = err
else:
ret = res.stdout.read()
if not ret: #如果没有相应的返回信息
ret="执行成功".encode("gbk") #就返回一个自定义的信息 #解决粘包方法
data_length = len(ret) #统计返回信息的长度
conn.send(str(data_length).encode("utf-8")) #第一次 把统计信息的长度，发送给客户端
data = conn.recv(buffersize) #第二次接收相应字节数据 print(data)
print(">>>>>>>>",data)
if data == b"ready": #判断接收相应的字节数据
conn.send(ret)#继续发送ret的数据 except Exception:
break
conn.close()

from socket import *
ip_port = ("127.0.0.1",8000)
buffersize = 1024
tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
cmd = input(":>>>")
if not cmd:continue
if cmd == "quit":break
tcp_client.send(cmd.encode("utf-8")) #发送相应的命令 #解决粘包
length = int(tcp_client.recv(buffersize).decode("utf-8"))#接收第一次收到的信息长度 tcp_client.send(b"ready") #第二次直接发送字节数据 recv_size = 0 #接收的字节大小，初始化为0
recv_msg = b"" #接收的字节数据
while recv_size < length: #每次接收的字节大小，跟第一次接收字节的大小相比 。 直到大于第一出现的字节，就不会出现粘包了
recv_msg += tcp_client.recv(buffersize) #加上每一次收的字节大小
recv_size = len(recv_msg) #等于上一次接收字节数据
print("命令执行结果是",recv_msg.decode("gbk"))
tcp_client.close()

from socket import *
import subprocess
import struct
ip_port = ("127.0.0.1",8000)
back_log = 5
buffersize = 1024
tcp_server = socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
while True:
conn,addr = tcp_server.accept()
print("新的客户端的链接:》》",addr)
while True:
try:
cmd = conn.recv(buffersize)
if not cmd:break
print("客户端命令是:》》",cmd.decode("utf-8"))
res = subprocess.Popen(cmd.decode("utf-8"),shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE)
err = res.stderr.read()
#发
if err:
ret = err
else:
ret = res.stdout.read()
if not ret: #如果没有相应的返回信息
ret="执行成功".encode("gbk") #就返回一个自定义的信息 #解决粘包方法
length = len(ret) #统计返回信息的长度
data_length = struct.pack("i",length) #把length的整型数据，封装bytes字节类型 该类型的产长度为4
conn.send(data_length)
conn.send(ret) #会粘包到一起，因为client第一次收的时候已经知道 收多少字节，就不会粘包了 except Exception:
break
conn.close()

from socket import *
import struct
ip_port = ("127.0.0.1",8000)
buffersize = 1024
tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
cmd = input(":>>>")
if not cmd:continue
if cmd == "quit":break
tcp_client.send(cmd.encode("utf-8")) #发送相应的命令 #解决粘包
length_data= tcp_client.recv(4) #接收第一次相应字节长度 4 "i"
length = struct.unpack("i",length_data)[0]
recv_size = 0
recv_msg = b""
while recv_size < length:
recv_msg += tcp_client.recv(buffersize)
recv_size = len(recv_msg)
print("客户端收到的信息是:>>",recv_msg.decode("gbk"))tcp_client.close()