• 9.3. 初探类
    • 9.3.1. 类定义语法
    • 9.3.2. 类对象
    • 9.3.3. 实例对象
    • 9.3.4. 方法对象
    • 9.3.5. 类和实例变量

    9.3. 初探类

    类引入了一些新语法,三种新对象类型和一些新语义。

    9.3.1. 类定义语法

    最简单的类定义看起来像这样:

    1. class ClassName:
    2. <statement-1>
    3. .
    4. .
    5. .
    6. <statement-N>

    类定义与函数定义 (def 语句) 一样必须被执行才会起作用。 (你可以尝试将类定义放在 if 语句的一个分支或是函数的内部。)

    在实践中,类定义内的语句通常都是函数定义,但也允许有其他语句,有时还很有用 —- 我们会稍后再回来说明这个问题。 在类内部的函数定义通常具有一种特别形式的参数列表,这是方法调用的约定规范所指明的 —- 这个问题也将在稍后再说明。

    当进入类定义时,将创建一个新的命名空间,并将其用作局部作用域 —- 因此,所有对局部变量的赋值都是在这个新命名空间之内。 特别的,函数定义会绑定到这里的新函数名称。

    当(从结尾处)正常离开类定义时,将创建一个 类对象。 这基本上是一个包围在类定义所创建命名空间内容周围的包装器;我们将在下一节了解有关类对象的更多信息。 原始的(在进入类定义之前起作用的)局部作用域将重新生效,类对象将在这里被绑定到类定义头所给出的类名称 (在这个示例中为 ClassName)。

    9.3.2. 类对象

    类对象支持两种操作:属性引用和实例化。

    属性引用 使用 Python 中所有属性引用所使用的标准语法: obj.name。 有效的属性名称是类对象被创建时存在于类命名空间中的所有名称。 因此,如果类定义是这样的:

    1. class MyClass:
    2. """A simple example class"""
    3. i = 12345
    4.  
    5. def f(self):
    6. return 'hello world'

    那么 MyClass.iMyClass.f 就是有效的属性引用,将分别返回一个整数和一个函数对象。 类属性也可以被赋值,因此可以通过赋值来更改 MyClass.i 的值。 doc 也是一个有效的属性,将返回所属类的文档字符串: "A simple example class"

    类的 实例化 使用函数表示法。 可以把类对象视为是返回该类的一个新实例的不带参数的函数。 举例来说(假设使用上述的类):

    1. x = MyClass()

    创建类的新 实例 并将此对象分配给局部变量 x

    实例化操作(“调用”类对象)会创建一个空对象。 许多类喜欢创建带有特定初始状态的自定义实例。 为此类定义可能包含一个名为 init() 的特殊方法,就像这样:

    1. def __init__(self):
    2. self.data = []

    当一个类定义了 init() 方法时,类的实例化操作会自动为新创建的类实例发起调用 init()。 因此在这个示例中,可以通过以下语句获得一个经初始化的新实例:

    1. x = MyClass()

    当然,init() 方法还可以有额外参数以实现更高灵活性。 在这种情况下,提供给类实例化运算符的参数将被传递给 init()。 例如,:

    1. >>> class Complex:
    2. ... def __init__(self, realpart, imagpart):
    3. ... self.r = realpart
    4. ... self.i = imagpart
    5. ...
    6. >>> x = Complex(3.0, -4.5)
    7. >>> x.r, x.i
    8. (3.0, -4.5)

    9.3.3. 实例对象

    现在我们可以用实例对象做什么?实例对象理解的唯一操作是属性引用。有两种有效的属性名称,数据属性和方法。

    数据属性 对应于 Smalltalk 中的“实例变量”,以及 C++ 中的“数据成员”。 数据属性不需要声明;像局部变量一样,它们将在第一次被赋值时产生。 例如,如果 x 是上面创建的 MyClass 的实例,则以下代码段将打印数值 16,且不保留任何追踪信息:

    1. x.counter = 1
    2. while x.counter < 10:
    3. x.counter = x.counter * 2
    4. print(x.counter)
    5. del x.counter

    另一类实例属性引用称为 方法。 方法是“从属于”对象的函数。 (在 Python 中,方法这个术语并不是类实例所特有的:其他对象也可以有方法。 例如,列表对象具有 append, insert, remove, sort 等方法。 然而,在以下讨论中,我们使用方法一词将专指类实例对象的方法,除非另外显式地说明。)

    实例对象的有效方法名称依赖于其所属的类。 根据定义,一个类中所有是函数对象的属性都是定义了其实例的相应方法。 因此在我们的示例中,x.f 是有效的方法引用,因为 MyClass.f 是一个函数,而 x.i 不是方法,因为 MyClass.i 不是一个函数。 但是 x.fMyClass.f 并不是一回事 —- 它是一个 方法对象,不是函数对象。

    9.3.4. 方法对象

    通常,方法在绑定后立即被调用:

    1. x.f()

    MyClass 示例中,这将返回字符串 'hello world'。 但是,立即调用一个方法并不是必须的: x.f 是一个方法对象,它可以被保存起来以后再调用。 例如:

    1. xf = x.f
    2. while True:
    3. print(xf())

    将继续打印 hello world,直到结束。

    当一个方法被调用时到底发生了什么? 你可能已经注意到上面调用 x.f() 时并没有带参数,虽然 f() 的函数定义指定了一个参数。 这个参数发生了什么事? 当不带参数地调用一个需要参数的函数时 Python 肯定会引发异常 —- 即使参数实际未被使用…

    实际上,你可能已经猜到了答案:方法的特殊之处就在于实例对象会作为函数的第一个参数被传入。 在我们的示例中,调用 x.f() 其实就相当于 MyClass.f(x)。 总之,调用一个具有 n 个参数的方法就相当于调用再多一个参数的对应函数,这个参数值为方法所属实例对象,位置在其他参数之前。

    如果你仍然无法理解方法的运作原理,那么查看实现细节可能会澄清问题。 当一个实例的非数据属性被引用时,将搜索实例所属的类。 如果被引用的属性名称表示一个有效的类属性中的函数对象,会通过打包(指向)查找到的实例对象和函数对象到一个抽象对象的方式来创建方法对象:这个抽象对象就是方法对象。 当附带参数列表调用方法对象时,将基于实例对象和参数列表构建一个新的参数列表,并使用这个新参数列表调用相应的函数对象。

    9.3.5. 类和实例变量

    一般来说,实例变量用于每个实例的唯一数据,而类变量用于类的所有实例共享的属性和方法:

    1. class Dog:
    2.  
    3. kind = 'canine' # class variable shared by all instances
    4.  
    5. def __init__(self, name):
    6. self.name = name # instance variable unique to each instance
    7.  
    8. >>> d = Dog('Fido')
    9. >>> e = Dog('Buddy')
    10. >>> d.kind # shared by all dogs
    11. 'canine'
    12. >>> e.kind # shared by all dogs
    13. 'canine'
    14. >>> d.name # unique to d
    15. 'Fido'
    16. >>> e.name # unique to e
    17. 'Buddy'

    正如 名称和对象 中已讨论过的,共享数据可能在涉及 mutable 对象例如列表和字典的时候导致令人惊讶的结果。 例如以下代码中的 tricks 列表不应该被用作类变量,因为所有的 Dog 实例将只共享一个单独的列表:

    1. class Dog:
    2.  
    3. tricks = [] # mistaken use of a class variable
    4.  
    5. def __init__(self, name):
    6. self.name = name
    7.  
    8. def add_trick(self, trick):
    9. self.tricks.append(trick)
    10.  
    11. >>> d = Dog('Fido')
    12. >>> e = Dog('Buddy')
    13. >>> d.add_trick('roll over')
    14. >>> e.add_trick('play dead')
    15. >>> d.tricks # unexpectedly shared by all dogs
    16. ['roll over', 'play dead']

    正确的类设计应该使用实例变量:

    1. class Dog:
    2.  
    3. def __init__(self, name):
    4. self.name = name
    5. self.tricks = [] # creates a new empty list for each dog
    6.  
    7. def add_trick(self, trick):
    8. self.tricks.append(trick)
    9.  
    10. >>> d = Dog('Fido')
    11. >>> e = Dog('Buddy')
    12. >>> d.add_trick('roll over')
    13. >>> e.add_trick('play dead')
    14. >>> d.tricks
    15. ['roll over']
    16. >>> e.tricks
    17. ['play dead']