python进阶：python高级编程技巧(上)

1、深入类和对象

1.1鸭子类型和多态

①鸭子类型多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚"鸭子类型"
动态语言调用实例方法时不检查类型，只要方法存在，参数正确，就可以调用。这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。就比如extend往列表中追加数据只要是可迭代对象什么多可以追加
②定义时的类型和运行时的类型不一样，就称为多态。

1.2抽象基类(abc模块)

1.2.1定义

①抽象基类（abstract base class,ABC）：抽象基类就是类里定义了纯虚成员函数的类。纯虚函数只提供了接口，并没有具体实现。抽象基类不能被实例化(不能创建对象)，通常是作为基类供子类继承，子类中重写虚函数，实现具体的接口。
②抽象基类就是定义各种方法而不做具体实现的类，任何继承自抽象基类的类必须实现这些方法，否则无法实例化。
③应用场景
1.我们去检查某个类中是否有某种方法

'''定义Demo类，类中含有__len__魔法方法
导入抽象基类中的Sized类'''
class Demo(object):
    def __init__(self,elist):
        self.elist = elist

    def __len__(self):
        return len(self.elist)

d = Demo(["oldAmy", "ls"])

from collections.abc import Sized
print(isinstance(d, Sized))        # True  d是Sized子类

2.我们需要强调某个子类必须实现某些方法

'''定义父类Cache
封装CRUD方法。强制子类重写该方法。
定义子类Redis'''
import abc
class CacheBase(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def dele(self,key):
        pass

    @abc.abstractmethod
    def crea(self,key,value):
        pass


class RedisBase(CacheBase):
    def dele(self,key,value):
        pass

    def crea(self,key):
        pass


r = RedisBase()  

使用isinstance和type的区别type 不考虑 继承关系但是isinstance要考虑继承关系

1.3类属性和实例属性查找顺序

①基本查找顺序对象是可以向上查找的，所以可以访问到类属性，当对象自己有该实例属性时 ，则输出的是自己的
②类不能向下查找，所以只能访问到类属性
在python2.2版本之后，引入BFS(广度优先)。
在python新式类，就引入了C3算法，通过className.__mro__来查看，类执行的顺序

1.4Python对象的自省机制

自省是通过一定的机制查询到对象的内部结构，Python中比较常见的自省（introspection）机制(函数用法)有： dir()，type(), hasattr(), isinstance()，通过这些函数，我们能够在程序运行时得知对象的类型，判断对象是否存在某个属性，访问对象的属性。

2、类与对象深度问题及解决技巧

2.1如何派生内置不可变类型并修改其实例化行为

列表使用的是init方法创建的，元组使用的是new方法创建的，具体验证参考下图

①例题我们想自定义一种新类型的元组，对于传入的可迭代对象，我们只保留其中int类型且值大于0的元素

class IntTuple(tuple):
    def __new__(cls, iterable ):
        f = [i for i in iterable if isinstance(i,int) and i>0]
        return super().__new__(cls,f)


int_t = IntTuple([2,-2,"beiyue",["x","y"],4])
print(int_t)    # (2, 4)

2.2创建大量实例节省内存

定义类的 _ _slots _ _ 属性，声明实例有哪些属性(关闭动态绑定),不影响子类实例，不会继承，除非子类里面自己定义了_ _slots _ _

class Player(object):
    def __init__(self, uid, name, status):
        self.uid = uid
        self.name = name
        self.status = status


class Player2(object):
    __slots__ = ("uid", "name", "status")
    def __init__(self, uid, name, status):
        self.uid = uid
        self.name = name
        self.status = status
        
# 实例化两个类
p1 = Player("1","zs",1)
p2 = Player2("2","ls",1)

"""
跟踪内存的使用
"""
import tracemalloc
tracemalloc.start()     # 开始跟踪内存分配

# pla_1 = [Player(1,2,3) for i in range(10000)] 	  #  size=1722 KiB
pla_2 = [Player2(1,2,3) for i in range(10000)] 		  # size=711 KiB

snapshot = tracemalloc.take_snapshot()  			  # 快照，当前内存分配
top = snapshot.statistics("filename")      			  # 快照对象的统计 监测文件

for start in top[:10]:
    print(start)
    

①使用 _ _dict _ _ 字典主要是为了提升查询效率，所以必须使用空间换时间
少量的实例，使用字典存储，问题不大。但如果像我们的业务达到数百万个实例，字典占用的总空间就比较大。
②这个 _ _slots _ _ 相当于告诉解释器，实例的属性都叫什么。而且既然需要节省内存，推荐定义时使用元组，而不是列表。

2.3Python中的with语句

with语句处理对象必须有 _ _ enter _ _ 方法及 _ _ exit _ _ 方法。并且 _ _ enter _ _ 方法在语句体(with语句包括起来的代码块)执行之前进入运行， _ _ exit _ _ 方法在语句体执行完毕退出后自动运行。可以通过contextlib.contextmanager这个装饰器来省略这些环节(contextlib简化上下文管理器)

@contextlib.contextmanager
def file_open(filename):
    # __enter__函数
    print("file open")
    yield {}
    # __exit__函数
    print("file close")


with file_open("test.txt") as f:
    print("file operation")

2.4类支持比较操作

如果要自定义类的实例间可以使用,<,<=,>,>=,==,!=符号进行比较,我们自定义比较的行业,例如,有一个矩形的类,比较两个矩形的实例时,比较的是他们的面积,

from functools import total_ordering

@total_ordering
class Rect(object):
    def __init__(self,w,h):
        self.w = w
        self.h = h

    def area(self):
        return self.w * self.h

    def __str__(self):
        return f"({self.w},{self.h})"

    def __lt__(self, other):
        return self.area() < other.area()

reac1 = Rect(1,2)
reac2 = Rect(3,4)
print(reac1)
print(reac2)

print(reac1 < reac2)           
print(reac1 > reac2)           

@total_ordering装饰器就只需要完成_ _ lt _ _与 _ _ gt _ _两个方法 就可以全部实现