分类 Python 下的文章

请输入图片描述
之前程序都是单一的一次演示,我们希望程序可以多用户使用,所以每个用户应该有登录与登出的操作
前面已经演示了用户注册,登录,这里接着增加登出的操作

'''
ver4.py: 增加用户logout功能
'''
class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
        self.is_checked_out = False

    def check_out(self):
        if not self.is_checked_out:
            self.is_checked_out = True
            print(f"The book '{self.title}' by {self.author} has been checked out.")
        else:
            print("Sorry, the book is already checked out.")

    def check_in(self):
        if self.is_checked_out:
            self.is_checked_out = False
            print(f"Thank you for returning '{self.title}' by {self.author}.")
        else:
            print("The book is not checked out.")

    def display_info(self):
        status = "Available" if not self.is_checked_out else "Checked Out"
        print(f"Title: {self.title}, Author: {self.author}, Status: {status}")


class User:
    def __init__(self, username, password):
        self.username = username
        self.password = password
        self.borrowed_books = []

    def borrow_book(self, book):
        if not book.is_checked_out:
            book.check_out()
            self.borrowed_books.append(book)
            print(f"{self.username} has borrowed '{book.title}'.")
        else:
            print("Sorry, the book is already checked out.")

    def return_book(self, book):
        if book in self.borrowed_books:
            book.check_in()
            self.borrowed_books.remove(book)
            print(f"{self.username} has returned '{book.title}'.")
        else:
            print("This book is not borrowed by the user.")

class Library:
    def __init__(self):
        self.books = []
        self.users = []
        self.current_user = None

    def add_book(self, book):
        self.books.append(book)

    def add_user(self, user):
        self.users.append(user)

    def list_books(self):
        print("Library Catalog:")
        for book in self.books:
            book.display_info()

    def search_book_by_name(self, book_name):
        for book in self.books:
            if book.title == book_name:
                return book
        return None

    def check_book_status(self, book_name):
        book = self.search_book_by_name(book_name)
        if book:
            if book.is_checked_out:
                print(f"The book '{book_name}' is checked out.")
            else:
                print(f"The book '{book_name}' is available.")
        else:
            print(f"The book '{book_name}' is not found in the library.")

    def user_login(self, username, password):
        for user in self.users:
            if user.username == username and user.password == password:
                self.current_user = user
                return user
        return None

    def user_registration(self, username, password):
        new_user = User(username, password)
        self.users.append(new_user)
        print(f"User '{username}' has been registered.")

    def user_logout(self):
        print(f"Goodbye, {self.current_user.username}!")
        self.current_user = None

# 创建图书馆对象
library = Library()

# 将图书加入图书馆
library.add_book(Book("The Great Gatsby", "F. Scott Fitzgerald"))
library.add_book(Book("To Kill a Mockingbird", "Harper Lee"))
library.add_book(Book("1984", "George Orwell"))

while True:
    print("\nLibrary Menu:")
    print("1. List Books")
    print("2. Check Book Status")
    print("3. User Login")
    print("4. User Registration")
    print("5. Logout")
    print("6. Exit")

    choice = input("Enter your choice (1-6): ")

    if choice == "1":
        library.list_books()
    elif choice == "2":
        book_name = input("Enter the book name: ")
        library.check_book_status(book_name)
    elif choice == "3":
        username = input("Enter your username: ")
        password = input("Enter your password: ")
        logged_in_user = library.user_login(username, password)
        if logged_in_user:
            print(f"Welcome, {logged_in_user.username}!")
            # 用户操作(借书、还书等)
            while True:
                print("\nUser Menu:")
                print("1. Borrow a Book")
                print("2. Return a Book")
                print("3. Logout")
                user_choice = input("Enter your choice (1-3): ")
                if user_choice == "1":
                    book_name = input("Enter the book name to borrow: ")
                    book = library.search_book_by_name(book_name)
                    if book:
                        logged_in_user.borrow_book(book)
                    else:
                        print("Book not found.")
                elif user_choice == "2":
                    book_name = input("Enter the book name to return: ")
                    book = library.search_book_by_name(book_name)
                    if book:
                        logged_in_user.return_book(book)
                    else:
                        print("Book not found.")
                elif user_choice == "3":
                    library.user_logout()
                    break
                else:
                    print("Invalid choice. Please enter a number between 1 and 3.")
        else:
            print("Login failed. Invalid username or password.")
    elif choice == "4":
        username = input("Enter your new username: ")
        password = input("Enter your new password: ")
        library.user_registration(username, password)
    elif choice == "5":
        if library.current_user:
            library.user_logout()
        else:
            print("No user currently logged in.")
    elif choice == "6":
        print("Exiting the library. Goodbye!")
        break
    else:
        print("Invalid choice. Please enter a number between 1 and 6.")

