教你拿捏Python面向对象（类）（鸭子类型）

Python 是一种广泛使用的高级编程语言，它支持多种编程范式，包括面向对象编程（Object-Oriented Programming, OOP）。面向对象编程是一种编程范式，它将现实世界或问题域中的事物抽象成对象，并通过类（Class）来定义这些对象所拥有的属性和方法（函数）。通过这种方式，面向对象编程有助于我们编写更加模块化、可重用和易于维护的代码。

一、面向对象编程的核心概念包括：

1.类（Class）：

类是一个模板，它定义了对象的属性和方法。通过类，我们可以创建（实例化）出具有相同属性和方法的对象。类中的变量称为属性，类中的函数称为方法。

2.对象（Object）：

对象是类的实例。通过类创建的对象会继承类中定义的属性和方法。每个对象都是独一无二的，它们各自拥有独立的属性副本，但共享类中的方法。

简单的创建一个类：

def print_score(stu: dict):
    print(f"{stu['name']}的成绩是{stu['score']}")
    pass





if __name__ == '__main__':
    stu_1 = {"name": "zs", "score": 90}
    stu_2 = {"name": "ls", "score": 89}

    print_score(stu_1)#输出：zs的成绩是90
    print_score(stu_2)#输出：ls的成绩是89

3.封装（Encapsulation）：

封装是一种将对象的状态信息隐藏在对象内部，不允许外部直接访问对象内部信息的做法，只能通过对象提供的接口（即方法）来访问和修改对象的状态。这样做可以保护对象的数据，并且可以控制对数据的访问。

4.继承（Inheritance）：

继承允许我们定义一个类（子类）来继承另一个类（父类）的属性和方法。子类可以扩展或重写父类的方法，或者添加新的属性和方法。继承是面向对象编程中实现代码重用的主要手段之一。

5.多态（Polymorphism）：

多态是指允许不同类的对象对同一消息作出响应。在 Python 中，多态通常通过继承和方法重写来实现。多态性增加了程序的灵活性，允许使用同一个接口处理不同类型的对象。

一个类的定义格式图

我们来写一个非常简单的代码示例：

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

    def run(self):
        print("Animal is run")


# 在括号里面写入父类的名称
class Dog(Animal):
    def __int__(self, name, leg, bark):
        self.name = name
        self.leg = leg
        # 使用父类的初始化方法
        # super().__init__(name,leg )
        self.bark = bark

    def bark(self):
        print("dog can wangwang")


class Cat(Animal):
    def __int__(self, name, leg, bark):
        self.name = name
        self.leg = leg
        self.bark = bark

    def bark(self):
        print("cat can miaomiao")

if __name__ == '__main__':
# 创建对象


    dog = Dog("Buddy", 4)
    cat = Cat("Whiskers", 4)

# 调用方法
    dog.bark()  # 输出:dog can wangwang
    cat.bark()  # 输出：cat can miaomiao
    cat.run()   #输出：Animal is run
    dog.run()   #输出：Animal is run

二、鸭子类型

在 Python 编程中，“鸭子类型”（Duck Typing）是一种动态类型的概念，源自一句俚语：“如果它看起来像鸭子，游泳像鸭子，叫声像鸭子，那么它很可能就是一只鸭子。”应用到编程中，这意味着一个对象的有效性取决于其行为，而不是其所属的类或类型。Python是一种动态语言，不像Java和C++这种强类型语言，Python里实际上没有严格的类型检查.

只要某个对象具有鸭子的方法，可以像鸭子那样走路和嘎嘎叫，那么它就可以被其它函数当做鸭子一样调用

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

    def bark(self):
        print(f"{self.name} is gagaga")

    def swim(self):
        print(f"{self.name} is swimming")


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

    def bark(self):
        print(f"{self.name} is eee")

    def swim(self):
        print(f"{self.name} is running")


def duck_show(duck: duck):
    duck.swim()
    duck.bark()


if __name__ == '__main__':
    donald = duck("donald")   

    mrPing = goose("ping")

    duck_show(donald)
    duck_show(mrPing)
    #mrPing不属于鸭子类型可以使用duck_show()
    #输出：
    # donald is swimming
    # donald is gagaga
    # ping is running
    # ping is eee
    pass

鸭子类型的优缺点

优点：

• 提高了代码的灵活性和可扩展性。
• 简化了设计模式的使用，如策略模式、访问者模式等。
• 减少了类型检查的代码量，使代码更加简洁。

缺点：

• 由于类型检查是在运行时进行的，因此可能会引入一些运行时错误。
• 要求程序员对代码的行为有深入的理解，以避免潜在的错误。