根据你所写的，你缺少了一个关键的理解：类和对象之间的区别。__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")
你是说，菲多是一只棕色的狗，有四条腿，而斯波特有点瘸，大部分是黄色的。函数__init__称为构造函数或初始值设定项，并在创建类的新实例时自动调用。在该函数中，新创建的对象被分配给参数self。符号self.legs是变量self中对象的名为legs的属性。属性类似于变量，但它们描述对象的状态或对象可用的特定操作(函数)。
但是，请注意，您没有为doghood本身设置colour这是一个抽象的概念。在类上有一些属性是有意义的。例如，population_size就是这样的一个——计算Fido是没有意义的，因为Fido总是一个。数狗确实有道理。假设世界上有2亿只狗。这是狗类的财产。Fido与2亿的数字无关，Spot也无关。它被称为“类属性”，而不是上面的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)，但我们现在将忽略它。在实际的代码中，我们不会这样做；我们会测试它以确保，甚至强制它(“你不是整数？天哪，你有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.colour是一个变量，而spot.colour是另一个变量。第一个绑定到变量fido中的对象；第二个绑定到变量spot。现在，当您调用Dog(4, "brown")，或者three.add(five)时，总会有一个不可见的参数，它将被分配给参数列表前面悬挂的额外参数。它通常被称为self，并将获取点前面对象的值。因此，机智在Dog的__init__(构造函数)中，self将是新的Dog的结果；在MyInteger的add中，self将绑定到变量three中的对象。因此，three.value将是add外部的相同变量，与add内部的self.value相同。
如果我说the_mangy_one = fido，我将开始使用另一个名称引用名为fido的对象。从现在起，fido.colour与the_mangy_one.colour是完全相同的变量。
所以，里面的东西。你可以把它们看作是在狗的出生证明上做了记录。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>, <__main__.cat instance at>]
# or something like that
注意，您不会得到[fluffy, sparky]。这些只是变量名。如果希望猫自己有名字，则必须为名字创建一个单独的属性，然后重写__str__方法以返回这个名字。此方法(即类绑定函数，就像add或__init__)的目的是描述如何将对象转换为字符串，就像打印出来一样。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
