面向对象编程（oop）是软件开发中使用的关键方法。
在本文中，我们将探讨 oop 的主要思想，特别是 Python 中的类、对象、继承和多态性。
在本指南结束时，您将了解如何使用 oop 原则组织 python 代码，使您的程序更加模块化、可重用且更易于维护。
什么是面向对象编程？
面向对象编程（oop）围绕数据或对象而不是函数和逻辑来组织软件设计。
立即学习“Python免费学习笔记（深入）”；
对象就像一个容器，具有独特的属性（数据）和行为（功能）。 oop 重点关注几个关键概念：
封装
这意味着将数据（属性）和对该数据进行操作的方法（函数）捆绑到一个单元中，称为类。
它还涉及限制对对象的某些组件的访问，使其更加安全。
抽象
这是隐藏复杂的实现细节并仅显示对象的基本特征的想法。
它降低了复杂性并允许程序员专注于更高级别的交互。
继承
这是一种从现有类（基类）创建新类（派生类）的机制。
新类继承现有类的属性和方法。
多态性
这是使用单个接口来表示不同数据类型的能力。
它允许将对象视为其父类的实例，并且可以在子类中定义与父类中的方法同名的方法。
python 中的 oop 基础知识：类和对象
python 中面向对象编程 (oop) 的核心是类和对象。
课程
类就像创建对象的蓝图。
它定义了对象将具有的一组属性（属性）和操作（方法）。
在 python 中，您可以使用 class 关键字创建一个类。这是一个例子：
|
1
2
3
4
5
6
7
8
|
class car:
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
def start_engine(self):
print(f"{self.make} {self.model}'s engine started.")
|
对象
对象是类的实例。
一旦定义了一个类，您就可以从中创建多个对象（实例）。
每个对象都可以为类中定义的属性拥有自己唯一的值。
以下是创建和使用对象的方法：
|
1
2
|
my_car = car("toyota", "corolla", 2020)
my_car.start_engine() # output: toyota corolla's engine started.
|
在此示例中，my_car 是 car 类的对象。
它有自己的品牌、型号和年份值，您可以使用 start_engine 等方法。
python 中的继承
继承让一个类（子类）具有另一个类（父类）的属性和方法。
这对于重用代码和在类之间设置层次结构非常有用。
这是一个例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
class vehicle:
def __init__(self, make, model):
self.make = make
self.model = model
def drive(self):
print("driving...")
class car(vehicle):
def __init__(self, make, model, year):
super().__init__(make, model)
self.year = year
def start_engine(self):
print(f"{self.make} {self.model}'s engine started.")
my_car = car("honda", "civic", 2021)
my_car.drive() # output: driving...
my_car.start_engine() # output: honda civic's engine started.
|
在此示例中，car 类继承自 vehicle 类。
因此，car 类可以使用 vehicle 类中定义的驱动方法。
方法重写
有时，子类需要更改或添加从父类继承的方法的行为。
这是通过方法重写完成的。
这是一个例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
class vehicle:
def drive(self):
print("driving a vehicle...")
class car(vehicle):
def drive(self):
print("driving a car...")
my_vehicle = vehicle()
my_vehicle.drive() # output: driving a vehicle...
my_car = car()
my_car.drive() # output: driving a car...
|
在此示例中，car 类中的drive 方法覆盖了vehicle 类中的drive 方法，从而允许自定义行为。
多重继承
python 还支持多重继承，即一个类可以从多个基类继承。
这是一个例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
class vehicle:
def __init__(self, make, model):
self.make = make
self.model = model
def drive(self):
print("driving a vehicle...")
class electric:
def charge(self):
print("charging...")
class car(vehicle):
def __init__(self, make, model, year):
super().__init__(make, model)
self.year = year
def start_engine(self):
print(f"{self.make} {self.model}'s engine started.")
class hybrIDCar(car, electric):
def switch_mode(self):
print("switching to electric mode...")
my_hybrid = hybridcar("toyota", "prius", 2022)
my_hybrid.start_engine() # output: toyota prius's engine started.
my_hybrid.drive() # output: driving a vehicle...
my_hybrid.charge() # output: charging...
my_hybrid.switch_mode() # output: switching to electric mode...
|
在此示例中，hybridcar 类继承自 car 和 electric，允许它访问两个父类的方法。
python 中的多态性
多态性是一项功能，允许方法根据它们正在使用的对象执行不同的操作，即使这些方法具有相同的名称。
这在处理继承时特别有用，因为它允许您以对每个类都有意义的方式在不同的类中使用相同的方法名称。
函数多态性
这是一个例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
class dog:
def speak(self):
return "woof!"
class cat:
def speak(self):
return "meow!"
def make_animal_speak(animal):
print(animal.speak())
dog = dog()
cat = cat()
make_animal_speak(dog) # output: woof!
make_animal_speak(cat) # output: meow!
|
make_animal_speak 函数通过接受任何具有 talk 方法的对象来演示多态性。
这使得它可以与 dog 和 cat 对象一起使用，尽管它们之间存在差异。
类方法的多态性
当使用类层次结构中的方法时，多态性也会发挥作用。
这是一个例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
class animal:
def speak(self):
raise notimplementederror("subclass must implement abstract method")
class dog(animal):
def speak(self):
return "woof!"
class cat(animal):
def speak(self):
return "meow!"
animals = [dog(), cat()]
for animal in animals:
print(animal.speak())
|
在此示例中，dog 和 cat 都是 animal 的子类。
speak 方法在两个子类中都实现了，允许多态性在迭代动物列表时生效。
封装和数据隐藏
封装是将数据和处理该数据的方法组合成一个单元（称为类）的做法。
它还涉及限制对对象某些部分的访问，这对于保护面向对象编程 (oop) 中的数据至关重要。
私有和公共属性
在 python 中，您可以通过其名称以下划线开头来指示属性是私有的。
虽然这实际上并不会阻止从类外部进行访问，但这是一种约定，表明不应直接访问该属性。
这是一个例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
class account:
def __init__(self, owner, balance=0):
self.owner = owner
self._balance = balance # private attribute
def deposit(self, amount):
self._balance += amount
def withdraw(self, amount):
if amount
<p>在这个例子中，account类有一个私有属性_balance，它可以通过deposit、withdraw和get_balance等方法进行操作。 </p>
<p>不鼓励从类外部直接访问 _balance。</p>
<hr><h2>
先进的面向对象编程概念
</h2>
<p>对于那些想要加深对 python 中面向对象编程 (oop) 的理解的人，这里有一些高级主题：</p>
<p><strong>类方法</strong><br>
这些方法连接到类本身，而不是连接到类的各个实例。 </p>
<p>它们可以更改类的状态，这会影响类的所有实例。<br></p>
<pre class="brush:php;toolbar:false">class car:
total_cars = 0
def __init__(self, make, model):
self.make = make
self.model = model
car.total_cars += 1
@classmethod
def get_total_cars(cls):
return cls.total_cars
|
静态方法
这些方法属于该类，但不会更改该类或其实例的状态。
它们是使用@staticmethod装饰器定义的。
|
1
2
3
4
|
class mathoperations:
@staticmethod
def add(x, y):
return x + y
|
物业装饰
python 中的属性装饰器提供了一种以更 pythonic 的方式定义类属性的 Getter、Setter 和 deleters 的方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
class Employee:
def __init__(self, name, salary):
self._name = name
self._salary = salary
@property
def salary(self):
return self._salary
@salary.setter
def salary(self, value):
if value
<p>在此示例中，salary 属性的访问方式与常规属性类似，但由 getter 和 setter 方法管理。</p>
<hr><h2>
结论
</h2>
<p>python 中的面向对象编程 (oop) 是一种组织和管理代码的强大方法。 </p>
<p>通过学习 oop 的原理，例如类、对象、继承、多态性和封装，您可以编写组织良好、可重用且易于维护的 python 程序。 </p>
<p>无论您正在开发小型脚本还是大型应用程序，使用 oop 原则都将帮助您创建更高效、可扩展且强大的软件。</p>
|
