python入门之面向对象

面向对象概念：

就是把现实中的事物都抽象为“对象”。每个对象是唯一的，且都可以拥有它的属性与行为。我们就可以通过调用这些对象的方法、属性去解决问题。

一、类（Class）

类是面向对象编程的基本单位，它是一种抽象的数据类型，不是真实存在的。例如人这个类就是抽象的而不是某个实体。用于描述对象的属性和行为。通过定义类，我们可以创建具体的对象实例。

class People:
	pass #由于这里未曾定义任何属性方法所以用pass防止报错

1、属性（Attribute）

属性是对象的特征或状态，例如颜色、大小等。

class People:
    def __init__(self, name, age, height, weight):
        """
        初始化方法（魔法方法）
        Args:
            name: 姓名
            age: 年龄
            height: 身高
            weight: 体重
        """
        self.name = name
        self.age = age
        self.height = height
        self.weight = weight

例子中，在初始化方法中创建属于人类的属性。
self是代表初始化出来的对象本身。

2、方法（Method）

方法是与对象相关联的函数，用于定义对象的行为。方法可以访问和操作对象的属性。在类中定义的方法通常以self作为第一个参数，表示方法所属的对象。

2.1 魔法方法

如上面例子中的__init__()初始化方法一样的前后都带有双下划线的方法。

2.1.1 str()

这个方法一般用于描述对象的，返回的是字符串。

class People:
    def __init__(self, name, age, height, weight):
        """
        初始化方法（魔法方法）
        Args:
            name: 姓名
            age: 年龄
            height: 身高
            weight: 体重
        """
        self.name = name
        self.age = age
        self.height = height
        self.weight = weight

    def __str__(self):
        return str(f"{self.name}")


xm = People("小明", 18, 175, 60)
print(xm)

2.1.2 call()

将对象作为函数调用

class People:
    def __init__(self, name, age, height, weight):
        """
        初始化方法（魔法方法）
        Args:
            name: 姓名
            age: 年龄
            height: 身高
            weight: 体重
        """
        self.name = name
        self.age = age
        self.height = height
        self.weight = weight

    def __call__(self, *args, **kwargs):
        print("这是call魔法方法")


xm = People("小明", 18, 175, 60)
xm()

魔法方法有很多，由于使用并不多不一一列举了，感兴趣的可以网上搜索或是查看官方文档。

2.2 普通方法

普通方法即是我们自己定义的一些方法函数，不是以双下划线开头结尾的。
直接上代码更直观：

class People:
    def __init__(self, name, age, height, weight):
        """
        初始化方法（魔法方法）
        Args:
            name: 姓名
            age: 年龄
            height: 身高
            weight: 体重
        """
        self.name = name
        self.age = age
        self.height = height
        self.weight = weight

    def speak(self, word: str):
        print(f"{self.name}说：“{word}”")


xm = People("小明", 18, 175, 60)
xm.speak("good morning")

上面例子中给人这个类定义了一个说话的方法（行为），对象调用说话的行为。这就是普通方法定义跟调用。

2.3 私有方法

私有方法就是只用于在类内调用方法，不能在类外调用。私有方法跟普通方法声明差异不大，就是以双下划线开头。

class People:
    def __init__(self, name, age, height, weight):
        """
        初始化方法（魔法方法）
        Args:
            name: 姓名
            age: 年龄
            height: 身高
            weight: 体重
        """
        self.name = name
        self.age = age
        self.height = height
        self.weight = weight

    def __speak(self, word: str):
        print(f"{self.name}说：“{word}”")


xm = People("小明", 18, 175, 60)
xm.__speak("good morning")
# Traceback (most recent call last):
#   File "D:\python\爬虫\test.py", line 25, in <module>
#     xm.__speak("good morning")
# AttributeError: 'People' object has no attribute '__speak'

例子中speak方法用双下划线开头便成为了私有方法，在类外调用会报错。

二、对象（Object）

对象是类的实例化，它是类的具体表现。例如人类即是一个抽象出来的类，而小明则是人类这个类的实例对象，是具体存在的。每个对象都有自己的状态（属性）和行为（方法）。

class People:
    def __init__(self, name, age, height, weight):
        """
        初始化方法（魔法方法）
        Args:
            name: 姓名
            age: 年龄
            height: 身高
            weight: 体重
        """
        self.name = name
        self.age = age
        self.height = height
        self.weight = weight

    def speak(self, word: str):
        print(f"{self.name}说：“{word}”")


xm = People("小明", 18, 175, 60)
zs = People("张三", 22, 160, 60)

print(f'张三属性：{zs.name},{zs.age},{zs.height}')  # 张三属性：张三,22,160
zs.speak("hello")  # 张三说：“hello”

print(f'小明属性：{xm.name},{xm.age},{xm.height}')  # 小明属性：小明,18,175
xm.speak("hello")  # 小明说：“hello”

三、面向对象的三大特性

1、封装（Polymorphism）

封装是一种将数据和操作封装在类中的概念，使得数据只能通过类的方法进行访问和修改。封装可以隐藏对象内部的实现细节，提供更好的安全性和代码组织。可以使用属性和方法的访问权限控制来实现封装，例如使用私有变量和方法（以双下划线开头命名）来限制外部访问。
实操就是跟前面的类的创建。

2、继承（Inheritance）

继承是一种机制，允许我们基于已经存在的类创建新的类，并继承父类的属性和方法。继承可以实现代码重用和层次结构的定义。
举个栗子：

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

    def eat(self):
        print(f"{self.name}的吃食物")


class Panda(Animal):
    def climb_tree(self):
        print(f"{self.name}会爬树")

    def eat(self):
        print(f"{self.name}吃竹子")

tt = Panda("团团")
tt.eat()  # 团团吃竹子

例子中定义了一个动物类（Animal），熊猫类（panda）继承动物类，并重写了动物吃方法，初始化方法继承自动物类。

3、多态（Encapsulation）

多态是指同一种操作（方法）可以在不同的对象上产生不同的行为。通过多态，我们可以使用统一的接口处理不同类型的对象。
举例说明：

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

    def eat(self):
        print(f"{self.name}的吃食物")


class Panda(Animal):
    def climb_tree(self):
        print(f"{self.name}会爬树")

    def eat(self):
        print(f"{self.name}吃竹子")


class Tiger(Animal):
    def eat(self):
        print(f"{self.name}吃肉")


class Rabbit(Animal):
    def eat(self):
        print(f"{self.name}吃胡罗卜")


def animal_eat(animal: Animal):
    animal.eat()


if __name__ == '__main__':
    tt = Panda("团团")
    tiger = Tiger("老虎")
    rabbit = Rabbit("兔子")
    for item in [tt, tiger, rabbit]:
        animal_eat(item)

    # 团团吃竹子
    # 老虎吃肉
    # 兔子吃胡罗卜

例子中子类通过重写父类吃（eat）的方法 ，通过调用函数animal_eat 传入不同的实例从而实现不同的吃方法也就是多态效果。