首页 > 代码库 > Python自动化开发课堂笔记【Day08】 - Python进阶(面向对象的高级用法,网络编程)

Python自动化开发课堂笔记【Day08】 - Python进阶(面向对象的高级用法,网络编程)

面向对象的高级用法

1. __str__

只要执行打印对象的操作,就会触发该对象类中的__str__方法(也就是对象的绑定方法)
它是一种默认的方法,默认的打印输出为<__main__.Foo object at 0x003EE350>,但是如果将该绑定方法
在类中重写的话,要求必须有以字符串类型的返回值,返回形式可以自己设定。

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __str__(self):
        return name:%s age:%d % (self.name,self.age)#返回值必须有

obj=Foo(Albert,18)
print(obj)

2. __del__(析构函数)

由类产生的对象是存放在内存中的,程序结束后要释放掉对象,则会触发__del__方法执行

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __del__(self): #注意:必须是程序执行结束后才会执行该方法
        print(__del__)

obj=Foo(Albert,18)
del obj #此时是主动触发执行__del__方法
print(after __del__)

3. __setitem__, __getitem__, __delitem__

利用字典的方式来操作对象的属性

#方法修改之前:
class Foo:

    def __init__(self,name):
        self.name = name

    def __getitem__(self, item):
        print(getitem)

    def __setitem__(self, key, value):
        print(setitem)

    def __delitem__(self, key):
        print(delitem)

obj = Foo(egon)
print(obj.__dict__) #{‘name‘: ‘egon‘}
obj[name] = Albert #虽然可以调用__setitem__方法,但是无法完成真正的修改操作
print(obj.__dict__) #{‘name‘: ‘egon‘}
obj.__dict__[name] = Albert #正确的修改方式
print(obj.__dict__) #{‘name‘: ‘Albert‘}


#方法修改之后:
class Foo:

    def __init__(self,name):
        self.name = name

    def __getitem__(self, item):
        print(getitem)
        return self.__dict__[item]

    def __setitem__(self, key, value):
        print(setitem)
        self.__dict__[key] = value

    def __delitem__(self, key):
        print(delitem)
        self.__dict__.pop(key)

obj = Foo(egon)
obj[name] = Albert #调用__setitem__
print(obj[name]) #调用__getitem__
del obj[name] #调用__delitem__
print(obj.__dict__) #结果:{},空字典,属性被删除

4. __getattr__,__setattr__,__delattr__

class Foo:

    def __init__(self,x):
        self.x = x

    def __getattr__(self, item):
        print(getattr)

    def __setattr__(self, key, value):
        print(setattr)
        self.__dict__[key] = value

    def __delattr__(self, item):
        print(delattr)
        self.__dict__.pop(item)

# obj=Foo()
# obj.x = 1 #触发__setattr__,但未执行成功
# print(obj.__dict__)
# del obj.x #触发__delattr__,但未执行成功
# print(obj.__dict__)
# print(obj.x) #触发__getattr__

obj = Foo(10) #触发__setattr__
print(obj.x) #没有触发__getattr__
print(obj.__dict__)
print(obj.y) #当属性不存在的时候才会触发__getattr__
del obj.x #触发__delattr__
print(obj.x) #触发__getattr__,说明x已经被删除

二次加工标准类型

1. 继承

需要改写的类型是一个类,可以通过继承的方式实现

需求:改写list规定只能加入字符串类型数据

class List(list):
class List(list):

    def __init__(self,item_list,tag=False):
        super().__init__(item_list)
        self.tag = tag

    def append(self, p_object):
        if not isinstance(p_object,str): #判断要加入的元素是否是字符串,非字符串元素会报错
            raise TypeError(must be str)
        else:
            super().append(p_object) #继承父类的方法
    @property
    def mid_num(self):
        mid_index = len(self) // 2
        return self[mid_index]

    def clear(self):
        if not self.tag:
            raise PermissionError(not allowed)#查看是否有清除列表权限
        super().clear() #继承父类的方法
        self.tag = False

l = List([1,2,3])
l.append(a)
print(l)
print(l.mid_num)
l.tag = True
l.clear()
print(l)

2. 授权

针对你需要改写的类型它不是一个类,无法用继承的方式实现,只能用授权的方式实现

import time

class Open:

    def __init__(self,filepath,mode=r,encoding=utf-8):
        self.filepath = filepath
        self.mode = mode
        self.encoding = encoding
        self.ff = open(self.filepath,mode=self.mode,encoding=self.encoding)

    def write(self,msg):
        t = time.strftime(%Y-%m-%d %X)
        self.ff.write(%s %s % (t,msg))

    def __getattr__(self, item):
        return getattr(self.ff, item)

obj = Open(a.txt,w,encoding=utf-8)

#未重写write方法时调用方式
# obj.ff.write(‘111\n‘)
# obj.ff.write(‘222\n‘)
# obj.ff.write(‘333\n‘)
# obj.ff.close()

