📌  相关文章
📜  Python 3-面向对象

📅  最后修改于: 2020-12-23 04:57:58             🧑  作者: Mango

自从存在以来， Python就一直是一种面向对象的语言。因此，创建和使用类和对象非常容易。本章可帮助您成为使用Python的面向对象编程支持的专家。

如果您以前没有使用面向对象(OO)编程的经验，则可能需要查阅有关它的入门课程或至少某种形式的教程，以便掌握基本概念。

但是，这里仅介绍一下面向对象编程(OOP)，以帮助您-

OOP术语概述

  • 类-对象的用户定义原型，该原型定义了表征该类任何对象的一组属性。属性是数据成员(类变量和实例变量)和方法，可通过点表示法进行访问。

  • 类变量-由类的所有实例共享的变量。类变量是在类内定义的，但是在类的任何方法之外。类变量的使用没有实例变量那么频繁。

  • 数据成员-保存与类及其对象关联的数据的类变量或实例变量。

  • 函数重载-将多个行为分配给特定函数。所执行的操作因所涉及的对象或参数的类型而异。

  • 实例变量-在方法内部定义的变量，仅属于类的当前实例。

  • 继承-将一个类的特征转移到从该类派生的其他类。

  • 实例-某个类的单个对象。例如，属于Circle类的对象obj是Circle类的实例。

  • 实例化-创建一个类的实例。

  • 方法-在类定义中定义的一种特殊函数。

  • 对象-由其类定义的数据结构的唯一实例。对象包含数据成员(类变量和实例变量)和方法。

  • 运算符重载-将多个函数分配给特定的运算符。

创建课程

class语句创建一个新的类定义。该类的名称紧随关键字class之后紧跟冒号，如下所示-

class ClassName:
   'Optional class documentation string'
   class_suite

  • 该类具有一个文档字符串，可以通过ClassName .__ doc__进行访问。

  • class_suite由定义类成员，数据属性和函数的所有组件语句组成。

例

以下是一个简单的Python类的示例-

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print ("Total Employee %d" % Employee.empCount)

   def displayEmployee(self):
      print ("Name : ", self.name,  ", Salary: ", self.salary)

  • 变量empCount是一个类变量，其值在此类中的所有实例之间共享。可以从类内部或类外部以Employee.empCount的形式进行访问。

  • 第一个方法__init __()是一个特殊方法，称为类构造函数或初始化方法，当您创建此类的新实例时Python调用该方法。

  • 您声明其他类方法(如普通函数)，但每个方法的第一个参数是self 。 Python为您将self参数添加到列表中；调用方法时不需要包含它。

创建实例对象

要创建类的实例，请使用类名称调用该类，然后传递其__init__方法接受的任何参数。

This would create first object of Employee class
emp1 = Employee("Zara", 2000)
This would create second object of Employee class
emp2 = Employee("Manni", 5000)

访问属性

您可以使用带点运算符和对象来访问对象的属性。将使用类名称访问类变量，如下所示：

emp1.displayEmployee()
emp2.displayEmployee()
print ("Total Employee %d" % Employee.empCount)

现在，将所有概念放在一起-

现场演示
#!/usr/bin/python3

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print ("Total Employee %d" % Employee.empCount)

   def displayEmployee(self):
      print ("Name : ", self.name,  ", Salary: ", self.salary)


#This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
#This would create second object of Employee class"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print ("Total Employee %d" % Employee.empCount)

执行以上代码后，将产生以下结果-

Name :  Zara ,Salary:  2000
Name :  Manni ,Salary:  5000
Total Employee 2

您可以随时添加，删除或修改类和对象的属性-

emp1.salary = 7000  # Add an 'salary' attribute.
emp1.name = 'xyz'  # Modify 'age' attribute.
del emp1.salary  # Delete 'age' attribute.

除了使用普通语句访问属性外，还可以使用以下功能-

  • getattr(obj，name [，default]) -访问对象的属性。

  • hasattr(obj，name) -检查属性是否存在。

  • setattr(obj，name，value) -设置属性。如果属性不存在，则将创建它。

  • delattr(obj，name) -删除属性。

