Python OOP

最新推荐文章于 2025-07-03 23:08:22 发布

原创最新推荐文章于 2025-07-03 23:08:22 发布 · 3.5k 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#oop #面向对象 #python

python 专栏收录该内容

116 篇文章

订阅专栏

本文深入探讨Python中的类与对象概念，包括类的声明、属性查看、特殊属性介绍、对象的理解，以及静态方法、类方法、继承等核心知识点。此外，文章还介绍了新式类的高级特性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. 类的声明和创建

对于 Python 函数来说，声明与定义类没什么区别，因为他们是同时进行的，定义（类体）紧跟在声明（含 class 关键字的头行[header line])和可选(但总是推荐使用)的文档字符串后面。同时，所有的方法也必须同时被定义。

请注意 Python 并不支持纯虚函数（像 C++）或者抽象方法（如在 JAVA 中），这些都强制程序员在子类中定义方法。作为替代方法，你可以简单地在基类方法中引发 NotImplementedError 异常，这样可以获得类似的效果。

2. 有关类的属性

（1）查看类的属性

要知道一个类有哪些属性，有两种方法。最简单的是使用 dir()内建函数(也可以查看实例属性)。另外是通过访问类的字典属性__dict__，这是所有类都具备的特殊属性之一。
python

>>> class HaHa:
        """Haha to you!"""
        variable1 = "Good"
        variable2 = "Nice"
        def change(self):
            self.variable1 = "Bad"

>>> dir(HaHa)
['__doc__', '__module__', 'change', 'variable1', 'variable2']
>>> HaHa.__dict__
{'variable1': 'Good', '__module__': '__main__', 'variable2': 'Nice', '__doc__': 'Haha to you!', 'change': <function change at 0x02A9A930>}

dir()返回的仅是对象的属性的一个名字列表，而__dict__返回的是一个字典，它的键(keys)是属性名，键值(values)是相应的属性对象的数据值。

（2）类的特殊属性

C.__name__      类Ｃ的名字（字符串）
C.__doc__       类Ｃ的文档字符串
C.__bases__     类Ｃ的所有父类构成的元组
C.__dict__      类Ｃ的属性
C.__module__    类Ｃ定义所在的模块（1.5 版本新增）
C.__class__     实例Ｃ对应的类（仅新式类中）

3. 对象

（1）Understanding `new` and `init`

Understanding __new__ and __init__

（2）`del()`方法

有一个相应的特殊解构器（destructor）方法名为__del__()。然而，由于 Python 具有垃圾对象回收机制（靠引用计数)，这个函数要直到该实例对象所有的引用都被清除掉后才会执行。
Python 中的解构器是在实例释放前提供特殊处理功能的方法，它们通常没有被实现，因为实例很少被显式释放。

要注意，解构器只能被调用一次，一旦引用计数为 0，则对象就被清除了。

总结：

不要忘记首先调用父类的__del__()。
调用 del x 不表示调用了 x.__del__() —–它仅仅是减少 x 的引用计数。
如果你有一个循环引用或其它的原因，让一个实例的引用逗留不去，该对象的__del__()可能永远不会被执行。
__del__()未捕获的异常会被忽略掉（因为一些在__del__()用到的变量或许已经被删除了）。
不要在__del__()中干与实例没任何关系的事情。
除非你知道你正在干什么，否则不要去实现__del__()。
如果你定义了__del__()，并且实例是某个循环的一部分，垃圾回收器将不会终止这个循环——你需要自已显式调用 del。

（3）跟踪对象

Python 没有提供任何内部机制来跟踪一个类有多少个实例被创建了，或者记录这些实例是些什么东西。如果需要这些功能，你可以显式加入一些代码到类定义或者__init__()和__del__()中去。最好的方式是使用一个静态成员来记录实例的个数。靠保存它们的引用来跟踪实例对象是很危险的，因为你必须合理管理这些引用，不然，你的引用可能没办法释放（因为还有其它的引用）！

class InstCt(object):

    count = 0 # count is class attr

    def __init__(self): # increment count
        InstCt.count += 1

    def __del__(self): # decrement count
        InstCt.count -= 1

    def howMany(self): # return count
        return InstCt.count