#重写write方法后的调用方式
obj.write(aaa\n)
obj.write(bbb\n)
obj.write(ccc\n)

print(obj.seek) #<built-in method seek of _io.TextIOWrapper object at 0x0056A530>
obj.close()

3. __next__和__iter__实现迭代器协议

class Foo:

    def __init__(self,n_start,n_stop):
        self.n_start = n_start
        self.n_stop = n_stop

    def __next__(self):
        if self.n_start >= self.n_stop:
            raise StopIteration #遍历到最后报出异常
        x = self.n_start
        self.n_start += 1
        return x


    def __iter__(self):
        return self

obj = Foo(0,10)
# print(next(obj))
# print(next(obj))
# print(next(obj))
for i in obj:
    print(i)
#相当于
for i in range(10):
    print(i)

4. __enter__和__exit__实现上下文管理协议

class Open:

    def __init__(self,name,mode=w,encoding=utf-8):
        self.name = name
        self.mode = mode
        self.encoding = encoding
        self.f = open(self.name,mode=self.mode,encoding=self.encoding)

    def __enter__(self):
        print(__enter__)
        return self.f

    def __exit__(self, exc_type, exc_val, exc_tb): #整个代码块结束触发
        print(__exit__)
        # print(‘exc_type‘,exc_type) #异常类型
        # print(‘exc_val‘,exc_val) #异常的值
        # print(‘exc_tb‘,exc_tb) #异常的追踪信息
        self.f.close()
        # return True #处理异常,保证异常所处子代码块以外的代码正常进行

obj = Open(b.txt,w)#没有文件的话会自动创建
print(obj) #<__main__.Open object at 0x002559F0>

with Open(a.txt) as f: #with Open(‘a.txt‘)操作的结果就是触发__enter__返回self.f, 之后as f相当于f=self.f
    print(f) #<_io.TextIOWrapper name=‘a.txt‘ mode=‘w‘ encoding=‘utf-8‘>
    # 1/0
    f.write(333\n)

5. __call__方法

class Foo:

    def __call__(self, *args, **kwargs):
        print(===>)

obj=Foo()
obj() #如果类内部没有定义__call__方法,对象是不能以加括号的方式调用的。

网络编程

1. socket是什么?
  socket是应用层与TCP/IP协议族通信的中间软件抽象层,它是一组接口。在设计模式中,socket其实就是一个门面模式,
  它把复杂的TCP/IP协议族隐藏在socket接口后面,对用户来说,一组简单的接口就是全部,让socket去组织数据,以符合
  指定的协议。我们无需深入理解TCP/UDP协议,socket已经为我们封装好了,我们只需要遵循socket的规定去编程,写出
  的程序自然就是遵循TCP/UDP标准的。

2. 基于TCP协议的socket的简单实现

Server端实现

import socket

#socket.AF_INET 指定套接字地址家族
#socket.SOCK_STREAM 指TCP流式协议
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.bind((127.0.0.1,8080)) #绑定IP地址端口号

phone.listen(5) #bind连接池

#conn为三次握手成功后建立的连接
#addr为客户端的地址
conn,addr = phone.accept() #等待连接
print(conn,conn)
print(client addr,addr)

client_msg = conn.recv(1024) #收消息
print(clent msg: %s % client_msg)

conn.send(client_msg.upper()) #发送消息

conn.close() #关闭连接
phone.close() #关闭通信


Client端实现

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect((127.0.0.1, 8080)) #客户端发起连接

phone.send(Hello.encode(utf-8)) #发消息

back_msg = phone.recv(1024)

print(back_msg)

phone.close()

3. 通信循环和连接循环

Server端实现

import socket

#socket.AF_INET 指定套接字地址家族
#socket.SOCK_STREAM 指TCP流式协议
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
phone.bind((127.0.0.1,8080)) #绑定IP地址端口号

phone.listen(5) #bind连接池

while True:#连接循环
    # conn为三次握手成功后建立的连接
    # addr为客户端的地址
    conn, addr = phone.accept()  # 等待连接
    print(conn, conn)
    print(client addr, addr)

    while True:  # 与conn的通信循环
        try:
            client_msg = conn.recv(1024)  # 收消息
            if not client_msg: break #针对Linux平台,收空内容后断开客户端连接,windows平台下可不写
            print(clent msg: %s % client_msg)
            conn.send(client_msg.upper())  # 发送消息
        except Exception:  # 解决服务端的异常终止
            break

    conn.close()  # 关闭连接
phone.close() #关闭通信


Client端实现

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect((127.0.0.1, 8080)) #客户端发起连接

while True:#通信循环
    msg = input(>>>:).strip()
    if not msg: continue #解决客服端发送空内容的问题
    phone.send(msg.encode(utf-8)) #发消息
    back_msg = phone.recv(1024)
    print(back_msg)

phone.close()