请输入图片描述
前面程序已经定了一个User类,接着程序里面增加一个菜单入口,让用户可以注册和登录操作:

'''
ver3.py: 增加用户注册与登录的界面
'''
class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
        self.is_checked_out = False

    def check_out(self):
        if not self.is_checked_out:
            self.is_checked_out = True
            print(f"The book '{self.title}' by {self.author} has been checked out.")
        else:
            print("Sorry, the book is already checked out.")

    def check_in(self):
        if self.is_checked_out:
            self.is_checked_out = False
            print(f"Thank you for returning '{self.title}' by {self.author}.")
        else:
            print("The book is not checked out.")

    def display_info(self):
        status = "Available" if not self.is_checked_out else "Checked Out"
        print(f"Title: {self.title}, Author: {self.author}, Status: {status}")


class User:
    def __init__(self, username, password):
        self.username = username
        self.password = password
        self.borrowed_books = []

    def borrow_book(self, book):
        if not book.is_checked_out:
            book.check_out()
            self.borrowed_books.append(book)
            print(f"{self.username} has borrowed '{book.title}'.")
        else:
            print("Sorry, the book is already checked out.")

    def return_book(self, book):
        if book in self.borrowed_books:
            book.check_in()
            self.borrowed_books.remove(book)
            print(f"{self.username} has returned '{book.title}'.")
        else:
            print("This book is not borrowed by the user.")

class Library:
    def __init__(self):
        self.books = []
        self.users = []

    def add_book(self, book):
        self.books.append(book)

    def add_user(self, user):
        self.users.append(user)

    def list_books(self):
        print("Library Catalog:")
        for book in self.books:
            book.display_info()

    def search_book_by_name(self, book_name):
        for book in self.books:
            if book.title == book_name:
                return book
        return None

    def check_book_status(self, book_name):
        book = self.search_book_by_name(book_name)
        if book:
            if book.is_checked_out:
                print(f"The book '{book_name}' is checked out.")
            else:
                print(f"The book '{book_name}' is available.")
        else:
            print(f"The book '{book_name}' is not found in the library.")

    def user_login(self, username, password):
        for user in self.users:
            if user.username == username and user.password == password:
                return user
        return None

    def user_registration(self, username, password):
        new_user = User(username, password)
        self.users.append(new_user)
        print(f"User '{username}' has been registered.")

# 创建图书馆对象
library = Library()

# 将图书加入图书馆
library.add_book(Book("The Great Gatsby", "F. Scott Fitzgerald"))
library.add_book(Book("To Kill a Mockingbird", "Harper Lee"))
library.add_book(Book("1984", "George Orwell"))

while True:
    print("\nLibrary Menu:")
    print("1. List Books")
    print("2. Check Book Status")
    print("3. User Login")
    print("4. User Registration")
    print("5. Exit")

    choice = input("Enter your choice (1-5): ")

    if choice == "1":
        library.list_books()
    elif choice == "2":
        book_name = input("Enter the book name: ")
        library.check_book_status(book_name)
    elif choice == "3":
        username = input("Enter your username: ")
        password = input("Enter your password: ")
        logged_in_user = library.user_login(username, password)
        if logged_in_user:
            print(f"Welcome, {logged_in_user.username}!")
            # 用户操作(借书、还书等)
            # 可以在这里添加一些用户交互的代码
        else:
            print("Login failed. Invalid username or password.")
    elif choice == "4":
        username = input("Enter your new username: ")
        password = input("Enter your new password: ")
        library.user_registration(username, password)
    elif choice == "5":
        print("Exiting the library. Goodbye!")
        break
    else:
        print("Invalid choice. Please enter a number between 1 and 5.")

请输入图片描述

