【Python】0基础学Python——进程创建，进程通信，TCP服务器和客户端，服务端与客户端聊天案例，python动态性

0基础学Python——进程创建，进程通信，TCP服务器和客户端，服务端与客户端聊天案例，python动态性

• 进程创建—构造方法
• • 1. 使用os模块中的 fork 函数（只能应用于 Linux 操作系统）
  • 2. 使用 from multiprocessing import Process
  • 3. 继承 Process 类来定义一个进程类,重写run方法
  • 获取进程相关信息
• 进程创建—继承Process类
• 进程—数据独立
• 进程—多进程卖票
• 网络编程概念
• • 网络七层模型
  • TCP和UDP的区别
• TCP—服务器
• • TCP—客户端
  • 聊天—服务端
  • 聊天—客户端
• python动态性

进程创建—构造方法

1. 使用os模块中的 fork 函数（只能应用于 Linux 操作系统）

该函数 会返回 2次结果 第一次结果代表创建的子进程的进程编号 第二次结果永远返回0，代表程序处于子进程中

2. 使用 from multiprocessing import Process

Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None) – target: 是一个函数、是进程执行任务的地方 – name : 设置进程的名字 – args : 给目标函数 target 传递不定项位置参数 – kwargs : 给目标函数 target 传递不定项关键字参数 – daemon ： 设置进程是否为守护进程、默认False

3. 继承 Process 类来定义一个进程类,重写run方法

获取进程相关信息

os.getpid()： 获取进程编号 os.getppid()： 获取父进程编号 p.name()： 获取进程名

import os
from multiprocessing import Process

def test(a, b):
print(os.getpid(), os.getppid(), a + b) # 7568 4168 30 (ID不唯一)

if __name__ == '__main__':
# 创建子进程
p = Process(target=test, args=(10, 20))
p.start()
# os.getpid() -> 获取当前进程ID
# os.getppid() -> 获取当前进程父进程的ID
print(os.getpid(), os.getppid()) # 4168 7188 (ID不唯一)

进程创建—继承Process类

import os
from multiprocessing import Process

class MyProcess(Process):
def __init__(self, a, b):
super().__init__() # 必须调用父类初始化方法
self.a = a
self.b = b

def run(self):
print(os.getpid(), os.getppid(), self.a + self.b)

if __name__ == '__main__':
p = MyProcess(10, 20)
p.start()

print(os.getpid(), os.getppid())

进程—数据独立

# 添加
import os
from multiprocessing import Process, current_process

# 进程之间数据独立
def addNum(ls):
for i in range(5):
ls.append(i)
print(os.getpid(), ls) # 7220 [0, 1, 2, 3, 4]

# 获取
def getNum(ls):
print(os.getpid(), ls) # 4072 []

if __name__ == '__main__':
ls = []
p1 = Process(target=addNum, args=(ls,))
p2 = Process(target=getNum, args=(ls,))
p1.start()
p2.start()

print(p1.name, p2.name) # Process-1 Process-2

进程—多进程卖票

import os
import time
from multiprocessing import RLock, Process, Queue
from typing import List

class Ticket:
def __init__(self, t_no):
self.t_no = t_no

def sell(t_list: Queue, lock):
while not t_list.empty():
time.sleep(0.2)
with lock:
if not t_list.empty():
ticket = t_list.get()
print(f'{os.getpid()}卖了{ticket.t_no}票,剩余{t_list.qsize()}张')

if __name__ == '__main__':
lock = RLock()
queue = Queue(maxsize=100)
for i in range(1, 101):
queue.put(Ticket(i))
pools = []
for i in range(5):
t = Process(target=sell, args=(queue, lock)) # lock必须传参
pools.append(t)
t.start()

for th in pools:
th.join() # 阻塞主进程，子进程执行完毕，主进程继续执行

print('票已售罄')

网络编程概念

网络七层模型

应用层： 为计算机用户提供服务,网站 表示层:数据处理(编解码、加密解密、压缩解压缩) 会话层:管理(建立、维护、重连)应用程序之间的会话 传输层：为两台主机进程之间的通信提供通用的数据传输服务，TCP UDP 网络层：路由和寻址(决定数据在网络的游走路径) 数据链路层：帧编码和误差纠正控制 物理层：透明地传送比特流传输

应用层、常见的协议 http, https , ftp, smtp, pop 等协议 数据传输层: TCP 和 UDP 协议