hasattr(emp1, 'salary')    # Returns true if 'salary' attribute exists
getattr(emp1, 'salary')    # Returns value of 'salary' attribute
setattr(emp1, 'salary', 7000) # Set attribute 'salary' at 7000
delattr(emp1, 'salary')    # Delete attribute 'salary'

内置类属性

每个Python类都遵循以下内置属性，并且可以像其他任何属性一样使用点运算符来访问它们-

  • __dict__-包含类名称空间的字典。

  • __doc__-类文档字符串，如果未定义，则为无。

  • __name__-类名。

  • __module__-定义类的模块名称。在交互模式下，此属性为“ __main__”。

  • __bases__-包含基类的可能为空的元组，按照基类在基类列表中的出现顺序排列。

对于上面的类，让我们尝试访问所有这些属性-

现场演示
#!/usr/bin/python3

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print ("Total Employee %d" % Employee.empCount)

   def displayEmployee(self):
      print ("Name : ", self.name,  ", Salary: ", self.salary)

emp1 = Employee("Zara", 2000)
emp2 = Employee("Manni", 5000)
print ("Employee.__doc__:", Employee.__doc__)
print ("Employee.__name__:", Employee.__name__)
print ("Employee.__module__:", Employee.__module__)
print ("Employee.__bases__:", Employee.__bases__)
print ("Employee.__dict__:", Employee.__dict__ )

执行以上代码后，将产生以下结果-

Employee.__doc__: Common base class for all employees
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: (,)
Employee.__dict__: {
   'displayCount': , 
   '__module__': '__main__', '__doc__': 'Common base class for all employees', 
   'empCount': 2, '__init__': 
   , 'displayEmployee': 
   ,
   '__weakref__': 
   , '__dict__': 
   
}

销毁物体(垃圾收集)

Python删除不需要的对象(内置类型或类实例)以释放内存空间。 Python定期回收不再使用的内存块的过程称为垃圾收集。

Python的垃圾收集器在程序执行期间运行，并在对象的引用计数达到零时触发。对象的引用计数随指向它的别名数量的变化而变化。

当为对象分配新名称或将其放置在容器(列表，元组或字典)中时，其引用计数就会增加。当用del删除对象，重新分配其引用或引用超出范围时，该对象的引用计数会减少。当对象的引用计数达到零时， Python会自动收集它。

a = 40      # Create object <40>
b = a       # Increase ref. count  of <40> 
c = [b]     # Increase ref. count  of <40> 

del a       # Decrease ref. count  of <40>
b = 100     # Decrease ref. count  of <40> 
c[0] = -1   # Decrease ref. count  of <40>

通常，您不会注意到垃圾收集器销毁一个孤立实例并回收其空间的时间。但是，一个类可以实现称为析构函数的特殊方法__del __() ，该方法将在实例即将被销毁时调用。此方法可能用于清除实例使用的任何非内存资源。

例

这个__del __()析构函数输出将要销毁的实例的类名-

现场演示
#!/usr/bin/python3