>>> a = InstTrack()
>>> b = InstTrack()
>>> b.howMany()
2
>>> a.howMany()
2
>>> del b
>>> a.howMany()
1
>>> del a
>>> InstTrack.count
0

（4）类、实例的其它内建函数

issubclass() 布尔函数判断一个类是另一个类的子类或子孙类。它有如下语法：issubclass(sub, sup)
isinstance() 布尔函数在判定一个对象是否是另一个给定类的实例时，非常有用。它有如下语法：isinstance(obj1, obj2)
hasattr(), getattr(),setattr(), delattr()这些函数顾名思义，不做解释。

4. 静态方法和类方法

有两种方式声明静态方法和类方法：

使用staticmethod()和 classmethod()内建函数

class TestStaticMethod:
    def foo():
        print 'calling static method foo()'
    foo = staticmethod(foo)

class TestClassMethod:
    def foo(cls):
        print 'calling class method foo()'
        print 'foo() is part of class:', cls.__name__
    foo = classmethod(foo)

使用装饰器

class TestStaticMethod:
    @staticmethod
    def foo():
        print 'calling static method foo()'

class TestClassMethod:
    @classmethod
    def foo(cls):
        print 'calling class method foo()'
        print 'foo() is part of class:', cls.__name__

静态方法和类方法的区别：

静态方法没有cls参数，所以它既不能访问实例变量，也不能访问类变量。

5. 继承

（1）`bases`类属性

我们可以通过此属性获得父类的信息。语法:ClassName.__bases__

（2）方法覆盖(overriding)

Code example :

>>> class Parent(object):
        def foo(self):
            print 'Parent foo'


>>> class Son(Parent):
        def foo(self):  # 父类的foo方法被覆盖
            print 'Son foo'


>>> son = Son()
>>> son.foo()
Son foo

被覆盖了的父类方法可以通过super()函数在子类中调用.
Code Example :

>>> class NewSon(Parent):
        def foo(self):
            super(NewSon, self).foo()


>>> new_son = NewSon()
>>> new_son.foo()
Parent foo

注意：
子类覆盖父类的__init__()方法后，如果你想调用父类的此方法，你必须显示调用！Python默认不会帮我们做这件事。

（3）多重继承

方法解释顺序（MRO）
经典类采用的是深度优先算法（python2.2之前），而新式类采用的是广度优先算法。因为在新式类中使用深度优先，会出现菱形效应。

假设我们有如下继承结构的类：
这里写图片描述
左边为经典类情况下，右边为新式类情况下。在新式类下B，C都继承自object类。

在新式类(右边继承结构)中采用旧的深度优先算法，假设在D的实例d中调用foo()方法，对于此方法的搜索顺序是D->B->A->C；采用广度优先算法，搜索顺序为D->B->C-A。因为D继承了B、C,多数情况下我们更希望首先搜索的是C而不是A，因为假设A、C中都有foo()方法时，你可能觉得A中的foo()方法太过通用了。很典型的就是__init__()方法。

（4）从标准类派生

比如你想从float类派生出一个子类，这都是很常见的需求。下面看两个例子：

继承float类

>>> class RoundFloat(float):                                             
...     def __new__(cls, val):                                           
...             return super(RoundFloat, cls).__new__(cls, round(val, 2))
...                                                                      
>>> RoundFloat(1.5955)                                                   
1.6

我们派生了一个可以自动四舍五入到两位小数的RoundFloat类。

继承dict类

>>> class SortedKeyDict(dict):
...     def keys(self):
...             return sorted(super(SortedKeyDict, self).keys())
...
>>> dict1 = SortedKeyDict((('wang', 1), ('jiang', 2), ('guo', 3), ('han', 4)))
>>> dict1.keys()  # 排序了
['guo', 'han', 'jiang', 'wang']
>>> [key for key in dict1]  # 散列顺序
['guo', 'jiang', 'wang', 'han']

6. 特殊方法定制类

Python中有很多特殊方法，它们是以__开头和结尾的。使用它们可以实现：

