对象实例化是面向对象编程中的一个基本概念，它指的是从类创建新对象的过程。此过程涉及使用构造函数，这是定义如何初始化新对象的特殊方法。本文介绍如何在 Python 中实例化对象，并提供如何在代码中创建和使用这些对象的示例。
探索 Python 的类构造函数
Python 中的类构造函数是在实例化类的对象时执行的特殊方法。它用于初始化类的属性。Python 中的构造函数方法称为 __init__()，它在类中定义。
如何实例化 Python 类
让我们探讨如何在 Python 中实例化类。为了实现此目的，我们必须通过创建类的实例来在 Python 中执行类实例化，该实例调用其构造函数方法。以下是一个简单类的示例以及如何实例化该类的对象。
class Recipe:
def __init__(self, name, ingredients):
self.name = name
self.ingredients = ingredients
# Instantiate a Recipe object
my_recipe = Recipe("Spaghetti Bolognese", ["spaghetti", "tomato sauce", "ground beef"])
# Access the object's attributes
print("Recipe Name:", my_recipe.name)
print("Ingredients:", my_recipe.ingredients)
在上面的示例中，Recipe 类有一个构造函数，它为每个实例化的新对象设置 name 和 ingredients 属性。my_recipe 对象实例化时名称为“意大利肉酱面”，并带有成分列表。打印 语句 将输出 Recipe Name: Spaghetti Bolognese 和 Ingredients: ['spaghetti', 'tomato sauce', 'ground beef']。
Python 中的继承和构造函数
在 Python 中，构造函数在类继承中发挥着至关重要的作用，它允许子类继承和扩展父类的属性和行为。
构造函数继承基础知识
子类继承其父类的构造函数，使它们能够重用父类的初始化逻辑。例如
class Vehicle:
def __init__(self, make, model):
self.make = make
self.model = model
class Car(Vehicle):
def __init__(self, make, model, year):
super().__init__(make, model)
self.year = year
在此示例中，Car 类继承自 Vehicle 并扩展了其属性。
构造函数重写
子类还可以重写父类的构造函数以自定义初始化
class Bike(Vehicle):
def __init__(self, make, model, wheel_count):
super().__init__(make, model)
self.wheel_count = wheel_count
抽象基类
抽象基类允许您在类层次结构中强制执行初始化模式。请参阅抽象类页面以阅读更多信息。
深入了解 Python 的对象实例化过程
在 Python 中实例化一个对象意味着创建一个类的实例。当您创建一个类的实例时，您就实例化了该对象。在 Python 中，实例化对象的过程涉及创建和初始化对象。
要实例化一个 Python 类，您需要使用构造函数方法，即 __init__() 方法。构造函数方法初始化对象的属性或特性。
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
person1 = Person("John", 25)
print(person1.name)
print(person1.age)
在此示例中，我们定义了一个名为 Person 的类，该类具有两个属性：name 和 age。我们实例化了一个对象 person1，并将两个参数传递给构造函数方法。最后，我们打印了 name 和 age 属性的值。
class Employee:
def __init__(self, firstname, lastname, salary):
self.firstname = firstname
self.lastname = lastname
self.salary = salary
def get_fullname(self):
return self.firstname + " " + self.lastname
employee1 = Employee("Jane", "Doe", 50000)
print(employee1.firstname)
print(employee1.get_fullname())
print(employee1.salary)
在此示例中，我们定义了一个名为 Employee 的类，该类具有三个属性：firstname、lastname 和 salary。我们实例化了一个对象 employee1，并将三个参数传递给构造函数方法。最后，我们打印了 firstname、get_fullname() 和 salary 属性的值。
在 Python 中，实例化对象是一种创建具有特定行为和属性的对象的强大且灵活的方法。
使用 __init__() 方法初始化对象
__init__() 方法在 Python 类中用于初始化新创建的对象。当使用类构造函数创建对象时，它会被自动调用。
下面是一个具有 __init__() 方法的类的示例
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
p1 = Person("Alice", 25)
print(p1.name) ### Output Alice
print(p1.age) ### Output 25
在此示例中，Person 类具有一个 init 方法，该方法接受两个参数：name 和 age。当您创建一个新的 Person 对象时，您会传入这些参数的值，并且 __init__() 方法会设置相应的实例变量。
您还可以在 __init__() 方法中使用可选参数或默认参数
class Rectangle:
def __init__(self, width=0, height=0):
self.width = width
self.height = height
r1 = Rectangle()
print(r1.width) ### Output 0
print(r1.height) ### Output 0
r2 = Rectangle(10, 20)
print(r2.width) ### Output 10
print(r2.height) ### Output 20
在此示例中，Rectangle 类具有一个 __init__() 方法，该方法接受两个可选参数：width 和 height。如果没有提供参数，则使用默认值 0。
自定义 Python 的对象初始化
在 Python 中，当创建类的对象时，会调用 __init__() 方法。它用于初始化对象的属性。但是，有时我们可能需要通过指定我们自己的参数来自定义对象初始化。可以使用以下方法来实现此目的
创建不带 __init__() 的 Python 类
自定义对象初始化的一种方法是定义一个自定义方法来初始化属性。此方法可以采用用于设置属性值的参数。这里有一个例子
class Car:
def set_values(self, make, model, year):
self.make = make
self.model = model
self.year = year
my_car = Car()
my_car.set_values('Toyota', 'Camry', 2022)
print(my_car.make) # Output: Toyota
在此示例中，我们定义了一个自定义方法 set_values() 来初始化属性 make、model 和 year。然后，我们在 Car 类的对象上调用此方法以设置属性值。
使用 __init__() 创建类
自定义对象初始化的另一种方法是使用类级属性。这些属性可以在类定义中设置，并用于初始化对象的属性。这里有一个例子
class Car:
make = ''
model = ''
year = 0
def __init__(self):
self.make = Car.make
self.model = Car.model
self.year = Car.year
my_car = Car()
my_car.make = 'Toyota'
my_car.model = 'Camry'
my_car.year = 2022
print(my_car.make) # Output: Toyota
在此示例中，我们将 make、model 和 year 定义为类级属性，并将它们的默认值设置为一个空字符串和 0。然后，我们在 __init__() 方法中使用这些属性来初始化对象的属性。我们稍后可以像在前面的示例中那样修改对象的属性值。
使用灵活的初始化器创建 Python 类对象
面向对象编程允许我们创建具有不同属性的对象。我们可以通过将不同的参数传递给构造函数来初始化具有固定属性或灵活属性的对象。在 Python 中，我们可以使用 __init__() 方法使用灵活的属性初始化对象。
class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height
rect = Rectangle(5, 10)
print(rect.width) # Output: 5
print(rect.height) # Output: 10
在上面的示例中，我们使用固定属性 width 和 height 初始化了 Rectangle 对象。构造函数返回的对象将始终具有相同的属性。
class Circle:
def __init__(self, radius, color='red', border=None):
self.radius = radius
self.color = color
self.border = border
circle = Circle(5)
print(circle.radius) # Output: 5
print(circle.color) # Output: red
print(circle.border) # Output: None
在上面的示例中，我们使用灵活的属性 radius、color 和 border 初始化了 Circle 对象。我们只向构造函数传递了一个参数 radius，但我们还为 color 和 border 指定了默认值。这允许我们只使用一个参数、三个参数或介于两者之间的任意数量的参数来创建 Circle 对象。
使用 __new__() 方法创建对象
__new__() 方法在 Python 中用于动态创建对象。它允许开发人员使用类名创建类对象，然后你可以在 Python 类的初始化后添加属性。
class Person:
pass
dave = Person.__new__(Person)
dave.name = "Dave"
dave.age = 25
print(dave.name)
在上面的示例中，我们创建了一个名为 Person 的类，然后使用 .new() 方法创建了一个名为 dave 的对象。然后，我们在初始化后向此对象添加了属性 name 和 age。
class Car:
def __init__(self, model, make):
self.model = model
self.make = make
car = Car.__new__(Car)
car.__init__("Corvette", "Chevrolet")
car.color = "red"
print(car.color)
在此示例中，我们创建了一个名为 Car 的类，并在初始化期间使用 __init__() 定义了它的属性。然后，我们使用 __new__() 方法创建了一个名为 car 的对象，并使用模型和制造属性对其进行初始化。最后，我们在初始化后向 car 对象添加了属性 color。