class Point:
   def __init__( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print (class_name, "destroyed")

pt1 = Point()
pt2 = pt1
pt3 = pt1
print (id(pt1), id(pt2), id(pt3))   # prints the ids of the obejcts
del pt1
del pt2
del pt3

执行以上代码后，将产生以下结果-

140338326963984 140338326963984 140338326963984
Point destroyed

注–理想情况下，您应该在单独的文件中定义类，然后使用import语句将它们导入到主程序文件中。

在上面的示例中，假设Point.py中包含Point类的定义，并且其中没有其他可执行代码。

#!/usr/bin/python3
import point

p1 = point.Point()

类继承

除了从头开始，您还可以通过在新类名称后面的括号中列出父类来从现有类派生该类，从而创建一个类。

子类继承其父类的属性，您可以使用这些属性，就像它们是在子类中定义的一样。子类也可以覆盖父类的数据成员和方法。

句法

派生类的声明与父类很相似；但是，在类名称后给出了要继承的基类列表-

class SubClassName (ParentClass1[, ParentClass2, ...]):
   'Optional class documentation string'
   class_suite

例

现场演示
#!/usr/bin/python3

class Parent:        # define parent class
   parentAttr = 100
   def __init__(self):
      print ("Calling parent constructor")

   def parentMethod(self):
      print ('Calling parent method')

   def setAttr(self, attr):
      Parent.parentAttr = attr

   def getAttr(self):
      print ("Parent attribute :", Parent.parentAttr)

class Child(Parent): # define child class
   def __init__(self):
      print ("Calling child constructor")

   def childMethod(self):
      print ('Calling child method')

c = Child()          # instance of child
c.childMethod()      # child calls its method
c.parentMethod()     # calls parent's method
c.setAttr(200)       # again call parent's method
c.getAttr()          # again call parent's method

执行以上代码后，将产生以下结果-

Calling child constructor
Calling child method
Calling parent method
Parent attribute : 200

以类似的方式，您可以从多个父类驱动一个类，如下所示：

class A:        # define your class A
.....

class B:         # define your calss B
.....

class C(A, B):   # subclass of A and B
.....

您可以使用issubclass()或isinstance()函数来检查两个类和实例之间的关系。

  • 如果给定的子类sub确实是超类sup的子类，则issubclass(sub，sup)布尔函数将返回True。

  • 如果obj是Class类的实例或Class的子类的实例，则isinstance(obj，Class)布尔函数返回True。

覆盖方法

您始终可以覆盖父类方法。覆盖父方法的原因之一是您可能需要子类中的特殊功能或其他功能。

例

现场演示
#!/usr/bin/python3

class Parent:        # define parent class
   def myMethod(self):
      print ('Calling parent method')

class Child(Parent): # define child class
   def myMethod(self):
      print ('Calling child method')

c = Child()          # instance of child
c.myMethod()         # child calls overridden method

执行以上代码后，将产生以下结果-

Calling child method

基础重载方法

下表列出了一些通用功能，您可以在自己的类中覆盖它们-

Sr.No. Method, Description & Sample Call
1

__init__ ( self [,args…] )

Constructor (with any optional arguments)

Sample Call : obj = className(args)
2

__del__( self )

Destructor, deletes an object

Sample Call : del obj
3

__repr__( self )

Evaluatable string representation

Sample Call : repr(obj)
4

__str__( self )

Printable string representation

Sample Call : str(obj)
5

__cmp__ ( self, x )

Object comparison

Sample Call : cmp(obj, x)

重载运算符

假设您已经创建了一个Vector类来表示二维矢量。当您使用加号运算符添加它们时会发生什么? Python很可能会对您大吼大叫。

但是，您可以在类中定义__add__方法以执行向量加法，然后plus运算符将按照预期的方式运行-

例

现场演示
#!/usr/bin/python3

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

执行以上代码后，将产生以下结果-

Vector(7,8)

资料隐藏

在类定义之外，对象的属性可能不可见。您需要使用双下划线前缀来命名属性，这样外部人就不会直接看到那些属性。

例

现场演示
#!/usr/bin/python3

class JustCounter:
   __secretCount = 0
  
   def count(self):
      self.__secretCount += 1
      print (self.__secretCount)

counter = JustCounter()
counter.count()
counter.count()
print (counter.__secretCount)

执行以上代码后，将产生以下结果-

1
2
Traceback (most recent call last):
   File "test.py", line 12, in 
      print counter.__secretCount
AttributeError: JustCounter instance has no attribute '__secretCount'

Python通过内部更改名称以包括类名称来保护这些成员。您可以访问诸如object._className__attrName之类的属性。如果您按以下方式替换最后一行，那么它对您有用-

.........................
print (counter._JustCounter__secretCount)

执行以上代码后，将产生以下结果-

1
2
2