下面小编就为大家带来一篇基于python3 类的属性、方法、封装、继承实例讲解。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Python 类
Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。
对象可以包含任意数量和类型的数据。
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__乘运算
__p__除运算
__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__方法运行：
方法
实例方法：只能通过实例调用，实例方法第一个定义的参数只能是实例本身引用
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参数变量。区别于在类中调用普通函数时并不需要带上self参数
3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。
如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。
语法：
派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后。
多态
如果父类方法的功能不能满足需求，可以在子类重写父类的方法。实例对象调用方法时会调用其对应子类的重写后的方法
python3.3 类与继承 小例
hon中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。
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__乘运算
__p__除运算
__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))Atas ialah kandungan terperinci 基于python3 类的属性、方法、封装、继承详解. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
laman web rasmi okex
Apakah peralatan yang diperlukan untuk siaran langsung Douyin?
proses paparan linux
Bagaimana untuk mengira bayaran pengendalian bayaran balik keretapi 12306
Cara membuat klon WeChat pada telefon bimbit Huawei
Bagaimana untuk melihat prosedur tersimpan dalam MySQL
Trend harga terkini Bitcoin
fail nh
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
