Python3基础（十） 类的初印象

发表于   |   分类于   |  

Python是一种面向对象的脚本语言，所以它也提供了面向对象编程的所有基本特征：允许多继承的类继承机制、派生类可以重写它父类的任何方法、一个方法可以调用父类中同名的方法、对象可以包含任意数量和类型的数据成员。关于继承，将在下一篇博文里面介绍，本文只简单的介绍Python中的类的定义和使用。

一、类定义

最简单的类的定义形式：

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

类定义会创建一个新的命名空间，作为一个局部的作用域。在Python中，类本身就是对象，当一个类定义结束后, 一个 Class Object 就被创建。


二、类对象

类对象（Class Object）支持两种操作：属性引用 和 实例化。

属性引用

类对象的属性引用和 Python 中所有的属性引用一样，形式为：obj.name 。类对象创建后，类命名空间中所有的名字都是有效属性名，像下面这个类：

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

它有一个属性 i 和 方法 f ，所以可以用MyClass.i 和 MyClass.f 进行属性引用，分别返回一个整数和一个函数对象。__doc__ 也是一个合法的属性，返回属于这个类的文档字符串。

实例化

类的实例化形式为：

1
x = MyClass()

创建了一个新的实例，并且将其指定给局部变量 x 。

在创建实例时，通常可能都需要有特定的初始状态，所以一个类可以定义一个名为 __init__()的特殊方法（构造方法）：

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

当一个类定义了 __init__() 方法，类在实例化时会自动调用 __init__() 方法，用于创建新的类实例。 就像C++中的构造函数一样， __init__() 也可以有更多的参数，这时实例化提供给类的参数会传给 __init__() ，比如：

1
2
3
4
5
6
7
class student:
    def __init__(self, n, a):
        self.name = n
        self.age = a

stu = student('Selena', 19)
print(stu.name, stu.age)     # 输出：Selena 19


三、实例对象

类对象实例化得到实例对象（Instance Object），实例对象只能进行 属性引用 这一种操作。合法的属性有两种：数据属性 和 方法。

数据属性

数据属性（data attributes）相当于C++中的数据成员，在Python中，数据属性不需要声明，当它们第一次指定时就会被引入：

1
2
3
4
5
6
7
8
9
class MyClass:
    i = 12345
    def f(self):
        return 'hello world'

x = MyClass()
x.counter = 1
print(x.counter)
del x.counter

注：在Python中每个值都是一个对象，可以通过object.__class__来获取对象的 class （即类型），其作用与 type() 相同。

方法

在类对象中定义的函数与普通函数只有一个特别的区别：它们的第一个参数必须是self，用以指定调用该方法的实例对象。

注意：类的方法只有被绑定到实例对象上才能够被调用。比如上面的例子中，x 是 MyClass类的一个实例对象，所以它可以直接调用 f 方法：

1
x.f()

为什么 f() 定义时是有一个参数的，而这里调用不需要参数呢？ 因为在调用时， x 对象作为参数传递给了函数的第一个参数（即 self）。也就是说，x.f() 是严格等价于 MyClass.f(x)的。

所以在多数情况下，调用一个方法（有个 n 个参数），和调用相应的函数（也有那 n 个参数，但是再额外加入一个使用该方法的对象） 是等价的。

另外，函数也可以在 class 外定义，指定该函数对象给类中的局部变量就可以了，例如：

1
2
3
4
5
6
7
8
9
10
11
12
# Function defined outside the class
def f1(self, x, y):
    return min(x, y)

class C:
    f = f1
    def g(self):
        return 'hello world'

c = C()    # 实例化
c.f(1,3)
c.g()


四、私有成员

从C++术语上讲，Python 类的成员（包括数据成员）通常都是 public 的，并且所有的成员函数都是 virtual 的。

那么，如何在类中定义私有变量或私有方法呢？

答：在Python中规定，以两个下划线开头的名字为私有成员，不能在类的外部使用。

示例：

1
2
3
4
5
6
7
8
9
10
11
class A:
    __str = 'python'
    def __f(self):
        return self.__str
    def f(self):
        return self.__str

a = A()
a.__str   # 'A' object has no attribute '__str'
a.__f()   # 'A' object has no attribute '__f'
a.f()     # 输出：python





附：作用域的探讨

在讲函数变量作用域时，曾经说过在一个局部作用域内重新绑定全局变量，需要使用global声明。否则，尝试给这个变量赋值，只是会简单的创建一个新的局部变量，而不会改变那个全局变量。

这里再介绍一个nonlocal语句，它用于指示，在外层的局部作用域中的变量可以在这里进行重新绑定。下面是一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def scope_test():   # 作用域测试
    def do_local():
        x = 'local x'
    def do_nonlocal():
        nonlocal x
        x = 'nonlocal x'
    def do_global():
        global x
        x = 'global x'

    x = 'test x'   # 局部变量

    do_local()
    print('After do_local():', x)
    do_nonlocal()
    print('After do_nonlocal():', x)
    do_global()
    print('After do_global():', x)

scope_test()
print('In global scope:', x)

可以看出，局部的赋值 do_local() 并没有改变 scope_test 绑定的 x 变量，而 do_nonlocal() 则改变了 scope_test 中的 x，而 do_global() 则改变了模块级别的绑定，即全局变量。