Python 进阶之类与面向对象编程

发表于 | 分类于 | | 阅读次数:
字数统计: 5.1k | 阅读时长 ≈ 0:05

一、类的定义

Python 语言中的类实际上是一种数据类型，同时 Python 中所有内置的数据类型也都是由类定义的。

1
2
3
4
5
6
>>> type(10)
<class 'int'>
>>> type('10')
<class 'str'>
>>> type([10,11,12])
<class 'list'>

可以使用 class 关键字定义一个类，格式如下：

1
2
class MyClass:
    pass

使用赋值的形式实例化某个类，格式如下：
instance = MyClass()
即创建一个以 MyClass 类为数据类型的新对象 instance 。

实例变量

Python 中的类实例可以作为类似于 struct 的数据类型存储数据或记录，且不同于 C 或 Java 语言中的类似结构，关联于类实例的数据不需要提前声明。

1
2
3
4
5
6
7
8
class Circle:
    pass

my_circle = Circle()
my_circle.radius = 4

print(2 * 3.14 * my_circle.radius)
# => 25.12

可以通过在类的定义代码中添加 __init__ 方法来初始化实例中的某些数据。每当新的类实例创建时，__init__ 方法都会自动被调用一次，类似于 Java 中的构造器。其第一个参数 self 用来指代新的类实例本身。

1
2
3
4
5
6
7
8
class Circle:
    def __init__(self):
        self.radius = 1

my_circle = Circle()

print(2 * 3.14 * my_circle.radius)
# => 6.28

上面代码中的 radius 即为 Circle 类的实例变量，每一个由 Circle 类生成的实例对象（如上面代码中的 my_circle）都包含一份独有的 radius 变量。
创建实例变量的语法如下：
instance.variable = value

类变量

类变量是关联于某个类的变量（而不是某个类实例），可以被所有的类实例访问，因此常用来追踪某些类级别的信息。类变量可以通过类结构体中的赋值语句进行创建（而类的实例变量需要在 __init__ 方法中定义）。

1
2
3
4
5
6
7
8
9
10
11
12
class Circle:
    pi = 3.14159
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return self.radius * self.radius * Circle.pi

print(Circle.pi)    # => 3.14159
Circle.pi = 4
c = Circle(3)
print(c.area())    # => 36

二、方法

方法是指与特定的类对象相关联的函数，比如前面的 __init__ 方法。
参考如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
class Circle:
    def __init__(self):
        self.radius = 1
    
    def area(self):
        return self.radius * self.radius * 3.14159

c = Circle()
c.radius = 3
print(c.area())

# => 28.27431

上面代码中的 area 方法的第一个参数仍为 self，它类似于很多语言中的 this 关键字，用于指代由类生成的实例对象本身。

类的方法定义中可以添加除 self 以外的其他参数，比如可以为 __init__ 方法关联一个 radius 参数，在实例化类的同时直接初始化一个 radius 变量，而不必在类实例创建以后手动进行额外的赋值操作。

1
2
3
4
5
6
7
8
9
10
11
class Circle:
    def __init__(self, radius=1):
        self.radius = radius

    def area(self):
        return self.radius * self.radius * 3.14159

c = Circle(3)
print(c.area())

# => 28.27431

三、静态方法与类方法

静态方法

Python 语言可以通过 @staticmethod 装饰器创建类中的静态方法。
静态方法不带 self 参数，即调用时不需要先对类进行实例化，不通过类的实例对象进行调用。它可以没有任何参数，可直接通过类名调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Circle:
    all_circles = []
    pi = 3.14159
    def __init__(self, r=1):
        self.radius = r
        self.__class__.all_circles.append(self)
    def area(self):
        return self.__class__.pi * self.radius * self.radius

    @staticmethod
    def total_area():
        total = 0
        for c in Circle.all_circles:
            total = total + c.area()
        return total

c1 = Circle(1)
c2 = Circle(2)
print(Circle.total_area())
# => 15.70795

类方法

可以使用 @classmethod 装饰器创建 Python 类中的类方法。
类方法默认有个 cls 参数（表示类本身），可以被类和实例调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Circle:
    all_circles = []
    pi = 3.14159
    def __init__(self, r=1):
        self.radius = r
        self.__class__.all_circles.append(self)

    def area(self):
        return self.__class__.pi * self.radius * self.radius

    @classmethod
    def total_area(cls):
        total = 0
        for c in cls.all_circles:
            total = total + c.area()
        return total

c1 = Circle(1)
c2 = Circle(2)
print(Circle.total_area())
# => 15.70795

PS：关于实例方法、类方法与静态方法的简要对比

实例方法

  • 定义：第一个参数必须是实例对象，一般约定为 self，通过它来传递实例的属性和方法（也可以传类的属性和方法）
  • 调用：只能由实例对象调用

类方法

  • 定义：使用装饰器 @classmethod。第一个参数必须是当前类对象，一般约定为 cls，通过它来传递类的属性和方法（不能传实例的属性和方法）
  • 调用：实例对象和类对象都可以调用

静态方法

  • 定义：使用装饰器 @staticmethod。参数随意，没有 self 和 cls 参数，方法体中不能使用类或实例的任何属性和方法
  • 调用：实例对象和类对象都可以调用

四、继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Shape:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def move(self, delta_x, delta_y):
        self.x = self.x + delta_x
        self.y = self.y + delta_y

class Square(Shape):
    def __init__(self, side=1, x=0, y=0):
        super().__init__(x, y)
        self.side = side

class Circle(Shape):
    def __init__(self, r=1, x=0, y=0):
        super().__init__(x, y)
        self.radius = r

c = Circle(1)
c.move(3, 4)
print(c.x)    # => 3
print(c.y)    # => 4

其中 super 函数用于在子类中调用父类定义的方法。
父类 Shape 中定义的 move 方法可以直接被子类实例化后的对象使用。从传统的 OOP 概念来看，即 Python 中所有的方法都是虚拟的，如某个被调用的方法在当前的类中不存在，则 Python 会尝试从它的父类中寻找同名的方法，最终使用第一个找到的结果。

五、私有变量

私有变量和私有方法是指在类中定义且在类外不可见的对象。在 Python 语言中，名称前面带双下划线（__）的变量或方法即为私有。

1
2
3
4
5
6
7
8
9
10
11
class Mine:
    def __init__(self):
        self.x = 2
        self.__y = 3
    def print_y(self):
        print(self.__y)

m = Mine()
print(m.x)    # => 2
m.print_y()    # => 3
print(m.__y)    # => AttributeError: 'Mine' object has no attribute '__y'

上面代码中的 __y 变量即为私有变量，因此当直接从类外部访问 __y 时会报出 AttributeError 错误，但是可以通过类内部定义的 print_y 方法（非私有方法）操作 __y 变量。

@property

Python 允许用户直接访问实例变量，而不需要类似于 Java 或其他面向对象语言中的 getter 或 setter 机制。Python 可以使用 property 机制完成类似的需求。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Temperature:
    def __init__(self):
        self._temp_fahr = 0
    
    @property
    def temp(self):
        return (self._temp_fahr - 32) * 5 / 9

    @temp.setter
    def temp(self, new_temp):
        self._temp_fahr = new_temp * 9 / 5 + 32

t = Temperature()
print(t._temp_fahr)    # => 0
print(t.temp)          # => -17.77777777777778

t.temp = 34
print(t._temp_fahr)    # => 93.2
print(t.temp)          # => 34.0

The Quick Python Book 3rd Edition
Python 实例方法、类方法、静态方法的区别与作用