根据您所写的内容，您缺少一个关键的理解：类和对象之间的区别。__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有点a弱，而且大多是黄色的。该__init__函数称为构造函数或初始化器，当您创建类的新实例时会自动调用该函数。在该函数中，将新创建的对象分配给parameterself。表示法self.legs是legs变量中称为对象的属性self。属性有点像变量，但是它们描述对象的状态或对象可用的特定操作（功能）。
但是，请注意，您并没有设置colour狗狗身份本身-这是一个抽象概念。有一些对类有意义的属性。例如，population_size就是这样- 计数Fido没什么意义，因为Fido始终是一个。数狗确实是有道理的。让我们说世界上有2亿只狗。这是Dog类的属性。菲多（Fido）与2亿数字无关，与Spot也无关。与“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变量。因此，是一个变量，但是是另一个变量。第一个绑定到变量内的对象; 第二个。现在，当您调用或时，将始终有一个不可见的参数，该参数将分配给参数列表前面悬空的多余参数。它通常称为，它将在点前面获取对象的值。因此，在狗的（构造函数）内部，新狗将成为什么样的狗。中的，将绑定到变量中的对象。从而， __fido.colour``spot.colour``fido``spot``Dog(4, "brown")``three.add(five)``self``__init__``self``MyInteger``add``self``three``three.value将在外部与add在self.value内部相同add。
如果我说the_mangy_one = fido，我将开始引用fido另一个名称的对象。从现在开始，fido.colour变量与完全相同the_mangy_one.colour。
所以，里面的东西__init__。您可以将它们视为在Dog的出生证明中注明的内容。colour本身是一个随机变量，可以包含任何内容。fido.colour或self.colour类似于“狗的身份证”上的表格字段；并且__init__是店员填充它的第一次。
更清晰吗？
：扩展下面的评论：
您的意思是列出 ，不是吗？
首先，fido实际上不是对象。它是一个变量，这是目前包含一个对象，只是当你说喜欢x = 5，x是目前包含数字五个变量。如果您以后改变主意，则可以fido = Cat(4, "pleasing")（只要创建了classCat）就可以这样做，并且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是class的类级属性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__）的目的是描述如何将对象转换为字符串，就像将其打印出来一样。
602392714
清零编程群