1、类（Class）

类是创建对象的蓝图。它定义了一组属性（称为字段或变量）和方法（类中定义的函数）。

class MyClass:
    def __init__(self, attribute_value):
        self.attribute = attribute_value

    def method(self):
        return self.attribute

2、对象（Object）

对象是类的实例。当类被实例化时，会创建一个对象。每个对象都有自己的属性和方法，它们与类中定义的属性和方法相关联。

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

    def say_hello(self):
        print(f"Hello, {self.name}。{self.age}岁")
        
person1 = Person("张三", 30)
person2 = Person("李四", 25)
person1.say_hello()
person2.say_hello()

3、属性（Attribute）

属性是对象的数据成员，它们用于存储对象的状态。属性通常在类的构造函数 __init__ 中初始化，并通过 self 关键字访问。

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

    def say_hello(self):
        print(f"Hello, {self.name}。{self.age}岁")
        
person1 = Person("张三", 30)
person2 = Person("李四", 25)
#访问对象的属性
print(person1.name)
print(person2.name)

4、方法（Method)

方法是与对象相关联的函数。它们用于执行特定的操作。方法通常以 self 作为第一个参数，以便访问对象的属性和其他方法。

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

    def say_hello(self):
        print(f"Hello, {self.name}。{self.age}岁")
        
person1 = Person("张三", 30)
person2 = Person("李四", 25)
#调用对象的方法
person1.say_hello()
person2.say_hello()

5、继承（Inheritance）

继承是一种机制，它允许创建一个新的类（子类），该类可以继承另一个类（父类）的属性和方法。子类可以扩展或修改继承的属性和方法。

1）基本继承

Python所有类都是object的特殊类的子类，这个和其它语言中的类似，我们不指定父类，类是自动从object继承过来。我们也可以显示声明从object类继承，例如，

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

    def say_hello(self):
        print(f"Hello, {self.name}。{self.age}岁")

class Student(Person, object):
    def __init__(self, name, age, student_id):
        super().__init__(name, age)  # 调用父类的构造函数
        self.student_id = student_id

    def study(self):
        print(f"{self.name} is studying.")

student = Student("Lingliang", 21, "12345")

student.say_hello()

2）扩展内置类

可以继承内置类并扩展它们，以添加自定义的功能或行为。这可以通过创建一个新的类，并在新的类中继承内置类的属性和方法来实现。例如，

class MyList(list):
    def sum(self):
        """计算列表元素的总和"""
        total = 0
        for num in self:
            total += num
        return total

    def average(self):
        """计算列表元素的平均值"""
        if len(self) == 0:
            return 0
        return sum(self) / len(self)

    def append_unique(self, item):
        """仅当元素不在列表中时才添加元素"""
        if item not in self:
            self.append(item)

# 创建 MyList 对象
my_list = MyList([1, 2, 3, 4, 5])

# 使用继承的方法
print("Sum:", my_list.sum())         # 输出 Sum: 15
print("Average:", my_list.average()) # 输出 Average: 3.0

# 使用自定义方法
my_list.append_unique(3)
my_list.append_unique(6)
print("Unique List:", my_list)       # 输出 Unique List: [1, 2, 3, 4, 5, 6]

3）重写和Super

可以使用继承、方法重写和super()函数来扩展和自定义父类的行为。

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

    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return f"{self.name} C#!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} Java!"

class Parrot(Animal):
    def __init__(self, name, words):
        super().__init__(name)  # 调用父类的构造函数
        self.words = words

    def speak(self):
        return f"{self.name} {self.words}!"

# 创建不同的动物对象
dog = Dog("d1")
cat = Cat("d2")
parrot = Parrot("cjavapy", "Python")

# 调用各自的speak方法
print(dog.speak())     
print(cat.speak())     
print(parrot.speak())  

4）多重继承

Python 3 支持多重继承，也就是一个类可以继承自多个父类。子类可以继承多个父类的属性和方法。多重继承在某些情况下非常有用，但也需要小心使用，以避免潜在的复杂性和命名冲突。

# 定义父类 A
class A:
    def method_A(self):
        print("Method A from class A")

# 定义父类 B
class B:
    def method_B(self):
        print("Method B from class B")

# 定义子类 C，继承自 A 和 B
class C(A, B):
    def method_C(self):
        print("Method C from class C")

# 创建 C 的对象
obj_C = C()

# 调用 C 的方法
obj_C.method_A()  # 输出 Method A from class A
obj_C.method_B()  # 输出 Method B from class B
obj_C.method_C()  # 输出 Method C from class C

5）多态

多态（Polymorphism）是面向对象编程的一个重要概念，它允许不同的对象对相同的方法名做出不同的响应。

class Animal:
    def speak(self):
        pass

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

class Cat(Animal):
    def speak(self):
        return "Meow!"

class Cow(Animal):
    def speak(self):
        return "Moo!"

# 创建不同的动物对象
animals = [Dog(),Cat(),Cow()]

# 调用相同的方法名，但不同的对象产生不同的输出
for animal in animals :
    print(animal.speak())

6）封装

封装（Encapsulation）是面向对象编程（OOP）的一个重要概念，它指的是将类的内部数据和实现细节隐藏起来，只暴露必要的接口。封装有助于保护数据的完整性和安全性，并使代码更具可维护性和可扩展性。

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

    # 使用属性来访问和修改私有属性name
    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, new_name):
        if isinstance(new_name, str):
            self.__name = new_name
        else:
            print("Name must be a string.")

    # 使用方法来访问和修改私有属性age
    def get_age(self):
        return self.__age

    def set_age(self, new_age):
        if isinstance(new_age, int) and 0 <= new_age <= 150:
            self.__age = new_age
        else:
            print("Age must be an integer between 0 and 150.")

    def display_info(self):
        print(f"Name: {self.name}, Age: {self.get_age()}")

# 创建Student对象
student = Student("Levi", 25)

# 通过属性和方法访问和修改对象的属性
student.name = "John"
student.set_age(30)

# 显示学生信息
student.display_info()