---
title: 类
date: 2020-09-26 15:25:10
tags: [Python]
categories: [Python]
author: Anges黎梦
---

### 类定义语法

类定义:

```python
class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>
```

类定义与函数定义 (def 语句) 一样必须被执行才会起作用。 

类定义内的语句通常都是函数定义，但也允许有其他语句。

在类内部的函数定义通常具有一种特别形式的参数列表，这是方法调用的约定规范所指明的。

当进入类定义时，将创建一个新的命名空间，并将其用作局部作用域 --- 因此，所有对局部变量的赋值都是在这个新命名空间之内。 

特别的，函数定义会绑定到这里的新函数名称。

当（从结尾处）正常离开类定义时，将创建一个 类对象。 

这基本上是一个包围在类定义所创建命名空间内容周围的包装器；

原始的（在进入类定义之前起作用的）局部作用域将重新生效，

类对象将在这里被绑定到类定义头所给出的类名称 (在这个示例中为 ClassName)。

### 类对象

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

属性引用 使用 Python 中所有属性引用所使用的标准语法: **obj.name**。 

有效的属性名称是类对象被创建时存在于类命名空间中的所有名称。 

因此，如果类定义是这样的:

```python
class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'
```

那么 **MyClass.i** 和 **MyClass.f** 就是有效的属性引用，将分别返回一个整数和一个函数对象。 

类属性也可以被赋值，因此可以通过赋值来更改 **MyClass.i** 的值。 

**__doc__** 也是一个有效的属性，将返回所属类的文档字符串: **"A simple example class"**。

类的 实例化 使用函数表示法。 

可以把类对象视为是返回该类的一个新实例的不带参数的函数。 

举例来说（假设使用上述的类）:

```python
x = MyClass()
```

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

实例化操作（“调用”类对象）会创建一个空对象。 

许多类喜欢创建带有特定初始状态的自定义实例。 

为此类定义可能包含一个名为 **__init__()** 的特殊方法，就像这样:

```python
def __init__(self):
    self.data = []
```

当一个类定义了 **__init__()** 方法时，类的实例化操作会自动为新创建的类实例发起调用 **__init__()**。 

因此在这个示例中，可以通过以下语句获得一个经初始化的新实例:

```python
x = MyClass()
```

当然，**__init__()** 方法还可以有额外参数以实现更高灵活性。 

在这种情况下，提供给类实例化运算符的参数将被传递给 **__init__()**。 例如，:

```python
>>> class Complex:
...     def __init__(self, realpart, imagpart):
...         self.r = realpart
...         self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)
```

### 实例对象

现在我们能用实例对象做什么？ 实例对象理解的唯一操作是属性引用。 

有两种有效的属性名称：数据属性和方法。

数据属性 对应于 Smalltalk 中的“实例变量”，以及 C++ 中的“数据成员”。 

数据属性不需要声明；像局部变量一样，它们将在第一次被赋值时产生。 

例如，如果 **x** 是上面创建的 MyClass 的实例，则以下代码段将打印数值 **16**，且不保留任何追踪信息:

```python
x.counter = 1
while x.counter < 10:
    x.counter = x.counter * 2
print(x.counter)
del x.counter
```

另一类实例属性引用称为 方法。 

方法是“从属于”对象的函数。 

（在 Python 中，方法这个术语并不是类实例所特有的：其他对象也可以有方法。 例如，列表对象具有 append, insert, remove, sort 等方法。 然而，在以下讨论中，我们使用方法一词将专指类实例对象的方法，除非另外显式地说明。）

实例对象的有效方法名称依赖于其所属的类。 

根据定义，一个类中所有是函数对象的属性都是定义了其实例的相应方法。 

因此在我们的示例中，**x.f** 是有效的方法引用，因为 **MyClass.f** 是一个函数，而 **x.i** 不是方法，因为 **MyClass.i** 不是一个函数。 

但是 **x.f** 与 **MyClass.f** 并不是一回事 --- 它是一个 方法对象，不是函数对象。

### 方法对象

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

```python
x.f()
```

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

```python
xf = x.f
while True:
    print(xf())
```

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

当一个方法被调用时到底发生了什么？ 你可能已经注意到上面调用 x.f() 时并没有带参数，虽然 f() 的函数定义指定了一个参数。 

这个参数发生了什么事？ 当不带参数地调用一个需要参数的函数时 Python 肯定会引发异常 --- 即使参数实际未被使用...

实际上，你可能已经猜到了答案：方法的特殊之处就在于实例对象会作为函数的第一个参数被传入。 

在我们的示例中，调用 x.f() 其实就相当于 MyClass.f(x)。 

总之，调用一个具有 n 个参数的方法就相当于调用再多一个参数的对应函数，这个参数值为方法所属实例对象，位置在其他参数之前。

