面向对象多继承(C3算法)/网络编程

https://www.cnblogs.com/aylin/p/5572104.html

一、面向对象多继承(c3算法)

a、有多个父类先找左，再找右，如下示例：

class A(object):
        pass

class B(object):
     def f1(self):
        print('B')

class C(A,B):
       pass

obj = C()
obj.f1()
    print(C.__mro__)  # 打印出C类的继承顺序，结果如下一行：
    # (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

先找左，再找右

先找左再找右

b、经典类和新式类

　　python2（其实是python2.2以后）：

　　经典类

　　新式类：如果自己或自己的前辈只要有人继承object，那么此类就是新式类。

　　python3：

　　　　没有经典类

　　新式类 ：如果自己或自己的前辈只要有人继承object，那么此类就是新式类。

　　经典类和新式类的查找成员的顺序不一样：

　　经典类：一条道走到黑（深度优先）；

　　新式类：c3算法实现（python2.3更新时有介绍c3算法）；

　　Foo + (C,D,F,G) + (G,D,G,W) + (I,G,D,G,W)

　　Foo, I,B,……

　　获取第一个表头 和 其他表尾进行比较：

　　不存在则拿走。

　　如果存在，则放弃，然后获取第二个表的表头再次和其他表的表尾进行比较。

# by luffycity.com
class A(object):
    pass
class B(A):
    pass
class C(B):
    pass
class D(object):
    pass
class E(D,C):
    pass
class F(object):
    pass
class G(F):
    pass
class H(C,G):
    pass
class Foo(E,H):
    pass

# print(E.__mro__)
# print(H.__mro__)
"""
L(Foo + L(E)  + L(H) )

L(E) = E,D,C,B,A,object
L(H) = H,C,B,A,G,F,object

Foo = (object) + (G,F,object)
Foo,E,D,H,C,B,A,G,F,object
"""
print(Foo.__mro__)

C3算法

总结：

　　经典类：一条道走到黑（深度优先）；

　　新式类：简单理解就是留个根，（科学原理是c3算法）；

注意事项：super是遵循__mro__的执行顺序的。

python3中如何获取指定类成员的查询顺序 -----__mro__

二、网络基础

a、开发模式：

　　(开发一个软件)需要安装客户端：CS架构，client  -- >  server

　　(开发一个网站)使用浏览器访问：BS架构，browser  -- >  server

b、如何实现相互通信：

　　方式一：编写两个软件，软件之间相互通信；

　　方式二：两个人直接连接（通过网线）；

　　方式三：同一个教室中的多台电脑相互通信（通过交换机）；

使用IP地址：ipconfig/ifconfig查看

　　方式四：和三亚的女友通信（通过交换机 + n*路由器）；

三亚女友需要 租公网IP

总结：

1）相互通信的本质是发送01010101（高低电频）；

2）交换机的作用（组成一个局域网，并在局域网内发广播）；

3）通过ipconfig（windows系统）/ifconfig（苹果系统和linux系统）查看自己的内网IP；

4）花钱 租公网IP；

三、编写网络相关的程序

a、基于socket模块实现网络通信，如下代码示例：

　　服务端简单示例：

import socket

    server = socket.socket()  # 创建服务端socket对象
    server.bind(('192.168.13.130',8000))  # 绑定IP和端口
    server.listen(5)  # 后边可以等5个人
    print('服务端准备开始接收客户端的连接')

    # 等待客户端来连接，如果没人来就傻傻的等待。
    # conn 是客户端和服务端连接的对象(伞)，服务端以后要通过该对象进行收发数据。
    # addr 是客户端的地址信息。
    # #### 阻塞,只有有客户端进行连接，则获取客户端连接然后开始进行通信。
    conn,addr = server.accept()
    print('已经有人连接上了，客户端信息：',conn,addr)

    # 通过对象去获取（客户端通过伞给我发送的消息）
    # 1024表示：服务端通过对象（伞）获取数据时，一次性最多拿1024字节。
    data = conn.recv(1024)
    print('已经有人发来信息了',data)

    # 服务端通过连接对象（伞）给客户端回复了一个消息。
    conn.send(b'stop')  # send不能发空 ''

    conn.close()  # 与客户端断开连接（放开那把伞）
    server.close()  # 关闭服务端的服务

　　客户端简单示例：

import socket

    client = socket.socket()  # 创建客户端socket对象

    # 客户端向服务端发起连接请求（递伞）
    # 阻塞，去连接，直到连接成功后才会继续向下走
    client.connect(('192.168.13.130',8000))

    # 连接上服务端后，向服务端发送消息
    client.send(b'hello')

    # 客户端等待服务端给他发送消息
    data = client.recv(1024)
    print('服务端发来消息了',data)

    # 关闭自己
    client.close()

总结：

　　服务端：

accept，阻塞：等待客户端来连接。

recv，   阻塞：等待客户端发来数据。

　　客户端：

connect，阻塞：一直在连接，直到连接成功才往下运行其他代码。

recv，    阻塞：等待服务端发来数据。

问题一：为什么要网络通信发送的是字节？而不是字符串？

python3，send/recv 都是字节

python2，send/recv 都是字符串

b、上述示例运行一次，服务端和客户端只能连接一次，发送和接收一次消息后服务端关闭，无法再连接其他客户端，现要实现服务端一旦启动，服务端和客户端之间可以持续发送和接收消息，且与某个客户端断开后还可以继续等待其他客户端来连接，如下示例：

服务端程序：

import socket
    server = socket.socket()  # 创建服务端socket对象
    server.bind(('192.168.13.130',8000))  # 绑定IP和端口
    server.listen(5)  # 后边可以等5个人
    print('服务端准备开始接收客户端的连接')

    while True:
        conn,addr = server.accept()
        print('已经有人连接上了，客户端信息：',conn,addr)
        while True:
            data = conn.recv(1024)
            print('已经有人发来信息了',data)
            if data == b'exit':
                break
            conn.send(b'stop')
        print('断开与客户端连接')
        conn.close()  # 与客户端断开连接

 客户端程序：

import socket
    client = socket.socket()  # 创建客户端socket对象
    client.connect(('192.168.13.130', 8000))

    while True:
        name = input('请输入姓名：')
        client.send(name.encode('utf-8'))
        if name == 'exit':
            break
        data = client.recv(1024)
        print('服务端发来消息了',data)
    client.close()