Python基础学习（十七）--网络编程，TCP协议，UDP协议，数据结构

最新推荐文章于 2022-05-26 19:16:19 发布

一个非常正经的人

最新推荐文章于 2022-05-26 19:16:19 发布

阅读量508

点赞数

分类专栏： python基础语法文章标签： python基础

本文链接：https://blog.csdn.net/qq_34244910/article/details/98958139

版权

python基础语法专栏收录该内容

23 篇文章 2 订阅

订阅专栏

一、网络编程

上次提到了网络编程中的，基于UDP协议的，使用Socket编写的简易聊天室。

今天细讲一下这些都是啥东西。

（一）软件开发架构

首先了解一下软件开发的架构，它分为两大类。

1.C/S架构

C/S即：Client和Server，即客户端与服务器架构。

这里的客户端一般泛指客户端应用程序，需要先安装才能在运行在用户的电脑上。

2.B/S架构

B/S即：Browser和Server，即浏览器端与服务器端架构。

只需在浏览器上通过HTTP去请求服务器端相关的资源（网页资源）。

（二）计算机网络

1.IP地址

每台电脑在网络世界中都有一个全球唯一的标识，就是ip地址。

当前ip地址正在由Ipv4向Ipv6转变。

2.广域网、局域网

局域网，简称LAN，是指在某个区域内由多台计算机互联成的计算机组。局域网是封闭型的，可以由办公室内的两台计算机组成，也可以由一个公司内的上千台计算机组成。局域网可以实现文件管理、应用软件共享、打印机共享、扫描仪共享、工作组内的日程安排、电子邮件和传真通信服务等功能。

广域网，简称WAN，是一种跨越大的、地域性的计算机网络的集合。通常跨越省、市，甚至是一个国家。广域网包括大大小小不同的子网，子网可以是局域网也可以是小型的广域网。

（三）网络协议（TCP/IP协议族）

互联网上有上百种协议，但是最重要的两个协议是TCP协议和IP协议，因此我们将上百种协议统称为TCP/IP协议族。TCP/IP协议族，根据协议的功能的不同抽象成了4层。

应用层

传输层

网络层

数据链路层

（四）TCP协议

TCP--可靠的，面向链接的协议。

TCP协议的特点：数据安全，速度略低。分为客户端和服务端。

TCP三次握手--建立连接

TCP四次挥手--终止连接

四次挥手

（五）UDP协议

UDP协议--面向无连接，数据不安全，不可靠，速度快。

（六）TCP和UDP的对比

TCP--提供的是面向连接、可靠的服务。当客户和服务器彼此交换数据前，必须先在双方之间建立一个TCP连接，之后才能传输数据。TCP提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传到另一端。

UDP--是一个简单的不可靠的运输层协议。它只是把应用程序传给IP层的数据报发送出去，但是并不能保证它们到达目的地。由于UDP在传输数据报之前，不用在客户和服务器之间建立连接，且没有超时重发机制，故而传输速度很快。

这里贴一段基于TCP协议，使用Socket实现的简单聊天室。

客户端：

import threading
from socket import *
client_socket=socket(AF_INET,SOCK_STREAM)
dest_address=('10.10.107.240',9999)    # 服务器id
client_socket.connect(dest_address)    # 建立连接，三次握手
def send():
    while True:
        d=input('')
        if d=='q' or d=='quit' or d=='exit':
            break
        client_socket.send(d.encode('utf-8'))
def get():
    while True:
        r=client_socket.recv(124)
        print(r.decode('utf-8'))
if __name__ == '__main__':
    t1=threading.Thread(target=send)
    t2 = threading.Thread(target=get)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    client_socket.close()

服务器端：

