Python进阶教程第二课——类

最新推荐文章于 2025-04-21 22:30:00 发布

本人来自霍格沃茨

最新推荐文章于 2025-04-21 22:30:00 发布

阅读量973

点赞数 24

分类专栏： python 文章标签： python 开发语言

本文链接：https://blog.youkuaiyun.com/liyibowen2006/article/details/145524383

版权

python 专栏收录该内容

12 篇文章

订阅专栏

系列文章目录

Python基础学习第一课——python环境的配置及vscode的安装汉化

Python基础第二课——基础知识

Python基础第三课——条件语句和循环语句

Python基础第四课——字符串的相关操作

Python基础第五课——列表和元组

Python基础第六课——字典

Python进阶教程第一课——函数

Python进阶教程第二课——类（本篇文章内容）

文章目录

编辑

系列文章目录

文章目录

前言

一、类是什么？

二、类的定义

1.定义

2.类的属性和方法

3.创建类的实例

三、类的方法类型

创建：

使用：

四、类的继承

1、基本继承

2、子类的初始化

3、方法重写

4、多重继承

五、特殊方法

六、封装

总结

前言

本篇文章中我们将详细介绍Python中类的相关知识点和概念，在系列文章目录中列出了我前面写过的文章内容，如果感兴趣的朋友可以去我的主页查阅。

在看文章的过程中，如果有问题的话，欢迎大家在评论区交流或者私信留言~

一、类是什么？

在Python中，类（class）是是面向对象编程（OOP）的核心概念之一。类是一个蓝图或模板，用于创建对象（实例）。类定义了对象的属性（数据）和方法（函数），允许你封装数据和行为，实现代码的复用和模块化。通过类，你可以创建多个具有相同属性和方法的对象。

单纯说概念，可能有些晦涩难懂，下面详细讲解类的定义和使用：

二、类的定义

1.定义

在Python中，我们使用关键字 class 来定义一个类。类名通常采用驼峰命名法（每个单词首字母大写）。

下面来给出一个简单的定义类的示例：

class MyClass:   # 定义类
    pass   # 空类

这只是在简单的定义一个类，所以我选择定义一个空类来举例，只是为了了解类是怎么定义的，并没有加入属性和方法的部分，那么接下来我们就讲讲类的组成。

2.类的属性和方法

属性：类的变量，用于存储数据。
方法：类的函数，用于定义行为。

class Dog:
    # 类属性（所有实例共享）
    species = "Canis familiaris"   # 类属性

    # 初始化方法（构造函数）
    def __init__(self, name, age): 
        # 实例属性（每个实例独有）
        self.name = name
        self.age = age

    # 实例方法
    def bark(self):
        return f"{self.name} says woof!"

    def get_age(self):
        return self.age  # 访问实例属性

代码解释

类定义：class Dog: 定义了一个名为 Dog 的类。
类属性：species = "Canis familiaris" 是一个类属性，它被所有 Dog 类的实例共享。这意味着无论创建多少个 Dog 实例，它们都具有相同的 species 属性值。
初始化方法：__init__ 是一个特殊的方法，也称为构造函数。当创建 Dog 类的新实例时，这个方法会自动调用。它接受两个参数 name 和 age，并将它们分别赋值给实例属性 self.name 和 self.age。
实例方法：
bark 方法返回一个字符串，表示狗在叫。它使用了实例属性 self.name 来显示狗的名字。
get_age 方法返回狗的年龄，即实例属性 self.age 的值。

看到这里是否还有些疑惑，感觉只是在创建和定义，还没有体会到类在其中的作用，不要心急，下面就来讲解如何创建类的实例以及如何访问类的属性和方法：

3.创建类的实例

通过类名加括号来创建实例，并传递初始化参数。

例如：

my_dog = Dog("Buddy", 3)  # 创建实例

现在我们的总代码就变成了这样：

class Dog:
    # 类属性（所有实例共享）
    species = "Canis familiaris"   # 类属性

    # 初始化方法（构造函数）
    def __init__(self, name, age): 
        # 实例属性（每个实例独有）
        self.name = name
        self.age = age

    # 实例方法
    def bark(self):
        return f"{self.name} says woof!"

    def get_age(self):
        return self.age  # 访问实例属性

my_dog = Dog("Buddy", 3)  # 创建实例

代码解释

创建了 Dog 类的一个实例 my_dog，实例的 name 属性值为 "Buddy"，age 属性值为 3。

然后再对这个类进行访问，我们可以访问他的属性和方法：