模拟标准类型
重载操作符

7. 私有化

Python 为类元素（属性和方法）的私有性提供初步的形式。由双下划线开始的属性在运行时被“混淆”(mixin)，所以直接访问是不允许的。

混淆会在名字前面加下划线和类名。比如，以例NumStr类中的 self.__num 属性为例，被“混淆”后，用于访问这个数据值的标识就变成了self._NumStr__num。把类名加上后形成的新的“混淆”结果将可以防止在祖先类或子孙类中的同名冲突。

8. 包装和授权

（1）包装(wrapping)

定义：
对一个已存在的对象进行包装，不管它是数据类型，还是一段代码，可以是对一个已存在的对象，增加新的，删除不要的，或者修改其它已存在的功能。你可以包装任何类型作为一个类的核心成员，以使新对象的行为模仿你想要的数据类型中已存在的行为，并且去掉你不希望存在的行为。

包装类：
你可以包装类，但是实际上没有必要。因为你完全可以通过派生实现相同的效果。

（2）授权

简介：
授权是包装的一个特性，采用已存在的功能以达到最大限度的代码重用。包装一个类型通常是对已存在的类型的一些定制。授权的过程，即是所有更新的功能都是由新类的某部分来处理，但已存在的功能就授权给已存在的对象的默认属性。

实现授权：
实现授权的关键点就是覆盖__getattr__()方法，在代码中包含一个对 getattr()内建函数的调用。特别地，调用 getattr()以得到默认对象属性（数据属性或者方法）并返回它以便访问或调用。特殊方法__getattr__()的工作方式是，当搜索一个属性时，任何局部对象首先被找到（定制的对象）。如果搜索失败了，则__getattr__()会被调用，然后调用 getattr()得到一个对象的默认行为。

我们来实现一个包装文件对象的例子：

>>> class UpperFile(object):
...     def __init__(self, fn, mode='r', buf=-1):
...             self.file = open(fn, mode, buf)
...     def __str__(self):
...             return str(self.file)
...     def __repr__(self):
...             return '%s' % self.file
...     def write(self, line):
...             self.file.write(line.upper())
...     def __getattr__(self, attr):
...             return getattr(self.file, attr)
...
>>> f = UpperFile(r'C:\test.txt', 'w')
>>> f.write('abcde')
>>> f.close()
>>> f
<open file 'C:\\test.txt', mode 'w' at 0x029F1D88>

我们包装了open()函数返回的文件对象。改写了write()方法。当使用包装后的类实例化的对象调用write()方法时，使用的是修改的方法；当调用close()方法时，因为我们并没有改动此方法，则授权给原始文件对象，调用它的close()方法。

9. 新式类的高级特性

（1）工厂函数

在python中，所有的内建转换函数都是工厂函数。当这些函数被调用时，实际上是对相应的类型实例化。

类型测试：
使用

isinstance(obj, int)

也可以使用

isinstance(obj, (int, bool))

检测obj是否是int或者bool类型。

但要注意：尽管 isinstance()很灵活，但它没有执行“严格匹配”比较—-如果 obj 是一个给定类型的实例或其子类的实例，也会返回 True。但如果想进行严格匹配，你仍然需要使用 is 操作符:

type(obj) is int

（2）`slots`类属性

__dict__属性跟踪所有实例属性，以字典格式存储（属性名为key，属性值为value）。字典会占据大量内存，如果你有一个属性数量很少的类，但有很多实例，那么正好是这种情况。为内存上的考虑，用户现在可以使用__slots__属性来替代__dict__。

__slots__是一个类变量，由一序列型对象组成，由所有合法标识构成的实例属性的集合来表示。它可以是一个列表，元组或可迭代对象。也可以是标识实例能拥有的唯一的属性的简单字符串。任何试图创建一个其名不在__slots__中的名字的实例属性都将导致 AttributeError 异常

Code Example :

>>> class SlottedClass(object):
...     __slots__ = ('foo', 'bar')
...
>>> c = SlottedClass()
>>> c.foo = 12
>>> c.xx = 12
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'SlottedClass' object has no attribute 'xx'