python 类构造函数

In the last tutorial, we learned how to create a class, its instance and how to access class members(variables and functions). In this tutorial, we will try to improve our understanding about classes by learning more about them. So far, it is known that class keyword is used to initiate the definition of a class, followed by the name of the class. After finishing the first line with colon we move to next line and starts defining variables or methods after providing proper indentation.

在上一教程中，我们学习了如何创建类，其实例以及如何访问类成员(变量和函数)。 在本教程中，我们将通过学习更多关于类的知识来尝试提高对类的理解。 到目前为止，已知可以使用class关键字来初始化类的定义，然后使用该类的名称。 用冒号结束第一行后，我们移至下一行，并在提供适当的缩进后开始定义变量或方法。

什么是构造函数？ (What is a Constructor?)

As seen in the last tutorial, we know that there are two ways to declare/define a variable of a class.

从上一教程中可以看到，我们知道有两种方法来声明/定义类的变量。

First, by simply defining it inside the class and maybe even initialize it with some value, then and there, pretty much like:

首先，只需在类中定义它，甚至可以使用一些值对其进行初始化，然后到那里，就像：

class Example:myVariable = "some value";

Second way is to declare them inside any function of the class, using the self keyword.

第二种方法是使用self关键字在类的任何函数中声明它们。

Also, it is possible to assign values to the variables while declaring them but sometimes it may happen that the values of these variables may vary for different objects of the same class. In such cases, you'll have to go for assigning values to the variables after the object creation.

同样，可以在声明变量时将其赋值，但有时可能会发生这些变量的值针对同一类的不同对象而变化的情况。 在这种情况下，您必须在创建对象后为变量分配值。

Again, this can be done in two ways. First, by calling each variable direct from the object, using the dot . symbol, like:

同样，这可以通过两种方式完成。 首先，使用dot直接从对象调用每个变量. 符号，例如：

>>> myObject.myVariable = "some other value";

or we can also ask user for an input:

或者我们也可以要求用户输入：

>>> myObject.myVariable = input();

Besides this we can also assign/modify values of our variables inside class functions using the self keyword.

除此之外，我们还可以使用self关键字在类函数中分配/修改变量的值。

class Example:def anotherFunction(self, parameter1):self.myVariable = parameter1;# or by calling for a user inputself.myVariable = input();

If we have such a function defined in our class, then the object's variables can be initialized or re-initialised by calling the anotherFunction() method and passing the desired value as parameter to this method/function.

如果我们在类中定义了这样的函数，则可以通过调用anotherFunction()方法并将所需的值作为参数传递给该方法/函数来初始化或重新初始化对象的变量。

>>> myObject = Example()
>>> myObject.anotherFunction("Amazing Spiderman")
>>> print (myObject.myVariable)

Amazing Spiderman

神奇蜘蛛侠

As it can be seen, this was a usual user-defined function inside Example class which is utilising parameters to initialize the variable. The concept is fairly simple here. Although, there exists something better, which uses pretty much the same principle and is a defined standard. It's known as a Constructor.

可以看出，这是Example类中通常使用的用户定义函数，它利用参数来初始化变量。 这里的概念非常简单。 虽然，存在更好的东西，它使用几乎相同的原理并且是已定义的标准。 它被称为构造函数 。

Constructor is a special type of function that is called automatically whenever an object of that class is created. For example,

构造函数是一种特殊的函数类型，每当创建该类的对象时，该函数便会自动调用。 例如，

>>> myObject = Example();

By writing Example() in the code above, we are informing python that myObject is an object of class Example. And that is exactly when the constructor of that class is called.

通过在上面的代码中编写Example() ，我们通知python myObject是Example类的对象。 正是在该类的构造函数被调用时。

But what will it do? Well, generally, the constructors are used to initialize the variables of the class for an object(instance), although it can perform some other tasks as well, like checking if there are enough resources, if the value used to initialize any variable is valid or not, etc.

