Pythoon高级编程技巧-类与对象深度问题及解决技巧

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

练习需求：

自定义一种新的类型元祖，对于传入的可迭代对象，我们只保留
 int类型且值大于0的元素。如下：
 xin_tuple([2,-2,"abc",["x","y"],4)
 输出结果：（2, 4）
 

class A(tuple):
	def __new__(cls,itable)
		f = [i for i in itable if instance(i,int) and i > 0]
		return super().__new__(cls,f)
a = A([2,-2,"abc",["x","y],4)
print(a)
输出结果为（2,4）

2.0 如何为创建大量实例而减少内存

练习需求：

在游戏开发中，有一个玩家类Player,每有一个玩家在线，
就会生成一个Player类的实例，当在线人数很多时，将产生大量实例
（百万级）。
如何降级这些大量实例的内存开销
解决方案：使用__slots__属性，声明实例有哪些属性（关闭动态绑定）

class Player(object):
	def __init__(self,name,age,grade):
		self.name = name
		self.age = age
		self.grade = grade

class Player1(object):
	__slots__ = ("name","age","grade")
	def __init__(self,name,age,grade):
		self.name = name
		self.age = age
		self.grade = grade

#实例化两个类
P1 = Player("zs","2","1")
P2 = Player1("lis","3","1")

'''
开始内存追踪
'''
import tracemalloc
tracemalloc.start  '开始内存追踪'

pl = [Player(1,2,3) for i in range(10000)]
pl = [Player1(1,2,3) for i in range(10000)]

snapshot = tracemalloc.take_snapshot() #快照，当前内存的分配

top = snapshot.statistics("filename")#快照对象的统计，监测文件
for start in top[:10]:
	print(start)

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

__slots__是否会继承？
__slots__ 不影响子类实例，不会继承，除非子类里面
自己定义了 __slots__

3.0 Python中的with语句

自定义类使用上下文管理器
whith语句处理对象必须要有__enter__,方法及__exit__方法，
with语句处理对象必须有 enter 方法及 exit 方法。并且 enter 方法在语句体(with语句包括起来的代码块)执行之前进入运行， exit 方法在语句体执行完毕退出后自动运行

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")

4.0 如何创建可管理的对象属性

A.get_age()访问器
A。set_age()设置器

通过
A.age  访问
A.age = 20 

**实现需求：**
• 定义类AgeDemo
• 通过访问器访问年龄
• 通过设置器设置年龄
• 年龄不是int类型则主动抛出异常

class AgeDemo:
	def __init__(self,age):
		self.age = age
	#访问器
	def get_age(self):
		return self.age
	#设置
	def set_age(self,age):
		if not isinstance(age,int):
			raise TypeError("返回一个错误")
		self.age = age
	#我们可以这样写，比较安装
	#property() 函数的作用是在新式类中返回属性值。
	age_pro = property(fget = get_age,fset = set_age)
a = AgeDemo(18)
a.age_pro = 20    #输出20，正常
a.age_pro = '20'  #报错，当设置属性时，会调用set_age，进行判断
#a.age = "20" # 可以直接访问属性，不安全
#print(a.age) # 20 str 直接访问属性不安全

5.0 如何让类支持比较操作

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

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__
两个方法 就可以全部实现**     

如何在环状数据结构中管理内存

在python中，垃圾回收器通过引用计数来回收垃圾对象，当一个对象引用计数为0，或者只剩下弱引用时，这个对象会被释放。

弱引用
弱引用不增加引用计数，使用弱引用访问对象得到对象引用

import weakref
class B:
	def __del__(self):
	print("__del__")

b1 = B()
b2 = weakref.ref(b1)
b1 = None           
__del__

双链表中的弱引用

变量head指向节点1，节点1右引用节点2，节点2右引用节点3。
节点3左弱引用节点2，节点2左弱引用节点1。
当变量head指向None时，节点1对象被释放，节点1的右引用节点2被释放，节点2的右引用节点3被释放。

import weakref

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

    def add_right(self, node):
        self.right = node
        node.left = self
        # 如果左右节点都用弱引用,3后面的节点引用数字都是3,会自动被消灭掉,所以采用一半实,一半虚
        # node.left = weakref.ref(self)
        
    def __str__(self):
        return 'Node:<%s>' % self.data

    def __del__(self):
        print('in __del__: delete %s' % self)

def create_linklist(n):
    head = current = Node(1)
    for i in range(2, n + 1):
        node = Node(i)
        current.add_right(node)
        current = node
    return head

head = create_linklist(1000)
head = None

import time
for _ in range(1000):
    time.sleep(1)
    print('run...')
input('wait...')