为什么我们在 Python 类中使用 __init__？

问题描述：

我无法理解类的初始化。

它们有什么用处？我们如何知道在它们中包含什么？在类中编写代码是否需要与创建函数不同的思维方式（我认为我可以创建函数，然后将它们包装在类中，这样我就可以重复使用它们。这样可行吗？）

以下是一个例子：

class crawler:
  # Initialize the crawler with the name of database
  def __init__(self,dbname):
    self.con=sqlite.connect(dbname)

  def __del__(self):
    self.con.close()

  def dbcommit(self):
    self.con.commit()

或者另一个代码示例：

class bicluster:
  def __init__(self,vec,left=None,right=None,distance=0.0,id=None):
    self.left=left
    self.right=right
    self.vec=vec
    self.id=id
    self.distance=distance

当我尝试阅读其他人的代码时，我遇到了很多类__init__，但我不明白创建它们的逻辑。

解决方案 1：

从你写的内容来看，你缺少一个关键的理解部分：类和对象之间的区别。__init__不初始化类，而是初始化类或对象的实例。每只狗都有颜色，但作为一个类的狗却没有。每只狗有四只或更少的脚，但狗的类却没有。类是对象的概念。当你看到 Fido 和 Spot 时，你会认识到它们的相似之处，它们都是狗。这就是类。

当你说

class Dog:
    def __init__(self, legs, colour):
        self.legs = legs
        self.colour = colour

fido = Dog(4, "brown")
spot = Dog(3, "mostly yellow")

你说，Fido 是一只棕色的狗，有 4 条腿，而 Spot 有点跛，全身都是黄色。该__init__函数称为构造函数或初始化程序，当你创建一个类的新实例时会自动调用。在该函数中，新创建的对象被分配给参数self。符号是变量中对象的self.legs属性。属性有点像变量，但它们描述了对象的状态，或者对象可用的特定操作（函数）。legs`self`

但是，请注意，您没有colour为狗本身设置 - 这是一个抽象概念。有些属性对类有意义。例如，population_size就是这样一个 - 计算 Fido 是没有意义的，因为 Fido 总是一个。计算狗的数量是有意义的。假设世界上有 2 亿只狗。这是 Dog 类的属性。Fido 与 2 亿这个数字无关，Spot 也一样。它被称为“类属性”，而不是 2 亿colour或legs以上的“实例属性”。

现在，我们来谈谈与狗无关、与编程有关的事情。正如我在下面所写的，添加事物的类是不明智的——它是属于什么的类？Python 中的类由行为类似的不同数据的集合组成。狗类包括 Fido 和 Spot 以及 199999999998 种与它们相似的其他动物，它们都在灯柱上撒尿。添加事物的类由什么组成？它们固有的哪些数据不同？它们有哪些共同的行为？

然而，数字……那些是更有趣的主题。比如说整数。整数的数量很多，比狗多得多。我知道 Python 已经有整数了，但让我们装傻，再次“实现”它们（通过作弊并使用 Python 的整数）。

因此，整数是一个类。它们有一些数据（值）和一些行为（“将我添加到另一个数字”）。让我们展示一下：

class MyInteger:
    def __init__(self, newvalue):
        # imagine self as an index card.
        # under the heading of "value", we will write
        # the contents of the variable newvalue.
        self.value = newvalue
    def add(self, other):
        # when an integer wants to add itself to another integer,
        # we'll take their values and add them together,
        # then make a new integer with the result value.
        return MyInteger(self.value + other.value)

three = MyInteger(3)
# three now contains an object of class MyInteger
# three.value is now 3
five = MyInteger(5)
# five now contains an object of class MyInteger
# five.value is now 5
eight = three.add(five)
# here, we invoked the three's behaviour of adding another integer
# now, eight.value is three.value + five.value = 3 + 5 = 8
print eight.value
# ==> 8

这有点脆弱（我们假设other它将是一个 MyInteger），但现在我们将忽略它。在实际代码中，我们不会这样做；我们会测试它以确保无误，甚至可能强制它（“你不是一个整数？天哪，你有 10 纳秒的时间变成一个整数！9... 8....”）

