学习Python：面向对象编程和模块化编程

• 面向对象编程（OOP）

  • 类和对象
  • 属性和方法
  • 构造函数和析构函数
  • 继承
  • 多态
  • 封装
  • 示例代码

• 模块化编程

  • 模块的导入和使用
  • 创建自定义模块
  • 包的概念
  • 示例代码

• 综合示例

  • 结合OOP和模块化编程编写一个简单的项目
  • 示例代码

1. 面向对象编程（OOP）

类和对象

类是创建对象的蓝图，对象是类的实例。

class Dog:
    def __init__(self, name, age):  # 构造函数，初始化对象的属性
        self.name = name
        self.age = age

    def bark(self):  # 类的方法
        print(f"{self.name} is barking!")

my_dog = Dog("Buddy", 3)  # 创建一个 Dog 类的实例
print(my_dog.name)  # 输出对象的属性
my_dog.bark()  # 调用对象的方法

属性和方法

属性是对象的状态，方法是对象的行为。

class Dog:
    def __init__(self, name, age):
        self.name = name  # 属性
        self.age = age

    def bark(self):  # 方法
        print(f"{self.name} is barking!")

my_dog = Dog("Buddy", 3)
print(f"My dog's name is {my_dog.name} and he is {my_dog.age} years old.")
my_dog.bark()

构造函数和析构函数

构造函数用于初始化对象，析构函数用于在对象被销毁前执行清理操作。

class Dog:
    def __init__(self, name, age):  # 构造函数
        self.name = name
        self.age = age
        print(f"{self.name} has been created.")

    def __del__(self):  # 析构函数
        print(f"{self.name} has been destroyed.")

my_dog = Dog("Buddy", 3)
del my_dog  # 销毁对象，调用析构函数

继承

继承允许一个类继承另一个类的属性和方法。

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

    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print(f"{self.name} says Woof!")

class Cat(Animal):
    def speak(self):
        print(f"{self.name} says Meow!")

my_dog = Dog("Buddy")
my_cat = Cat("Whiskers")
my_dog.speak()
my_cat.speak()

多态

多态允许不同类的对象通过相同接口调用不同的方法。

class Animal:
    def speak(self):
        pass

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

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

def make_animal_speak(animal):
    animal.speak()

my_dog = Dog()
my_cat = Cat()
make_animal_speak(my_dog)
make_animal_speak(my_cat)

封装

封装是将数据和方法包装在类中，并隐藏类的内部实现。

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

    def get_name(self):  # 公开方法
        return self.__name

    def set_name(self, name):  # 公开方法
        self.__name = name

my_dog = Dog("Buddy", 3)
print(my_dog.get_name())  # 通过方法访问私有属性
my_dog.set_name("Max")
print(my_dog.get_name())

2. 模块化编程

模块的导入和使用

模块是包含Python代码的文件。可以使用import语句导入模块。

import math  # 导入标准库模块

print(math.sqrt(16))  # 使用模块中的函数

创建自定义模块

可以创建包含自定义函数和类的模块。

# my_module.py
def greet(name):
    print(f"Hello, {name}!")

# main.py
import my_module  # 导入自定义模块

my_module.greet("Alice")  # 使用模块中的函数

包的概念

包是包含多个模块的目录，必须包含一个__init__.py文件。

# my_package/__init__.py
# 该文件可以为空，表示 my_package 是一个包

# my_package/module1.py
def func1():
    print("Function 1")

# my_package/module2.py
def func2():
    print("Function 2")

# main.py
from my_package import module1, module2  # 从包中导入模块

module1.func1()  # 调用模块中的函数
module2.func2()

模块化编程示例代码

# utils.py
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

# main.py
import utils  # 导入自定义模块

result1 = utils.add(5, 3)
result2 = utils.subtract(5, 3)
print(f"Addition: {result1}, Subtraction: {result2}")

3. 综合示例

结合OOP和模块化编程，编写一个简单的项目来管理一个图书馆的书籍信息。

# book.py
class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

    def display_info(self):
        print(f"Title: {self.title}, Author: {self.author}")

# library.py
from book import Book

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

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

    def show_books(self):
        for book in self.books:
            book.display_info()

# main.py
from library import Library
from book import Book

library = Library()

book1 = Book("1984", "George Orwell")
book2 = Book("To Kill a Mockingbird", "Harper Lee")

library.add_book(book1)
library.add_book(book2)

library.show_books()

通过今天的学习，你应该能够掌握Python中面向对象编程和模块化编程的基本概念和使用方法。