本章引言

由于Python是动态语言，一般情况下，当定义了一个class，并且创建了一个class的实例后，可以给该实例绑定任何属性和方法。并且我们已经学习过对象绑定属性既可以是类属性也存在对象属性；

类属性：表示的是将属性信息声明在类中，但是在实际开发中，其属性通常会在每个类的初始化方法中进行完成初始化赋值操作；

对象属性：通过创建对象后进行使用引用名进行添加，添加完成后，该属性只能够在当前对象中所引用，其他对象无法获取

# -*- coding: utf-8 -*-#

#-------------------------------------------------------------------------------

# ProjectName:     PythonTest

# FileName:       StudentTest 

# Author:        MuTou

# Date:         2019/9/28

# Description:

#-------------------------------------------------------------------------------

#给实例绑定属性的方法是通过实例变量，或者通过self变量

class Student(object):

    def __init__(self, name):

        self.name = name

s = Student('张三')

s.score = 90

#但是，如果Student类本身需要绑定一个属性呢？可以直接在class中定义属性，这种属性是类属性，归Student类所有：

class Student(object):

    name = 'Student'

#当我们定义了一个类属性后，这个属性虽然归类所有，但类的所有实例都可以访问到。来测试一下：

>>> class Student(object):

...     name = 'Student'

...

>>> s = Student() # 创建实例s

>>> print(s.name) # 打印name属性，因为实例并没有name属性，所以会继续查找class的name属性

Student

>>> print(Student.name) # 打印类的name属性

Student

>>> s.name = 'lisi' # 给实例绑定name属性

>>> print(s.name) # 由于实例属性优先级比类属性高，因此，它会屏蔽掉类的name属性

lisi

>>> print(Student.name) # 但是类属性并未消失，用Student.name仍然可以访问

Student

>>> del s.name # 如果删除实例的name属性

>>> print(s.name) # 再次调用s.name，由于实例的name属性没有找到，类的name属性就显示出来了

Student

之前是通过实例进行绑定一个属性，同样还可以通过实例进行绑定一个方法：

>>> def set_age(self, age): # 定义一个函数作为实例方法

...     self.age = age

...

>>> from types import MethodType

>>> s.set_age = MethodType(set_age, s) # 给实例绑定一个方法

>>> s.set_age(25) # 调用实例方法

>>> s.age # 测试结果

25

#但是，给一个实例绑定的方法，对另一个实例是不起作用的：

>>> s2 = Student() # 创建新的实例

>>> s2.set_age(25) # 尝试调用方法

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

AttributeError: 'Student' object has no attribute 'set_age'

    如果需要给所有实例都绑定方法，可以给class绑定方法：

>>> def set_score(self, score):

...     self.score = score

...

>>> Student.set_score = set_score

#给class绑定方法后，所有实例均可调用：

>>> s.set_score(110)

>>> s.score

110

>>> s2.set_score(995)

>>> s2.score

995

#通常情况下，上面的set_score方法可以直接定义在class中，但动态绑定允许我们在程序运行的过程中动态给class加上功能，这在静态语言中很难实现。

使用__slots__

        但是，如果我们想要限制实例的属性怎么办？比如，只允许对Student实例添加name和age属性。

        为了达到限制的目的，Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性：

class Student(object):

    __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称

>>> s = Student() # 创建新的实例

>>> s.name = 'Michael' # 绑定属性'name'

>>> s.age = 25 # 绑定属性'age'

>>> s.score = 99 # 绑定属性'score'

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

AttributeError: 'Student' object has no attribute 'score'

#由于'score'没有被放到__slots__中，所以不能绑定score属性，试图绑定score将得到AttributeError的错误。

#使用__slots__要注意，__slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的：

>>> class GraduateStudent(Student):

...     pass

...

>>> g = GraduateStudent()

>>> g.score = 9999

#除非在子类中也定义__slots__，这样，子类实例允许定义的属性就是自身的__slots__加上父类的__slots__。

注意:使用__slots__要注意，__slots__定义的属性仅对当前类实例起作用，对于继承的自类是不起作用的

slots应用实例

如何为创建大量实例节省内存?

需求：某游戏中，定义了玩家类Player（uid, name, status...），每有一个在线玩家，在服务器程序内则有一个Player的实例，当在线人数很多时，将产生大量实例（如百万级）

解决方案：定义类的slots属性，它时用来声明实例属性名字的列表。

# coding:utf-8

class Player(object):

    def __init__(self, uid, name, stat=0, level=1):

        self.uid = uid

        self.name = name

        self.stat = stat

        self.level = level

class Player2(object):

    __slots__ = ['uid', 'name', 'stat', 'level', 'sex']

    def __init__(self, uid, name, stat=0, level=1):

        self.uid = uid

        self.name = name

        self.stat = stat

        self.level = level

class Player3(Player2):

    def __init__(self, uid, name):

        super(Player3, self).__init__(uid, name)

class Player4(Player2):

    __slots__ = ['age']

    def __init__(self, uid, name):

        super(Player4, self).__init__(uid, name)

# 创建实例

p1 = Player('001', 'Jim')

p2 = Player2('002', 'Jim2')

p3 = Player3('003', 'Jim3')

p4 = Player4('004', 'Jim4')

# p1实例

print(p1.name)  # jim

p1.age = 16

print(p1.age)  # 16

# p2实例

print(p2.name)  # Jim2

p2.sex = 'boy'

print(p2.sex)  # boy

# p2.age = 16

# print(p2.age)  # 错误异常 AttributeError

# p3实例 __slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的

print(p3.name)  # Jim3

p3.age = 16

print(p3.age)  # 16

# p4实例 

# 子类中也定义__slots__，这样，子类实例允许定义的属性就是自身的__slots__加上父类的__slots__

print(p4.name)  # Jim4

p4.age = 16

print(p4.age)  # 16

p4.sex = 'girl'

print(p4.sex)  # girl

# p4.date = '2019'

# print(p4.date)  # 错误异常 AttributeError

交互模式下看到p1和p2的属性，p1比p2使用的内存多，为什么呢，通过对比发现，属性多了__dict__和__weakref__

p1中的p1.__dict__中是一个为实例动态绑定属性的字典

也可以直接往字典中给添加、删除属性

这种动态绑定属性是以牺牲内存为代价的

我们可以导入sys模块查看占用字节数

所以，在创建对象的时候提前使用__slots__提前声明好了所需的属性，就可以达到节省内存的目的

python培训：http://www.baizhiedu.com/python2019