Python3学习笔记第二十三篇--面向对象

---

### 23.1 面向对象编程的基本概念（掌握）

面向对象编程（OOP）是一种编程范式，它将数据和操作数据的方法封装在一起，称之为对象。Python 是一门面向对象语言，OOP 中的关键概念有以下几个：

- **类（Class）**：类是创建对象的模板或蓝图，它定义了对象的属性和方法。
- **对象（Object）**：对象是类的实例，通过类来创建。
- **属性（Attribute）**：属性是对象的特征或数据，通常是类中定义的变量。
- **方法（Method）**：方法是对象的行为或操作，通常是类中定义的函数。

#### 示例：定义一个简单的类

```python
class Dog:
    # 类属性
    species = "Canis lupus"

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

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

# 创建对象
my_dog = Dog("Buddy", 3)
print(my_dog.name)  # 输出: Buddy
my_dog.bark()       # 输出: Buddy says Woof!
```

---

### 23.2 类的定义和实例化（掌握）

在 Python 中，使用 `class` 关键字定义类，类名通常遵循首字母大写的命名约定。定义完类后，通过调用类名并传入必要的参数来创建类的实例（即对象）。

- **定义类**：
  ```python
  class ClassName:
      # 类的内容（属性和方法）
  ```

- **实例化对象**：
  ```python
  object_name = ClassName(parameters)
  ```

#### 示例

```python
class Car:
    def __init__(self, make, model):
        self.make = make  # 实例属性
        self.model = model

my_car = Car("Toyota", "Corolla")
print(my_car.make)  # 输出: Toyota
print(my_car.model) # 输出: Corolla
```

---

### 23.3 `__init__` 方法（构造函数）（掌握）

`__init__` 方法是类的构造函数，在创建对象时自动调用，用于初始化对象的属性。它通常接收参数来为属性赋初始值。

- **定义 `__init__` 方法**：
  
  ```python
  def __init__(self, 参数1, 参数2):
      self.属性1 = 参数1
      self.属性2 = 参数2
  ```

#### 示例

```python
class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

my_book = Book("1984", "George Orwell")
print(my_book.title)  # 输出: 1984
print(my_book.author) # 输出: George Orwell
```

---

### 23.4 实例属性和类属性（掌握）

- **实例属性**：每个对象独立拥有的属性，由 `self` 关键字定义。实例属性在不同的对象中可以拥有不同的值。
- **类属性**：类本身的属性，不属于任何一个特定的对象，由类名直接访问。类属性在所有对象中共享。

#### 示例

```python
class Animal:
    species = "Mammal"  # 类属性

def __init__(self, name):
        self.name = name  # 实例属性

a1 = Animal("Lion")
a2 = Animal("Tiger")

print(a1.species)  # 输出: Mammal
print(a2.species)  # 输出: Mammal
print(a1.name)     # 输出: Lion
print(a2.name)     # 输出: Tiger
```

---

### 23.5 实例方法和类方法（掌握）

- **实例方法**：实例方法是作用于对象的方法，第一个参数为 `self`，表示该方法属于对象，可以访问对象的属性。
- **类方法**：类方法由 `@classmethod` 装饰器定义，第一个参数为 `cls`，表示该方法属于类，可以访问类属性。类方法通常用于创建或操作类级别的数据。

#### 示例

```python
class Circle:
    pi = 3.14  # 类属性

def __init__(self, radius):
        self.radius = radius  # 实例属性

def area(self):  # 实例方法
        return Circle.pi * (self.radius ** 2)

@classmethod
    def set_pi(cls, new_pi):  # 类方法
        cls.pi = new_pi

c1 = Circle(5)
print(c1.area())  # 输出: 78.5

Circle.set_pi(3.1416)
print(c1.area())  # 输出: 78.54（使用新值 3.1416）
```

---

### 23.6 静态方法（掌握）

**静态方法**不需要传入 `self` 或 `cls` 参数，通常不与类或对象的属性进行交互，常用于工具方法。使用 `@staticmethod` 装饰器定义静态方法。

#### 示例

```python
class Math:
    @staticmethod
    def add(x, y):
        return x + y

result = Math.add(5, 3)
print(result)  # 输出: 8
```

---

### 23.7 封装与私有属性（掌握）

封装是 OOP 的核心思想之一，通过将对象的内部数据隐藏起来，只允许通过特定方法访问。Python 使用双下划线前缀 `__` 将属性定义为私有属性，限制外部直接访问。

#### 示例

```python
class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance  # 私有属性

def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

def get_balance(self):
        return self.__balance

account = Account("Alice", 1000)
account.deposit(500)
print(account.get_balance())  # 输出: 1500
# print(account.__balance)  # 访问报错，私有属性
```