print(my_dog.name)    # 访问实例属性 输出：Buddy
print(my_dog.age)     # 访问实例属性 输出：3
print(my_dog.bark())     # 调用实例方法 输出：Buddy says woof!
print(my_dog.get_age())  # 调用实例方法 输出：3
print(my_dog.species)  # 访问类属性 输出：Canis familiaris

最后运行程序，终端就得到了这样的结果：

三、类的方法类型

创建：

实例方法：操作实例属性，第一个参数是 self。

类方法：操作类属性，使用 @classmethod 装饰器，第一个参数是 cls。

静态方法：与类和实例无关，使用 @staticmethod 装饰器，不需要 self 或 cls。

这里给出一个代码示例：

class MyClass:
    class_attr = "Class Attribute"     # 类属性

    def __init__(self, value):    # 实例初始化时，会调用__init__方法
        self.instance_attr = value    # 实例属性

    # 实例方法
    def instance_method(self):    # 实例方法可以访问实例属性
        return f"Instance method: {self.instance_attr}"

    # 类方法
    @classmethod    # 类方法的第一个参数必须是cls
    def class_method(cls):      # 类方法可以访问类属性
        return f"Class method: {cls.class_attr}"

    # 静态方法
    @staticmethod    # 静态方法不需要访问类或实例属性
    def static_method():      # 静态方法可以被调用，但不能访问类或实例属性
        return "Static method: No access to class or instance"

代码解释

这段代码定义了一个名为 MyClass 的类，展示了类属性、实例属性以及实例方法、类方法和静态方法的使用。
MyClass 类包含一个类属性 class_attr，其值为 "Class Attribute"。类属性由该类的所有实例共享，意味着无论创建多少个 MyClass 实例，它们都能访问相同的 class_attr 值。
__init__ 是类的初始化方法，也就是构造函数。当创建 MyClass 的新实例时，此方法会自动执行。它接收一个参数 value，并将其赋值给实例属性 self.instance_attr。这使得每个实例可以拥有不同的 instance_attr 值，具体取决于创建实例时传入的参数。
instance_method 是一个实例方法，意味着它需要通过类的实例来调用。在方法内部，使用 self 关键字访问当前实例的 instance_attr 属性，从而返回包含该属性值的字符串信息。
class_method 是一个类方法，通过 @classmethod 装饰器进行标记。类方法的第一个参数通常为 cls，它指向类本身，而非类的实例。这使得类方法能够访问和操作类属性，在这个例子中返回包含 class_attr 值的字符串。类方法既可以通过类名直接调用，也可以通过实例调用。
static_method 是一个静态方法，由 @staticmethod 装饰器定义。静态方法没有像 self 或 cls 这样的特殊默认参数，这表明它既不能直接访问类属性，也不能访问实例属性。静态方法通常用于实现一些与类或实例相关，但不需要依赖其属性的通用功能，这里仅返回一条固定的字符串信息。

使用：

obj = MyClass("Instance Value")

print(obj.instance_method())  # 输出: Instance method: Instance Value
print(MyClass.class_method()) # 输出: Class method: Class Attribute
print(MyClass.static_method())# 输出: Static method: No access to class or instance

四、类的继承

继承是面对对象编程（OOP）的重要特性，它允许一个类（子类、派生类）继承另一个类（父类、基类）的属性和方法。通过继承，子类可以重用父类的代码，并且可以在此基础上添加新的功能或修改现有功能，从而提高代码的可复用性和可维护性。

1、基本继承

在 Python 中，定义子类时，可以在类名后面的括号中指定父类。下面给出一个简单的示例：

# 定义父类
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound.")

# 定义子类，继承自Animal类
class Dog(Animal):
    pass

# 创建Dog类的实例
dog = Dog("Buddy")
# 可以调用父类的方法
dog.speak()   #输出: Buddy makes a sound.

代码解释

在这个例子中，Dog类继承自Animal类，虽然Dog类本身没有定义任何方法，但它可以使用Animal类中定义的__init__和speak方法。

2、子类的初始化

当子类需要有自己独特的属性时，需要在子类中定义自己的__init__方法。在子类的__init__方法中，可以通过super()函数调用父类的__init__方法来初始化父类的属性。

下面给出代码示例：

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

    def speak(self):
        print(f"{self.name} makes a sound.")

class Dog(Animal):
    def __init__(self, name, breed):
        # 调用父类的__init__方法
        super().__init__(name)
        self.breed = breed

    def bark(self):
        print(f"{self.name} the {self.breed} barks.")

dog = Dog("Buddy", "Golden Retriever")
dog.speak()     # 输出: Buddy makes a sound.
dog.bark()     # 输出: Buddy the Golden Retriever barks.