前面展示了一个简单的面向对象的图书馆应用,定义了Library,Book两个类,缺少用户的管理,比如默认只有一个用户借书、还书
对于正常实际的图书馆应用比如涉及多个用户使用借书、还书的功能,这里我们就在前面程序的基础上增加用户管理的功能 - 简单的用户注册

这个程序首先新增加了一个类定义User

class User:
    def __init__(self, username, password):
        self.username = username
        self.password = password
        self.borrowed_books = []

    def borrow_book(self, book):
        if not book.is_checked_out:
            book.check_out()
            self.borrowed_books.append(book)
            print(f"{self.username} has borrowed '{book.title}'.")
        else:
            print("Sorry, the book is already checked out.")

    def return_book(self, book):
        if book in self.borrowed_books:
            book.check_in()
            self.borrowed_books.remove(book)
            print(f"{self.username} has returned '{book.title}'.")
        else:
            print("This book is not borrowed by the user.")

User类包含用户基本信息,同时也维护所借阅book的信息

Library类内部需要增加一些数据定义,维护用户的信息

def __init__(self):
        self.books = []
        self.users = []

使用一个list保存注册到Library的用户

完整的演示

class User:
        def __init__(self, username, password):
            self.username = username
            self.password = password
            self.borrowed_books = []
    
        def borrow_book(self, book):
            if not book.is_checked_out:
                book.check_out()
                self.borrowed_books.append(book)
                print(f"{self.username} has borrowed '{book.title}'.")
            else:
                print("Sorry, the book is already checked out.")
    
        def return_book(self, book):
            if book in self.borrowed_books:
                book.check_in()
                self.borrowed_books.remove(book)
                print(f"{self.username} has returned '{book.title}'.")
            else:
                print("This book is not borrowed by the user.")
    
    class Library:
        def __init__(self):
            self.books = []
            self.users = []
    
        def add_book(self, book):
            self.books.append(book)
    
        def add_user(self, user):
            self.users.append(user)
    
        def list_books(self):
            print("Library Catalog:")
            for book in self.books:
                book.display_info()
    
        def search_book_by_name(self, book_name):
            for book in self.books:
                if book.title == book_name:
                    return book
            return None
    
        def check_book_status(self, book_name):
            book = self.search_book_by_name(book_name)
            if book:
                if book.is_checked_out:
                    print(f"The book '{book_name}' is checked out.")
                else:
                    print(f"The book '{book_name}' is available.")
            else:
                print(f"The book '{book_name}' is not found in the library.")
    
        def user_login(self, username, password):
            for user in self.users:
                if user.username == username and user.password == password:
                    return user
            return None
    
    # 创建图书馆对象
    library = Library()
    
    # 将图书加入图书馆
    library.add_book(Book("The Great Gatsby", "F. Scott Fitzgerald"))
    library.add_book(Book("To Kill a Mockingbird", "Harper Lee"))
    library.add_book(Book("1984", "George Orwell"))
    
    # 注册用户
    user1 = User("user1", "password1")
    user2 = User("user2", "password2")
    
    # 将用户加入图书馆
    library.add_user(user1)
    library.add_user(user2)
    
    # 用户登录
    logged_in_user = library.user_login("user1", "password1")
    
    if logged_in_user:
        # 用户借书
        library.check_book_status("The Great Gatsby")
        logged_in_user.borrow_book(library.search_book_by_name("The Great Gatsby"))
    
        # 用户还书
        logged_in_user.return_book(library.search_book_by_name("The Great Gatsby"))
    
        # 再次查询书籍状态
        library.check_book_status("The Great Gatsby")
    else:
        print("Login failed. Invalid username or password.")

8-LeWD3rr3UzgTEpt.png

虚拟环境

在Python中,虚拟环境是一种用于隔离项目依赖和包的工具,以便在不同项目之间管理不同版本的库和包。虚拟环境允许你在同一系统上同时运行多个Python项目,每个项目都可以有自己独立的依赖,而不会互相干扰。

创建虚拟环境的基本步骤

以下是在Python中创建虚拟环境的基本步骤:

1. 安装virtualenv(可选):

在某些Python发行版中,virtualenv已经包含在内,你可以直接使用。如果你使用的是较旧的Python版本或者没有安装virtualenv,你可以通过以下方式安装它:

pip install virtualenv

2. 创建虚拟环境:

选择一个用于存放虚拟环境的目录,并使用virtualenv命令创建虚拟环境。例如,假设你想在项目目录中创建一个名为myenv的虚拟环境,你可以运行以下命令:

virtualenv myenv

这将在当前目录下创建一个myenv文件夹,并在其中创建一个独立的Python解释器和标准库。

3. 激活虚拟环境:

在不同的操作系统上,激活虚拟环境的方式有所不同:

  • 在 Windows 上,使用以下命令激活虚拟环境:

    myenv\Scripts\activate

  • 在 macOS 和 Linux 上,使用以下命令激活虚拟环境:

    source myenv/bin/activate

一旦虚拟环境被激活,你的命令行提示符将会显示虚拟环境的名称,表示你正在使用虚拟环境。

3. 安装依赖:

在虚拟环境中,你可以使用pip来安装项目所需的依赖包,这些依赖包将仅在当前虚拟环境中可用,不会影响系统Python或其他虚拟环境。
例如

pip install pygame

4. 退出虚拟环境:

当你完成项目工作或者需要切换到另一个虚拟环境时,可以使用以下命令退出当前虚拟环境:

deactivate

这样,你就可以创建和管理多个独立的Python虚拟环境,每个虚拟环境都可以具有不同的依赖项,使项目之间保持隔离。这对于开发和维护Python项目非常有用。

virtualenv myenv 和 python -m venv myenv两种方式的区别

virtualenvpython -m venv 是两种用于创建 Python 虚拟环境的不同工具,它们有一些区别,包括支持的 Python 版本和一些功能。

1. virtualenv:

virtualenv 是一个独立的第三方工具,需要单独安装(使用 pip install virtualenv)。
它兼容多个 Python 版本,并且可以用于创建 Python 2.x 和 Python 3.x 的虚拟环境。
virtualenv 生成的虚拟环境通常较小,因为它不包含 Python 标准库。
可以使用 --system-site-packages 标志来让虚拟环境访问系统全局安装的包。
示例创建虚拟环境的命令:

virtualenv myenv

2. python -m venv:

python -m venv 是 Python 内置的虚拟环境创建工具,不需要额外安装。
它是 Python 3.3 及更高版本的一部分,因此只能用于创建 Python 3.x 的虚拟环境。
python -m venv 生成的虚拟环境包含了 Python 标准库。
默认情况下,虚拟环境是隔离的,不会访问系统全局安装的包,这有助于确保项目的依赖独立。
示例创建虚拟环境的命令:

python -m venv myenv

总的来说,如果你在使用 Python 3.x,推荐使用 python -m venv 来创建虚拟环境,因为它是 Python 内置的工具,并且通常更容易使用。如果你需要在多个 Python 版本之间切换,或者需要使用 Python 2.x,那么 virtualenv 可能是一个更好的选择。

小结

最新的python3 是主流,已经到python 3.12了,所以还是推荐使用python -m venv方式创建虚拟环境变量,用起来比较顺手。介绍的知识作为参考,上网查询的时候可能会碰到这些不同的做法,有个心理准备!

除了 virtualenv 和 python -m venv,还有其他一些方式可以创建虚拟环境,具体取决于你的需求和环境。以下是一些其他常见的虚拟环境管理工具, conda, pyenv,Pipenv
这些工具都具有不同的优点和特点,可以根据你的需求和偏好选择其中之一来管理虚拟环境。每种工具都有其独特的用例,因此可以根据项目的具体需求来选择最合适的方式。
细节就不展开了,等有了足够的经验,再自行探索,目前我们就用python -m venv myvenv创建虚拟环境
>python -m venv myvenv
>source myvenv/bin/activate
>deactivate

R-C.png

当涉及到面向对象编程(Object-Oriented Programming,OOP)时,Python是一种非常强大且灵活的编程语言。在Python中,一切皆对象,你可以使用类(class)和对象(object)来实现面向对象的编程范例。这使得代码更加模块化、可重用,并且更易于理解。

下面是一个简单的Python面向对象编程入门指南:

1. 类和对象

类是一个定义了对象的结构和行为的蓝图,而对象则是类的实例化。类是创建对象的模板,包含了属性(成员变量)和方法(成员函数)。可以使用关键字class来创建类。

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

    def greet(self):
        return f"Hello, {self.name}!"

