为什么我们在 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__的类，但是我不理解创建它们的逻辑。

190049 次浏览
小开

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

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

小开

__init__函数正在设置类中的所有成员变量。因此，一旦创建了双簇，就可以访问该成员并返回一个值:

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

查看 巨蟒文档获得一些信息。你会想要拿起一本关于面向对象概念的书来继续学习。

小开

以 车为例: 当你得到一辆车时，你不会随机选择一辆车，我的意思是，你可以选择颜色、品牌、座位数等等。而且有些东西也是“初始化”，没有你选择它，如车轮数量或注册号码。

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)。

小开
最佳答案

根据您所写的内容，您缺少了一个关键的理解: 类和对象之间的区别。__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 是一只棕色的狗，有四条腿，而 Spot 是一个瘸子，大部分是黄色的。__init__函数称为构造函数或初始值设定项，在创建类的新实例时会自动调用该函数。在该函数中，新创建的对象被分配给参数 self。表示法 self.legs是变量 self中对象的一个称为 legs的属性。属性有点像变量，但它们描述对象的状态，或对象可用的特定操作(函数)。

然而，请注意，您并没有为 Doghood 本身设置 colour——它是一个抽象的概念。有一些属性对于类是有意义的。例如，population_size就是一个这样的例子-它没有意义去计算 Fido，因为 Fido 总是一个。数狗确实有意义。假设世界上有两亿只狗。这是 Dog 类的属性。Fido 和2亿这个数字没有任何关系，Spot 也一样。它被称为“ class 属性”，与上面的 colour或 legs的“实例属性”相反。

现在，让我们来看看更多的编程相关的东西，而不是犬科动物。正如我在下面写的，类添加东西是不明智的-它是一个什么类？Python 中的类由行为相似的不同数据集合组成。狗的类别包括 Fido 和 Spot 和19999999998其他类似的动物，它们都在路灯柱上撒尿。用于添加内容的类由什么组成？它们与生俱来的数据有什么不同？他们有什么共同的行动？

然而，数字... 那些是更有趣的课题。比如说，整数。他们有很多人，比狗多得多。我知道 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) ，但是现在我们将忽略它。在实际代码中，我们不会这样做; 我们会测试它以确保，甚至可能会强制它(“ you’re not a int？天啊，你有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，在这个例子中)来区分它们。

属性是绑定到对象的变量。像数组一样，我们可以有很多 colour变量，fido.colour8。因此，fido.colour是一个变量，而 spot.colour是另一个变量。第一个绑定到变量 fido中的对象; 第二个绑定到 spot。现在，当您调用 Dog(4, "brown")或 three.add(five)时，总会有一个不可见的参数，它将被分配给位于参数列表前面的悬挂的额外参数。它通常被称为 self，并将得到对象前面的点的值。因此，在狗的 __init__(构造函数)中，self将是任何新的狗将被证明是; 在 fido.colour0的 fido.colour1中，self将被绑定到变量 fido.colour3中的对象。因此，fido.colour4将是 fido.colour1之外的同一个变量，就像 fido.colour1之内的 fido.colour6一样。

如果我说 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将“包含”一个 cat 对象。如果你做 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__一样)的用途是描述如何将对象转换为字符串，比如打印出来的时候。

小开

类是具有特定于该对象的属性(状态、特征)和方法(函数、能力)的对象(比如鸭子的白色和苍蝇能力)。

当您创建一个类的实例时，您可以赋予它一些初始个性(状态或字符，比如新生儿的名字和衣服的颜色)。你用 __init__做这个。

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

小开

把我的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-loop。但是它们会暴露出一个个体特征，那就是多态性(3)。

因此，每个人都有自己喜欢的饮料，但是每个民族都倾向于一种特殊的饮料。 如果你从人类的类型中继承了一个国籍，你可以覆盖继承的行为，就像我上面用 drink()方法演示的那样。 但这仍然是在类级别，因此它仍然是一个概括。

hans = German(favorite_drink = "Cola")

在开始时实例化类 German 和 I“更改”了默认特征。 (但是如果你叫他 hans.drink (‘ Milk’) ，他还是会打印“我需要更多的啤酒”——一个明显的错误... ... 或者如果我是一个大公司的员工，也许这就是我所说的功能。;-)! )

类型的特征，例如，German (hans)通常在实例化时通过构造函数(在 python: __init__中)定义。这是您定义一个类成为一个对象的时候。你可以说呼吸生活到一个抽象的概念(类) ，通过填充它的个人特点，成为一个对象。

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

为了保护封装它们的每个对象的特征——意味着你要尝试将行为和特征耦合起来，并且使得从对象外部操作它变得困难。这就是封装(1)

小开

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

请看下面的例子:

>>> 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]
小开 
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__

小开

__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类的实例，并从 __init__()返回 None，如下所示:

"__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

以下错误发生:

TypeError: Init()应该返回 Nothing，而不是‘ str’


提交答案