网络编程
网络编程初识
基本概念
1. 网络通信协议
就是计算机与计算机之间进行通信的时候有一些约定
使用网络的目的：
就是为了联通多方然后进行通信用的，即把数据从以方传递给另一方
所谓的网络编程就是让在不同的电脑上的软件能够进行数据传递，即进程之间的通信。
TCP/IP是一个协议族，
2. ip地址
作用：用来标记网络上的一台电脑,在本地局域网上是唯一的
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jGvwGAcv-1589893746614)(…/…/image/image-20200519031703116.png)]
3. Linux ,windows查看网卡信息
windows: win +R --》cmd--- 》ipconfig
关闭网卡：右下角无线右键–》打开网络和intent设置，找到更改适配器，进去后右键停用
Linux: ifconfig
关闭网卡：sudo ifconfig username down
开启网卡：sudo ifconfig username up
4.ip地址的分类I
ipv4 :由四组数组成，点号 隔开， 每个数最大值是255
ip version 4 版本
前三组是网络号，最后一组是主机号，要想传输信息，网络号必须一样，最多可以容纳256台电脑，但是0和255不能用，网络哈也可以是前两个，根据需求来变，如果前两个是网络号，那么就可以有256*256台电脑
5.端口 port
网络通讯必备ip和port
6.端口分类：
端口是通过端口号来标记的，端口号只有整数，范围 0~65535
知名端口（Well Know Port）：是众所周知的端口号，范围0~1023
80端口分配给HTTP服务
21端口分配给FTP服务
可以理解。一些常用的功能使用的号码是估计的，好比电话号码110 、10086、10010一样
一般情况下，如果程序使用知名端口得需要有root权限
动态端口：（Dynamic Port）
范围：1024~65535
之所以称为i动态，是因为一般不固定分配某种服务，而是动态分配
动态分配是指当一个系统程序或应用程序需要网络通信时。它向主机申请一个端口，主机从可用的端口号中分配一个供他使用。
当程序关闭，同时也就释放了所占用的端口号
7. TCP/UDP协议
是传输层两种协议，Socket是传出层供给应用层的编程接口，所有Socket就分为TCP编程和UDP编程
在网络同通信中，TCP方式就类似于拨打电话，使用该方式进行网络通讯时，需要建立专门的虚拟机连接，然后进行可靠的数据传输，如果传输失败，则客户端会自动重发该数据，而UDP方式类似于发送短信，使用这种方式进行通讯时，不需要建立专们的虚拟连接，传出也不是很可靠，如果发送失败则客户端无法获得
重要的数据一般使用TCP方式进行数据传输，而大量的非核心数据则可以通过UDP方式进行传递，在一些程序种甚至结合使用这两种方式进行传递。
由于TCP需要建立专用过的虚拟机连接以及确认传输是否正确，所以使用TCP方式的速度稍微慢了些，而且传输时产生的数据量要比UDP稍微大一些
总结：
- TCP是面向连接的，传输数据安全，稳定，效率相对较低
- UDP是面向无连接的，传输数据不安全，效率较高
8. socket（套接字）简介
不同电脑上的进程之间如何通信
首先解决的问题是如何解决唯一标识一个进程，否则无从谈起
在1台电脑上可以通过进程号（PID）来唯一标识一个进程，但是在网络中这是不行的
其实TCP/IP协议族已经帮我们解决了这个问题，网络层的”ip地址“可以唯一标识网络的主机，而传输的“协议+端口" 可以唯一标识主机中的应用进程（进程）
这样就可以利用==IP地址，协议，端口==，就可以标识网络的进程了，网络中的进程通信就可以利用这个标志与其他进程进行交互
- 所谓的进程，就是运行的程序以及运行时用到的资源这个整体称之为进程，
- 所谓 进程间通信 指的是 ：运行的程序之间的数据共享
- 进程时资源单位，线程是执行单位
2.社么是socket：
socket是一种完成网络通信的必备的东西
socket（套接字）是进程间通信的一种方式，它与其他进程通信的一个主要不同时：它能实现不同主机间的进程间通信，我么在网络上各种各样的服务大多都是基于Socket来完成通信的；
例如：我们每天浏览的网页，QQ 聊天，收发email等
- 创建socket
import socket
socket.socket(AddressFamily,Type)
说明：
函数socket.socket创建一个socket，该函数有两个参数：
AddressFamily:可以选择IAF_INET（用于Internet进程间通信）,或者AF_UNIX（用于同一台机器进程间通信，实际工作种常用 AF_INET ）
Type:套接字类型，可以是 SOCK_STREAM（流式套接字，主要用于TCP协议）或者SOCK_DGRAM（数据报套接字，主要用于UDP协议）
创建一个tcp socket （tcp套接字）
import socket
#创建tcp套接字
s=socket.socket(socket,AF_INEF,socket.SOCK_STREAM)
#。。。。使用套接字功能省略
#不用的时候关闭套接字
s.close()
创建一个udp socket（udp套接字）
import socket
#创建tcp套接字
s=socket.socket(socket,AF_INEF,socket.SOCK_DGRAM)
#。。。。使用套接字功能省略
#不用的时候关闭套接字
s.close()
说明：
- 套接字使用流程 与文件的使用流程很类似
- 创建套接字
- 使用套接字收 / 发数据
- 关闭套接字
01基于tcp协议的简单套接字通信
- 客户端
# @Time : 2022/8/24 10:33
# @File : 客户端1.py
import socket
#1 买手机
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#2. 拨通电话
phone.connect(('127.0.0.1',8080))
#3. 通信
phone.send('hello,service,哈哈哈'.encode('utf-8'))
data=phone.recv(1024)
print(data.decode('utf-8'))
#4.关闭链接(必选的回收资源操作)
phone.close()
- 服务端
# @Time : 2022/8/24 10:34
# @File : 服务端.py
import socket
# 1. 买手机
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # SOCK_STREAM流式协议 =>tcp协议 SOCK_DGRAM=>udp协议
# 2. 绑定手机卡
phone.bind(('127.0.0.1', 8080)) # 0-65535 1024以前的都被系统保留使用
# 3. 开机
phone.listen(5) # 5指的是半连接池的大小
print('服务端启动完成，监听地址为%s:%s' % ('127.0.0.1', 8080))
# 4. 等待电话链接请求：拿到电话链接conn
conn, client_addr = phone.accept()
print(conn)
print('客户端的IP和端口：', client_addr)
# 5.通信：收\发消息
data = conn.recv(1024) # 最大接受的数据量为1024Bytes，收到的时Bytes类型
print('客户端发来的消息', data.decode('utf-8'))
conn.send(data.upper())
# 6. 挂电话，关闭电话链接conn （必选的回收资源操作）
conn.close()
# 7. 关机(可选操作)
phone.close()
02基于tcp协议的通信循环
- 客户端
# @Time : 2022/8/24 10:33
# @File : 客户端1.py
import socket
#1 买手机
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#2. 拨通电话
phone.connect(('127.0.0.1',8080))
#3. 通信
while True:
msg=input("请输入内容>>>>").strip()
if msg=='quit':break
# if len(msg)==0:continue
if not msg:continue
phone.send(msg.encode('utf-8'))
data=phone.recv(1024)
print(data.decode('utf-8'))
#4.关闭链接(必选的回收资源操作)
phone.close()
- 服务端
# @Time : 2022/8/24 10:34
# @File : 服务端.py
import socket
# 1. 买手机
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # SOCK_STREAM流式协议 =>tcp协议 SOCK_DGRAM=>udp协议
# 2. 绑定手机卡
phone.bind(('127.0.0.1', 8080)) # 0-65535 1024以前的都被系统保留使用
# 3. 开机
phone.listen(5) # 5指的是半连接池的大小
# print('服务端启动完成，监听地址为%s:%s'%('127.0.0.1',8080))
# 4. 等待电话链接请求：拿到电话链接conn
conn, client_addr = phone.accept()
print(conn)
print('客户端的IP和端口：', client_addr)
# 5.通信：收\发消息
while True:
try:
data = conn.recv(1024) # 最大接受的数据量为1024Bytes，收到的时Bytes类型
if len(data) == 0:
# 在Unix系统下，一旦data收到的是空，意味着一种异常的行为：客户端非法断开了连接
break
print('客户端发来的消息', data.decode('utf-8'))
conn.send(data.upper())
except Exception:
#针对windows系统
break
# 6. 挂电话，关闭电话链接conn （必选的回收资源操作）
conn.close()
# 7. 关机(可选操作)
phone.close()
03链接循环
客户端
# @Time : 2022/8/24 10:33
# @File : 客户端1.py
import socket
#1 买手机
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#2. 拨通电话
phone.connect(('127.0.0.1',8080))
#3. 通信
while True:
msg=input("请输入内容>>>>").strip()
if msg=='quit':break
# if len(msg)==0:continue
if not msg:continue
phone.send(msg.encode('utf-8'))
data=phone.recv(1024)
print(data.decode('utf-8'))
#4.关闭链接(必选的回收资源操作)
phone.close()
服务端
# @Time : 2022/8/24 10:34
# @File : 服务端.py
import socket
#服务端满足的特点：
#1.一直提供服务
#2.并发的提供服务
# 1. 买手机
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # SOCK_STREAM流式协议 =>tcp协议 SOCK_DGRAM=>udp协议
# 2. 绑定手机卡
phone.bind(('127.0.0.1', 8080)) # 0-65535 1024以前的都被系统保留使用
# 3. 开机
phone.listen(5) # 5指的是半连接池的大小
# print('服务端启动完成，监听地址为%s:%s'%('127.0.0.1',8080))
# 4. 等待电话链接请求：拿到电话链接conn
#加上链接循环
while True:
conn, client_addr = phone.accept()
# 5.通信：收\发消息
while True:
try:
data = conn.recv(1024) # 最大接受的数据量为1024Bytes，收到的时Bytes类型
if len(data) == 0:
# 在Unix系统下，一旦data收到的是空，意味着一种异常的行为：客户端非法断开了连接
break
print('客户端发来的消息', data.decode('utf-8'))
conn.send(data.upper())
except Exception:
#针对windows系统
break
# 6. 挂电话，关闭电话链接conn （必选的回收资源操作）
conn.close()
#
# # 7. 关机(可选操作)
# phone.close()
05基于udp协议的套接字简答通信
UDP是无连接的，所以先启动那一段都不会报错
- 客户端
# @Time : 2022/8/24 10:33
# @File : 客户端1.py
import socket
client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 数据包协议 SOCK_DGRAM=>udp协议
while True:
msg = input('请输入内容：》》》').strip()
client.sendto(msg.encode('utf-8'), ('127.0.0.1', 8080))
data, srever_addr = client.recvfrom(1024)
print(data.decode('utf-8'))
client.close()
- 服务端
# @Time : 2022/8/24 10:34
# @File : 服务端.py
import socket
server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 数据包协议 SOCK_DGRAM=>udp协议
server.bind(('127.0.0.1', 8080)) # 0-65535 1024以前的都被系统保留使用
while True:
data, client_addr = server.recvfrom(1024)
print(data.decode('utf-8'))
server.sendto(data.upper(), client_addr)
server.close()
06基于tcp协议实现远程执行命令
- 客户端
# @Time : 2022/8/27 9:11
# @File : client1.py
from socket import *
client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.3', 8080))
while True:
cmd = input('请输入内容》》》：').strip()
if len(cmd) == 0: continue
client.send(cmd.encode('utf-8'))
# 解决粘包问题思路：
# 1拿到数据的总大小total_size
# 2.recv_size=0,循环接收，每接受一次，reve_size+=拿到的数据大小
# 3.直到rece_size = total_size,结束循环
cmd_res = client.recv(1024)
print(cmd_res.decode('gbk')) # windows系统用gbk ,linux用utf-8
# 粘包问题出现的问题
# 1.tcp是流水协议，数据像水一样粘在一起，没有任何分界
# 2.收数据没收干净，有残留，就会跟下一次结果混淆在一起
# 解决的核心法门就是：收干净，不要有任何 残留
- 服务端
# @Time : 2022/8/27 9:11
# @File : server.py
# 服务端特点：
# 1.一直对外服务
# 2.并发的服务多个客户端
from socket import *
import subprocess
server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.3', 8080))
server.listen(5)
# 服务端应该做到两件事：
# 1.循环的从半连接池中取出链接请求，与其建立双向链接，获取链接对象
while True:
conn, client_addr = server.accept()
# 2.拿到链接对象，与其进行通信循环
while True:
try:
cmd = conn.recv(1027)
if len(cmd) == 0: break
obj = subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
stdout_res = obj.stdout.read()
stderr_res = obj.stderr.read()
print(len(stderr_res) + len(stdout_res))
# conn.send(srderr_res+stdout_res)
conn.send(stderr_res)
conn.send(stdout_res)
# with open('1.mp4',mode='rb') as fp:
# for i in fp:
# conn.send(i)
except Exception:
break
conn.close()
07udp协议没有粘包问题
- 客户端
# @Time : 2022/8/27 10:30
# @File : udpClient.py
import socket
client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
client.sendto(b'hello',('127.0.0.5',8080))
client.sendto(b'python',('127.0.0.5',8080))
"""
udp是用户数据报协议，必须一个sendto对应一个recefrom,
不像tcp,tcp是基于数据流的
"""
client.close()
- 服务端
# @Time : 2022/8/27 10:30
# @File : udpServer.py
import socket
server=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
server.bind(('127.0.0.5',8080))
res1=server.recvfrom(3)#收过来的是hello,只收3个字节，其余的扔掉，而tcp不一样，多余的会放在缓存中。下一次接着给你，不会扔掉
print(res1)
res2=server.recvfrom(2)
print(res2)
server.close()
08基于（06）tcp协议实现远程执行命令，解决粘包问题
- 客户端
# @Time : 2022/8/27 9:11
# @File : client1.py
from socket import *
import struct
client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.3', 8080))
while True:
cmd = input('请输入内容》》》：').strip()
if len(cmd) == 0: continue
client.send(cmd.encode('utf-8'))
# 解决粘包问题思路：
# 1,先收固定长度的头，解析出数据的描述信息，拿到数据的总大小total_size
header=client.recv(4)
total_size=struct.unpack('i',header)[0]
#根据解析出的描述信息，接收真实数据
# 2.recv_size=0,循环接收，每接受一次，reve_size+=拿到的数据大小
# 3.直到rece_size = total_size,结束循环
recv_size=0
while recv_size <total_size:
cmd_res = client.recv(1024)
recv_size+=len(cmd_res)
print(cmd_res.decode('gbk'))
else:
print()
# 粘包问题出现的问题
# 1.tcp是流水协议，数据像水一样粘在一起，没有任何分界
# 2.收数据没收干净，有残留，就会跟下一次结果混淆在一起
# 解决的核心法门就是：收干净，不要有任何 残留
- 服务端
# @Time : 2022/8/27 9:11
# @File : server.py
# 服务端特点：
# 1.一直对外服务
# 2.并发的服务多个客户端
from socket import *
import subprocess
import struct
server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.3', 8080))
server.listen(5)
# 服务端应该做到两件事：
# 1.循环的从半连接池中取出链接请求，与其建立双向链接，获取链接对象
while True:
conn, client_addr = server.accept()
# 2.拿到链接对象，与其进行通信循环
while True:
try:
cmd = conn.recv(1027)
if len(cmd) == 0: break
obj = subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
stdout_res = obj.stdout.read()
stderr_res = obj.stderr.read()
total_size=len(stderr_res) + len(stdout_res)
#1.先发头信息，（固定长度的bytes）,对数据的描述信息
#.int类型转成Bytes
header=struct.pack('i',total_size)
conn.send(header)
#2.再发真实的数据
conn.send(stderr_res)
conn.send(stdout_res)
# with open('1.mp4',mode='rb') as fp:
# for i in fp:
# conn.send(i)
except Exception:
break
conn.close()
发送数据
'''发送数据'''
#导入模块
from socket import socket,AF_INET,SOCK_DGRAM
#创建udp套接字
udp_socket = socket(AF_INET,SOCK_DGRAM)
#创建接受信息的地址
addr =("192.168.0.103",8080)
#键盘接收发送的消息
data = input("请输入要发送的信息：")
#调用sendto发送信息
udp_socket.sendto(data.encode("gb2312"),addr)
#关闭套接字
udp_socket.close()
实现多线程聊天:
from socket import *
from threading import Thread
#创建套接字对象
udp_socket = socket(AF_INET,SOCK_DGRAM)
#绑定本机和端口，
udp_socket.bind(("",8888))
#接受
def recv_fun():
while 1:
recv_data =udp_socket.recvfrom(1024)
print("》》%s:%s"%(recv_data[1][0],recv_data[0].decode("gb2312")))
#发送
def send_fun():
while 1:
addr =("192.168.0.103",8080)
data = input("《《:")
udp_socket.sendto(data.encode("gb2312"),addr)
if __name__ == '__main__':
# 创建两个线程
t1 = Thread(target=send_fun)
t2 = Thread(target=recv_fun)
t1.start()
t2.start()
t1.join()
t2.join()
本文含有隐藏内容，请 开通VIP 后查看