python类相关术语附带案例

面向对象：

面向对象编程是一种编程范式，它将程序看作是一系列相互作用的对象的集合，通过定义对象的属性和方法来描述问题的解决方案。对象的属性描述了对象的状态，而对象的方法描述了对象可以执行的操作。

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

    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        print(f"{self.name} 发出汪汪声")

class Cat(Animal):
    def make_sound(self):
        print(f"{self.name} 发出喵喵声")

dog = Dog("旺财")
cat = Cat("咪咪")

dog.make_sound()  
cat.make_sound()  

类：

类是面向对象编程中的一个重要概念，它是描述一组具有相同属性和方法的对象的模板。类可以看作是一种数据类型，它定义了对象的状态和行为，并可以通过实例化创建具体的对象。

class ClassName:
    # 类的属性和方法定义

实例：

在面向对象编程中，实例是指通过类创建的具体对象。

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

    def say_hello(self):
        print(f"Hello, my name is {self.name}, and I'm {self.age} years old.")

# 创建 Person 类的实例
p1 = Person("Alice", 30)
p2 = Person("Bob", 25)

初始化方法：

初始化方法是一个特殊的方法，用于在创建类的实例时进行对象的初始化操作

初始化方法的名称固定为 __init__，它在类定义中被定义为一个普通的方法，用于初始化对象的属性

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

# 创建 Person 类的实例
p1 = Person("Alice", 30)
p2 = Person("Bob", 25)

print(p1.name)  # 输出：Alice
print(p2.age)   # 输出：25

魔法方法：

是一些具有特殊命名规则的特殊函数

魔法方法的命名以双下划线开头和结尾，例如 __init__、__str__、__add__ 等。这些方法在特定情况下会被自动调用，而不需要我们直接调用。

以下是一些常用的魔法方法：

• __init__(self, ...)：初始化方法，在创建对象时自动调用，用于初始化对象的属性。
• __str__(self)：字符串表示方法，使用 str() 函数时自动调用，并返回对象的可读性好的字符串表示。
• __repr__(self)：对象表示方法，使用 repr() 函数时自动调用，并返回对象的官方字符串表示。
• __len__(self)：长度方法，使用 len() 函数时自动调用，并返回对象的长度。
• __getitem__(self, key)：索引访问方法，当通过索引来访问对象时自动调用。
• __setitem__(self, key, value)：索引赋值方法，当通过索引来修改对象时自动调用。
• __delitem__(self, key)：索引删除方法，当通过索引删除对象的元素时自动调用。
• __add__(self, other)：加法方法，当使用 + 运算符时自动调用。
• __sub__(self, other)：减法方法，当使用 - 运算符时自动调用。
• __eq__(self, other)：相等比较方法，当使用 == 运算符时自动调用。

字符串方法：

字符串是一种不可变的数据类型，它们具有许多内置的方法，用于执行各种操作和转换

s = "Hello, World!"
print(s.upper())       # 输出：HELLO, WORLD!
print(s.lower())       # 输出：hello, world!
print(s.capitalize())  # 输出：Hello, world!
print(s.title())       # 输出：Hello, World!
print(s.strip())       # 输出：Hello, World!
print(s.startswith("Hello"))  # 输出：True
print(s.endswith("!"))        # 输出：True
print(s.replace("Hello", "Hi"))  # 输出：Hi, World!

self：

self 是一个约定俗成的参数名

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def say_hello(self):
        print("Hello, my name is", self.name)
        print("I am", self.age, "years old.")

# 创建 Person 类的实例
p = Person("Alice",
[Something went wrong, please try again later.]

数据、属性、操作、行为：

• 数据：数据是类中存储的信息，可以是数字、字符串、列表、字典等。数据用于描述类的状态或特征。
• 属性：属性是与类相关联的数据，用于表示类的特征。属性通常直接存储在类的实例（对象）中，并且可以通过访问和修改属性的方式来操作数据。例如，一个 Person 类可能有一个 name 属性，用于存储人的姓名。
• 操作：操作是类中定义的方法，用于执行某些操作或处理数据。操作可以访问和操作类的属性，并根据需要执行特定的逻辑。例如，一个 Person 类可能有一个 say_hello 方法，用于打印人的姓名和问候语。
• 行为：行为是类的实例（对象）表现出来的动作或反应。行为通常由类的操作触发，并且可以改变类的状态或产生一些结果。例如，当调用 say_hello 方法时，一个 Person 对象会表现出打印问候语的行为。

class Person:
    def __init__(self, name):
        self.name = name
    
    def say_hello(self):
        print("Hello, my name is", self.name)

# 创建 Person 类的实例
p1 = Person("Alice")
p2 = Person("Bob")

# 访问对象的属性
print(p1.name)  # 输出：Alice
print(p2.name)  # 输出：Bob

# 调用对象的方法
p1.say_hello()  # 输出：Hello, my name is Alice
p2.say_hello()  # 输出：Hello, my name is Bob

父类、基类、超类：

父类、基类和超类都是描述一个类被继承的概念。子类可以从父类继承属性和方法，并且可以在此基础上扩展自己的功能

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

    def speak(self):
        print("I am an animal")

class Dog(Animal):
    def speak(self):
        print("I am a dog")

class Cat(Animal):
    def speak(self):
        print("I am a cat")

# 创建 Dog 和 Cat 类的实例
d = Dog("Fido")
c = Cat("Whiskers")

# 调用子类的方法
d.speak()  # 输出：I am a dog
c.speak()  # 输出：I am a cat

# 调用父类的方法
d.name    # 输出：Fido
c.name    # 输出：Whiskers

子类、派生类：

子类是从父类继承属性和方法的一个新类。子类通常也被称为派生类。

子类可以从父类继承属性和方法，并且可以在此基础上添加新的属性和方法，或者重写父类的方法。子类还可以调用父类的方法或属性，以便更好地扩展自己的功能。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def say_hello(self):
        print(f"My name is {self.name} and I am {self.age} years old.")

class Student(Person):
    def __init__(self, name, age, student_id):
        super().__init__(name, age)
        self.student_id = student_id
    
    def say_hello(self):
        super().say_hello()
        print(f"I am a student with ID {self.student_id}.")

class Teacher(Person):
    def __init__(self, name, age, subject):
        super().__init__(name, age)
        self.subject = subject
    
    def say_hello(self):
        super().say_hello()
        print(f"I am a teacher of {self.subject}.")

# 创建 Student 和 Teacher 类的实例
s = Student("Alice", 20, "12345")
t = Teacher("Bob", 30, "Math")

# 调用子类的方法
s.say_hello()  # 输出：My name is Alice and I am 20 years old. I am a student with ID 12345.
t.say_hello()  # 输出：My name is Bob and I am 30 years old. I am a teacher of Math.

# 调用父类的方法
print(s.name)  # 输出：Alice
print(t.age)   # 输出：30