网络编程-Python

目录

• 00基本概念
  • 1. 网络通信协议
  • 2. ip地址
  • 3. Linux ,windows查看网卡信息
  • 4.ip地址的分类I
  • 5.端口 port
  • 6.端口分类：
  • 7. TCP/UDP协议
  • 8. socket（套接字）简介
• 01基于tcp协议的简单套接字通信
• 02基于tcp协议的通信循环
• 03链接循环
• 05基于udp协议的套接字简答通信
• 06基于tcp协议实现远程执行命令
• 07udp协议没有粘包问题
• 08基于（06）tcp协议实现远程执行命令，解决粘包问题
  • 发送数据

@

目录

• 00基本概念
  • 1. 网络通信协议
  • 2. ip地址
  • 3. Linux ,windows查看网卡信息
  • 4.ip地址的分类I
  • 5.端口 port
  • 6.端口分类：
  • 7. TCP/UDP协议
  • 8. socket（套接字）简介
• 01基于tcp协议的简单套接字通信
• 02基于tcp协议的通信循环
• 03链接循环
• 05基于udp协议的套接字简答通信
• 06基于tcp协议实现远程执行命令
• 07udp协议没有粘包问题
• 08基于（06）tcp协议实现远程执行命令，解决粘包问题
  • 发送数据

00基本概念

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. 不同电脑上的进程之间如何通信

   首先解决的问题是如何解决唯一标识一个进程，否则无从谈起

   在1台电脑上可以通过进程号（PID）来唯一标识一个进程，但是在网络中这是不行的

   其实TCP/IP协议族已经帮我们解决了这个问题，网络层的”ip地址“可以唯一标识网络的主机，而传输的“协议+端口" 可以唯一标识主机中的应用进程（进程）

   这样就可以利用IP地址，协议，端口，就可以标识网络的进程了，网络中的进程通信就可以利用这个标志与其他进程进行交互

• 所谓的进程，就是运行的程序以及运行时用到的资源这个整体称之为进程，
• 所谓 进程间通信 指的是 ：运行的程序之间的数据共享
• 进程时资源单位，线程是执行单位

2.社么是socket：

• socket是一种完成网络通信的必备的东西

  • socket（套接字）是进程间通信的一种方式，它与其他进程通信的一个主要不同时：它能实现不同主机间的进程间通信，我么在网络上各种各样的服务大多都是基于Socket来完成通信的；

例如：我们每天浏览的网页，QQ 聊天，收发email等

3. 创建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()