---

### 23.8 继承（掌握）

**继承**允许我们创建一个新的类，并从现有类中继承属性和方法。继承使代码重用更高效，新类称为子类，继承的类称为父类或超类。

#### 示例

```python
class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):  # Dog 类继承 Animal 类
    def bark(self):
        print("Dog barks")

dog = Dog()
dog.speak()  # 调用父类方法，输出: Animal speaks
dog.bark()   # 调用子类方法，输出: Dog barks
```

---

### 23.9 方法重写（掌握）

**方法重写**（Override）允许子类重写父类的方法。子类重写的方法可以覆盖父类的方法，实现不同的功能。

#### 示例

```python
class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):  # 重写父类方法
        print("Dog barks")

dog = Dog()
dog.speak()  # 输出: Dog barks
```

---

### 23.10 多态（掌握）

**多态**是指对象在不同的场景中表现出不同的行为。Python 的多态性允许使用相同的方法名调用不同类的实例，而不关心实例的具体类型。

#### 示例

```python
class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        print("Dog barks")

class Cat(Animal):
    def speak(self):
        print("Cat meows")

animals = [Dog(), Cat()]

for animal in animals:
    animal.speak()  # 输出 Dog barks 和 Cat meows
```

---

### 23.11 面向对象的优势（了解）

1. **封装**：将数据和行为封装在一起，提高代码安全性。
2. **继承**：实现代码重用，减少重复代码。
3. **多态**：同一方法在不同对象中表现出不同的行为，提高代码的灵活性。
4. **抽象**：隐藏复杂实现，暴露简单接口，提高代码的可维护性。

23.1 面向对象编程的基本概念（掌握）

面向对象编程（OOP）是一种编程范式，它将数据和操作数据的方法封装在一起，称之为对象。Python 是一门面向对象语言，OOP 中的关键概念有以下几个：

类（Class）：类是创建对象的模板或蓝图，它定义了对象的属性和方法。
对象（Object）：对象是类的实例，通过类来创建。
属性（Attribute）：属性是对象的特征或数据，通常是类中定义的变量。
方法（Method）：方法是对象的行为或操作，通常是类中定义的函数。

示例：定义一个简单的类

class Dog:
    # 类属性
    species = "Canis lupus"

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

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

# 创建对象
my_dog = Dog("Buddy", 3)
print(my_dog.name)  # 输出: Buddy
my_dog.bark()       # 输出: Buddy says Woof!

23.2 类的定义和实例化（掌握）

在 Python 中，使用 class 关键字定义类，类名通常遵循首字母大写的命名约定。定义完类后，通过调用类名并传入必要的参数来创建类的实例（即对象）。

定义类：

class ClassName:
    # 类的内容（属性和方法）

实例化对象：
```
object_name = ClassName(parameters)
```

示例

class Car:
    def __init__(self, make, model):
        self.make = make  # 实例属性
        self.model = model

my_car = Car("Toyota", "Corolla")
print(my_car.make)  # 输出: Toyota
print(my_car.model) # 输出: Corolla

23.3 `init` 方法（构造函数）（掌握）

__init__ 方法是类的构造函数，在创建对象时自动调用，用于初始化对象的属性。它通常接收参数来为属性赋初始值。

定义 __init__ 方法：

def __init__(self, 参数1, 参数2):
    self.属性1 = 参数1
    self.属性2 = 参数2

示例

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

my_book = Book("1984", "George Orwell")
print(my_book.title)  # 输出: 1984
print(my_book.author) # 输出: George Orwell

23.4 实例属性和类属性（掌握）

实例属性：每个对象独立拥有的属性，由 self 关键字定义。实例属性在不同的对象中可以拥有不同的值。
类属性：类本身的属性，不属于任何一个特定的对象，由类名直接访问。类属性在所有对象中共享。

示例

class Animal:
    species = "Mammal"  # 类属性

    def __init__(self, name):
        self.name = name  # 实例属性

a1 = Animal("Lion")
a2 = Animal("Tiger")

print(a1.species)  # 输出: Mammal
print(a2.species)  # 输出: Mammal
print(a1.name)     # 输出: Lion
print(a2.name)     # 输出: Tiger

23.5 实例方法和类方法（掌握）

实例方法：实例方法是作用于对象的方法，第一个参数为 self，表示该方法属于对象，可以访问对象的属性。
类方法：类方法由 @classmethod 装饰器定义，第一个参数为 cls，表示该方法属于类，可以访问类属性。类方法通常用于创建或操作类级别的数据。

示例

class Circle:
    pi = 3.14  # 类属性

    def __init__(self, radius):
        self.radius = radius  # 实例属性

    def area(self):  # 实例方法
        return Circle.pi * (self.radius ** 2)

    @classmethod
    def set_pi(cls, new_pi):  # 类方法
        cls.pi = new_pi