如果你仍然无法理解方法的运作原理，那么查看实现细节可能会澄清问题。 

当一个实例的非数据属性被引用时，将搜索实例所属的类。 

如果被引用的属性名称表示一个有效的类属性中的函数对象，

会通过打包（指向）查找到的实例对象和函数对象到一个抽象对象的方式来创建方法对象：这个抽象对象就是方法对象。 

当附带参数列表调用方法对象时，将基于实例对象和参数列表构建一个新的参数列表，并使用这个新参数列表调用相应的函数对象。

### 类和实例变量

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

```python
class Dog:

    kind = 'canine'         # 所有实例共享的类变量

    def __init__(self, name):
        self.name = name    # 每个实例唯一的实例变量

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.kind                  # 所有狗共享
'canine'
>>> e.kind                  # 所有狗共享
'canine'
>>> d.name                  # 只属于d
'Fido'
>>> e.name                  # 只属于e
'Buddy'
```

以下代码中的 tricks 列表不应该被用作类变量，因为所有的 Dog 实例将只共享一个单独的列表:

```python
class Dog:

    tricks = []             # 错误使用类变量

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

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks                # 意外地被所有狗共享
['roll over', 'play dead']
```
正确的类设计应该使用实例变量:

```python
class Dog:

    def __init__(self, name):
        self.name = name
        self.tricks = []    # 为每只狗创建一个新的空列表

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks
['roll over']
>>> e.tricks
['play dead']
```

### self

- self 代表类实例化对象本身，类中所有的方法，第一个参数必须是类实例化对象，表示方法与类的从属关系
- self 不属于关键字，它是一个约定俗成的编写
- self 使用，不包含类方法和静态方法

### 补充

如果同样的属性名称同时出现在实例和类中，则属性查找会优先选择实例:

```python
>>> class Warehouse:
        purpose = 'storage'
        region = 'west'

>>> w1 = Warehouse()
>>> print(w1.purpose, w1.region)
storage west
>>> w2 = Warehouse()
>>> w2.region = 'east'
>>> print(w2.purpose, w2.region)
storage east
```
数据属性可以被方法以及一个对象的普通用户（“客户端”）所引用。 

换句话说，类不能用于实现纯抽象数据类型。 实际上，在 Python 中没有任何东西能强制隐藏数据 --- 它是完全基于约定的。 

客户端应当谨慎地使用数据属性 --- 客户端可能通过直接操作数据属性的方式破坏由方法所维护的固定变量。 

请注意客户端可以向一个实例对象添加他们自己的数据属性而不会影响方法的可用性，只要保证避免名称冲突 --- 再次提醒，在此使用命名约定可以省去许多令人头痛的麻烦。

在方法内部引用数据属性（或其他方法！）并没有简便方式。 

我发现这实际上提升了方法的可读性：当浏览一个方法代码时，不会存在混淆局部变量和实例变量的机会。

方法的第一个参数常常被命名为 self。 

这也不过就是一个约定: self 这一名称在 Python 中绝对没有特殊含义。 

但是要注意，不遵循此约定会使得你的代码对其他 Python 程序员来说缺乏可读性，而且也可以想像一个 类浏览器 程序的编写可能会依赖于这样的约定。

任何一个作为类属性的函数都为该类的实例定义了一个相应方法。

函数定义的文本并非必须包含于类定义之内：将一个函数对象赋值给一个局部变量也是可以的。 例如:

```python
# 类外定义的函数
def f1(self, x, y):
    return min(x, x+y)

class C:
    f = f1

    def g(self):
        return 'hello world'

    h = g
```

现在 f, g 和 h 都是 C 类的引用函数对象的属性，因而它们就都是 C 的实例的方法 --- 其中 h 完全等同于 g。 

但请注意，本示例的做法通常只会令程序的阅读者感到迷惑。

方法可以通过使用 self 参数的方法属性调用其他方法:

```python
class Bag:
    def __init__(self):
        self.data = []

    def add(self, x):
        self.data.append(x)

    def addtwice(self, x):
        self.add(x)
        self.add(x)
```

方法可以通过与普通函数相同的方式引用全局名称。 

与方法相关联的全局作用域就是包含其定义的模块。 

（类永远不会被作为全局作用域。） 

虽然我们很少会有充分的理由在方法中使用全局作用域，

但全局作用域存在许多合法的使用场景：举个例子，导入到全局作用域的函数和模块可以被方法所使用，在其中定义的函数和类也一样。 

通常，包含该方法的类本身是在全局作用域中定义的，而在下一节中我们将会发现为何方法需要引用其所属类的很好的理由。

每个值都是一个对象，因此具有 类 （也称为 类型），并存储为 object.__class__ 。