快速了解python面向对象编程

一、什么是面向对象

面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它通过将数据和功能组织为对象来设计程序。Python 作为一种支持面向对象的语言，提供了面向对象编程的基本概念和语法结构。

1、类

用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

class Student:
    def __init__(self,id,name):
        self.id = '1000'   #对象属性
        self.name = '张三'

    def ret(self):    #对象方法
        return f"id是{self.id}姓名是{self.name}的同学爱学习"

2、对象

对象是类的实例，是类的实际存在。每个对象都有自己独立的数据和方法。

class Student:
    def __init__(self,id,name):
        self.id = id   #对象属性
        self.name = name

    def ret(self):    #对象方法
        return f"id是{self.id},姓名是{self.name}的同学爱学习"

s1 = Student(1000,'张三')
print(s1.ret())

3、访问属性

可以使用点号 . 来访问对象的属性。使用如下类的名称访问类变量:

#访问属性
对象名.属性
#访问方法
对象名.方法

4、构造函数 与 析构函数

__init__ 构造函数：完成对象的初始化工作，方便统一管理、调用类创建对象时，自动执行。

__del__ 析构函数：删除对象时执行一些操作，自动执行。

__str__ 打印方法：输出执行信息，自动执行。

class Student:
    def __init__(self,id,name):
        self.id = id
        self.name = name

    def __str__(self):
        return f"id是{self.id},姓名是{self.name}的同学爱学习"

    def __del__(self):
        print  (f"{self.name}学累了，出去玩了")

s1 = Student(1000,'张三')
print(s1)

二、类属性和实例属性

1、类属性

类属性是绑定到类本身的属性，而不是绑定到类的实例。类属性的值对于类的所有实例都是共享的。这意味着如果修改了类属性，所有实例都会受到影响。

特点：

        1、类属性是通过类名访问的，也可以通过实例来访问（但建议通过类访问）。

        2、所有的实例共享同一个类属性。

        3、类属性通常用于存储类级别的信息

class Student:
    age = 18    #类属性
    def __init__(self,name,id):
        self.name = name    #实例属性
        self.id  =id    #实例属性

s1 = Student('张三',1000)
s2 = Student('李四',1001)

print(s1.age)
print(s2.age)

#修改类属性
Student.age = 20

print(s1.age)
print(s2.age)

2、实例属性

实例属性是绑定到类的实例（对象）上的属性。每个实例都有自己独立的实例属性，修改一个实例的属性不会影响其他实例的相同属性。

特点:

        1、实例属性通过实例来访问。

        2、每个实例都有自己的实例属性，互不影响。

        3、实例属性通常用于存储每个对象的特有信息。

class Student:
    def __init__(self,name,id):
        self.name = name    #实例属性
        self.id  =id    #实例属性

s1 = Student('张三',1000)
s2 = Student('李四',1001)

print(s1.name)
print(s2.name)

#修改实例属性
s1.name = '王五'

print(s1.name)
print(s2.name)

三、类方法与实例方法与静态方法

1、类方法

类方法是绑定到类本身的方法，而不是绑定到实例。类方法的第一个参数是 cls，表示当前类（而不是实例）。类方法主要用于操作类级别的数据（即类属性），而不是实例级别的数据。

        1、特点：类方法无法直接访问实例属性，只能访问类属性。

        2、使用：通过类或实例来调用，但它的第一个参数是 cls，代表类对象

        3、定义方式：使用 @classmethod 装饰器来定义类方法。

2、实例方法

实例方法是最常见的方法，它是绑定到实例对象的。实例方法的第一个参数通常是 self，self 代表当前实例对象。

        1、特点：实例方法可以访问和修改实例属性，也可以访问类属性。

        2、使用：通过实例来调用，方法内部可以操作实例数据。

3、静态方法

静态方法是绑定到类本身，但它不需要访问类或实例的任何属性或方法。静态方法没有 self 或 cls 参数，它就像一个普通的函数，只是放在类的命名空间下。静态方法常用于一些与类功能相关的任务，但不涉及实例数据或类数据的操作。

        1、特点：静态方法不需要访问类或实例的属性和方法，通常用于一些独立的功能。

        2、使用：通过类或实例来调用，但它没有默认的 self 或 cls 参数。

4、例子：