我们甚至可以定义分数。分数也知道如何自我相加。

class MyFraction:
    def __init__(self, newnumerator, newdenominator):
        self.numerator = newnumerator
        self.denominator = newdenominator
        # because every fraction is described by these two things
    def add(self, other):
        newdenominator = self.denominator * other.denominator
        newnumerator = self.numerator * other.denominator + self.denominator * other.numerator
        return MyFraction(newnumerator, newdenominator)

分数比整数还多（其实不是，但计算机不知道）。我们来算两个吧：

half = MyFraction(1, 2)
third = MyFraction(1, 3)
five_sixths = half.add(third)
print five_sixths.numerator
# ==> 5
print five_sixths.denominator
# ==> 6

您实际上并没有在这里声明任何东西。属性就像是一种新的变量。普通变量只有一个值。假设您写了colour = "grey"。您不能有另一个名为 的变量colour-"fuchsia"不能在代码中的同一位置。

数组在一定程度上解决了这个问题。如果你说colour = ["grey", "fuchsia"]，你已经将两种颜色堆叠到变量中，但你通过它们的位置（在本例中为 0 或 1）来区分它们。

属性是与对象绑定的变量。与数组一样，我们可以在不同的 dogs 上colour有多个变量。因此，是一个变量，而是一个变量。第一个变量与变量内的对象绑定；第二个变量是。现在，当您调用或 时，总会有一个不可见的参数，它将被分配给参数列表前面悬垂的额外参数。它通常被称为，并将获取点前面对象的值。因此，在 Dog （构造函数）内，将是新 Dog 的任何值；在的内，将绑定到变量 中的对象。因此，外面的变量与内的变量相同。fido.colour`spot.colourfidospotDog(4, "brown")three.add(five)selfinitselfMyIntegeraddselfthreethree.valueaddself.value`add

如果我说，我将开始用另一个名称the_mangy_one = fido引用 的对象。从现在开始，是与 完全相同的变量。fido`fido.colour`the_mangy_one.colour

所以，里面的东西__init__。你可以把它们看作是把东西记在狗的出生证明上。colour本身是一个随机变量，可以包含任何东西。fido.colour或者self.colour就像狗身份证上的一个表单字段；是__init__职员第一次填写的。

有更清楚的吗？

编辑：扩展以下评论：

您的意思是对象列表，不是吗？

首先，fido实际上不是一个对象。它是一个变量，当前包含一个对象，就像您说的 一样x = 5，x是一个当前包含数字 5 的变量。如果您后来改变主意，您可以这样做fido = Cat(4, "pleasing")（只要您创建了一个类Cat），fido从那时起它将“包含”一个猫对象。如果您这样做fido = x，它将包含数字 5，而不是动物对象。

类本身并不知道它的实例，除非你专门编写代码来跟踪它们。例如：

class Cat:
    census = [] #define census array

    def __init__(self, legs, colour):
        self.colour = colour
        self.legs = legs
        Cat.census.append(self)

这里，census是类的类级属性Cat。

fluffy = Cat(4, "white")
spark = Cat(4, "fiery")
Cat.census
# ==> [<__main__.Cat instance at 0x108982cb0>, <__main__.Cat instance at 0x108982e18>]
# or something like that

请注意，您不会得到[fluffy, sparky]。这些只是变量名。如果您希望猫本身有名字，您必须为该名称创建一个单独的属性，然后重写方法__str__以返回此名称。此方法（即类绑定函数，就像add或__init__）的目的是描述如何将对象转换为字符串，就像您将其打印出来时一样。

解决方案 2：

对Amadan 的详尽解释贡献我的 5 分之见。

类是抽象的“类型”描述。对象是它们的实现：活生生的东西。在面向对象的世界中，有一些基本思想几乎可以称为万物的本质。它们是：

1. 封装（不再详述）

2. 遗产

3. 多态性

