【Python】0基础学Python——进程创建，进程通信，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)