class Student(object):

    grade = 'py24101'

    @classmethod
    def cls_fun(cls):
        """类方法中只能调用类属性和类方法"""
        print(f"班级名称是{cls.grade}")

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def fun1(self):
        """实例方法中能调用类属性、实例属性"""
        print(f"实例方法中输出类属性{self.grade}, 输出实例属性{self.name}")

    @staticmethod
    def sta_fun(x):
        print(f"{x}静态方法一般实现与类和对象无关联的操作，例如：游戏说明书等")

s1 = Student('张三', 18)
# 如何调用类方法
Student.cls_fun()
s1.cls_fun()

# 如何调用实例方法
Student.fun1(s1)
s1.fun1()

# 如何调用静态方法
Student.sta_fun(3)
s1.sta_fun(3)

四、封装

1、私有属性

私有属性是通过在属性名前加上两个下划线（__）来表示，Python 会对其进行名称改写，使其不能被直接访问。私有属性主要用于保护对象的内部状态，防止外部直接修改。尽管如此，Python 仍然允许通过一些特殊方式来访问私有属性。

class Student:
    def __init__(self, name, age):
        self.__name = name  # 私有属性
        self.__age = age    # 私有属性

    def speak(self):
        return f"{self.__name} 爱学习"

# 创建实例
s1 = Student("张三", 3)

# 直接访问私有属性会报错
# print(s1.__name)  # 会抛出 AttributeError

# 可以通过类名访问
print(s1._Student__name)  # 输出: 张三

# 可以通过方法访问
print(s1.speak())  # 输出: 张三爱学习

2、私有方法

和私有属性相差不大。

class Student:
    def __init__(self, name, age):
        self.__name = name  # 私有属性
        self.__age = age    # 私有属性

    def __info(self):
        print( f"{self.__name} 爱学习")

    def get_info(self):
        self.__info()

# 创建实例
s1 = Student("张三", 3)

# 可以通过类名访问
print(s1._Student__name)  # 输出: 张三

# 可以通过方法访问
s1.get_info()  # 输出: 张三爱学习

五、继承

在 Python 中，继承（Inheritance）是面向对象编程（OOP）中的一个核心概念，它允许我们创建一个新类（子类），继承现有类（父类）的属性和方法，从而实现代码重用和扩展功能。通过继承，子类可以继承父类的所有公有和受保护的属性和方法，同时也可以重写或扩展父类的方法。

继承的基本概念：

        1、父类：被继承的类。

        2、子类：从父类继承的类。

基本语法

class 父类:
    # 父类的方法和属性

class 子类(父类):
    # 子类可以继承父类的方法和属性，也可以扩展或重写父类的方法

关键概念

1. super() 函数

super() 函数用于调用父类的方法或构造函数，通常用于在子类中调用父类的 __init__ 方法，确保父类初始化的操作能够正确执行。

在上面的示例中，super().__init__(name) 用于调用父类 Animal 的构造方法来初始化 name 属性。

2. 方法重写

子类可以重写父类的方法，以便提供特定的实现。通过重写，子类可以修改或扩展父类的行为。

在上面的示例中，Dog 和 Cat 类都重写了父类 Animal 的 speak 方法，使得每个子类都有自己特定的行为。

3. 多继承

Python 支持多继承，这意味着一个子类可以继承多个父类的属性和方法。多继承在某些情况下很有用，但也可能导致一些复杂性，尤其是当多个父类中有同名方法时。

4、例子

class Student1:
    def Std1(self):
        return "张三爱学习"

class Student2:
    def Std2(self):
        return "李四爱学习"

class Dog(Student1, Student2):
    def Std1(self):
        return "王五爱学习"

# 创建实例
dog = Dog()
print(dog.Std1())  # 输出: 王五爱学习
print(dog.Std2())  # 输出: 李四爱学习

六、多态

在 Python 中，多态是面向对象编程中的一个重要特性，它指的是不同的类可以通过相同的方法名来执行不同的操作。换句话说，多个不同的类可以定义相同的方法名，但每个类的实现可以不同。通过多态，程序能够以一致的方式处理不同类型的对象，从而使得代码更加灵活和可扩展。

例子：

class Animal(object):
    name = '动物'
    age = 0
    def speak(self):
        print("动物的声音")

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

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

a = Animal()
d = Dog()
c = Cat()

a.speak()
d.speak()
c.speak()