对象具有一个或多个特征（= 属性）和行为（= 方法）。行为主要取决于特征。类以一般方式定义行为应完成的任务，但只要类未实现（实例化）为对象，它就仍然是可能性的抽象概念。让我借助“继承”和“多态性”来说明。

    class Human:
        gender
        nationality
        favorite_drink
        core_characteristic
        favorite_beverage
        name
        age

        def love    
        def drink
        def laugh
        def do_your_special_thing                

    class Americans(Humans)
        def drink(beverage):
            if beverage != favorite_drink: print "You call that a drink?"
            else: print "Great!" 

    class French(Humans)
        def drink(beverage, cheese):
            if beverage == favourite_drink and cheese == None: print "No cheese?" 
            elif beverage != favourite_drink and cheese == None: print "Révolution!"

    class Brazilian(Humans)
        def do_your_special_thing
            win_every_football_world_cup()

    class Germans(Humans)
        def drink(beverage):
            if favorite_drink != beverage: print "I need more beer"
            else: print "Lecker!" 

    class HighSchoolStudent(Americans):
        def __init__(self, name, age):
             self.name = name
             self.age = age

jeff = HighSchoolStudent(name, age):
hans = Germans()
ronaldo = Brazilian()
amelie = French()

for friends in [jeff, hans, ronaldo]:
    friends.laugh()
    friends.drink("cola")
    friends.do_your_special_thing()

print amelie.love(jeff)
>>> True
print ronaldo.love(hans)
>>> False

某些特征定义了人类。但每个民族都有所不同。因此，“民族类型”有点像人类，但又有额外特征。“美国人”是“人类”的一种，从人类类型（基类）继承了一些抽象特征和行为：这就是继承。所以所有人类都可以笑和喝，因此所有子类也可以！继承 (2)。

但因为它们都是同一种类（类型/基类：人类），所以有时你可以交换它们：参见最后的 for 循环。但它们会暴露出一个个体特征，那就是多态性 (3)。

因此，每个人都有自己最喜欢的饮料，但每个民族都倾向于喝一种特殊的饮料。如果您从人类类型中子类化一个民族，则可以覆盖继承的行为，正如我上面使用drink()方法所演示的那样。但这仍然处于类级别，因此它仍然是一种概括。

hans = German(favorite_drink = "Cola")

实例化 German 类，并且我在开始时“更改”了默认特性。（但如果您调用 hans.drink('Milk')，他仍然会打印“我需要更多啤酒” - 一个明显的错误……或者如果我是一家大公司的员工，也许这就是我所说的功能。;-)！）

类型的特征，例如德国人（hans），通常__init__在实例化时通过构造函数（在 python 中为 : ）定义。这是您将类定义为对象的时刻。可以说，通过为抽象概念（类）填充个体特征并将其变为对象，为其注入生命。

但是因为每个对象都是某个类的一个实例，所以它们共享一些基本的特征类型和一些行为。这是面向对象概念的一个主要优点。

为了保护每个对象的特性，你需要封装它们 - 这意味着你试图将行为和特性结合起来，使对象外部很难对其进行操作。这就是封装 (1)

解决方案 3：

它只是为了初始化实例的变量。

例如，创建一个crawler具有特定数据库名称的实例（来自上面的示例）。

解决方案 4：

继续以您的汽车为例：当您得到一辆车时，您并不是随机地得到一辆汽车，我的意思是，您可以选择颜色、品牌、座位数等。并且一些东西也会在您不选择的情况下“初始化”，例如车轮数量或注册号码。

class Car:
    def __init__(self, color, brand, number_of_seats):
        self.color = color
        self.brand = brand
        self.number_of_seats = number_of_seats
        self.number_of_wheels = 4
        self.registration_number = GenerateRegistrationNumber()

因此，在__init__方法中，您要定义要创建的实例的属性。因此，如果我们想要一辆蓝色雷诺汽车，供 2 人使用，我们将初始化或实例如下Car：

my_car = Car('blue', 'Renault', 2)

这样，我们就创建了Car类的一个实例。__init__是处理特定属性（如color或brand）的类，它还生成其他属性，如registration_number。

• 有关Python 中的类的更多信息

• 有关该方法的更多信息__init__

解决方案 5：