4. 基于socket实现远程执行shell命令

Server端实现

import socket
import subprocess

#socket.AF_INET 指定套接字地址家族
#socket.SOCK_STREAM 指TCP流式协议
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
phone.bind((127.0.0.1,8080)) #绑定IP地址端口号

phone.listen(5) #bind连接池

while True:#连接循环
    # conn为三次握手成功后建立的连接
    # addr为客户端的地址
    conn, addr = phone.accept()  # 等待连接
    print(conn, conn)
    print(client addr, addr)

    while True:  # 与conn的通信循环
        try:
            cmd = conn.recv(1024)  # 收消息
            if not cmd: break
            res = subprocess.Popen(cmd.decode(utf-8),shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE)
            err = res.stderr.read()
            if err:
                cmd_res = err
            else:
                cmd_res = res.stdout.read()
            conn.send(cmd_res)
        except Exception:  # 解决服务端的异常终止
            break

    conn.close()  # 关闭连接
phone.close() #关闭通信


Client端实现

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect((127.0.0.1, 8080)) #客户端发起连接

while True:#通信循环
    cmd = input(>>>:).strip()
    if not cmd: continue #解决客服端发送空内容的问题
    phone.send(cmd.encode(utf-8)) #发消息
    cmd_res = phone.recv(1024)
    print(cmd_res.decode(gbk))

phone.close()

自定义包头解决粘包问题

P.S.只有TCP有粘包现象,UDP永远不会粘包

什么是粘包?
所谓粘包问题主要还是因为接收方不知道消息之间的界限,不知道一次性提取多少字节的数据所造成的。这取决于TCP的工作原理。

粘包发生在客户端:受限于网络传送介质的速度,未来得及每条都及时发送给服务端,导致发送的数据在客户端的缓存堆积并一块送到服务端
粘包发生在服务端:服务端的接收的数据在缓存中未及时被取完,导致接下来从客户端发送过来的数据堆积在服务端的缓存,下一次可能被一并取出

CPU工作的两种状态
内核态:运行操作系统,可以操作硬件
用户态:运行用户的应用程序

如何解决粘包的问题:
需要自己定制报头让发送端在发送数据之前,把自己将要发送的字节流总大小让接收端知晓,然后接收端来一个死循环接收完所有的数据。

Server端实现

import socket
import subprocess
import struct
import json

#socket.AF_INET 指定套接字地址家族
#socket.SOCK_STREAM 指TCP流式协议
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
phone.bind((127.0.0.1,8080)) #绑定IP地址端口号

phone.listen(5) #bind连接池

while True:#连接循环
    # conn为三次握手成功后建立的连接
    # addr为客户端的地址
    conn, addr = phone.accept()  # 等待连接
    print(conn=, conn)
    print(client addr=, addr)

    while True:  # 与conn的通信循环
        try:
            cmd = conn.recv(1024)  # 收消息
            if not cmd: break
            res = subprocess.Popen(cmd.decode(utf-8),shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE)
            err = res.stderr.read()
            if err:
                cmd_res = err
            else:
                cmd_res = res.stdout.read()
            # conn.send(struct.pack(‘i‘,len(cmd_res))) #先发报头
            head_dict={‘filename‘:None,‘hash‘:None,‘total_size‘:len(cmd_res)}
            head_json = json.dumps(head_dict) #报头信息序列化
            head_bytes = head_json.encode(‘utf-8‘)#将报头信息转化为字节形式传输
            conn.send(struct.pack(‘i‘,len(head_bytes))) #发送报头长度
            conn.send(head_bytes) #再发送报头数据
            conn.send(cmd_res) #再发真实的数据
        except Exception:  # 解决服务端的异常终止
            break

    conn.close()  # 关闭连接
phone.close() #关闭通信


Client端实现

import socket
import struct
import json

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect((127.0.0.1, 8080)) #客户端发起连接

while True:#通信循环
    cmd = input(>>>:).strip()
    if not cmd: continue #解决客服端发送空内容的问题
    phone.send(cmd.encode(utf-8)) #发消息
    head_len_info = phone.recv(4) #收到报头的长度信息
    head_len = struct.unpack(‘i‘, head_len_info)[0] #得到报头的长度
    head_bytes = phone.recv(head_len) #获取报头信息
    head_json = head_bytes.decode(‘utf-8‘) #报头信息反序列化
    head_dict = json.loads(head_json) #获取报头字典格式
    total_size = head_dict[‘total_size‘] #从字典中取出真实的数据
    # total_size = struct.unpack(‘i‘,head)[0]
    recv_size = 0
    data = b‘‘
    while recv_size < total_size:
        recv_data = phone.recv(1024)
        data += recv_data
        recv_size += len(recv_data)
    print(data.decode(gbk))
phone.close()

Python自动化开发课堂笔记【Day08】 - Python进阶(面向对象的高级用法,网络编程)