Python基础—面向对象

面向对象简介
- 什么是面向对象
- 类与对象
- 父类与子类
面向对象的特性
- 单继承与多继承
- - 单继承
  - 多继承
  - 多层继承
  - 封装
  - 多态
重写与调用
- - python重写
  - python调用
  - super函数

前言：
🏠个人主页：以山河作礼。
📝📝此专栏文章是专门针对Python零基础，欢迎免费订阅！💕💕
🎈🎈欢迎大家一起学习，一起成长！！
💕💕：悲索之人烈焰加身，堕落者不可饶恕。永恒燃烧的羽翼，带我脱离凡间的沉沦。

面向对象简介

什么是面向对象

面向对象是一种编程范式，它将程序中的数据和操作封装在一个对象中，从而使得程序更加模块化、可重用和易于维护。在面向对象编程中，对象是类的实例化，类是一种抽象的数据类型，它定义了一组属性和方法。

面向对象编程的核心思想是封装、继承和多态。封装是将数据和操作封装在一个对象中，隐藏对象的内部实现细节，只暴露必要的接口给外部访问。继承是通过继承父类的属性和方法，来创建一个新的子类，子类可以重写父类的属性和方法，从而实现更加灵活的功能。多态是指同一个方法可以根据不同对象的实现方式，实现不同的行为。

类与对象

在这里插入图片描述
类与对象是面向对象编程中的两个重要概念。

类是一种抽象的数据类型，它定义了一组属性和方法，描述了一类对象的共同特征和行为。

对象是类的实例化，是具体的数据实体，具有类所定义的属性和方法。

在这里插入图片描述

Python使用class关键字定义类，使用实例化来创建对象。下面是一个简单的Python类的例子：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def eat(self):
        print(self.name + " is eating.")
    
    def sleep(self):
        print(self.name + " is sleeping.")
    
    def work(self):
        print(self.name + " is working.")

这个类名为Person，它有两个属性name和age，以及三个方法eat、sleep和work。__init__方法是特殊的方法，它在创建对象时被调用。self参数是指向对象本身的引用，可以在方法内部使用来访问对象的属性和方法。

要创建一个Person对象，可以使用如下代码：

p = Person("Tom", 20)

这个例子创建了一个名为p的Person对象，它的name属性为"Tom"，age属性为20。

可以通过对象的属性和方法来访问和修改对象的状态：

print(p.name)  # 输出"Tom"
p.eat()  # 输出"Tom is eating."
p.name = "Jerry"
p.sleep()  # 输出"Jerry is sleeping."

这个例子输出p的name属性，调用p的eat方法，然后修改p的name属性，最后调用p的sleep方法。

再举个栗子帮助大家理解：

class WashingMachine:
    h = 850
    w = 460
    c = 595
    brand = '海尔'

    # self 自己 具体的一个对象

    def __init__(self):
        self.__color = 'red'  # 设置属性或者方法为私有方法
        # 在属性或者方法前加两根下划线

    def get_color(self):
        """获取颜色"""
        return self.__color

    def set_color(self, color):
        """设置颜色"""
        if color in ['red', 'blue', 'yellow']:
            self.__color = color
        else:
            print('违规的颜色')

    def start(self):
        print('启动洗衣机，开始洗衣服')

    def stop(self):
        print('关闭洗衣机')


# 类通过加括号来进行使用 生成一个具体的对象
haier1 = WashingMachine()
haier1.set_color('blue')  # 通过给予的修改方法，去修改对象里面的颜色
print(haier1.get_color())  # 通过get方法获取当前的颜色

运行结果：
在这里插入图片描述

在类的初始化方法__init__中，使用self.__color来定义了一个私有属性__color，并提供了get_color和set_color方法来获取和设置颜色。在set_color方法中，判断给定的颜色是否合法，如果不合法则输出提示信息。

通过创建对象haier1，并使用set_color方法修改颜色为’blue’，然后使用get_color方法获取当前颜色，并输出到控制台。

父类与子类

在Python中，一个类可以从另一个类继承，被继承的类称为父类，继承的类称为子类。

子类可以继承父类的属性和方法，并且可以添加自己的属性和方法。
子类也可以重写父类的方法，从而改变其行为。

例如，下面的代码创建了一个Animal类作为父类，然后创建了一个Dog类作为子类：

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Dog(Animal):
    def speak(self):
        return "Woof"

my_dog = Dog("Rufus")
print(my_dog.name)
print(my_dog.speak())

运行结果：
在这里插入图片描述

在这个例子中，Animal类包含一个构造函数和一个抽象方法speak。Dog类继承了Animal类，并重写了speak方法。我们可以创建一个Dog对象并调用它的方法，它将返回“Woof”。

面向对象的特性

单继承与多继承

在这里插入图片描述

