目录
Python语言设计之初，就是为了面向对象。所以Python的面向对象更加易于理解。如果你以前学过Java、C++你大概就懂得什么是面向对象，但如果你是第一门编程语言就选择Python，那么也不要害怕。这篇文章，我们尽量讲简单些，把Python面向对象编程的入门知识讲清楚。后续我们继续较为难一些的讲解，逐步加深大家的理解。
接下来我们先来简单的了解下面向对象的一些基本特征。
1. 什么是面向对象编程（OOP）？
面向对象编程（Object-Oriented Programming，OOP）是一种程序设计范式，它以对象为中心，将数据和操作数据的方法（函数）组合到一个单元中，这个单元就是对象。每个对象都是类的一个实例，而类则定义了对象的属性（数据）和方法（代码）。换句话说，面向对象编程将现实世界中的实体抽象为程序中的对象，这些对象可以相互交互、传递消息，并且可以继承和扩展。
面向对象编程通常具有以下几个核心概念：
- 类（Class）：定义了对象的模板，包括数据和方法。
- 对象（Object）：类的实例，具有特定的属性和方法。
- 封装（Encapsulation）：将数据（属性）和操作数据的方法（函数）封装到对象中，使得对象的内部细节对外部不可见。
- 继承（Inheritance）：允许一个类（子类）继承另一个类（父类）的属性和方法，并且可以添加自己的特定属性和方法。
- 多态（Polymorphism）：允许不同类的对象对同一个方法做出不同的响应，提高代码的灵活性和可重用性。
很好，上面的概念，你已经云里雾里了。那么下面我们简单来讲一下。
一个简单的例子：
假设我们要模拟一个动物园中的动物。我们可以使用定义一个 Animal（动物）类，并创建具体的动物对象。这就是面向对象编程的两个概念了，类、对象。
# 定义 Animal（动物）类
class Animal:
def __init__(self, name, age):
self.name = name
self.age = age
def make_sound(self):
pass
# 定义具体的动物类：猫（Cat）和狗（Dog）
class Cat(Animal):
def make_sound(self):
return "Meow"
class Dog(Animal):
def make_sound(self):
return "Woof"
# 创建动物对象
cat1 = Cat("Kitty", 3)
dog1 = Dog("Buddy", 5)
# 调用动物对象的方法
print(cat1.name, "says:", cat1.make_sound()) # 输出：Kitty says: Meow
print(dog1.name, "says:", dog1.make_sound()) # 输出：Buddy says: Woof
上面的代码，我们一步步来说：
第一步：首先定义了一个 Animal（动物）类，它有两个属性 name（名字）和 age（年龄）。在 __init__ 构造函数中，我们初始化了这两个属性。
第二步：Animal 类有一个 make_sound（发出声音）方法，但在基类中我们只定义了方法的签名，没有具体的实现。这是因为我们无法确定所有动物的叫声，具体的叫声会在子类中实现。
第三步：然后我们定义了两个具体的动物类 Cat（猫）和 Dog（狗），它们都继承自 Animal 类。这意味着 Cat 和 Dog 类会继承 Animal 类的属性和方法，并且可以根据需要添加自己的属性和方法。
第四步：在 Cat 类和 Dog 类中，我们重写了 make_sound 方法，分别返回了猫和狗的叫声
第五步：最后，我们创建了两个具体的动物对象 cat1 和 dog1，分别是一只名叫 "Kitty" 的猫和一只名叫 "Buddy" 的狗。
第六步：我们调用了这两个动物对象的 make_sound 方法，并打印出它们的名字和叫声。
上面总共讲了6步，6步里面涉及到了：类（Class）、对象（Object）、封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism）。这些概念，具体怎么看呢？往下看：
- 类：
Animal、Cat、Dog分别是类，它们定义了对象的模板，包括属性和方法。 - 对象：
cat1和dog1是Cat和Dog类的对象，它们是具体的实例，具有特定的属性和方法。 - 封装：每个动物对象封装了自己的属性
name和age，并且调用了自己的make_sound方法。 - 继承：
Cat和Dog类继承了Animal类的属性和方法，避免了重复定义。 - 多态：
make_sound方法在不同的子类中表现出不同的行为，根据对象的类型返回不同的叫声。
那么，你现在将这些概念，一个个对应到前面的六步中去，你就大概明白了。明白个大概也行！
下面接着讲.......
2. 类和对象
让我们以一个仍然用上面的例子来说明什么是类和对象。我们创建了一个"动物"（Animal）类，然后创建该类的对象，比如"狗"（Dog）和"猫"（Cat）。
2.1 类的定义和创建
我们可以定义一个"动物"（Animal）类，该类具有一些基本属性（如名称和年龄），以及一些行为（如发出声音）。
class Animal:
def __init__(self, name, age):
self.name = name
self.age = age
def make_sound(self):
pass # 此处留空，因为这是一个抽象的动作，每种动物发出的声音不同，后续会在子类中实现
在这个类中，我们定义了一个构造函数 __init__()，它接收 name 和 age 作为参数，并将它们分配给对象的属性。我们还定义了一个 make_sound() 方法，但目前它什么也不做，因为每种动物发出的声音都不同，所以我们会在子类中覆盖这个方法。
2.2 对象的创建和使用
现在，让我们创建具体的动物对象，比如一个狗对象和一个猫对象，并使用它们的属性和方法。
class Dog(Animal):
def make_sound(self):
return "Woof!"
class Cat(Animal):
def make_sound(self):
return "Meow!"
# 创建狗对象和猫对象
my_dog = Dog("Buddy", 3)
my_cat = Cat("Whiskers", 5)
# 访问对象的属性
print(f"My dog's name is {my_dog.name} and it is {my_dog.age} years old.")
print(f"My cat's name is {my_cat.name} and it is {my_cat.age} years old.")
# 调用对象的方法
print(f"My dog says: {my_dog.make_sound()}")
print(f"My cat says: {my_cat.make_sound()}")
2.3 类和对象的关系
在这个例子中，Animal 是一个基类（父类），它定义了动物的基本属性和方法。然后，Dog 和 Cat 是 Animal 类的子类（也可以称为派生类），它们继承了 Animal 类的属性和方法，并且还可以定义自己独特的属性和方法。
当我们创建 my_dog 和 my_cat 时，实际上是在内存中实例化了两个对象，每个对象都有自己的 name 和 age 属性，并且可以调用 make_sound() 方法。
类是对对象的抽象，它定义了对象的属性和方法。
对象是类的实例，它具体化了类的定义，并可以执行类中定义的操作。
类和对象之间的关系就像是模具和制造出的产品之间的关系：模具定义了产品的形状和特性，而产品则是模具的具体实例。
3. 属性和方法
3.1 实例属性和类属性
- 实例属性：实例属性是指属于特定实例的属性。它们在创建实例时被赋予，并且每个实例都可以有不同的值。通常在类的
__init__方法中初始化。
class Car:
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
在这里，make, model, 和 year 就是 Car 类的实例属性。
- 类属性：属于类本身的属性，被所有类的实例共享。可以直接在类定义中设置。
class Car:
num_cars = 0 # 类属性
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
Car.num_cars += 1 # 每创建一个实例，num_cars 加一
在这里，num_cars 就是 Car 类的类属性，它被所有 Car 类的实例共享。
3.2 实例方法和类方法
- 实例方法：操作实例属性的方法，第一个参数通常是
self，代表对象本身。可以访问实例属性，并且可以改变实例的状态。
class Car:
def __init__(self, brand):
self.brand = brand
self.speed = 0
def accelerate(self, amount):
self.speed += amount
def brake(self, amount):
self.speed -= amount
car1 = Car("Toyota")
print(car1.speed) # 输出: 0
car1.accelerate(50)
print(car1.speed) # 输出: 50
car1.brake(20)
print(car1.speed) # 输出: 30
accelerate 、brake 就是 Car 类的实例方法，用于打印汽车信息。
- 类方法：操作类属性的方法，使用
@classmethod装饰器定义，第一个参数通常是cls，代表类本身。可以访问类属性，并且可以在整个类上执行操作。
class Dog:
num_of_dogs = 0
def __init__(self, name):
self.name = name
Dog.num_of_dogs += 1
@classmethod
def get_num_of_dogs(cls):
return cls.num_of_dogs
dog1 = Dog("Buddy")
dog2 = Dog("Max")
print(Dog.get_num_of_dogs()) # 输出: 2
get_num_of_dogs 就是 Dog 类的类方法，用于显示狗总数。
3.3 静态方法
- 静态方法：不操作实例属性或类属性的方法，使用
@staticmethod装饰器定义。它们与类无关，不传递self或cls参数。可以在类中定义，但是不能访问self或cls。
class Math:
@staticmethod
def add(x, y):
return x + y
result = Math.add(5, 10)
print(result) # 输出: 15
add 就是 Math 类的静态方法，提供关于类的一般信息。
以上是关于Python中类（Class）、对象（Object）以及属性和方法的基本概念。希望对你的理解有帮助。
结语
在这里，我们讲了Python面向对象的入门知识：类（Class）、对象（Object）。大家可以跟着上面的代码联系操作一下，加深一下理解，下一篇文章继续讲解Python面向对象的教深一点的知识：封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。
欢迎大家和我一起继续学习、记录python的下一个知识点。
如果感觉阅读对您还有些作用，可以评论留言，关注我。谢谢您的阅读！
往期学习：
VSCode安装教程（版本：1.87.0）Windows10
Python字符串操作及方法详解！一篇就搞定！-CSDN博客
标签：Python,self,入门篇,对象,面向对象编程,方法,make,属性 From： https://blog.csdn.net/TiYong/article/details/136767095