但是它将做什么？ 好吧，通常，构造函数用于初始化一个对象(实例)的类的变量，尽管它也可以执行其他一些任务，例如检查是否有足够的资源，用于初始化任何变量的值是否有效。是否，等等。

在类中定义构造方法 (Defining Constructor method in a class)

In python, the object creation part is divided into two parts:

在python中，对象创建部分分为两部分：

1. Object Creation

   对象创建

2. Object Initialisation

   对象初始化

对象创建 (Object Creation)

Object creation is controlled by a static class method with the name __new__. Hence when you call Example(), to create an object of the class Example, then the __new__ method of this class is called. Python defines this function for every class by default, although you can always do that explicitly too, to play around with object creation.

对象的创建由名称为__new__的static类方法控制。 因此，当您调用Example()来创建Example类的对象时，将调用该类的__new__方法。 Python默认情况下为每个类都定义了此函数，尽管您也可以始终明确地执行此操作，以进行对象创建。

class Example:def __new__(self):return 'studytonight';# creating object of the class Example
mutantObj = Example()# but this will return that our object
# is of type str
print (type(mutantObj))

In the example above, we have used the __new__ function to change the tyoe of object returned, just to show you what we can do using this function.

在上面的示例中，我们使用了__new__函数来更改返回对象的类型，只是向您展示了我们可以使用该函数做什么。

To see how the default __new__ function works, run the code below, and you will see that this time the object created is of the type Example

若要查看默认的__new__函数如何工作，请运行以下代码，您将看到这次创建的对象属于Example类型

class Example:myVariable = "some value";simpleObj = Example()
print (type(simpleObj))

对象初始化 (Object Initialisation)

Object initialisation is controlled by an instance method with the name __init__ and which is also generally called as a Constructor. Although, both __new__ and __init__ together forms a constructor.

对象初始化由一个名为__init__的实例方法控制，该实例方法通常也称为构造函数 。 虽然__new__和__init__共同构成一个构造函数。

Once the object is created, you can make sure that every variable in the object is correctly initialised by defining an __init__ method in your class, which pretty much means init-iate.

创建对象后，可以通过在类中定义__init__方法来确保正确初始化了对象中的每个变量，这几乎意味着init-iate 。

Thus, it doesn't matter what the class name is, if you want to write a constructor(to initialise your object) for that class, it has to be the __init__() method. Within this function, you're free to declare a class variable(using self) or initialize them. Here is a quick example for our Example class with __init__ method:

因此，类名是什么都没有关系，如果您想为该类编写一个构造函数(以初始化您的对象)，则必须使用__init__()方法。 在此函数中，您可以自由声明类变量(使用self )或对其进行初始化。 这是一个使用__init__方法的Example类的快速示例：

class Example:def __init__(self, value1, value2):self.myVariable1 = value1;self.myVariable2 = value2;print ("All variable initialized")

Once you define the __init__ method in a class, then while creating an object, when you call Example(), you can provide all the necessary parameters required for the object's variables, because when we call Example(), behind the scene python calls the __init__ function for the created object automatically.

一旦在类中定义了__init__方法，然后在创建对象时，调用Example() ，就可以提供对象变量所需的所有必要参数，因为当我们调用Example() ，python在后台调用了__init__函数自动创建的对象。

This is how the code will look:

代码如下所示：

>>> myObj = Example("first variable", "second variable")

You can use this function in lots of ways for initialization. One is already mentioned above using a parameter, another way could be asking user for input inside the constructor.

您可以通过多种方式使用此函数进行初始化。 上面已经提到了使用参数的一种方法，另一种方法是要求用户在构造函数中进行输入。

def __init__(self):self.myVariable1 = input();self.myVariable2 = input();

Below we have a diagram which summarises it all.

在下面，我们有一个图表，总结了这一切。

翻译自: https://www.studytonight.com/python/constructors-in-python

python 类构造函数