单继承

在Python中，单继承是指一个子类只能继承一个父类的属性和方法。Python中的类可以通过继承来扩展父类的功能，并添加自己的属性和方法。

下面是一个简单的Python单继承的例子：

class Animal:
    def __init__(self, name):
        self.name = name
    
    def eat(self):
        print(self.name + " is eating.")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed
    
    def bark(self):
        print(self.name + " is barking.")

dog = Dog("Tom", "Husky")
dog.eat()  # 输出"Tom is eating."
dog.bark()  # 输出"Tom is barking."

运行结果：
在这里插入图片描述

这段代码定义了一个Animal类和一个继承自Animal类的Dog类。Animal类有一个构造函数__init__()和一个eat()方法，eat()方法输出动物正在吃东西的信息。Dog类有一个构造函数__init__()和一个bark()方法，bark()方法输出狗正在叫的信息。

在Dog类的构造函数中，使用super()函数调用父类的构造函数，并传递name参数。然后，为Dog类添加一个名为breed的属性。

多继承

多继承是指一个类可以同时继承多个父类的特性和方法。

多继承的语法非常简单，只需要在定义类时在类名后面添加括号，括号中写上要继承的所有父类的名称，用逗号隔开即可。

例如，下面的代码定义了一个名为MyClass的类，它同时继承了父类A和B：

class A:
    def method1(self):
        print("Method 1 of A called.")

class B:
    def method2(self):
        print("Method 2 of B called.")

class MyClass(A, B):
    def method3(self):
        print("Method 3 of MyClass called.")

my_object = MyClass()
my_object.method1()  # 输出"Method 1 of A called."
my_object.method2()  # 输出"Method 2 of B called."
my_object.method3()  # 输出"Method 3 of MyClass called."

运行结果：
在这里插入图片描述

在这个例子中，我们定义了两个父类A和B，它们分别有一个方法method1和method2。然后，我们定义了一个名为MyClass的类，它同时继承了A和B两个父类，并添加了一个方法method3。

在主程序中，我们创建了一个MyClass对象，并调用了它的三个方法，它们分别输出了不同的信息。

多层继承

在Python中，一个类可以同时继承多个父类，这被称为多重继承。多重继承可以形成多层继承，即一个类继承了另一个类，而另一个类又继承了另一个类，以此类推。

例如，下面的代码定义了一个名为A的父类，一个名为B的子类，和一个名为C的子类，C类同时继承了A和B类：

class A:
    def method1(self):
        print("Method 1 of A called.")

class B:
    def method2(self):
        print("Method 2 of B called.")

class C(A, B):
    def method3(self):
        print("Method 3 of C called.")

my_object = C()
my_object.method1()  # 输出"Method 1 of A called."
my_object.method2()  # 输出"Method 2 of B called."
my_object.method3()  # 输出"Method 3 of C called."

在这里插入图片描述

在这个例子中，A类有一个名为method1()的方法，B类有一个名为method2()的方法，C类同时继承了A和B类，并添加了一个名为method3()的方法。在主程序中，我们创建了一个名为my_object的C对象，并调用了它的三个方法，它们分别输出了不同的信息。

封装

在这里插入图片描述

Python封装是一种面向对象编程的概念，它指的是将数据和方法封装在一个类中，并且对外部隐藏其实现细节，只暴露必要的接口供外部访问。

封装的目的是为了保护数据的完整性和安全性，防止外部程序意外修改或破坏数据，同时也提高了代码的可维护性和可读性。

Python中的封装可以通过以下方式实现：

使用私有变量和方法：在变量或方法名称前加上双下划线“__”即可将其定义为私有的，外部程序无法直接访问。需要注意的是，Python中的私有变量和方法并非完全无法访问，而是通过一定的方式进行访问。
使用属性：Python中的属性是一种特殊的方法，可以用来控制对类的成员变量的访问。通过属性，可以在访问成员变量时进行一些逻辑判断和处理，从而保护数据的完整性和安全性。
使用访问器和修改器：访问器和修改器分别是用来获取和设置私有变量的方法，可以在方法内部进行一些逻辑判断和处理，从而保护数据的完整性和安全性。
使用装饰器：装饰器是Python中一种特殊的语法结构，可以用来修改或扩展函数或类的功能。通过装饰器，可以在类或方法定义时对其进行修饰，从而实现封装的目的。

多态

在这里插入图片描述

Python多态是一种面向对象编程的概念，它指的是同一种行为或方法可以在不同的对象上产生不同的结果。换句话说，多态允许不同的对象对同一方法做出不同的响应。这种特性可以提高代码的灵活性和可扩展性，使程序更加易于维护和扩展。

在Python中，实现多态的方式主要有两种：