import threading
from socket import *
server_socket=socket(AF_INET,SOCK_STREAM)
local_address=('10.10.107.240',9999)
server_socket.bind(local_address)
server_socket.listen(5)    # 监听 5--最多可收5个链接
print('server_socket:',server_socket)
lianjie=server_socket.accept()
def send():
    while True:
        # print('收到的链接',lianjie)
        # lianjie[0]比server_socket多一个远程地址
        x=input('')
        if x=='q' or x=='quit' or x=='exit':
            break
        lianjie[0].send(x.encode('utf-8'))
def get():
    while True:
        r = lianjie[0].recv(124)
        print(r.decode('utf-8'))
if __name__ == '__main__':
    t1=threading.Thread(target=send)
    t2=threading.Thread(target=get)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    server_socket.close()

（七）OSI模型

OSI模型是国际标准化组织制定的一个用于计算机或通信系统间互联的标准体系，一般称为OSI参考模型或七层模型。

应用层

表示层

会话层

运输层

网络层

数据链路层

物理层

二、数据结构

栈和队列是两种应用非常广泛的数据结构，它们都来自线性表数据结构，都是“操作受限”的线性表。

（一）队列

是一种前进先出的（简称FIFO）的线性表。只允许在表的一段进行插入，另一端进行删除。

队首（front）：允许进行删除的一端为队首。

队尾（rear）：允许进行插入的一端为队尾。

队列中没有元素时，称为空队列。

a=[]
while True:
    bh=int(input('请输入编号：'))
    # 入队
    if bh == 1:
        data=input('请输入入队数据：')
        a.append(data)
    # 出队
    elif bh==2:
        if len(a)<1:
            print('空队列')
        else:
            # data=a[0]
            # del a[0]
            # print(data,'出队')
            print(a.pop(0),'出队')
    # 查看
    elif bh==3:
        print(a)
    else:
        break

（二）栈

又称为后进先出（LIFO）或先进后出（FILO）的线性表。

栈顶（top）：允许进行插入、删除操作的一端，又称为表尾。用栈顶指针（top）来指示栈顶元素。

栈底（bottom）：是固定端，不允许进行操作，又称为表头。

空栈：当表中没有元素时称为空栈。

class Stack():
    def __init__(self):
        self.top=-1
        self.sList=[]
    def inStack(self):
        d=int(input('请输入入栈数据：'))
        self.top+=1
        self.sList.append(d)
    def outStack(self):
        if self.top==-1:
            print('空栈')
        else:
            d=self.sList[self.top]
            del self.sList[self.top]
            print(d,'出栈')
            self.top-=1
    def printStack(self):
        print(self.sList)
s=Stack()
while True:
    bh=int(input('请输入操作编号：'))
    if bh==1:
        s.inStack()
    elif bh==2:
        s.outStack()
    elif bh==3:
        s.printStack()
    else:
        break

栈的应用--括号匹配

dict={'(':')','{':'}','[':']'}
class Stack():
    def __init__(self):
        self.top=-1
        self.sList=[]
    def inStack(self,z):
        self.top+=1
        self.sList.append(z)
    def outStack(self,y):
        if dict[self.sList[self.top]]==y:
            del self.sList[self.top]
            self.top -= 1
        elif dict[self.sList[self.top]]!=y:
            print('括号不匹配')
            exit()
    def pd(self,kh):
        if len(kh)%2==1:
            print('匹配失败')
            exit()
        for i in range(len(kh)):
            if kh[i] in dict.keys():
                self.inStack(kh[i])
            else:
                self.outStack(kh[i])
        if self.top == -1:
            print('匹配成功')
kh=(input('请输入：'))
s=Stack()
s.pd(kh)

栈的应用--进制转换

class Stack():
    def __init__(self):
        self.top=-1
        self.sList=[]
    def inStack(self,data):
        self.top += 1
        self.sList.append(data)
    def outStack(self):
        while self.top>-1:
            data=self.sList[self.top]
            del self.sList[self.top]
            print(data,end='')
            self.top -= 1
s=Stack()
num=int(input('请输入一个十进制数：'))
while num!=0:
    s.inStack(num%2)
    num//=2
s.outStack()