Python 面向对象

Python从设计开始就是面向对象的语言。正因为如此，用Python创建一个类和对象是很容易的。在本章中，我们将详细介绍Python的面向对象编程。
如果你之前没有接触过面向对象的编程语言，你可能需要了解面向对象语言的一些基本特性，并在脑海中形成一个基本的面向对象概念，这将有助于你更容易地学习Python的面向对象编程。
接下来，我们将简要了解面向对象的一些基本特性。
面向对象技术简介
类:用于描述具有相同属性和方法的对象的集合。它定义集合中每个对象共有的属性和方法。对象是类的实例。
类变量:类变量在整个实例化对象中是通用的。类变量在类中和函数体之外定义。类变量通常不用作实例变量。
数据成员:类变量或实例变量，用于处理类及其实例对象的相关数据。
方法覆盖:如果从父类继承的方法不能满足子类的需要，可以被覆盖。这个过程称为方法重写，也称为方法重写。
局部变量:方法中定义的变量，只作用于当前实例的类。
实例变量:在类的声明中，属性由变量表示。这种变量称为实例变量，在类声明中声明，但在类的其他成员方法之外声明。
继承:派生类继承基类的字段和方法。继承还允许将派生类的对象视为基类对象。例如，有一种设计，其中狗类型的对象是从动物类派生的，它模拟了“是-一”关系(在插图中，狗是一种动物)。
实例化:创建一个类的实例，一个类的具体对象。
方法:类中定义的函数。
对象:由类定义的数据结构的实例。对象包括两个数据成员(类变量和实例变量)和方法。
创建类
使用class语句创建一个新类，后跟该类的名称，并以冒号结尾:
类别类别名称:
“#class”类文档字符串的帮助信息
Class_suite#类体
可以通过类名查看类帮助信息。__doc__。
Class_suite由类成员、方法和数据属性组成。
例子
下面是一个简单的Python类的示例:
例子
#!/usr/bin/python
#-*-编码:UTF-8-*-
员工类别:
所有员工的基本类别
empCount=0
def__init__(自我，姓名，工资):
self.name=name
薪水=薪水
Employee.empCount+=1
def显示计数(自身):
打印“员工总数%d”%Employee.empcount
定义显示员工(自己):
打印“姓名:“，自我。姓名，”，工资:“，自我。工资
empCount变量是一个类变量，它的值将在这个类的所有实例之间共享。您可以使用Employee.empCount访问内部类或外部类。
第一个方法是__init__()方法，它是一种特殊的方法，称为类的构造函数或初始化方法，在创建该类的实例时调用。
Self代表一个类的实例，在定义一个类的方法时是必须的，虽然在调用时不需要传入相应的参数。
Self代表一个类的实例，而不是一个类
类的方法和普通函数只有一个特殊的区别——它们必须有一个额外的第一个参数名，传统上称为self。
班级测试:
defprt(自):
打印(自我)
打印(自我。__class__)
t=测试()
t.prt()
上面例子的执行结果是:
__main__。测试
从执行结果可以清楚地看到，self表示类的实例和当前对象的地址，而self。__class__指向该类。
Self不是python关键字，如果改成runoob就可以正常执行了:
例子
班级测试:
defprt(runoob):
打印(runoob)
打印(runoob。__class__)
t=测试()
t.prt()
上面例子的执行结果是:
__main__。测试
创建实例对象
在其他编程语言中，一般使用关键字new来实例化类，但是在Python中找不到这个关键字。类实例化类似于函数调用。
下面用类的名称Employee实例化，并通过__init__方法接收参数。
“创建雇员类的第一个对象”
emp1=雇员(“Zara”，2000年)
“创建雇员类的第二个对象”
emp2=员工(“曼尼”，5000)
访问属性
可以用点。访问对象的属性。使用下列类名访问类变量:
emp1.displayEmployee()
emp2.displayEmployee()
打印“员工总数%d”%Employee.empcount
完整示例:
例子
#!/usr/bin/python
#-*-编码:UTF-8-*-
员工类别:
所有员工的基本类别
empCount=0
def__init__(自我，姓名，工资):
self.name=name
薪水=薪水
Employee.empCount+=1
def显示计数(自身):
打印“员工总数%d”%Employee.empcount
定义显示员工(自己):
打印“姓名:“，自我。姓名，”，工资:“，自我。工资
“创建雇员类的第一个对象”
emp1=雇员(“Zara”，2000年)
“创建雇员类的第二个对象”
emp2=员工(“曼尼”，5000)
emp1.displayEmployee()
emp2.displayEmployee()
打印“员工总数%d”%Employee.empcount
执行上述代码的输出结果如下:
姓名:扎拉，工资:2000
姓名:曼尼，工资:5000
员工总数2
您可以添加、删除和修改类的属性，如下所示:
Emp1.age=7#添加“age”属性
Emp1.age=8#修改“age”属性
删除“年龄”属性
您也可以使用以下函数来访问属性:
Getattr(obj，name[，default]):访问对象的属性。
Hasattr(obj，name):检查是否有属性。
Setattr(obj，name，value):设置属性。如果该属性不存在，则会创建一个新属性。
Delattr(obj，name):删除属性。
Hasattr(emp1，“age”)#如果“age”属性存在，则返回True。
Getattr(emp1，“age”)#返回“age”属性的值
Setattr(emp1，“age”，8)#添加值为8的属性“age”
Delattr(emp1，“年龄”)#删除属性“年龄”
Python内置的类属性
__dict___:类的属性(包括由类的数据属性组成的字典)
__doc___:类的文档字符串
__name___:类名
__module__:类定义所在的模块(该类的全名是“__main__”。如果类位于导入模块mymod中，则为类名称。__module__等于mymod)
__bases__:一个类的所有父类构成元素(包括由所有父类组成的元组)
Python内置类属性调用的示例如下:
例子
#!/usr/bin/python
#-*-编码:UTF-8-*-
员工类别:
所有员工的基本类别
empCount=0
def__init__(自我，姓名，工资):
self.name=name
薪水=薪水
Employee.empCount+=1
def显示计数(自身):
打印“员工总数%d”%Employee.empcount
定义显示员工(自己):
打印“姓名:“，自我。姓名，”，工资:“，自我。工资
打印“员工”。__doc__::，员工。__doc__
打印“员工”。__姓名__::，员工。__名称__
打印“员工”。__模块__::，员工。__模块__
打印“员工”。__基础__::，员工。__基础__
打印“员工”。__格言__::，员工。__格言__
执行上述代码的输出结果如下:
员工。__doc___:所有员工的基类
员工。__姓名__:员工
员工。__模块__:__main__
员工。__碱基__:()
员工。__dict__:{‘__module__’:’__main__’，’displayCount’:，’empCount’:0，’displayEmployee’:，__doc_’:’\xe6\x89\X80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xb1\xbb’，’__init_’:}
Python对象销毁(垃圾收集)
Python使用简单的引用计数技术来跟踪和回收垃圾。
在Python中，记录所有在用对象的引用次数。
称为参考计数器的内部跟踪变量。
创建对象时，会创建引用计数。当不再需要该对象时，即当该对象的引用计数变为0时，它被垃圾收集。但是恢复不是“即时”的，解释器会在适当的时候恢复垃圾对象占用的内存空间。
A=40#创建对象
增加引用的数量
C=[b]#增加引用数
Dela#减少引用的数量
B=100#减少引用的数量
C[0]=-1#减少引用的数量
垃圾收集机制不仅可以处理引用计数为0的对象，还可以处理循环引用。循环引用是指两个对象相互引用，但没有其他变量引用它们。在这种情况下，仅使用引用计数是不够的。Python中的垃圾收集器实际上是一个引用计数器和循环垃圾收集器。作为对引用计数的补充，垃圾收集器还会关注大量分配的对象(即那些没有被引用计数破坏的对象)。在这种情况下，解释器暂停并尝试清除所有未引用的循环。
例子
对象被销毁时调用析构函数__del__，__del__。当对象不再使用时，__del__方法运行:
例子
#!/usr/bin/python
#-*-编码:UTF-8-*-
分类点:
def__init__(self，x=0，y=0):
self.x=x
self.y=y
def__del__(自我):
class_name=self。__class__。__名称__
打印类名，“销毁”
pt1=点()
pt2=pt1
pt3=pt1
打印对象的打印id(pt1)、id(pt2)、id(pt3)#id
delpt1
delpt2
delpt3
上述示例的运行结果如下:
308340132430834013243083401324
点破坏
注意:通常你需要在一个单独的文件中定义一个类。
阶级继承
面向对象编程的主要好处之一是代码重用，而实现这种重用的途径之一就是通过继承机制。
继承创建的新类称为子类或派生类，继承的类称为基类、父类或超类。
继承语法
类派生类名称(基类名称)
…
python中继承的一些特征:
1.如果子类中需要父类的构造函数，需要显式调用父类的构造函数，或者不重写父类的构造函数。详细描述可以看如下:python子类继承父类构造函数的描述。
2.调用基类的方法时，在基类的类名前加前缀，并带自参数变量。不同的是，在类中调用普通函数时，不需要带self参数
3.Python总是先寻找对应类型的方法。如果在派生类中找不到对应的方法，就开始在基类中一个一个的找。(先在这个类中查找被调用的方法，如果找不到就在基类中查找。).
如果继承元组中列出了多个类，则称为“多重继承”。
语法:
派生类的声明与其父类相似，继承的基类列表跟随类名，如下所示:
class子类名称(ParentClass1[，ParentClass2，…]):
…
例子
#!/usr/bin/python
#-*-编码:UTF-8-*-
类父类:#定义父类
parentAttr=100
def__init__(self):
打印“调用父类构造函数”
defparentMethod(自身):
打印“调用父类方法”
defsetAttr(self，Attr):
Parent.parentAttr=attr
defgetAttr(自):
打印”父类属性:”，Parent.parentAttr
类别子(父):#定义一个子类
def__init__(self):
打印“调用子类构造函数”
def子方法(自身):
打印“调用子类方法”
C=Child()#实例化一个子类
C.childMethod()#调用子类的方法
C.parentMethod()#调用父类方法
C.setAttr(200)#再次调用父类的方法——设置属性值
C.getAttr()#再次调用父类的方法——获取属性值
以上代码执行结果如下:
调用子类构造函数
调用子类方法
调用父类方法
父类属性:200
您可以继承多个类
A类:#定义A类。
…..
B类:#定义B类。
…..
C类(A，B):#继承A类和B类。
…..
您可以使用issubclass()或isinstance()方法来检测。
issubclass()-判断一个类是子类还是另一个类的后代的布尔函数，语法:issubclass(sub，sup)
如果对象是类的实例对象或子类的实例对象，isinstance(obj，Class)布尔函数返回true。
过度浸渍法
如果父类方法的功能不能满足您的需要，您可以在子类中重写父类方法:
示例:
例子
#!/usr/bin/python
#-*-编码:UTF-8-*-
父类:#定义父类
定义我的方法(自身):
打印“调用父类方法”
类别子(父):#定义一个子类
定义我的方法(自身):
打印“调用子类方法”
C=Child()#子类实例
C.mymethod()#子类调用重写方法