代码解释

在这个例子中，Dog类有自己的__init__方法，它首先调用父类的__init__方法来初始化name属性，然后再初始化自己的breed属性。同时，Dog类还定义了一个新的方法bark。

3、方法重写

子类可以重写父类的方法，即子类可以定义一个与父类中同名的方法，从而改变该方法的行为。

给出代码示例如下：

class Animal:    # 父类
    def __init__(self, name):    # 父类构造函数
        self.name = name     # 实例变量

    def speak(self):    # 父类的方法
        print(f"{self.name} makes a sound.")

class Dog(Animal):    # 子类
    def __init__(self, name, breed):    # 子类构造函数
        super().__init__(name)    # 调用父类构造函数
        self.breed = breed     # 实例变量

    # 重写父类的speak方法
    def speak(self):
        print(f"{self.name} the {self.breed} barks.")

dog = Dog("Buddy", "Golden Retriever")
dog.speak()     #输出：Buddy the Golden Retriever barks.

代码解释

在这个例子中，Dog类重写了Animal类的speak方法，当调用dog.speak()时，会执行Dog类中定义的speak方法。

4、多重继承

Python 支持多重继承，即一个子类可以继承多个父类。多重继承可以让子类同时拥有多个父类的属性和方法。

依然给出代码示例：

class Flyable:    #定义Flyable类
    def fly(self):     #定义fly方法
        print("Can fly.")

class Swimmable:    #定义Swimmable类
    def swim(self):    #定义swim方法
        print("Can swim.")

class Duck(Flyable, Swimmable):    #定义Duck类，继承Flyable和Swimmable类
    def quack(self):    #定义quack方法
        print("Quack!")

duck = Duck()     #实例化Duck对象
duck.fly()      #调用Flyable类的fly方法  输出：Can fly.
duck.swim()     #调用Swimmable类的swim方法  输出：Can swim.
duck.quack()    #调用Duck类的quack方法  输出：Quack!

五、特殊方法

Python类中有一些以双下划线 __ 开头和结尾的特殊方法，用于实现特定功能。例如：

__init__：构造函数。

__str__：定义对象的字符串表示。

__len__：定义对象的长度。

定义：

class Book:
    def __init__(self, title, author):   #构造函数 
        self.title = title     #实例变量
        self.author = author   #实例变量

    def __str__(self):    #打印实例变量
        return f"{self.title} by {self.author}"   #返回实例变量

    def __len__(self):    #返回实例变量的长度
        return len(self.title)    #返回实例变量的长度

使用:

book = Book("Python Programming", "John Doe")
print(book)        # 输出: Python Programming by John Doe
print(len(book))   # 输出: 18

六、封装

封装是OOP的核心概念之一，通过将数据和方法隐藏在类内部，只暴露必要的接口。

使用 _ 开头的属性或方法表示受保护的（约定俗成，非强制）。
使用 __ 开头的属性或方法表示私有的（名称会被改写，无法直接访问）。

这部分内容讲解起来就有些复杂了，可以看看代码，通过代码的逻辑关系来理解，我在必要的地方都补上了注释便于阅读。

class BankAccount:
    def __init__(self, owner, balance=0):
        # 初始化账户所有者姓名
        self.owner = owner
        # 初始化账户余额，使用双下划线将其设为私有属性
        self.__balance = balance  

    def deposit(self, amount):
        # 存款操作，将存入的金额累加到账户余额中
        self.__balance += amount

    def withdraw(self, amount):
        # 检查取款金额是否小于等于账户余额
        if amount <= self.__balance:
            # 如果余额足够，从账户余额中减去取款金额
            self.__balance -= amount
        else:
            # 如果余额不足，打印提示信息
            print("Insufficient funds")

    def get_balance(self):
        # 返回当前账户的余额
        return self.__balance

使用：

# 创建一个 BankAccount 类的实例对象 account
# 账户所有者是 "Alice"，初始余额为 1000
account = BankAccount("Alice", 1000)

# 调用 account 对象的 deposit 方法，向账户中存入 500 元
# 此时账户余额变为 1000 + 500 = 1500
account.deposit(500)

# 调用 account 对象的 withdraw 方法，从账户中取出 200 元
# 由于账户余额 1500 大于 200，取款操作成功，账户余额变为 1500 - 200 = 1300
account.withdraw(200)

# 调用 account 对象的 get_balance 方法获取当前账户余额
# 并使用 print 函数将余额输出，预期输出结果为 1300
print(account.get_balance())