Python3 面向对象编程核心：类、属性、方法与继承详解
本文深入讲解 Python3 中面向对象编程的核心概念，涵盖类的定义、实例化、属性访问与封装机制。详细解析构造函数 __init__ 与析构函数 __del__ 的使用，区分实例方法、类方法与静态方法的调用差异。通过多重继承、多态及私有属性实现原理（名称改写），结合代码示例展示如何高效复用代码并管理访问权限。
Python 类
Python 中的类实现了面向对象编程的基础功能。其继承机制支持多基类，派生类可重写基类方法，并在方法内部调用基类同名方法。
对象可存储任意数量和类型的数据。
Python 类与 C++ 类相似，支持封装、继承、多继承、构造函数及析构函数。
在 Python3 中，所有类的顶层父类均为 object。若定义类时未指定父类，object 即为其直接父类，这与 Java 类似。
类定义
类定义的语法格式如下：
class ClassName: <statement-1> . . . <statement-N>
类对象：创建类后，可通过类名访问或修改其属性与方法。
实例对象：类实例化后，可使用其属性，并可动态为实例添加属性（类似 JavaScript），这不会影响类对象本身。
类的属性
可使用点号（.）访问对象属性。
也可通过以下函数方式访问属性：
getattr(obj, name[, default])：访问对象属性。
hasattr(obj, name)：检查属性是否存在。
setattr(obj, name, value)：设置属性，若不存在则创建新属性。
delattr(obj, name)：删除属性。
Python 内置类属性
__dict__：包含类的数据属性字典。
__doc__：类的文档字符串。
__name__：类名。
__module__：类定义所在的模块（全名为 '__main__.className'，若在模块 mymod 中导入，则等于 mymod）。
__bases__：包含所有父类的元组。
class Person:
"Person类"
def __init__(self, name, age, gender):
print('进入Person的初始化')
self.name = name
self.age = age
self.gender = gender
print('离开Person的初始化')
def getName(self):
print(self.name)
p = Person('ice', 18, '男')
print(p.name) # ice
print(p.age) # 18
print(p.gender) # 男
print(hasattr(p, 'weight')) # False
# 为p添加weight属性
p.weight = '70kg'
print(hasattr(p, 'weight')) # True
print(getattr(p, 'name')) # ice
print(p.__dict__) # {'age': 18, 'gender': '男', 'name': 'ice'}
print(Person.__name__) # Person
print(Person.__doc__) # Person类
print(Person.__dict__) # {'__doc__': 'Person类', '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__init__': <function Person.__init__ at 0x000000000284E950>, 'getName': <function Person.getName at 0x000000000284EA60>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__module__': '__main__'}
print(Person.__mro__) # (<class '__main__.Person'>, <class 'object'>)
print(Person.__bases__) # (<class 'object'>,)
print(Person.__module__) # __main__
类的方法
在类内部使用 def 定义方法，与常规函数不同，类方法必须包含参数 self 且为第一个参数。
类的专有方法：
__init__ 构造函数，生成对象时调用。
__del__ 析构函数，释放对象时使用。
__repr__ 打印与转换。
__setitem__ 按索引赋值。
__getitem__ 按索引获取值。
__len__ 获取长度。
__cmp__ 比较运算。
__call__ 函数调用。
__add__ 加运算。
__sub__ 减运算。
__mul__ 乘运算。
__div__ 除运算。
__mod__ 求余运算。
__pow__ 乘方。
__init__() 是特殊方法，称为构造函数或初始化方法，创建实例时调用，类似 C++ 构造函数。只需在自定义类中重写该方法即可。
class Person:
def __init__(self, name, age, gender):
print('进入Person的初始化')
self.name = name
self.age = age
self.gender = gender
print('离开Person的初始化')
def getName(self):
print(self.name)
# Person实例对象
p = Person('ice', 18, '男')
print(p.name)
print(p.age)
print(p.gender)
p.getName()
# 进入Person的初始化
# 离开Person的初始化
# ice
# 18
# 男
# ice
析构函数 __del__ 在对象消逝时调用，当对象不再使用时运行：
方法
实例方法：仅能通过实例调用，第一个参数必须是实例本身引用。
class Myclass:
def foo(self):
print(id(self),'foo')
a=Myclass()#既然是实例对象，那就要创建实例
a.foo()#输出类里的函数地址
print(id(a))#输出类对象的地址
#结果地址一样
类方法：使用装饰器 @classmethod 定义，第一个参数为类对象引用，可通过类或实例直接调用。
class Myclass:
@classmethod#类装饰器
def foo2(cls):
print(id(cls),'foo2')
#类对象，直接可以调用，不需要实例化
print(id(Myclass),'yy')
Myclass.foo2()#直接可以调用
静态方法：使用装饰器 @staticmethod 定义，无默认必须参数，通过类和实例直接调用。
class Myclass:
@staticmethod#静态方法
def foo3():
print('foo3')
Myclass.foo3()#没有参数
a.foo3()
#结果foo3
类的封装
Python 通过变量名命名区分访问权限，默认权限相当于 C++ 和 Java 中的 public。
类的私有属性：以两个下划线开头（__private_attrs），声明为私有，不能在类外部使用或直接访问。在类内部方法中使用 self.__private_attrs。
类的私有方法：以两个下划线开头（__private_method），声明为私有，不能在类外部调用。在类内部调用 self.__private_methods。
虽然 Python 不允许直接访问私有数据，但可使用 object._className__attrName 访问。Python 内部私有化实现仅是将 attrName 变为 _className__attrName。
class Demo:
__id = 123456
def getId(self):
return self.__id
temp = Demo()
# print(temp.__id) # 报错 AttributeError: 'Demo' object has no attribute '__id'
print(temp.getId()) # 123456
print(temp._Demo__id) # 123456
类的继承
面向对象编程的主要好处之一是代码重用，继承是实现重用的机制之一，可理解为类之间的类型和子类型关系。
注意：继承语法 class 派生类名（基类名）：//... 基类名在括号内，定义时指明于元组中。
Python 继承特点：
1：基类构造（__init__()）不会自动调用，需在派生类构造中专门调用。使用 super().__init__() 或 parentClassName.__init__()。
2：调用基类方法时，需加上基类名前缀并带上 self 参数。这与调用普通函数不同。
3：Python 优先在派生类中查找方法，若未找到才在基类中查找（先本类后基类）。
若继承元组中包含多个类，称为“多重继承”。
语法：
派生类声明与父类类似，基类列表跟在类名之后。
多态
若父类方法功能不足，可在子类重写父类方法。实例调用方法时，将调用子类重写后的方法。
Python3.3 类与继承小例
Python 中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。
class Base:
def __init__(self):
self.data=[]
def add(self,x):
self.data.append(x)
def addtwice(self,x):
self.add(x)
self.add(x)
# child extends base
class Child(Base):
def plus(self,a,b):
return a+b
oChild=Child()
oChild.add("str1")
oChild.add(999)
oChild.addtwice(4)
print(oChild.data)
print(oChild.plus(2,3))
对象可以包含任意数量和类型的数据。
Python 类与 C++ 类相似，提供了类的封装，继承、多继承，构造函数、析构函数。
在 Python3 中，所有类最顶层父类都是 object 类，与 Java 类似，如果定义类的时候没有写出父类，则 object 类就是其直接父类。
类定义
类定义语法格式如下：
class ClassName: <statement-1> . . . <statement-N>
类对象：创建一个类之后，可以通过类名访问、改变其属性、方法
实例对象：类实例化后，可以使用其属性，可以动态的为实例对象添加属性(类似 JavaScript)而不影响类对象。
类的属性
可以使用点(.)来访问对象的属性
也可以使用以下函数的方式来访问属性：
getattr(obj, name[, default]) : 访问对象的属性
hasattr(obj,name) : 检查是否存在一个属性 setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性
delattr(obj, name) : 删除属性
Python 内置类属性
__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
__doc__ :类的文档字符串
__name__: 类名
__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块 mymod 中，那么 className.__module__ 等于 mymod）
__bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组）
class Person:
"Person类"
def __init__(self, name, age, gender):
print('进入Person的初始化')
self.name = name
self.age = age
self.gender = gender
print('离开Person的初始化')
def getName(self):
print(self.name)
p = Person('ice', 18, '男')
print(p.name) # ice
print(p.age) # 18
print(p.gender) # 男
print(hasattr(p, 'weight')) # False
# 为p添加weight属性
p.weight = '70kg'
print(hasattr(p, 'weight')) # True
print(getattr(p, 'name')) # ice
print(p.__dict__) # {'age': 18, 'gender': '男', 'name': 'ice'}
print(Person.__name__) # Person
print(Person.__doc__) # Person类
print(Person.__dict__) # {'__doc__': 'Person类', '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__init__': <function Person.__init__ at 0x000000000284E950>, 'getName': <function Person.getName at 0x000000000284EA60>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__module__': '__main__'}
print(Person.__mro__) # (<class '__main__.Person'>, <class 'object'>)
print(Person.__bases__) # (<class 'object'>,)
print(Person.__module__) # __main__
类的方法
在类地内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数。
类的专有方法：
__init__ 构造函数，在生成对象时调用
__del__ 析构函数，释放对象时使用
__repr__ 打印，转换
__setitem__按照索引赋值
__getitem__按照索引获取值
__len__获得长度
__cmp__比较运算
__call__函数调用
__add__加运算
__sub__减运算
__mul__乘运算
__div__除运算
__mod__求余运算
__pow__称方
__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法，与 C++ 中构造函数类似。只需在自定义的类中重写 __init__()方法即可。
class Person:
def __init__(self, name, age, gender):
print('进入Person的初始化')
self.name = name
self.age = age
self.gender = gender
print('离开Person的初始化')
def getName(self):
print(self.name)
# Person实例对象
p = Person('ice', 18, '男')
print(p.name)
print(p.age)
print(p.gender)
p.getName()
# 进入Person的初始化
# 离开Person的初始化
# ice
# 18
# 男
# ice
析构函数 __del__ ，__del__在对象消逝的时候被调用，当对象不再被使用时，__del__方法运行：
类的封装
Python 通过变量名命名来区分属性和方法的访问权限，默认权限相当于 C++ 和 Java 中的 public
类的私有属性： __private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
类的私有方法：__private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 self.__private_methods
虽然 Python 不允许实例化的类访问私有数据，但可以使用 object._className__attrName 访问属性。其实 Python 内部私有化的实现只是将 attrName 属性变为了 _className__attrName 而已
class Demo:
__id = 123456
def getId(self):
return self.__id
temp = Demo()
# print(temp.__id) # 报错 AttributeError: 'Demo' object has no attribute '__id'
print(temp.getId()) # 123456
print(temp._Demo__id) # 123456
类的继承
面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。
需要注意的地方：继承语法 class 派生类名（基类名）：//... 基类名写作括号里，基本类是在类定义的时候，在元组之中指明的。
在 Python 中继承中的一些特点：
1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。使用 super().__init__()或 parentClassName.__init__()
2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上 self 参数变量。区别于在类中调用普通函数时并不需要带上 self 参数
3：Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。
如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。
语法：
派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后。
多态
如果父类方法的功能不能满足需求，可以在子类重写父类的方法。实例对象调用方法时会调用其对应子类的重写后的方法
Python3.3 类与继承 小例
class Base:
def __init__(self):
self.data=[]
def add(self,x):
self.data.append(x)
def addtwice(self,x):
self.add(x)
self.add(x)
# child extends base
class Child(Base):
def plus(self,a,b):
return a+b
oChild=Child()
oChild.add("str1")
oChild.add(999)
oChild.addtwice(4)
print(oChild.data)
print(oChild.plus(2,3))
以上这篇基于 Python3 类的属性、方法、封装、继承实例讲解就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持本站。
免责声明：本文内容仅供参考，不代表本站观点。转载或引用请注明出处。