TCP和UDP的区别

TCP 是一个面向连接的 安全协议、采用三次握手和四次挥手保证数据传输的稳定性 UDP 是一个不可靠的协议、通过数据报文的形式进行数据传输、速度快、不稳定，在数据传输过程中，容易产生 数据丢失 三次握手 客户端第一次请求连接 服务端确认是否连接 客户端确认要连接 四次挥手 客户端请求断开连接 服务端发送未完成的信息 服务端确认是否断开连接 客户端确认要断开连接

TCP—服务器

import pickle
from socket import socket

# 1.创建一个服务端套接字
socket_server = socket()

# 2.绑定ip和端口
# ip:0.0.0.0 本地:127.0.0.1 本机:192.168.17.19
# 端口: 范围0-65535,不能和已知的端口发生冲突
socket_server.bind(('127.0.0.1',8888))

# 3.监听
socket_server.listen(5)

# 4.被动等待客户端连接
while True:
# 5.获取连接通道对象和address
socket_client,address = socket_server.accept()
print(socket_client,address)
# 6.接收信息
msg = socket_client.recv(1024 * 5)
# print(msg.decode())
print(pickle.loads(msg))

# 7. ① 向客户端回复信息
# socket_client.send('服务器发来的消息1'.encode())
# socket_client.send('服务器发来的消息1'.encode())

# 7. ② 向客户端回复信息
ls = ['信息1', '信息2']
socket_client.send(pickle.dumps(ls))

TCP—客户端

import pickle
from socket import socket

# 1.创建客户端套接字
socket_client = socket()

# 2.连接服务器
socket_client.connect(('127.0.0.1', 8888))

# 3.发送信息
# socket_client.send('客户端发送的信息1'.encode())
# socket_client.send('客户端发送的信息1'.encode())
ls = ['客户端发送的信息1', '客户端发送的信息2']
socket_client.send(pickle.dumps(ls))

# 4.接收信息
msg = socket_client.recv(1024 * 5)
while msg:
# ①
# print(msg.decode())
# ②
# print(pickle.loads(msg))
print(' '.join(map(str, pickle.loads(msg))))
msg = socket_client.recv(1024 * 5)
# 5.关闭连接
socket_client.close()

聊天—服务端

1.创建服务端套接字 2.绑定ip地址和端口 3.监听 4.被动等待客户端发送消息 5.获取连接通道对象和地址 6.收发消息

from socket import socket

# 1.创建一个服务端套接字
socket_server = socket()
# 2.绑定ip和端口
socket_server.bind(('127.0.0.1', 8888))
# 3.监听
socket_server.listen(5)
# 4.被动等待客户端连接
while True:
# 5.获取连接通道对象和address
socket_client, address = socket_server.accept()
# 收发信息
while True:
# 接收信息
msg = socket_client.recv(1024 * 5)
s = msg.decode()
if s == 'exit':
break
print(s)
info = input('服务端说:')
socket_client.send(info.encode())

聊天—客户端

1.创建客户端套接字 2.连接服务端 3.发送消息 4.接收信息 5关闭连接

from socket import socket

# 1.创建客户端套接字
socket_client = socket()
# 2.连接服务端
socket_client.connect(('127.0.0.1', 8888))
# 3.发送消息
socket_client.send('这是客户端'.encode())
# 4.接收信息
while msg := socket_client.recv(1024 * 5):
print(msg.decode())
info = input('客户端说:')
socket_client.send(info.encode())

# 5关闭连接
socket_client.close()

python动态性

import os
import types

class Student:
pass

stu = Student()
# 添加实例属性
stu.name = 'zs'
stu.age = 18

def show(self):
print('实例方法')

# 添加实例方法
stu.shows = types.MethodType(show, stu)
stu.shows()

# 添加类方法
@classmethod
def test1(cls):
print('类方法')

Student.test11 = test1
Student.test11()

@staticmethod
def test2():
print('静态方法')

Student.test22 = test2
Student.test22()

# 猴子补丁
def eat(name):
print(f'{name}吃西红柿')

def eat2(name):
print(f'{name}吃番茄')

eat('张三')
eat = eat2
eat('张三')

p = os.walk('./a')
# print(next(p))
# print(next(p))
# print(p)
res = []
for i in p:
# print(i)
res.extend(i[2])
print(res)