c1 = Circle(5)
print(c1.area())  # 输出: 78.5

Circle.set_pi(3.1416)
print(c1.area())  # 输出: 78.54（使用新值 3.1416）

23.6 静态方法（掌握）

静态方法不需要传入 self 或 cls 参数，通常不与类或对象的属性进行交互，常用于工具方法。使用 @staticmethod 装饰器定义静态方法。

示例

class Math:
    @staticmethod
    def add(x, y):
        return x + y

result = Math.add(5, 3)
print(result)  # 输出: 8

23.7 封装与私有属性（掌握）

封装是 OOP 的核心思想之一，通过将对象的内部数据隐藏起来，只允许通过特定方法访问。Python 使用双下划线前缀 __ 将属性定义为私有属性，限制外部直接访问。

示例

class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance  # 私有属性

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def get_balance(self):
        return self.__balance

account = Account("Alice", 1000)
account.deposit(500)
print(account.get_balance())  # 输出: 1500
# print(account.__balance)  # 访问报错，私有属性

23.8 继承（掌握）

继承允许我们创建一个新的类，并从现有类中继承属性和方法。继承使代码重用更高效，新类称为子类，继承的类称为父类或超类。

示例

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):  # Dog 类继承 Animal 类
    def bark(self):
        print("Dog barks")

dog = Dog()
dog.speak()  # 调用父类方法，输出: Animal speaks
dog.bark()   # 调用子类方法，输出: Dog barks

23.9 方法重写（掌握）

方法重写（Override）允许子类重写父类的方法。子类重写的方法可以覆盖父类的方法，实现不同的功能。

示例

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):  # 重写父类方法
        print("Dog barks")

dog = Dog()
dog.speak()  # 输出: Dog barks

23.10 多态（掌握）

多态是指对象在不同的场景中表现出不同的行为。Python 的多态性允许使用相同的方法名调用不同类的实例，而不关心实例的具体类型。

示例

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        print("Dog barks")

class Cat(Animal):
    def speak(self):
        print("Cat meows")

animals = [Dog(), Cat()]

for animal in animals:
    animal.speak()  # 输出 Dog barks 和 Cat meows

23.11 面向对象的优势（了解）

封装：将数据和行为封装在一起，提高代码安全性。
继承：实现代码重用，减少重复代码。
多态：同一方法在不同对象中表现出不同的行为，提高代码的灵活性。
抽象：隐藏复杂实现，暴露简单接口，提高代码的可维护性。

结束

本文标题： Python3学习笔记第二十三篇--面向对象

本文链接： https://blog.oyooy.com/archives/69.html

除非另有说明，本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议。

声明：转载请注明文章来源。

最后修改：2025 年 02 月 08 日

如果觉得我的文章对你有用，请随意赞赏

Python3学习笔记第二十三篇--面向对象

23.1 面向对象编程的基本概念（掌握）

示例：定义一个简单的类

23.2 类的定义和实例化（掌握）

示例

23.3 `init` 方法（构造函数）（掌握）

示例

23.4 实例属性和类属性（掌握）

示例

23.5 实例方法和类方法（掌握）

示例

23.6 静态方法（掌握）

示例

23.7 封装与私有属性（掌握）

示例

23.8 继承（掌握）

示例

23.9 方法重写（掌握）

示例

23.10 多态（掌握）

示例

23.11 面向对象的优势（了解）

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

Python3学习笔记第四篇--缩进和注释

你好，世界！

Python3学习笔记第二篇--标识符

Python3学习笔记第十五篇--for循环和while循环比较

Python3学习笔记第一篇--基础内容

Python3学习笔记第二十四篇--面向对象综合案例

宝塔 Windows 面板 8.2.0 开心版

Python3学习笔记第一篇--基础内容

宝塔Linux面板9.4.0开心版

WIN10/11背景桌面收集

Python3学习笔记第二十三篇--面向对象

23.1 面向对象编程的基本概念（掌握）

示例：定义一个简单的类

23.2 类的定义和实例化（掌握）

示例

23.3 __init__ 方法（构造函数）（掌握）

示例

23.4 实例属性和类属性（掌握）

示例

23.5 实例方法和类方法（掌握）

示例

23.6 静态方法（掌握）

示例

23.7 封装与私有属性（掌握）

示例

23.8 继承（掌握）

示例

23.9 方法重写（掌握）

示例

23.10 多态（掌握）

示例

23.11 面向对象的优势（了解）

发表评论 取消回复 使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

Python3学习笔记第二十三篇--面向对象

23.3 `init` 方法（构造函数）（掌握）

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款