【Python 入门第十六讲】类（Class）和对象（Object）
原创【Python 入门第十六讲】类（Class）和对象（Object）
原创
类是用户定义的蓝图或原型，从中创建对象。类提供了一种将数据和功能捆绑在一起的方法。创建新类会创建一种新类型的对象，从而允许创建该类型的新实例。每个类实例都可以附加属性以维护其状态。类实例还可以具有用于修改其状态的方法（由其类定义）。
什么叫做类
为了理解在 Python 中创建类和对象的必要性，让我们考虑一个例子，假设你想跟踪可能具有不同属性（如品种和年龄）的狗的数量。如果使用列表，第一个元素可能是狗的品种，而第二个元素可以表示它的年龄。假设有 100 只不同的狗，那么你怎么知道哪个元素应该是哪个？如果您想为这些狗添加其他属性怎么办？这缺乏组织性，正是对课程的需求。
类定义语法：
class ClassName:
# Statement对象定义语法：
obj = ClassName()
print(obj.atrr)该类创建一个用户定义的数据结构，该结构包含自己的数据成员和成员函数，可以通过创建该类的实例来访问和使用这些成员和函数。类就像一个对象的蓝图。
关于Python类的几点：
- 类由关键字 class 创建。
- 属性是属于类的变量。
- 属性始终是公共的，可以使用点 （.） 运算符进行访问。例如：我的班级。我的属性
创建 Python 类
在这里，class 关键字指示您正在创建一个类，后跟该类的名称（在本例中为 Dog）。
class Dog:
sound = "bark"Python 类的对象
Object 是 Class 的实例。类似于蓝图，而实例是具有实际值的类的副本。这不再是一个想法，它是一只真正的狗，就像一只七岁的哈巴狗。可以有很多狗来创建许多不同的实例，但如果没有类作为指导，会迷失方向，不知道需要什么信息。
对象由以下部分组成：
- State: 它由对象的属性表示。它还反映了对象的属性。
- Behavior: 它由对象的方法表示。它还反映了一个对象对其他对象的响应。
- Identity: 它为对象提供唯一名称，并使一个对象能够与其他对象进行交互。
声明 Claas 对象：
（也称为实例化类）当创建一个类的对象时，该类被称为实例化。所有实例都共享类的属性和行为。但是这些属性的值，即状态对于每个对象都是唯一的。单个类可以有任意数量的实例。
示例：
Python 类和对象示例：
# 程序演示了实例化一个类
class Dog:
# 一个简单的类
# 属性
attr1 = "哺乳动物"
attr2 = "狗"
# 一个示例方法
def fun(self):
print("我是", self.attr1)
print("我是", self.attr2)
# 驱动代码
# 对象实例化
Rodger = Dog()
# 通过对象访问类属性
# 和方法
print(Rodger.attr1)
Rodger.fun()输出：
哺乳动物
我是 哺乳动物
我是 狗在上面的例子中，创建了一个对象，它基本上是一只名叫Rodger的狗。这个类只有两个类属性，告诉我们罗杰是狗和哺乳动物。
解释：
在此示例中，我们将创建一个 Dog 类，并创建了两个类变量 attr1 和 attr2。我们创建了一个名为 fun（）的方法，它返回字符串 我是， {attr1}” 和 我是， {attr2}。我们已经创建了一个 Dog 类的对象，并在该对象的 attr1 处打印。最后，我们调用 fun（）函数。
Self 参数
当我们将这个对象的方法调用为 myobject.method（arg1， arg2） 时，Python 会自动将其转换为 MyClass.method（myobject， arg1， arg2） – 这就是特殊Self的全部内容。
class GFG:
def __init__(self, name, company):
self.name = name
self.company = company
def show(self):
print("Hello my name is " + self.name+" and I" +
" work in "+self.company+".")
obj = GFG("John", "Tencent")
obj.show()输出
Self 参数不会将其称为 Self，可以使用任何其他名称来代替它。在这里，我们将 self 更改为单词 someone，输出将相同。
class GFG:
def __init__(self, name, company):
self.name = name
self.company = company
def __str__(self):
return f"我的名字是 {self.name}，我在 {self.company} 工作。"
my_obj = GFG("John", "Tencent")
print(my_obj)
输出：
pass 语句
程序的执行不受 pass 语句不作为的影响。它只是允许程序跳过代码的该部分而不执行任何操作。当 Python 的语法约束需要有效的语句但不必执行有用的代码时，它经常被使用。
class MyClass:
pass__init__（） 方法
__init__ 方法类似于 C++ 和 Java 中的构造函数。构造函数用于初始化对象的状态。与方法一样，构造函数也包含在创建对象时执行的语句（即指令）的集合。一旦实例化了类的对象，它就会运行。该方法可用于对对象执行任何初始化操作。
# 带有初始化方法的示例类
class Person:
# 初始化方法或构造函数
def __init__(self, name):
self.name = name
# 示例方法
def say_hi(self):
print('你好，我的名字是', self.name)
p = Person('Nikhil')
p.say_hi()输出：
你好，我的名字是 Nikhil在此示例中我们创建一个 Person 类，并在构造函数中创建了一个 name 实例变量。我们创建了一个名为 say_hi（） 的方法，它返回字符串“Hello， my name is {name}”。我们创建了一个 person 类对象，并将名称 Nikhil 传递给实例变量。最后，我们调用类的 say_hi（）。
__str__（） 方法
Python 有一个名为 __str__（） 的特定方法。用于定义类对象应如何表示为字符串。它通常用于为对象提供人类可读的文本表示形式，这有助于记录、调试或显示用户对象信息。当使用类对象通过内置函数 print（） 和 str（） 创建字符串时，会自动使用 __str__（） 函数。您可以通过定义 __str__（） 方法来更改类对象在字符串中的表示方式。
class GFG:
def __init__(self, name, company):
self.name = name
self.company = company
def __str__(self):
return f"我的名字是 {self.name}，我在 {self.company} 工作。"
my_obj = GFG("John", "Tencent")
print(my_obj)输出：
我的名字是 John，我在 Tencent工作。类和实例变量
实例变量用于数据，每个实例都是唯一的，类变量用于类的所有实例共享的属性和方法。实例变量是其值在具有 self 的构造函数或方法中赋值的变量，而类变量是在类中赋值的变量。
使用构造函数定义实例变量
# 程序展示了在类声明中分配值的变量是类变量，
# 而方法和构造函数中的变量是实例变量。
# Dog 类
class Dog:
# 类变量
animal = '狗'
# 初始化方法或构造函数
def __init__(self, breed, color):
# 实例变量
self.breed = breed
self.color = color
# Dog 类的对象
Rodger = Dog("哈巴狗", "棕色")
Buzo = Dog("斗牛犬", "黑色")
print('Rodger 的详情:')
print('Rodger 是一只', Rodger.animal)
print('品种：', Rodger.breed)
print('颜色：', Rodger.color)
print('\nBuzo 的详情:')
print('Buzo 是一只', Buzo.animal)
print('品种：', Buzo.breed)
print('颜色：', Buzo.color)
# 类变量也可以使用类名来访问
print("\n使用类名访问类变量")
print(Dog.animal)输出：
Rodger 的详情:
Rodger 是一只 狗
品种： 哈巴狗
颜色： 棕色
Buzo 的详情:
Buzo 是一只 狗
品种： 斗牛犬
颜色： 黑色
使用类名访问类变量
狗定义名为 Dog 的类时，将类变量 animal 设置为字符串 “dog”。类变量由类的所有对象共享，可以使用类名进行访问。Dog 类有两个实例变量 breed 和 color。稍后，我们将创建 Dog 类的两个对象，并使用名为 animal 的类变量打印这两个对象的值。
使用 normal 方法定义实例变量
# 程序展示了我们可以在方法内创建实例变量
# Dog 类
class Dog:
# 类变量
animal = '狗'
# 初始化方法或构造函数
def __init__(self, breed):
# 实例变量
self.breed = breed
# 添加一个实例变量
def setColor(self, color):
self.color = color
# 获取实例变量
def getColor(self):
return self.color
# 驱动代码
Rodger = Dog("哈巴狗")
Rodger.setColor("棕色")
print(Rodger.getColor())输出：
棕色在这个例子中，我们定义了一个名为 Dog 的类，并创建了一个类变量 animal。我们在构造函数中创建了一个实例变量 breed。Dog 类由两个方法 setColor 和 getColor 组成，它们用于创建和初始化实例变量以及检索实例变量的值。我们已经创建了一个 Dog 类的对象，并将实例变量值设置为棕色，并在终端中打印该值。
Python 中的构造函数
构造函数通常用于实例化对象。构造函数的任务是在创建类的对象时初始化（赋值）到类的数据成员。在 Python 中，__init__（） 方法称为构造函数，并且始终在创建对象时调用。
构造函数声明的语法：
def __init__(self):
# body of the constructor构造函数的类型：
- 默认构造函数：默认构造函数是不接受任何参数的简单构造函数。它的定义只有一个参数，即对正在构造的实例的引用。
- 参数化构造函数：带参数的构造函数称为参数化构造函数。参数化构造函数将其第一个参数作为对正在构造的实例的引用，称为 self，其余参数由程序员提供。
默认构造函数示例：
class Tencent:
# 默认构造函数
def __init__(self):
self.geek = "Tencent"
# 用于打印数据成员的方法
def print_Geek(self):
print(self.geek)
# 创建类的对象
obj = Tencent()
# 使用对象 obj 调用实例方法
obj.print_Geek()输出：
Tencent参数化构造函数的示例：
class Addition:
first = 0
second = 0
answer = 0
# 带参数的构造函数
def __init__(self, f, s):
self.first = f
self.second = s
def display(self):
print("第一个数字 = " + str(self.first))
print("第二个数字 = " + str(self.second))
print("两个数字的加法 = " + str(self.answer))
def calculate(self):
self.answer = self.first + self.second
# 创建类的对象
# 这将调用带参数的构造函数
obj1 = Addition(1000, 2000)
# 创建同一类的第二个对象
obj2 = Addition(10, 20)
# 对 obj1 执行加法
obj1.calculate()
# 对 obj2 执行加法
obj2.calculate()
# 显示 obj1 的结果
obj1.display()
# 显示 obj2 的结果
obj2.display()输出：
第一个数字 = 1000
第二个数字 = 2000
两个数字的加法 = 3000
第一个数字 = 10
第二个数字 = 20
两个数字的加法 = 30示例：
class MyClass:
def __init__(self, name=None):
if name is None:
print("调用默认构造函数")
else:
self.name = name
print("使用名称", self.name, "调用带参数的构造函数")
def method(self):
if hasattr(self, 'name'):
print("使用名称", self.name, "调用方法")
else:
print("调用方法时没有名称")
# 使用默认构造函数创建类的对象
obj1 = MyClass()
# 调用类的方法
obj1.method()
# 使用带参数的构造函数创建类的对象
obj2 = MyClass("John")
# 调用类的方法
obj2.method()输出：
调用默认构造函数
调用方法时没有名称
使用名称 John 调用带参数的构造函数
使用名称 John 调用方法解释：
在此示例中，我们定义了一个具有默认构造函数和参数化构造函数的类 MyClass。默认构造函数检查是否已传入参数，并相应地将消息输出到控制台。参数化构造函数采用单个参数名称，并将对象的 name 属性设置为该参数的值。
我们还定义了一个方法 method（），用于检查对象是否具有 name 属性，并相应地将消息打印到控制台。
我们使用这两种类型的构造函数创建 MyClass 类的两个对象。首先，我们使用默认构造函数创建一个对象，该构造函数将消息“调用的默认构造函数”打印到控制台。然后，我们在此对象上调用 method（） 方法，该方法将消息“无名调用的方法”打印到控制台。
接下来，我们使用参数化构造函数创建一个对象，并传入名称“John”。将自动调用构造函数，并将消息“使用名称 John 调用的参数化构造函数”打印到控制台。然后，我们在此对象上调用 method（） 方法，该方法将消息“以名称 John 调用的方法”打印到控制台。
在 Python 中使用构造函数的优点：
- 对象初始化：构造函数用于初始化类的对象。它们允许您设置特性或属性的默认值，还允许您使用自定义数据初始化对象。
- 易于实现：构造函数在 Python 中易于实现，可以使用 __init__（） 方法定义。
- 更好的可读性：构造函数通过明确初始化哪些值以及如何初始化这些值来提高代码的可读性。
- 封装：构造函数可用于强制实施封装，方法是确保以受控方式正确初始化对象的属性。
在 Python 中使用构造函数的缺点：
- 不支持重载：与其他面向对象的语言不同，Python 不支持方法重载。这意味着不能在单个类中具有多个具有不同参数的构造函数。
- 功能有限：与其他编程语言中的构造函数相比，Python 中的构造函数在功能上受到限制。例如，Python 没有带有访问修饰符（如 public、private 或 protected）的构造函数。
- 构造函数可能是不必要的：在某些情况下，构造函数可能不是必需的，因为属性的默认值可能就足够了。在这些情况下，使用构造函数可能会给代码增加不必要的复杂性。
总的来说，Python 中的构造函数对于初始化对象和强制封装很有用。但是，与其他编程语言中的构造函数相比，它们可能并不总是必需的，并且其功能受到限制。
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。