方法重写：方法重写是指在子类中重新定义父类的方法，从而实现对该方法的重载。这种方式可以让子类对父类的方法进行扩展或修改，从而实现多态。

方法重载：方法重载是指在同一类中定义多个同名的方法，但是它们的参数列表不同。这种方式可以让同一个方法名实现不同的功能，从而实现多态。

例如，假设有一个动物类Animal，其中定义了一个speak()方法，不同的动物可以根据自己的特点进行不同的叫声。我们可以定义一个Dog类和一个Cat类继承自Animal类，并且重写speak()方法，使得它们能够发出不同的叫声：

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("汪汪汪！")

class Cat(Animal):
    def speak(self):
        print("喵喵喵！")

以上代码实现了多态，因为不同的对象（Dog和Cat）对相同的方法（speak()）做出了不同的响应。在调用speak()方法时，可以根据对象的类型来决定调用哪个子类的方法，从而实现多态。

重写与调用

python重写

在Python中，子类可以重写（覆盖）父类的方法，以实现自己的功能。
重写方法时，需要注意以下几点：

子类的方法名与父类的方法名相同。
子类的方法参数与父类的方法参数相同。
子类的方法返回值类型与父类的方法返回值类型相同或者是父类方法返回值类型的子类型。

例如，下面的代码定义了一个名为Animal的父类和一个名为Dog的子类，子类重写了父类的方法：

class Animal:
    def make_sound(self):
        print("The animal makes a sound.")

class Dog(Animal):
    def make_sound(self):
        print("The dog barks.")

my_dog = Dog()
my_dog.make_sound()  # 输出"The dog barks."

在这里插入图片描述

在这个例子中，Animal类有一个名为make_sound()的方法，它输出“动物发出声音”的信息。Dog类继承了Animal类，并重写了make_sound()方法，使其输出“狗叫”的信息。在主程序中，我们创建了一个Dog对象my_dog，并调用了它的make_sound()方法，输出了“狗叫”的信息。

python调用

在Python中，调用父类的方法有两种方式：

使用super()函数调用父类的方法。
直接使用父类的类名调用父类的方法。

使用super()函数调用父类的方法是比较常用的方式，它可以自动识别出哪个父类的方法需要被调用。例如：

class Animal:
    def __init__(self, name):
        self.name = name
    
    def eat(self):
        print(self.name + " is eating.")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed
    
    def bark(self):
        print(self.name + " is barking.")

my_dog = Dog("Tom", "Husky")
my_dog.eat()  # 输出"Tom is eating."

在这里插入图片描述

在这个例子中，Animal类有一个名为eat()的方法，它输出动物正在吃东西的信息。Dog类继承了Animal类，并使用super()函数调用了父类的构造函数__init__()，以初始化name属性。在主程序中，我们创建了一个名为my_dog的Dog对象，并调用了它的eat()方法，输出了“Tom is eating.”的信息。

直接使用父类的类名调用父类的方法也是一种有效的方式。例如：


class Animal:
    def __init__(self, name):
        self.name = name
    
    def eat(self):
        print(self.name + " is eating.")

class Dog(Animal):
    def __init__(self, name, breed):
        Animal.__init__(self, name)
        self.breed = breed
    
    def bark(self):
        print(self.name + " is barking.")

my_dog = Dog("Tom", "Husky")
my_dog.eat()  # 输出"Tom is eating."

在这里插入图片描述

在这个例子中，Dog类的构造函数使用Animal类名和self参数调用了父类的构造函数__init__()，以初始化name属性。在主程序中，我们创建了一个名为my_dog的Dog对象，并调用了它的eat()方法，输出了“Tom is eating.”的信息。

super函数

在Python中，super()函数用于调用父类的方法。使用super()函数调用父类的方法时，可以不使用父类的类名，而是使用super()函数自动识别出需要调用的父类的方法。

super()函数的语法如下：

super([type[, object-or-type]])

其中，type是子类的类型，object-or-type是子类的对象或类型。如果只有一个参数，则默认为子类的类型。

例如，下面的代码定义了一个名为Animal的父类和一个名为Dog的子类，子类使用super()函数调用了父类的方法：

class Animal:
    def __init__(self, name):
        self.name = name
    
    def eat(self):
        print(self.name + " is eating.")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed
    
    def bark(self):
        print(self.name + " is barking.")

my_dog = Dog("Tom", "Husky")
my_dog.eat()  # 输出"Tom is eating."

在这里插入图片描述

Animal类有一个名为eat()的方法，它输出动物正在吃东西的信息。Dog类继承了Animal类，并使用super()函数调用了父类的构造函数__init__()，以初始化name属性。在主程序中，我们创建了一个名为my_dog的Dog对象，并调用了它的eat()方法，输出了“Tom is eating.”的信息。

在这里插入图片描述