这两个类别有何不同?
class A():
x=3
class B():
def __init__(self):
self.x=3
有什么明显的区别吗?
Answers:
A.x
是一个类变量。
B
的self.x
是一个实例变量。
即A
的x
被实例之间共享。
用可以像列表这样修改的东西来证明区别是比较容易的:
#!/usr/bin/env python
class A:
x = []
def add(self):
self.x.append(1)
class B:
def __init__(self):
self.x = []
def add(self):
self.x.append(1)
x = A()
y = A()
x.add()
y.add()
print("A's x:", x.x)
x = B()
y = B()
x.add()
y.add()
print("B's x:", x.x)
输出量
A's x: [1, 1]
B's x: [1]
正如一个侧面说明:self
实际上只是一个随机选择的话,每个人都使用,但你也可以使用this
,foo
或myself
或者其他任何你想要的,它只是一个类每一个非静态方法的第一个参数。这意味着单词self
不是语言构造,而只是名称:
>>> class A:
... def __init__(s):
... s.bla = 2
...
>>>
>>> a = A()
>>> a.bla
2
Ax是一个类变量,并且将在A的所有实例之间共享,除非在实例中被特别覆盖。Bx是一个实例变量,并且B的每个实例都有其自己的版本。
我希望以下Python示例可以阐明这一点:
>>> class Foo():
... i = 3
... def bar(self):
... print 'Foo.i is', Foo.i
... print 'self.i is', self.i
...
>>> f = Foo() # Create an instance of the Foo class
>>> f.bar()
Foo.i is 3
self.i is 3
>>> Foo.i = 5 # Change the global value of Foo.i over all instances
>>> f.bar()
Foo.i is 5
self.i is 5
>>> f.i = 3 # Override this instance's definition of i
>>> f.bar()
Foo.i is 5
self.i is 3
我曾经用这个例子来解释
# By TMOTTM
class Machine:
# Class Variable counts how many machines have been created.
# The value is the same for all objects of this class.
counter = 0
def __init__(self):
# Notice: no 'self'.
Machine.counter += 1
# Instance variable.
# Different for every object of the class.
self.id = Machine.counter
if __name__ == '__main__':
machine1 = Machine()
machine2 = Machine()
machine3 = Machine()
#The value is different for all objects.
print 'machine1.id', machine1.id
print 'machine2.id', machine2.id
print 'machine3.id', machine3.id
#The value is the same for all objects.
print 'machine1.counter', machine1.counter
print 'machine2.counter', machine2.counter
print 'machine3.counter', machine3.counter
然后输出将
machine1.id 1 machine2.id 2 machine3.id 3 machine1.counter 3 machine2.counter 3 machine3.counter 3
我刚刚开始学习Python,这也让我感到困惑。为了弄清楚总体上它们是如何工作的,我想到了以下非常简单的代码:
# Create a class with a variable inside and an instance of that class
class One:
color = 'green'
obj2 = One()
# Here we create a global variable(outside a class suite).
color = 'blue'
# Create a second class and a local variable inside this class.
class Two:
color = "red"
# Define 3 methods. The only difference between them is the "color" part.
def out(self):
print(self.color + '!')
def out2(self):
print(color + '!')
def out3(self):
print(obj2.color + '!')
# Create an object of the class One
obj = Two()
当我们打电话给out()
我们时:
>>> obj.out()
red!
当我们打电话给out2()
:
>>> obj.out2()
blue!
当我们打电话给out3()
:
>>> obj.out3()
green!
因此,在第一种方法中,self
指定Python应该使用变量(属性),该变量“属于”我们创建的类对象,而不是全局类(在类外部)。因此它使用color = "red"
。在该方法中,Python隐式替换self
了我们创建的对象的名称(obj
)。self.color
意思是“我收到color="red"
来自obj
”
在第二种方法中,没有self
指定要从中获取颜色的对象,因此它获得了全局对象color = 'blue'
。
在第三个方法中,self
我们代替了使用obj2
-要获取的另一个对象的名称color
。它得到color = 'green'
。