Python OOP 概念

在Python中，面向对象编程 (OOP) 是一种在编程中使用对象和类的编程范式。它旨在在编程中实现继承、多态、封装等现实世界的实体。 OOP 的主要概念是将数据和对其工作的函数作为一个单元绑定在一起，这样代码的其他部分就无法访问这些数据。

面向对象编程 (OOP) 的主要概念

• 班级
• 对象
• 多态性
• 封装
• 遗产

班级

类是对象的集合。一个类包含创建对象的蓝图或原型。它是一个逻辑实体，包含一些属性和方法。

为了理解创建类的必要性，让我们考虑一个示例，假设您想要跟踪可能具有不同属性（如品种、年龄）的狗的数量。如果使用列表，第一个元素可以是狗的品种，而第二个元素可以代表它的年龄。假设有 100 只不同的狗，那么你怎么知道哪个元素应该是哪个？如果您想为这些狗添加其他属性怎么办？这缺乏组织，这是对课程的确切需求。

Python类的一些要点：

• 类由关键字 class 创建。
• 属性是属于一个类的变量。
• 属性始终是公共的，可以使用点 (.)运算符进行访问。例如：Myclass.Myattribute

类定义语法：

class ClassName:
   # Statement-1
   .
   .
   .
   # Statement-N

示例：在Python中创建一个空类

Python

# Python3 program to
# demonstrate defining
# a class
  
class Dog:
    pass

在上面的示例中，我们使用 class 关键字创建了一个名为 dog 的类。

对象

对象是具有与其相关联的状态和行为的实体。它可以是任何现实世界的对象，如鼠标、键盘、椅子、桌子、笔等。整数、字符串、浮点数，甚至数组和字典，都是对象。更具体地说，任何单个整数或任何单个字符串都是对象。数字 12 是一个对象，字符串“Hello, world”是一个对象，列表是一个可以容纳其他对象的对象，依此类推。您一直在使用对象，甚至可能没有意识到这一点。

一个对象包括：

• 状态：由对象的属性表示。它还反映了对象的属性。
• 行为：它由对象的方法表示。它还反映了一个对象对其他对象的响应。
• 身份：它为一个对象赋予一个唯一的名称，并使一个对象能够与其他对象交互。

为了理解状态、行为和身份，让我们以类狗为例（如上所述）。

• 身份可以认为是狗的名字。
• 状态或属性可以被视为狗的品种、年龄或颜色。
• 该行为可以被认为是狗是在吃东西还是在睡觉。

示例：创建对象

Python3

obj = Dog()

这将创建一个名为 obj 的对象，该对象属于上面定义的 Dog 类。在深入研究对象和类之前，让我们了解一些在处理对象和类时将使用的基本关键字。

自己

1. 类方法在方法定义中必须有一个额外的第一个参数。我们在调用方法的时候没有给这个参数赋值， Python提供了
2. 如果我们有一个不带参数的方法，那么我们仍然必须有一个参数。
3. 这类似于 C++ 中的 this 指针和Java中的 this 引用。

当我们将此对象的方法称为 myobject.method(arg1, arg2) 时， Python会自动将 this 转换为 MyClass.method(myobject, arg1, arg2)——这就是特殊的 self 的全部内容。

注：更多信息请参考Python类中的self

__init__ 方法

__init__ 方法类似于 C++ 和Java中的构造函数。一旦实例化类的对象，它就会运行。该方法对于执行您想要对对象执行的任何初始化很有用。

现在让我们定义一个类并使用 self 和 __init__ 方法创建一些对象。

示例 1：创建具有类和实例属性的类和对象

Python3

class Dog:
  
    # class attribute
    attr1 = "mammal"
  
    # Instance attribute
    def __init__(self, name):
        self.name = name
  
# Driver code
# Object instantiation
Rodger = Dog("Rodger")
Tommy = Dog("Tommy")
  
# Accessing class attributes
print("Rodger is a {}".format(Rodger.__class__.attr1))
print("Tommy is also a {}".format(Tommy.__class__.attr1))
  
# Accessing instance attributes
print("My name is {}".format(Rodger.name))
print("My name is {}".format(Tommy.name))

输出

Rodger is a mammal
Tommy is also a mammal
My name is Rodger
My name is Tommy

示例 2：使用方法创建类和对象

Python3

class Dog:
  
    # class attribute
    attr1 = "mammal"
  
    # Instance attribute
    def __init__(self, name):
        self.name = name
          
    def speak(self):
        print("My name is {}".format(self.name))
  
# Driver code
# Object instantiation
Rodger = Dog("Rodger")
Tommy = Dog("Tommy")
  
