python高级技术（网络编程二）

Posted 2023-05-07 coderxueshan

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python高级技术（网络编程二）相关的知识，希望对你有一定的参考价值。

一粘包现象（基于TCP协议实现远程执行命令）

1、TCP协议，会出现粘包现象

例：ipconfig命令，客户端收到的字符串比较短，客户端能够收完整，

　　tasklist命令，客户端收到的字符串超过1024，客户端收到信息不完整，就是粘包问题

服务端：

# 服务端应该满足两个特点
# 1、一直对外提供服务
# 2、并发的服务多个客户端
import subprocess
from socket import *

server = socket(AF_INET, SOCK_STREAM)
server.bind((\'127.0.0.1\', 8081))
server.listen(5)

# 服务端应该做两件事
# 第一件事：循环地从半链接池中取出链接请求与其建立双向链接，拿到链接对象
while True:
    conn, client_addr = server.accept()

    # 第二件事：拿到链接对象，与其进行通信循环
    while True:
        try:
            cmd = conn.recv(1024)
            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(stdout_res)+len(stderr_res))
            print(stderr_res.decode(\'gbk\'))
            print(stdout_res.decode(\'gbk\'))
            conn.send(stdout_res+stderr_res)
            # with open(\'1.mp4\',model=\'rb\') as f:
            #   for line in f:
            #       conn.send(line)
        except Exception:
            break
    conn.close()

客户端：

from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect((\'127.0.0.1\', 8081))

while True:
    msg = input(\'请输入命令>>>:\').strip()
    if len(msg) == 0:
        continue
    client.send(msg.encode(\'utf-8\'))

    # 解决粘包问题思路：
    # 1、拿到数据的总大小total_size
    # 2、recv_size=0,循环接受，每接受一次，recv_size+=接受的长度
    # 3、直到recv_size=total_size,结束循环

    cmd_res = client.recv(1024)  # 本次接受，最大接受1024Bytes
    print(cmd_res.decode(\'gbk\'))  # windows系统用gbk

# 粘包问题出现的原因
# 1、tcp是流式协议，数据像水流一样粘在一起，没有任何边界区分
# 2、收数据没收干净，有残余，就会下一次结果混淆在一起。

# 解决的核心方法就是：每次都收干净，不要任何残留

2、UDP协议，不会出现粘包现象

一个sendto对应一个recvfrom，不会出现粘包的底层原理是，不需要建立三次握手，发信息类似于集装箱

超出的集装箱部分的信息，就扔掉，所以不会出现粘包现象，是不可靠传输。

服务端：

import socket

server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server.bind((\'127.0.0.1\', 8080))
res1 = server.recvfrom(1024)

print(res1)

res2 = server.recvfrom(1024)
print(res2)

server.close()

客户端：

import socket

client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
client.sendto(b\'hello\', (\'127.0.0.1\', 8080))
client.sendto(b\'world\', (\'127.0.0.1\', 8080))

client.close()

# UDP协议一个sendto 对应 一个服务端的recvfrom

二什么是粘包

发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束

所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。

此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。即面向流的通信是无消息保护边界的。
UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头，实验略

udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠

tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。

两种情况下会发生粘包。

发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）

服务端：

from socket import *
ip_port=(\'127.0.0.1\',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)


conn,addr=tcp_socket_server.accept()


data1=conn.recv(10)
data2=conn.recv(10)

print(\'----->\',data1.decode(\'utf-8\'))
print(\'----->\',data2.decode(\'utf-8\'))

conn.close()

客户端：

import socket
BUFSIZE=1024
ip_port=(\'127.0.0.1\',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)


s.send(\'hello\'.encode(\'utf-8\'))
s.send(\'feng\'.encode(\'utf-8\'))

接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

服务端：

from socket import *
ip_port=(\'127.0.0.1\',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)


conn,addr=tcp_socket_server.accept()


data1=conn.recv(2) #一次没有收完整
data2=conn.recv(10)#下次收的时候,会先取旧的数据,然后取新的

print(\'----->\',data1.decode(\'utf-8\'))
print(\'----->\',data2.decode(\'utf-8\'))

conn.close()

客户端：

import socket
BUFSIZE=1024
ip_port=(\'127.0.0.1\',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)


s.send(\'hello feng\'.encode(\'utf-8\'))

三、解决粘包的方法

1、struct模块

该模块可以把一个类型，如数字，转成固定长度的bytes

struct.pack(\'i\',1111111111111)

2、解决办法

为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据

服务端：

import subprocess
import struct
from socket import *

server = socket(AF_INET, SOCK_STREAM)
server.bind((\'127.0.0.1\', 8081))
server.listen(5)

# 服务端应该做两件事
# 第一件事：循环地从半链接池中取出链接请求与其建立双向链接，拿到链接对象
while True:
    conn, client_addr = server.accept()

    # 第二件事：拿到链接对象，与其进行通信循环
    while True:
        try:
            cmd = conn.recv(1024)
            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(stdout_res) + len(stderr_res)

            # 1、先发头信息（固定长度的bytes):对数据描述信息
            # int--->固定长度的bytes
            header = struct.pack(\'i\', total_size)
            conn.send(header)
            # 2、再发真实的数据
            conn.send(stdout_res)
            conn.send(stderr_res)
        except Exception:
            break
    conn.close()

客户端：

import struct
from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect((\'127.0.0.1\', 8081))

while True:
    msg = input(\'请输入命令>>>:\').strip()
    if len(msg) == 0:
        continue
    client.send(msg.encode(\'utf-8\'))

    # 解决粘包问题思路：
    # 一、先收固定长度的头：解析出数据的描述信息，包括数据的总大小total_size
    header = client.recv(4)
    total_size = struct.unpack(\'i\', header)[0]  # 解析出来，是个小元组
    # 二、根据解析出的描述信息，接受真实的数据
    # 2、recv_size=0,循环接受，每接受一次，recv_size+=接受的长度
    # 3、直到recv_size=total_size,结束循环
    recv_size = 0
    while recv_size < total_size:
        recv_data = client.recv(1024)  # 本次接受，最大接受1024Bytes
        recv_size += len(recv_data)
        print(recv_data.decode(\'gbk\'), end=\'\')  # windows系统用gbk
    else:
        print()

# 粘包问题出现的原因
# 1、tcp是流式协议，数据像水流一样粘在一起，没有任何边界区分
# 2、收数据没收干净，有残余，就会下一次结果混淆在一起。

# 解决的核心方法就是：每次都收干净，不要任何残留

3、自制报头，报头是字典情况

我们可以把报头做成字典，字典里包含将要发送的真实数据的详细信息，然后json序列化，然后用struck将序列化后的数据长度打包成4个字节（4个自己足够用了）

发送时：

先发报头长度

再编码报头内容然后发送

最后发真实内容

接收时：

先手报头长度，用struct取出来

根据取出的长度收取报头内容，然后解码，反序列化

从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容

服务端：

import subprocess
import struct
import json
from socket import *

server = socket(AF_INET, SOCK_STREAM)
server.bind((\'127.0.0.1\', 8081))
server.listen(5)

# 服务端应该做两件事
# 第一件事：循环地从半链接池中取出链接请求与其建立双向链接，拿到链接对象
while True:
    conn, client_addr = server.accept()

    # 第二件事：拿到链接对象，与其进行通信循环
    while True:
        try:
            cmd = conn.recv(1024)
            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(stdout_res) + len(stderr_res)

            # 1、制作头
            header_dic = 
                \'filename\': \'a.txt\',
                \'total_size\': total_size,
                \'md5\': \'12sddeio\'
            
            json_str = json.dumps(header_dic)
            json_str_bytes = json_str.encode(\'utf-8\')
            # 2、先发头信息（固定长度的bytes):对数据描述信息
            # int--->固定长度的bytes
            header_size = struct.pack(\'i\', len(json_str_bytes))
            # 发头的长度信息
            conn.send(header_size)

            # 3、发头信息
            conn.send(json_str_bytes)
            # 4、再发真实的数据
            conn.send(stdout_res)
            conn.send(stderr_res)
        except Exception:
            break
    conn.close()

客户端：

import struct
import json
from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect((\'127.0.0.1\', 8081))

while True:
    msg = input(\'请输入命令>>>:\').strip()
    if len(msg) == 0:
        continue
    client.send(msg.encode(\'utf-8\'))

    # 解决粘包问题思路：
    # 一、先收固定长度的头：解析出数据的描述信息，包括数据的总大小total_size
    header_size = client.recv(4)
    header_len = struct.unpack(\'i\', header_size)[0]

    json_str_bytes = client.recv(header_len)
    json_str = json_str_bytes.decode(\'utf-8\')
    header_dic = json.loads(json_str)
    print(header_dic)
    total_size = header_dic[\'total_size\']
    # 二、根据解析出的描述信息，接受真实的数据
    # 2、recv_size=0,循环接受，每接受一次，recv_size+=接受的长度
    # 3、直到recv_size=total_size,结束循环
    recv_size = 0
    while recv_size < total_size:
        recv_data = client.recv(1024)  # 每次接受，最大接受1024Bytes
        recv_size += len(recv_data)
        print(recv_data.decode(\'gbk\'), end=\'\')  # windows系统用gbk
    else:
        print()

# 粘包问题出现的原因
# 1、tcp是流式协议，数据像水流一样粘在一起，没有任何边界区分
# 2、收数据没收干净，有残余，就会下一次结果混淆在一起。

# 解决的核心方法就是：每次都收干净，不要任何残留

四、socketserver实现并发

1、TCP协议的并发

服务端：

import socketserver


class MyRequestHandle(socketserver.BaseRequestHandler):
    def handle(self):
        print(self.request)  # 如果TCP协议，self.request--->conn
        print(self.client_address)
        while True:
            try:
                msg = self.request.recv(1024)
                if len(msg) == 0:
                    break
                self.request.send(msg.upper())
            except Exception:
                break
        self.request.close()


# 服务端应该做两件事
# 第一件事：循环地从半链接池中取出链接请求与其建立双向链接，拿到链接对象
s = socketserver.ThreadingTCPServer((\'127.0.0.1\', 8080), MyRequestHandle)
s.serve_forever()
# 等同于
# while True:
#     conn, client_addr = server.accept()

# 第二件事：拿到链接对象，与其进行通信循环----》handle方法

客户端：

from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect((\'127.0.0.1\', 8080))

while True:
    msg = input(\'请输入命令>>>:\').strip()
    if len(msg) == 0:
        continue
    client.send(msg.encode(\'utf-8\'))

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

2、UDP协议

服务端：

import socketserver


class MyRequesthandle(socketserver.BaseRequestHandler):
    def handle(self):
        client_data = self.request[0]
        server = self.request[1]
        client_address = self.client_address
        print(\'客户端发来的数据\'.format(client_data))
        server.sendto(client_data.upper(), client_address)


s = socketserver.ThreadingUDPServer((\'127.0.0.1\', 8080), MyRequesthandle)
s.serve_forever()

# 相当于：只负责循环的收
# while True:
#     data, server_addr = client.recvfrom(1024)
#     启动一个线程处理后续的事情（data,client_addr)

客户端：

import socket

client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # 数据报协议---》UDP协议

while True:
    msg = input(\'>>>:\').strip()
    client.sendto(msg.encode(\'utf-8\'), (\'127.0.0.1\', 8080))
    data, server_addr = client.recvfrom(1024)
    print(data.decode(\'utf-8\'))
client.close()

Python面对对象高级编程

文章目录

此文章参考廖雪峰官网：面向对象高级编程 - 廖雪峰的官方网站 (liaoxuefeng.com)

一、使用`slots`

正常情况下，当我们定义了一个类，并且根据类创建了实例后，我们可以给这些实例绑定任何属性和方法，就这是动态语言的灵活性，下面来看案例：

- 创建一个类
>>> class Student(object):
...     pass
... 

- 创建一个实例，并且绑定属性'name'
>>> zhangsan = Student()
>>> zhangsan.name = 'zhangsan' 
>>> zhangsan.name
'zhangsan'

- 还可以绑定方法
>>> def set_age(self,age):
...     self.age = age
... 
>>> from types import MethodType  #导入模块
>>> zhangsan.set_age = MethodType(set_age,zhangsan)  #给zhangsan实例绑定方法 
>>> zhangsan.set_age(22) 
>>> zhangsan.age
22

- 上面的'zhangsan'实例绑定的方法，只对'zhangsan'本身生效，如果根据'Student'类再次创建实例，'新创建的实例是没有这些方法的'
>>> lisi = Student() 
>>> lisi.set_age
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'set_age'
>>> lisi.set_age(33)    #无法调用
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'set_age'
    
- 如果想让上面的方法绑定到所有根据'Student'类创建的实例，我们可以直接给'Student类'绑定方法
>>> def set_score(self,score):
...     self.score = score
... 
>>> Student.set_score = set_score
>>> lisi.set_score(99) 
>>> lisi.score      
99
>>> zhangsan.set_score(98) 
>>> zhangsan.score
98

通常情况下，上面的set_score方法是可以直接定义到类中的，但是动态绑定允许我们在程序运行的过程中动态的为类添加功能，这在静态语言中很难实现

当我们需要限制实例的属性，例如，只允许对Student类创建的实例添加name和age属性，想要达到这种效果，我们可以在定义类的时候，定义一个特殊的__slots__变量，来限制实例可添加的属性：

- 可以看到在使用'__slots__'变量后，创建的实例'zhangsan'只可以绑定特点的属性
>>> class Student(object):
...     __slots__ = ('name','age')
... 
>>> zhangsan = Student()
>>> zhangsan.name = 'zhangsan' 
>>> zhangsan.age = 22
>>> zhangsan.score = 98  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'score'
    
- 要注意的是，类中的'__slots__'变量'只对当前类的实例有效，对继承的子类是无效的'
>>> class Test_Student(Student):
...     pass
... 
>>> lisi = Test_Student()
>>> lisi.score = 98
>>> lisi.score
98

注意：在类中的__slots__变量只对当前类创建的实例有效，对继承的子类是无效的

二、使用装饰器——@property

在绑定属性时，如果直接把属性暴露出去，这样虽然写起来简单，但是无法检查参数，导致可以随意修改属性，例如：
```
>>> class Student(object):
...     pass
... 
>>> zhangsan = Student()
>>> zhangsan.score = 98 
>>> zhangsan.score
98
```

可以看到，上面的zhangsan实例的score属性是可以随意定义、修改的，在实际环境中，肯定不允许这样随意进行定义、修改，为了限制score属性的范围，我们可以在类中通过添加set_score()方法来限制score属性，然后再添加一个get_score()方法来获取score，这种方式在之前的私有变量中提到过，下面来看案例：

- 在类中使用if语句进行判断，限制score属性，可以看到在根据类创建实例后，实例的'score'属性无法随意定义、修改了
>>> class Student(object):         
...     def get_score(self):
...             return self.score
...     def set_score(self,value):
...             if not isinstance(value,int):  #使用isinstance判断传入参数value的类型是否为int类型
...                     raise ValueError('score not is int')  #使用raise抛出异常
...             if value < 0 or value > 100:
...                     raise ValueError('score must between 0 — 100!!')  
...             self.score = value
... 
>>> zhangsan = Student()
>>> zhangsan.set_score('98') 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 6, in set_score
ValueError: score not is int
>>> zhangsan.set_score(120)  
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 8, in set_score
ValueError: score must between 0 — 100!!
>>> zhangsan.set_score(98)  
>>> zhangsan.score
98

虽然上面创建类的方式可以实现效果，但是调用方法略显复杂，没有直接使用属性那么简单

之前有说过装饰器这个概念，装饰器可以动态的给函数添加功能，而在Python中，对于类的方法，装饰器一样有效，Python内置的@property装饰器就是负责把一个方法变成属性进行调用

- '@property'的实现比较复杂，来看下面的'Student'类，想要把一个'获取属性的方法'变成属性，只需要加上'@property'即可，而在下面，还可以看到'@property.setter'，这是创建的另一个装饰器，负责把一个'赋值属性的方法'变成属性，于是，我们就有拥有了一个可控的属性操作
>>> class Student(object):
...     @property
...     def score(self):
...             return self._score
...     @score.setter
...     def score(self,value):
...             if not isinstance(value,int):
...                     raise ValueError('score not is int!')
...             if value < 0 or value > 100:
...                     raise ValueError('score must between 0 - 100!!') 
...             self._score = value
... 
>>> zhangsan = Student()
>>> zhangsan.score = 98  #进行赋值操作，实际调用的是第二个score方法，也就是zhangsan.set_score(98)这样的
>>> zhangsan.score      #同样的，进行获取操作，实际调用的是第一个score方法，也就是zhangsan.get_score()这样的
98
>>> zhangsan.score = '98'   #可以看到在赋值时不符合属性要求会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 8, in score
ValueError: score not is int!
>>> zhangsan.score = 120 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 10, in score
ValueError: score must between 0 - 100!!

上面的代码中，单独的@property其实就是getter方法，并且是只读属性的，例如：

- 下面只使用了'getter'的装饰器，可以看到，除了在创建实例的时候可以传入'self._age'的值，创建后直接修改'zhangsan'的'age'属性值会报错，这就是'只读属性'
>>> class Student(object):
...     def __init__(self,age):
...             self._age = age
...     @property
...     def age(self):
...             return print(self._age) 
... 
>>> zhangsan = Student(22) 
>>> zhangsan.age
22
>>> zhangsan.age = 25
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: can't set attribute 'age'

而上面代码中的@score.setter其实就是setter方法，也就是用来修改属性的值的，例如：

- 可以看到在使用'@age.setter'后，可以随意的去修改'self._age'的值
>>> class Student(object):
...     @property
...     def age(self):
...             return print(self._age)
...     @age.setter
...     def age(self,value):
...             self._age = value
... 
>>> zhangsan = Student()
>>> zhangsan.age = 22
>>> zhangsan.age
22
>>> zhangsan.age = 25
>>> zhangsan.age      
25

注意:

要特别注意的是，属性的方法名千万不要和实例变量重名，否则会造成无限递归，导致栈溢出报错，例如：

>>> class Student(object):
...     @property
...     def age(self):
...             return print(self._age)  #这里设置为self._age，就是因为如果不加下划线，那么变量就跟方法名冲突了
...     @age.setter
...     def age(self,value):
...             self._age = value

其实这个上面装饰器达到的效果可以添加多个方法来实现，例如添加get_age和set_age等，但是最终调用的是方法，如zhangsan.get_age()，而使用装饰器后，可以看到调用的是属性zhangsan.age

三、多重继承（多继承）

在之前说面向对象编程时，说到过三大基本特性之一的继承特性，继承是面向对象编程的一个重要方式，因为通过继承，子类就可以继承并扩展父类的功能，而一个类是可以继承多个父类的，这种继承就叫做多重继承，也就是多继承，下面来看一个案例，理解多继承的作用：
假如我们要实现以下四种动物：
1. Dog——狗
2. Bat——蝙蝠
3. Parrot——鹦鹉
4. Ostrich——鸵鸟
首先可以根据特性进行分类，例如通过哺乳动物和鸟类动物，可以这样分：
而如果通过“能跑”和“能飞”来说，可以这样分：
如果在分的细点，就需要设置更多的层次，例如，哺乳动物中能飞能跑的，鸟类中能飞能跑的

如果还要增加“宠物类”和“非宠物类”的话，类的数量会呈指数增长，这样明显是不行的，正确的做法就是使用多重继承，通过多重继承，一个子类就可以同时获得多个父类的所有功能，例如：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#最上层的Animal类
class Animal(object):
    pass

#第二层的哺乳动物和鸟类
class Mammal(Animal):
    pass

class Bird(Animal):
    pass

#第三层的各种动物
class Dog(Mammal):
    pass

class Bat(Mammal):
    pass

class Parrot(Bird):
    pass

class Ostrich(Bird):
    pass

下面，我们要给动物加上各种功能，例如：

- 添加跑和飞的类
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#添加跑和飞的类
class Runnable(object):
    def run(self):
        return print('Running...')

class Flyable(object):
    def fly(self):
        return print('Flying...')
    
#最上层的Animal类
class Animal(object):
    pass

#第二层的哺乳动物和鸟类
class Mammal(Animal):
    pass

class Bird(Animal):
    pass

#第三层的各种动物
class Dog(Mammal):
    pass

class Bat(Mammal):
    pass

class Parrot(Bird):
    pass

class Ostrich(Bird):
    pass

可以利用多重继承的特性让动物继承多个类，例如：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#添加跑和飞的类
class Runnable(object):
    def run(self):
        return print('Running...')

class Flyable(object):
    def fly(self):
        return print('Flying...')
    
#最上层的Animal类
class Animal(object):
    pass

#第二层的哺乳动物和鸟类
class Mammal(Animal):
    pass

class Bird(Animal):
    pass

#第三层的各种动物
class Dog(Mammal,Runnable):
    pass

class Bat(Mammal,Flyable):
    pass

class Parrot(Bird,Flyable):
    pass

class Ostrich(Bird,Runnable):
    pass

多重继承这种让类继承多个类的设计，也叫做Mixln，是一种常见设置，只允许单一继承的语言，例如java是不能使用Mixln设计的

四、定制类

在看到类似于__xx__这样的变量或者函数时要知道，这种函数是有特殊用途的，例如可以限制实例添加属性的__slots__变量，以及判断字符长度的__len__()函数，除了这些，Python的类还有许多这样有特殊用途的函数，可以帮助我们定义类
下面来看几个常用的定义方法：

`str`

我们先来定义一个Student类，并且打印一个实例：

>>> class Student(object):
...     def __init__(self,name):
...             self.name = name
... 
>>> print(Student('lisi'))   #打印lisi实例
<__main__.Student object at 0x0000028800FF61D0>

可以看到在打印实例时，输出了一堆<__main__.Student object at 0x0000028800FF61D0>，这样不易阅读，我们可以在类中添加一个__str__()方法，从而使输出更容易阅读，例如：

>>> class Student(object):       
...     def __init__(self,name):
...             self.name = name 
...     def __str__(self):
...             return 'Student object (name is : %s)' % self.name 
... 
>>> print(Student('lisi')) 
Student object (name is : lisi)

- 通过'__str__()'方法，我们可以自定义想要输出的内容，在打印实例的时候会输出，但是只有直接使用'print'时才会输出，赋值给变量的话，则还是原来的
>>> lisi = Student('lisi') 
>>> lisi
<__main__.Student object at 0x00000208C62F64A0>

在赋值变量后，输出的还是原来的不易阅读的输出，这是因为直接显示变量调用的不是__str__()，而是__repr__()，这两个方法的区别是==__str__()返回用户看到的字符串==，而==__repr__()返回程序开发者看到的字符串，即__repr__()是为了调试服务的==

解决上面的方法就是再定义一个__repr__()方法，但是通常可以写成__repr__ = __str__

>>> class Student(object):
...     def __init__(self,name):
...             self.name = name
...     def __str__(self):
...             return 'Student object (name is : %s)' % self.name
...     __repr__ = __str__
... 
>>> print(Student('lisi')) 
Student object (name is : lisi)
>>> lisi = Student('lisi') 
>>> print(lisi) 
Student object (name is : lisi)

`iter`

如果一个类想像字典或者元组那样被用于for循环，那么就必须要添加一个__iter__()方法，该方法会返回一个迭代对象，Python的for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值，直到遇到StopIteration错误时退出，下面来看一个案例：

- 斐波那契数列：
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
class Fib(object):
    def __init__(self):
        self.a,self.b = 0,1  #初始化定义两属性的值
    def __iter__(self):  #__iter__返回实例本身
        return self
    def __next__(self):  
        self.a,self.b = self.b,self.a + self.b  
        if self.a > 100:以上是关于python高级技术（网络编程二）的主要内容，如果未能解决你的问题，请参考以下文章 
 如何快速掌握Python数据采集与网络爬虫技术
 Python面对对象高级编程
 Python面对对象高级编程
 高校Python数据挖掘与网络爬虫技术研修
 010 深入理解Python语言
 阿里内部竞品分析工具：如何快速掌握 Python 数据采集与网络爬虫技术

python高级技术（网络编程二）

一 粘包现象（基于TCP协议实现远程执行命令）

二 什么是粘包

三、解决粘包的方法

四、socketserver实现并发

Python面对对象高级编程

文章目录

一、使用__slots__

二、使用装饰器——@property

三、多重继承（多继承）

四、定制类

__str__

__iter__

一粘包现象（基于TCP协议实现远程执行命令）

二什么是粘包

一、使用`slots`

`str`

`iter`