__init__如果您想正确初始化实例的可变属性，似乎需要在 Python 中使用。

请参阅以下示例：

>>> class EvilTest(object):
...     attr = []
... 
>>> evil_test1 = EvilTest()
>>> evil_test2 = EvilTest()
>>> evil_test1.attr.append('strange')
>>> 
>>> print "This is evil:", evil_test1.attr, evil_test2.attr
This is evil: ['strange'] ['strange']
>>> 
>>> 
>>> class GoodTest(object):
...     def __init__(self):
...         self.attr = []
... 
>>> good_test1 = GoodTest()
>>> good_test2 = GoodTest()
>>> good_test1.attr.append('strange')
>>> 
>>> print "This is good:", good_test1.attr, good_test2.attr
This is good: ['strange'] []

这在 Java 中有很大不同，Java 中的每个属性都会自动用新值进行初始化：

import java.util.ArrayList;
import java.lang.String;

class SimpleTest
{
    public ArrayList<String> attr = new ArrayList<String>();
}

class Main
{
    public static void main(String [] args)
    {
        SimpleTest t1 = new SimpleTest();
        SimpleTest t2 = new SimpleTest();

        t1.attr.add("strange");

        System.out.println(t1.attr + " " + t2.attr);
    }
}

产生我们直观期望的输出：

[strange] []

但是如果你声明attr为static，它就会像 Python 一样运行：

[strange] [strange]

解决方案 6：

该__init__函数设置类中的所有成员变量。因此，一旦创建了双聚类，您就可以访问成员并获取返回值：

mycluster = bicluster(...actual values go here...)
mycluster.left # returns the value passed in as 'left'

查看Python 文档获取一些信息。您将需要阅读一本有关 OO 概念的书来继续学习。

解决方案 7：

类是具有特定于该对象的属性（状态、特征）和方法（功能、容量）的对象（例如，鸭子分别具有白色和飞行能力）。

创建类的实例时，可以赋予它一些初始个性（状态或特征，如新生儿的名字和衣服颜色）。您可以使用 来执行此操作__init__。

基本上，__init__当您调用时会自动设置实例特征instance = MyClass(some_individual_traits)。

解决方案 8：

class Dog(object):

    # Class Object Attribute
    species = 'mammal'

    def __init__(self,breed,name):
        self.breed = breed
        self.name = name

在上面的例子中，我们将物种用作全局变量，因为它总是相同的（你可以说是一种常数）。当你调用__init__方法时，里面的所有变量都__init__将被启动（例如：品种，名称）。

class Dog(object):
    a = '12'

    def __init__(self,breed,name,a):
        self.breed = breed
        self.name = name
        self.a= a

如果你通过下面的调用来打印上面的示例

Dog.a
12

Dog('Lab','Sam','10')
Dog.a
10

这意味着它只会在对象创建期间被初始化。因此，任何你想声明为常量的东西都应该是全局的，任何改变的东西都应该使用 __init__

解决方案 9：

__init__()能：

• 初始化类的实例。

• 被多次调用。

• 仅返回None。

例如Person类有__init__()如下所示：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print('"__init__()" is called.')

现在，我们创建并初始化类的实例Person，如下所示：

       # Here
obj = Person("John", 27)

然后，__init__()被调用，如下所示：

"__init__()" is called.

接下来，我们检查name和是否age已初始化，如下所示：

obj = Person("John", 27)
print(obj.name) # Here
print(obj.age) # Here

然后，name和age的初始化如下所示：

"__init__()" is called.
John # Here
27   # Here

并且__init__()可以被多次调用，如下所示：

obj = Person("John", 27)
print(obj.__init__("Tom", "18")) # Here
print(obj.name)
print(obj.age)

然后，被调用并且类__init__()的实例被重新初始化并返回，如下所示：Person`None`__init__()

"__init__()" is called.
"__init__()" is called.
None
Tom
18

最后，如果__init__()没有返回None，我们调用__init__()如下方法：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print('"__init__()" is called.')
        return "Hello" # Here

obj = Person("John", 27) # Here

出现以下错误：

类型错误：init（）应该返回 None，而不是 'str'