【 Python 全栈开发 - 语法基础篇 - 17 】面向对象、继承、多态、类方法与类属性

---

一、面向对象编程

Python 面向对象编程 是一种编程范式，它将数据和操作数据的方法组合在一起，形成一个“对象”，并且该对象可以被复用。在 Python 中，每一个对象都拥有一些属性和方法，它们是该对象的特征和行为。

面向对象编程可以帮助我们更好地组织和管理代码，使得代码更加模块化、可复用和易于维护。在 Python 中，使用类来定义对象的属性和方法，实例化对象时可以使用构造函数来初始化对象的属性。

在 Python 面向对象编程中，还有一些与对象相关的概念，例如继承、封装和多态等，它们都是为了更好地组织和管理对象的特征和行为。

Python面向对象编程的方法主要包括以下几个方面：

1. 定义类：通过class关键字定义类，指定类名和属性、方法等内容。

2. 创建对象：通过类名和参数来创建对象，并且可以指定对象的属性。

3. 实例方法：定义在类中的方法，第一个参数是self，用于引用当前实例对象的属性和方法。

4. 继承：通过继承已有的类，创建一个子类，可以共享父类的属性和方法，并且可以覆盖父类的方法。

5. 多态：同一个方法可以处理不同的对象，实现了多态。

6. 封装：将对象的属性和方法进行封装，对外只暴露必要的接口，避免直接访问对象的属性和方法。

下面是使用Python面向对象编程的一个简单的例子：

class Person:
    def __init__(self, name):
        self.name = name
    
    def say_hello(self):
        print("Hello, my name is {}".format(self.name))

class Student(Person):
    def __init__(self, name, grade):
        super().__init__(name)
        self.grade = grade
    
    def say_hello(self):
        print("Hello, my name is {} and I'm in grade {}".format(self.name, self.grade))
        
p = Person("Tom")
p.say_hello()

s = Student("Bob", 3)
s.say_hello()

在这个例子中，定义了一个Person类和一个继承自 Person 类的 Student 类。Person 类有一个构造方法__init__和一个实例方法say_hello，Student 类也有一个构造方法和一个覆盖了父类方法的say_hello方法。通过创建 Person 对象和 Student 对象，可以调用它们的实例方法输出各自的信息。这个例子展示了 Python 面向对象编程的一些基本方法，包括类的定义、继承、多态等。

---

二、继承

Python 中的继承是一种面向对象编程的机制，它可以使一个已有的类（即父类）成为其它类（即子类）的基础，子类从父类继承属性和方法，同时还可以添加自己的属性和方法，从而充分利用已有的代码。

Python 中的继承是通过在类定义时使用括号指定父类来实现的。例如：

class Parent:
    def __init__(self):
        self.parentAttr = 100
        
    def parentMethod(self):
        print("Calling parent method")
        
class Child(Parent):
    def __init__(self):
        super().__init__()
        self.childAttr = 50
        
    def childMethod(self):
        print("Calling child method")

在这个例子中，Parent 类有一个属性parentAttr和一个方法parentMethod，Child 类继承了Parent 类，并添加了一个属性childAttr和一个方法childMethod。在 Child 类的定义中，将 Parent 类作为参数传递给class语句，以便 Child 类可以继承 Parent 类的所有属性和方法。此外，super().__init__()用于调用父类的构造方法，以确保继承的属性能够正确初始化。

通过继承，Child 类可以使用 Parent 类的属性和方法，如下所示：

c = Child()
print(c.parentAttr)      # 100
c.parentMethod()         # Calling parent method
print(c.childAttr)       # 50
c.childMethod()          # Calling child method

在这个例子中，Child 类对象可以访问 Parent 类的属性和方法，同时也可以访问自己的属性和方法。这样，继承使得 Python 编程更加模块化和易于管理，同时也避免了代码重复。

---

三、多态

在面向对象编程中，多态是指同一操作作用于不同的对象可以有不同的解释，即不同的对象有不同的表现行为。简单来说，多态就是同一个方法在不同的对象上有不同的表现。

在 Python 中，多态可以通过继承来实现。在继承中，子类可以重写父类的方法，当使用子类对象调用这个方法时，就会调用子类的方法而不是父类的方法。这种调用方式就是多态。下面是一个简单的例子：

class Animal:
    def make_sound(self):
        print("Animal makes a sound")
        
class Dog(Animal):
    def make_sound(self):
        print("Dog barks")
        
class Cat(Animal):
    def make_sound(self):
        print("Cat meows")
        
def animal_sounds(animal):
    animal.make_sound()
    
a = Animal()
d = Dog()
c = Cat()

animal_sounds(a)     # Animal makes a sound
animal_sounds(d)     # Dog barks
animal_sounds(c)     # Cat meows

在这个例子中，Animal 类有一个方法make_sound，而 Dog 和 Cat 类都继承了 Animal 类并重写了make_sound方法。animal_sounds函数接受一个 Animal 对象作为参数，当调用make_sound方法时，会根据传入的对象类型来选择调用相应的方法。通过多态，我们可以使用相同的函数animal_sounds来处理不同类型的对象，这使得代码更灵活、可扩展。

需要注意的是，在 Python 中，由于是动态类型语言，不同的对象不需要显式声明相同的接口或实现相同的方法，只要它们有相同的方法，就可以达到多态的效果。

---

四、类方法与类属性

Python 中的类方法和类属性都属于类级别的方法和属性，也就是说，它们是属于整个类而不是类的实例的。

类方法是通过@classmethod装饰器定义的方法，它的第一个参数必须是类本身，通常命名为cls。类方法可以访问类级别的属性，也可以调用其他类方法，但不能直接访问实例级别的属性。下面是一个简单的例子：

class MyClass:
    class_var = "I am a class variable"
    
    @classmethod
    def class_method(cls):
        print("This is a class method")
        print(cls.class_var)
        
MyClass.class_method()     # This is a class method
                           # I am a class variable

在这个例子中，我们定义了一个MyClass类，并创建了一个类方法class_method。在类方法中，我们可以使用cls参数来访问类级别的属性，例如class_var。当我们调用class_method方法时，会输出This is a class method和I am a class variable。

类属性是属于整个类的属性，而不是类的实例的属性。类属性通常在类定义时声明并初始化，也可以在类的任何地方直接赋值。在类的任何方法中，可以通过类名.属性名或self.__class__.属性名来访问类属性。下面是一个简单的例子：

class MyClass:
    class_var = "I am a class variable"
    
    def __init__(self, instance_var):
        self.instance_var = instance_var
        
    def instance_method(self):
        print("This is an instance method")
        print(self.instance_var)
        print(self.__class__.class_var)
    
print(MyClass.class_var)     # I am a class variable

a = MyClass("I am an instance variable")
a.instance_method()         # This is an instance method
                            # I am an instance variable
                            # I am a class variable

在这个例子中，我们定义了一个MyClass类，并创建了一个类属性class_var。在instance_method方法中，我们可以通过self.__class__.class_var来访问类属性class_var。当我们创建一个MyClass实例并调用instance_method方法时，会输出This is an instance method、I am an instance variable和I am a class variable。需要注意的是，虽然我们在实例方法中访问了类属性，但我们并没有修改它。如果需要修改类属性，应该直接使用类名.属性名来赋值。