1.3、Python基础-面向对象

1、面向对象概念

1、面向对象是一种编程范式，它将程序中的数据和操作封装在一个对象中，从而使得程序更加模块化、可重用和易于维护。在面向对象编程中，对象是类的实例化，类是一种抽象的数据类型，它定义了一组属性和方法。
2、面向对象编程的核心思想是封装、继承和多态。
3、封装是将数据和操作封装在一个对象中，隐藏对象的内部实现细节，只暴露必要的接口给外部访问。
4、继承是通过继承父类的属性和方法，来创建一个新的子类，子类可以重写父类的属性和方法，从而实现更加灵活的功能。
5、多态是指同一个方法可以根据不同对象的实现方式，实现不同的行为。

2、类和对象

类与对象是面向对象编程中的两个重要概念。
类是一种抽象的数据类型，它定义了一组属性和方法，描述了一类对象的共同特征和行为。
对象是类的实例化，是具体的数据实体，具有类所定义的属性和方法。

2.1、案例一

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

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.")


if __name__ == '__main__':
    p = Person("Tom", 20)
    print(p.name)
    p.eat()
    p.name = "Jerry"
    p.sleep()

2.2、案例二

下面这个类名为WashingMachine，在类的初始化方法__init__中，使用self.__color来定义了一个私有属性__color，并提供了get_color和set_color方法来获取和设置颜色。在set_color方法中，判断给定的颜色是否合法，如果不合法则输出提示信息。
通过创建对象haier1，并使用set_color方法修改颜色为’blue’，然后使用get_color方法获取当前颜色，并输出到控制台。

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方法获取当前的颜色

3、面向对象-继承

在Python中，一个类可以从另一个类继承，被继承的类称为父类， 继承的类称为子类。
子类可以继承父类的属性和方法，并且可以添加自己的属性和方法。
子类也可以重写父类的方法，从而改变其行为。

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

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())

3.1、单继承

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

下面代码中定义了一个Animal类和一个继承自Animal类的Dog类。Animal类有一个构造函数__init__()和一个eat()方法，eat()方法输出动物正在吃东西的信息。Dog类有一个构造函数__init__()和一个bark()方法，bark()方法输出狗正在叫的信息。
在Dog类的构造函数中，使用super()函数调用父类的构造函数，并传递name参数。然后，为Dog类添加一个名为breed的属性。

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."

3.2、多继承

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

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

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."

4、封装

封装是对具体对象的一种抽象，即将某些部分隐藏起来，在程序外部看不到，其含义是其他程序无法调用，说白了，我把一个类中的某个变量、方法封装起来，其他地方无法调用。
封装分为两个层面：
1、创建类和对象会分别创建二者的名称空间，我们只能用类名.或者obj.的方式去。
2、类中把某些属性和方法隐藏起来(或者说定义成私有的)，只在类的内部使用、外部无法访问，或者留下少量接口（函数）供外部访问。

封装的注意事项：
1、Python中私有化的方法也比较简单，即在准备私有化的属性（包括方法、变量）名字前面加两个下划线即可。
2、类中所有双下划线开头的属性名称（包括方法、变量）如__x都会自动变形成：_类名__x的形式。可以直接通过变形后的形式访问，这样实际封装也就没意义了。
3、在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

class A:
    __N = 0  # 类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
    M = 9

    def __init__(self):
        self.__X = 10  # 变形为self._A__X

    def __foo(self):  # 变形为_A__foo
        print('from A')

    def bar(self):
        self.__foo()  # 只有在类内部才可以通过__foo的形式访问到.　　


a = A()
a.bar()
print(a.M)
print(a.__dict__)  # 打印变形的内容
# 封装后，实际可以通过变形后的形式访问的。
a._A__foo()
print(a._A__X)

5、多态

多态是指对象可以用多种形态来引用。这样做可以使代码更加灵活，因为同样的操作可以应用于不同的类型。多态有两种实现方式，一种是基于继承的实现，在这种实现中，父类定义一些通用的方法，子类则可以重写这些方法并实现不同的功能。另一种实现方式是接口，这种实现方式可以让不同的类实现同一个接口，从而实现多态。

class Animal:
    def move(self):
        pass
 
class Dog(Animal):
    def move(self):
        print("狗在跑")
 
class Cat(Animal):
    def move(self):
        print("猫在爬")
 
class Zoo:
    def __init__(self):
        self.animals = []
 
    def addAnimal(self, animal):
        self.animals.append(animal)
 
    def moveAll(self):
        for animal in self.animals:
            animal.move()
 
zoo = Zoo()
zoo.addAnimal(Dog())
zoo.addAnimal(Cat())
zoo.moveAll()

6、类方法和静态方法

6.1、类方法

在Python中，定义类方法需要使用‘@classmethod’装饰器。类方法的第一个参数必须是‘cls’，表示类本身，可以通过‘cls’来调用类属性和类方法。

class Person:
    total_persons = 0
 
    def __init__(self, name):
        self.name = name
        Person.total_persons += 1
 
    @classmethod
    def show_total_persons(cls):
        print("Total persons: ", cls.total_persons)
 
p1 = Person("Tom")
p2 = Person("Jerry")
Person.show_total_persons()

6.2、静态方法

在Python中，定义静态方法需要使用‘@staticmethod’装饰器。静态方法没有参数限制，它只是一个普通函数，涉及到类和对象的问题，都需要在函数内部进行处理。

class Calculator:
 
    @staticmethod
    def add(x, y):
        return x + y
 
Calculator.add(3, 5)