slots属性，doc属性，module和class，析构方法del，call方法

'''
1.__slots__是什么：是一个类变量，变量值可以是列表，元组，或者可迭代对象，也可以是一个字符串(意味着所有实例只有一个数据属性)
2.引子：使用点来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的，而每个实例的字典是独立的)
3.为何使用__slots_：字典会占用大量内存，如果你有一个属性很少的类，但是有很多实例，为了节省内存可以使用__slots__取代实例的__dict__；当你定义
__slots__后，__slots__就会为实例使用一种更加紧凑的内部展示。实例通过一个很小的固定大小的数组来构建，而不是为每个实例定义一个字典，这跟元组或
列表很类似。在__slots__中列出的属性名在内部被映射到这个数组的指定小标上。使用__slots__一个不好的地方就是我们不能再给实例添加新的属性了，只能
使用在__slots__中定义的那些属性名。
4.注意事项：__slots__的很多特性都依赖于普通的基于字典的实现。另外，定义了__slots__后的类不再支持一些普通类特性了，比如多继承。大多数情况下，
你应该只在那些经常被使用到的用作数据结构的类上定义__slots__比如在程序中需要创建某个类的几百万个实例对象。关于__slots__的一个常见误区是它可以
作为一个封装工具来防止用户给实例增加新的属性。尽管使用__slots__可以达到这样的目的，但是这个并不是它的初衷。更多的是用来作为一个内存优化工具。
'''

class Foo:
   __slots__ = 'name' # {'name': None}

f1 = Foo()
f1.name = 'alex'
print(f1.name) # 'alex'
# f1.addr = 'sz' # 添加其它新的属性，本质上__setattr__ ---> f1.__dict__['addr'] = 'sz'；此条添加报错：AttributeError: 'Foo' object has no attribute 'age'
# print(f1.__dict__) # 报错：AttributeError: 'Foo' object has no attribute '__dict__'
print(f1.__slots__) # 打印name，所以只能添加name属性
print(Foo.__slots__) # __slots__本属于类的属性，实例是在调用类属性


class Foo_1:
   __slots__ = ['name', 'age'] # {'name': None, 'age': None}

f2 = Foo_1()
print(Foo_1.__slots__) # ['name', 'age']
print(f2.__slots__) # ['name', 'age']
f2.name = 'sb'
f2.age = 18
print(f2.name) # 'sb'
print(f2.age) # 18
# f2.addr = 'gz' # 一样的不能添加其它新的属性


'''__doc__(该属性不能被继承)，每一个类都有__doc__属性，没有写默认为None'''
class Dog:
   '''这是一个狗的类'''
   pass

class Cat(Dog):
   pass

print(Dog.__doc__) # 这是一个狗的类
print(Cat.__doc__) # None


'''__module__和__class__'''
# from s58 import Date_one # import的时候，会把所导入文件执行一遍
#
# d1 = Date_one(2021, 4, 1)
# print(d1.year)
# print(d1.__module__) # 打印 s58，即输出模块名
# print(d1.__class__) # 打印 <class 's58.Date_one'>，即输出模块里的类


'''__del__析构方法：析构方法，当对象在内存中被释放时，自动触发执行。注：如果产生的对象仅仅只是python程序级别的（用户级），那么无需定义__del__,如果产生的对象的同时还会向操作系统发起系统调用，即一个对象有用户级与内核级两种资源，比如（打开一个文件，创建一个数据库链接），
则必须在清除对象的同时回收系统资源，这就用到了__del__'''
class Del:
   def __init__(self, name):
      self.name = name

   def __del__(self):
      print('我执行啦')

de = Del('alex')
del de
print('------') # 先打印'我执行啦'，后打印'------'；de为实例对象，删除会自动触发__del__


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

   def __del__(self):
      print('我又执行啦')

dd = Del_1('wupeiqi')
del dd.name
print('------') #先打印'------'，后打印'我又执行啦'；dd.name不是对象，所以删除时没有触发__del__，所以先打印'------'，但是文件运行完毕后，python自动把对象回收触发了__del__


# 应用场景：创建数据库类，用该类实例化出数据库链接对象，对象本身是存放于用户空间内存中，而链接则是由操作系统管理的，存放于内核空间内存中;
# 当程序结束时，python只会回收自己的内存空间，即用户态内存，而操作系统的资源则没有被回收，这就需要我们定制__del__，在对象被删除前向操作系统
# 发起关闭数据库链接的系统调用，回收资源；这与文件处理是一个道理
# f = open('a.txt', 'w') # 做了两件事，在用户空间拿到一个f变量，在操作系统内核空间打开一个文件
# del f # 只回收了用户空间的f，操作系统的文件还处于打开状态
# 所以我们应该在del f之前保证f.colst()执行，即便是没有del，程序执行完毕也会自动del清理资源，于是文件操作的正确用法应该是
# f = open('a.txt', 'w')
# 读写...
# f.close()
# 很多情况下大家都容易忽略f.colse()，这就用到了with上下文管理


'''__call__对象后面加括号，触发执行。注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()'''
class Cal:
   def __call__(self, *args, **kwargs):
      print('执行call')

cc = Cal() # Cal()，一切皆对象，Cal也能加括号运行，肯定也是执行的是某个对象下的__call__
cc() # 执行Cal下的__call__，打印'执行call'
Cal()() # 执行Cal下的__call__，打印'执行call'