2. 构造函数和实例化

在上面的例子中,__init__是一个特殊的方法,称为构造函数(Constructor)。它在创建对象时自动调用,并用于初始化对象的属性。self参数表示类的实例本身。

实例化一个类意味着创建类的一个具体对象,这可以通过以下方式完成:

obj = MyClass("John")

3. 成员变量和成员函数

成员变量是类中存储数据的属性,可以通过self.variable_name来定义和访问它们。成员函数是类中定义的方法,可以访问和操作成员变量,也可以执行其他操作。

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

    def greet(self):
        return f"Hello, {self.name}!"

    def set_name(self, new_name):
        self.name = new_name

4. 继承

继承是OOP中的一个重要概念,允许你创建一个新类(子类),并从现有类(父类)继承属性和方法。子类可以覆盖父类的方法或添加新的方法。

class ChildClass(MyClass):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age

    def greet(self):
        return f"Hello, {self.name}! You are {self.age} years old."

5. 多态

多态性允许不同类的对象对相同的方法进行调用,但是根据对象的类型,方法的实现可能会有所不同。这增加了灵活性和可扩展性。
举例说明一下多态:
当涉及到多态时,我们通常会利用继承和方法重写的特性。多态允许不同类的对象对相同的方法进行调用,但是根据对象的类型,方法的实现可能会有所不同。这增加了代码的灵活性,使得我们可以在运行时选择调用哪个类的方法。

让我们通过一个简单的例子来说明多态:

假设我们有一个动物类 Animal,它有一个 speak 方法,用于返回该动物的叫声。然后我们有两个子类 Dog 和 Cat,它们分别继承自 Animal 类,并且都重写了 speak 方法。

class Animal:

def speak(self):
    return "Unknown animal sound."

class Dog(Animal):

def speak(self):
    return "Woof!"

class Cat(Animal):

def speak(self):
    return "Meow!"

在我们可以创建 Dog 和 Cat 的对象,并调用它们的 speak 方法:

dog = Dog()
cat = Cat()

print(dog.speak()) # 输出: "Woof!"
print(cat.speak()) # 输出: "Meow!"

在这个例子中,我们使用多态来实现了不同类型的动物有不同的叫声。虽然我们调用了相同的 speak 方法,但由于对象的类型不同,它们的实现也不同。这就是多态的效果。

多态性还可以在更复杂的场景中发挥作用,比如创建一个函数,该函数接受 Animal 类的对象作为参数,并调用它们的 speak 方法:

def animal_sound(animal):

return animal.speak()

使用多态调用不同对象的 speak 方法

print(animal_sound(dog)) # 输出: "Woof!"
print(animal_sound(cat)) # 输出: "Meow!"

通过这种方式,我们可以根据传递给 animal_sound 函数的实际对象来调用不同类的方法,而无需显式地编写多个条件判断语句。这提高了代码的可读性和可维护性。

6. 封装

封装是OOP中的另一个重要概念,它意味着将数据和代码(方法)包装在一个单独的单位中,对外部隐藏内部的实现细节。这可以通过使用私有成员变量和方法来实现,例如在成员变量前加上双下划线__。
举例详细说明一下封装的概念

封装是面向对象编程中的一个重要概念,它指的是将数据(成员变量)和代码(成员函数)包装在一个单独的单位中,并对外部隐藏内部的实现细节。封装使得对象的内部实现对外部是不可见的,只有通过公共接口(成员函数)才能与对象进行交互。这样可以保护数据的完整性,避免直接访问和修改对象的内部状态,从而降低了代码的耦合性,提高了代码的安全性和可维护性。

在Python中,封装通过使用访问控制修饰符来实现,这些修饰符是命名约定,而不是强制性的。Python有三种类型的访问控制修饰符:

公有访问修饰符:成员变量和成员函数默认为公有,可以在类的内部和外部进行访问。

受保护的访问修饰符:在成员变量或成员函数名前加上一个下划线 _,表示这些成员在类的内部和子类中可以访问,但在类的外部不应直接访问。

私有访问修饰符:在成员变量或成员函数名前加上两个下划线 __,表示这些成员只能在类的内部访问,对于类的外部是不可见的。

让我们通过一个简单的示例来说明封装的概念:

