【python开发】并发编程和网络编程的结合+并发和并行概念区别+单例模式通过类来实现

一、并发编程&网络编程

网络编程：基于网络基础知识、socket模块实现网络的数据传输；
并发编程：基于多进程、多线程等来提升程序的执行效率。

但在很多框架的内部其实会让两者结合，使用多进程和多线程来提高网络编程的处理效率。

（一）多线程socket服务端

服务端：

# 收发数据
def task(conn):
    while True:
        client_data = conn.recv(1024)
        data = client_data.decode('utf-8')
        print("收到客户端发来的信息", data)
        if data.upper() == 'Q':
            break
        conn.sendall("收到收到".encode('utf-8'))
    conn.close()


# 连接服务器
def run():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind(('127.0.0.1', 8001))
    sock.listen(5)
    while True:
        # 等待客户端连接（主线程）
        conn, addr = sock.accept()

        # 创建子线程
        t = threading.Thread(target=task, args=(conn,))
        t.start()

    socket.close()


if __name__ == '__main__':
    run()

客户端

import socket


#向指定ip发送连接请求
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8001))



while True:
    txt = input(">>>")
    client.sendall(txt.encode('utf-8'))
    if txt.upper() == "Q":
        break

    reply = client.recv(1024)
    print(reply.decode('utf-8'))


#关闭连接，关闭连接时会向服务端发出空数据
client.close()

（二）多进程&socket服务端

服务端：

import socket
import multiprocessing




def task(conn):
    while True:
        client_data = conn.recv(1024)
        data = client_data.decode('utf-8')
        print("收到客户端发来的消息:", data)
        if data.upper == 'Q':
            break
        conn.sendall("收到收到".encode('utf-8'))




def run():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind(('127.0.0.1', 8001))
    sock.listen(5)
    while True:
        #等待客户端来连接
        conn, addr = sock.accept()
        #创建子进程
        t = multiprocessing.Process(target=task, args=(conn, ))
        t.start()
    sock.close()
    
    
if __name__ == '__main__':
    run()

客户端

import socket


#向指定ip发送连接请求
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8001))



while True:
    txt = input(">>>")
    client.sendall(txt.encode('utf-8'))
    if txt.upper() == "Q":
        break

    reply = client.recv(1024)
    print(reply.decode('utf-8'))


#关闭连接，关闭连接时会向服务端发出空数据
client.close()

二、并发和并行

串型：多个任务排队按照先后顺序逐一执行；

并发：假设有多个任务，只有一个CPU，同一时刻只能处理一个任务，为了避免串行，让CPU每个任务都执行一点，然后再切换，达到并发效果（看似都在同时进行）。
python代码有：协程、多线程。

并行：假设有多个任务，有多个CPU，那么同一时刻每个CPU都执行一个任务，任务可以真正的同时运行。并行在python代码中体现为：多进程。

三、单例模式

（一）基于__new__方法来实现

这个单例模式中带了锁

import threading
import time


class Singleton:
    isinstance = None
    lock = threading.RLock()

    def __init__(self):
        self.name = "高宇星"

    def __new__(cls, *args, **kwargs):

        if cls.isinstance:
            return cls.isinstance

        with cls.lock:
            if cls.isinstance:
                return cls.isinstance
            cls.isinstance = object.__new__(cls)
        return cls.isinstance


obj1 = Singleton()
obj2 = Singleton()

print(obj1, obj2)
#<__main__.Singleton object at 0x7ff73aa417f0> <__main__.Singleton object at 0x7ff73aa417f0>

（二）基于模块导入方法

用类方法定义单例，然后通过导入模块来实现，首先在uilts.py中实现了单例类，并示例化了一个single

class Singleton:

    def __init__(self):
        self.name = "高宇星"


single = Singleton()

然后在app.py文件中通过引入模块中的方法来实现单例模式：

from utils import single

print(single)

四、补充题目

（一）比较以下两段代码的区别

class F1(object):
    def func(self, num):
        print("F1.func", num)

class F2(object):
    def func(self, num):
        print("F2.func", num)

class F3(object):
    def run(self):
        F1.func(self, 1)


obj = F3()
obj.run()
#F1.func 1

上述代码在F3中直接定义了执行F1的func还是

class F1(object):
    def func(self, num):
        print("F1.func", num)

class F2(object):
    def func(self, num):
        print("F2.func", num)

class F3(F2):
    def run(self):
        super().func(2)  #根据mro的顺序，执行F2中 的func方法

obj = F3()
obj.run()
#F2.func 2

上述代码中，F3继承了F2类，并要求根据mro顺序调用父类的func方法。

（二）根据如下要求编写代码

已知一个订单对象（tradeOrder）有如下字段

字段英文名	中文名	字段类型	取值举例
nid	ID	int	123456
name	姓名	str	张三
item	商品列表	list	可以存放多个订单对象
is_number	是否是会员	bool	True

商品对象有如下字段：

字段英文名	中文名	字段类型	取值举例
id	主键	int	987654321
name	商品名称	str	手机

请根据要求实现如下功能：

1. 编写订单和商品类；
2. 创建订单对象并根据关系关联多个商品对象；
3. 用json模块对象进行序列化为JSON格式（提示：需要自定义JSONEncoder）。

import json


#定义好订单和商品类之后，还需要序列化程Json格式
class ObjectJsonEncoder(json.JSONEncoder):
    def default(self, o):
        if type(o) in {Order, Goods}:
            return o.__dict__
        else:
            return o


class Order(object):
    def __init__(self, nid, name, is_member):
        self.nid = nid
        self.name = name
        self.is_member = is_member
        self.items = []


class Goods(object):
    def __init__(self, id, name):
        self.id = id
        self.name = name



od = Order(666, "高宇星", True)
od.items.append(Goods(1, '汽车'))
od.items.append(Goods(2, '帅哥'))
od.items.append(Goods(3, '别墅'))

data = json.dumps(od, cls=ObjectJsonEncoder)
print(data)
#"nid": 666, "name": "\u9ad8\u5b87\u661f", "is_member": true, "items": [{"id": 1, "name": "\u6c7d\u8f66"}, {"id": 2, "name": "\u5e05\u54e5"}, {"id": 3, "name": "\u522b\u5885"}]}