# Accessing class methods
Rodger.speak()
Tommy.speak()

输出

My name is Rodger
My name is Tommy

注意：有关更多信息，请参阅Python类和对象

遗产

继承是一个类从另一个类派生或继承属性的能力。派生属性的类称为派生类或子类，而派生属性的类称为基类或父类。继承的好处是：

• 它很好地代表了现实世界的关系。
• 它提供了代码的可重用性。我们不必一次又一次地编写相同的代码。此外，它允许我们在不修改类的情况下向类添加更多功能。
• 它本质上是可传递的，这意味着如果类 B 继承自另一个类 A，那么 B 的所有子类将自动继承自类 A。

示例： Python中的继承

Python3

# Python code to demonstrate how parent constructors
# are called.
  
# parent class
class Person(object):
  
    # __init__ is known as the constructor
    def __init__(self, name, idnumber):
        self.name = name
        self.idnumber = idnumber
  
    def display(self):
        print(self.name)
        print(self.idnumber)
          
    def details(self):
        print("My name is {}".format(self.name))
        print("IdNumber: {}".format(self.idnumber))
      
# child class
class Employee(Person):
    def __init__(self, name, idnumber, salary, post):
        self.salary = salary
        self.post = post
  
        # invoking the __init__ of the parent class
        Person.__init__(self, name, idnumber)
          
    def details(self):
        print("My name is {}".format(self.name))
        print("IdNumber: {}".format(self.idnumber))
        print("Post: {}".format(self.post))
  
  
# creation of an object variable or an instance
a = Employee('Rahul', 886012, 200000, "Intern")
  
# calling a function of the class Person using
# its instance
a.display()
a.details()

输出

Rahul
886012
My name is Rahul
IdNumber: 886012
Post: Intern

在上面的文章中，我们创建了两个类，即Person（父类）和Employee（子类）。 Employee 类继承自 Person 类。我们可以通过employee类使用person类的方法，如上面代码中的显示函数所示。子类也可以通过 details() 方法修改父类的行为。

注意：有关更多信息，请参阅我们的Python中的继承教程。

多态性

多态性只是意味着具有多种形式。例如，我们需要确定给定的鸟类是否会飞，使用多态性，我们可以使用单个函数来完成。

示例： Python中的多态性

Python3

class Bird:
    
    def intro(self):
        print("There are many types of birds.")
  
    def flight(self):
        print("Most of the birds can fly but some cannot.")
  
class sparrow(Bird):
    
    def flight(self):
        print("Sparrows can fly.")
  
class ostrich(Bird):
  
    def flight(self):
        print("Ostriches cannot fly.")
  
obj_bird = Bird()
obj_spr = sparrow()
obj_ost = ostrich()
  
obj_bird.intro()
obj_bird.flight()
  
obj_spr.intro()
obj_spr.flight()
  
obj_ost.intro()
obj_ost.flight()

输出

There are many types of birds.
Most of the birds can fly but some cannot.
There are many types of birds.
Sparrows can fly.
There are many types of birds.
Ostriches cannot fly.

注意：有关更多信息，请参阅我们的Python教程中的多态性。

封装

封装是面向对象编程（OOP）中的基本概念之一。它描述了包装数据的想法以及在一个单元内处理数据的方法。这限制了直接访问变量和方法，并且可以防止意外修改数据。为防止意外更改，对象的变量只能通过对象的方法进行更改。这些类型的变量称为私有变量。

类是封装的一个例子，因为它封装了成员函数、变量等所有数据。

示例： Python中的封装

Python3

# Python program to
# demonstrate private members
  
# Creating a Base class
class Base:
    def __init__(self):
        self.a = "GeeksforGeeks"
        self.__c = "GeeksforGeeks"
  
# Creating a derived class
class Derived(Base):
    def __init__(self):
  
        # Calling constructor of
        # Base class
        Base.__init__(self)
        print("Calling private member of base class: ")
        print(self.__c)
  
  
# Driver code
obj1 = Base()
print(obj1.a)
  
# Uncommenting print(obj1.c) will
# raise an AttributeError
  
# Uncommenting obj2 = Derived() will
# also raise an AtrributeError as
# private member of base class
# is called inside derived class

输出

GeeksforGeeks

在上面的示例中，我们创建了 c 变量作为私有属性。我们甚至不能直接访问这个属性，甚至不能改变它的值。

注意：有关更多信息，请参阅我们的Python教程中的封装。

Python中的面向对象编程| Set 2（数据隐藏和对象打印）

https://youtu.be/CiH7lN4