class Car:
    def __init__(self, make, model, year):
        self.make = make  # 公有变量
        self.model = model  # 公有变量
        self.__year = year  # 私有变量

    def start_engine(self):
        return "Engine started!"

    def __display_year(self):  # 私有方法
        return f"Manufactured in {self.__year}"

    def get_year(self):  # 公有方法,用于获取私有变量的值
        return self.__display_year()


car = Car("Toyota", "Camry", 2022)

print(car.make)  # 输出: "Toyota"
print(car.start_engine())  # 输出: "Engine started!"

# 下面这两行代码会导致错误,因为 __year 是私有变量
# print(car.__year)
# print(car.__display_year())

# 使用公有方法获取私有变量的值
print(car.get_year())  # 输出: "Manufactured in 2022"

在上面的示例中,我们定义了一个 Car 类,其中包含一个公有变量 make、model,和一个私有变量 __year。我们还定义了一个公有方法 get_year(),用于获取私有变量 __year 的值。通过这种方式,我们实现了封装,隐藏了 __year 变量的实现细节,同时还提供了一个公共接口来访问和获取这个私有变量的值。

总结来说,封装是面向对象编程的一种核心原则,它通过访问控制修饰符来隐藏对象的内部实现细节,提高代码的安全性和可维护性,同时也提供了一个公共接口,通过该接口来与对象进行交互。这样可以有效地隔离和组织代码,让代码更易于理解和维护。

7. 访问控制

Python没有严格的访问控制机制,但通过命名约定来实现对类成员的访问限制。以单下划线开头的成员被认为是受保护的,应该避免直接访问,而以双下划线开头的成员是私有的,外部无法直接访问。
举例详细解释一下访问控制概念

访问控制是面向对象编程中用于限制类成员(成员变量和成员函数)访问权限的机制。在Python中,访问控制是通过访问控制修饰符实现的,这些修饰符是命名约定,不是强制性的。

Python中有三种类型的访问控制修饰符:

公有访问修饰符:成员变量和成员函数默认为公有,在类的内部和外部都可以进行访问。

受保护的访问修饰符:在成员变量或成员函数名前加上一个下划线 _,表示这些成员在类的内部和子类中可以访问,但在类的外部不应直接访问。虽然在语法上是可以访问的,但是通常认为这些成员不应该被外部直接访问。

私有访问修饰符:在成员变量或成员函数名前加上两个下划线 __,表示这些成员只能在类的内部访问,对于类的外部是不可见的。外部无法直接访问私有成员,但在类的内部是可以访问的。

让我们通过一个示例来解释访问控制的细节:

class MyClass:
    def __init__(self):
        self.public_var = "This is a public variable."
        self._protected_var = "This is a protected variable."
        self.__private_var = "This is a private variable."

    def public_method(self):
        return "This is a public method."

    def _protected_method(self):
        return "This is a protected method."

    def __private_method(self):
        return "This is a private method."

变量和成员函数:

public_var 和 public_method 是公有的,可以在类的内部和外部直接访问。

_protected_var 和 _protected_method 是受保护的,在类的内部和子类中可以访问,但在类的外部也可以直接访问。但是通常不建议在类的外部直接访问受保护的成员。

__private_var 和 __private_method 是私有的,只能在类的内部访问,对于类的外部是不可见的。

现在,我们来测试一下是否能够直接访问这些成员:

obj = MyClass()

# 访问公有成员
print(obj.public_var)        # 输出: "This is a public variable."
print(obj.public_method())   # 输出: "This is a public method."

# 访问受保护成员(不建议这样做,但是语法上是可以的)
print(obj._protected_var)    # 输出: "This is a protected variable."
print(obj._protected_method())  # 输出: "This is a protected method."

# 下面这两行代码会导致错误,因为 __private_var 和 __private_method 是私有成员
# print(obj.__private_var)
# print(obj.__private_method)

虽然在Python中语法上是可以直接访问受保护的成员和私有成员的,但是通常建议遵循访问控制的原则,不要在类的外部直接访问受保护和私有成员。应该使用类提供的公共接口(公有方法)来访问和操作类的成员,这样可以更好地控制访问权限,提高代码的安全性和可维护性。
这是一个简单的面向对象编程入门指南。掌握这些基本概念将使你能够更好地利用Python的面向对象编程特性,创建复杂且结构良好的程序。