我试着去理解。除了名字，这些课程有什么区别吗？当声明变量' value '时，在i t_uu()函数中使用或不使用uuu会有什么不同吗？

具有类()的类：

def __init__(self):

self.value='Bob '

def my_func(self):

印刷(自我价值)

没有类()的类：

值='鲍勃'

def my_func(self):

印刷(自我价值)

我主要担心的是我会在某种程度上使用它，导致我的问题进一步发展(我目前正在使用init call)。

重复问题中的详细答案和示例：stackoverflow.com/a//911945

在__init__之外设置的变量属于这个类。它们由所有实例共享。

在__init__中创建的变量，从self开始。(和所有其他方法函数)属于对象实例。

变量以“self”为前缀，即。

Python并没有为我做这些。如果您没有在__init__()中创建list /dict/etc，那么它们将在所有实例之间共享。

@太多@PHP:类方法中的所有变量(不考虑可变性，—— list和dict都是变量)都是共享的。对于不可改变的对象，分享并不好玩。共享对于可变对象(列表和字典)非常重要。

我怀疑可能是这样，但我觉得如果我陈述我的假设，可能会分散对问题本身的注意力。为解决问题干杯：)

我以为是这样，但我不知道。谢谢你清理干净。

我是新手，看不懂S.lott的回答。有人能给我们这些初学者解释一下吗？

在__init__之外创建的变量有什么类比？如果所有实例共享这些实例，修改一个会影响所有其他实例吗？

否，只有更改后声明的新实例才会被更改。现有实例仍将具有旧的变量值。

这有点误导。在init外部设置的Varname变量不属于该类，可以通过self.varname读取，以便为所有实例生成相同的值。但是，当实例引用赋值时(例如，self.varname=X)，将只为实例创建一个新的self.varname，从而隐藏类变量。仍然可以通过类引用访问类var(例如：WithClass.varname)。变量也可以用任何方式设置，比如在类名前添加类名(WithClass.myvar=X)而不是在实例引用前添加类名(self.myvar=X)。

没有自我

创建一些对象：

类foo(对象):

X='原始类'

c1，c2=foo()，foo()

我可以更改c1实例，但它不会影响c2实例：

C1.x='已更改的实例'

c2.x

'原始类别'

但是如果我更改foo类，该类的所有实例也将更改：

O.x='已更改类别'

c2.x

'类别已更改'

请注意python作用域的工作方式：

c1.x

'实例已更改'

利用你自己。

对类别的更改不会影响实例：

类foo(对象):

def __init__(self):

Self.x='最初的自己'

c1=foo()

O.x='已更改类别'

c1.x

“原始自我”

注意，这个例子只适用于新类型的类，对于旧类型的类，它们会有相同的结果。

@ abdeloahab是这样吗？我尝试使用旧的样式类，得到了与新的样式对象相同的结果。Python 2.7.8

我想对这个帖子和在这个帖子里读到的回复(引用这个帖子)做些补充。

声明：这句话来自我做的一个实验。

__init__以外的变量：

实际上，这些是静态的类变量，所以类的所有实例都可以被访问。

__init__中的变量：

这些实例变量的值只能访问手边的实例(自引用)。

我的贡献：

程序员在使用静态类变量时必须考虑的一点是，它们可能被实例变量隐藏(如果你是通过自引用访问静态类变量)。

描述：

之前我认为这两种声明变量的方法是完全一样的(我很傻)，部分原因是我可以通过自引用来访问这两个变量。现在如果你有困难，研究一下这个话题，澄清一下。

通过访问静态类变量的问题进行自引用，意味着它只引用静态类变量，而没有同名的实例变量。更糟糕的是，试图通过自引用来重定义静态类变量是行不通的，因为创建了一个实例变量，然后它隐藏了以前可访问的静态类变量。亚伯。

为了解决这个问题，您应该总是通过类名来引用静态类变量。

示例：

#!/usr/bin/env python

富人(中国姓氏)阶层：

Static_var='每个实例都可以访问'

def __init__(self，name):

Self.instance_var='我是% name

定义打印全部(自己):

自己打印吧。instance _ var=% s ' % self .实例变量

自己打印吧。static _ var=% s ' % self .静态变量

打印“foo”。static _ var=% s“% foo .静态变量

f1=Foo('f1 ')

f1.printAll()

f1 .Static _ var='隐藏Static _ var '

f1.printAll()

f2=Foo('f2 ')

f2.printAll()

Foo.static_var='modified class '

f1.printAll()

f2.printAll()

输出：

Self.instance_var=我是第一个孩子。

每个实例都有访问权限。

每个实例都有访问权限。

Self.instance_var=我是第一个孩子。

自我。静态变量=隐藏静态变量。

每个实例都有访问权限。

Self.instance_var=我是老二。

每个实例都有访问权限。

每个实例都有访问权限。

Self.instance_var=我是第一个孩子。

自我。静态变量=隐藏静态变量。

O.static _ var=修改后的类

Self.instance_var=我是老二。

Self.static_var=已修改的类

O.static _ var=修改后的类

希望对某个人有帮助。

在Lott的回复中，class变量被传递给新的元类方法，在定义元类时可以通过字典访问。因此，甚至在创建和实例化类之前，就可以访问类变量。

例如：

类元素(类型):

def __new__(cls，name，bases，dicto):

#下一行的原件中缺少两个字符。

if dicto[' class _ var ']=' A ':

打印“那里”

类proxyclass(对象):

class_var='A '

_ _元类_ _=元类。

用户(对象):

电子邮件='无'

Name='无'

姓氏='无'

def __init__(self，email=None，firstname=None，lastname=None):

Self.email=电子邮件

self.firstname=firstname

Self.lastname=姓氏

@classmethod

def print_var(cls，obj):

打印('对象。电子邮件对象。名字obj。姓氏’)

打印(对象。电子邮件，对象。名称，对象。姓氏)

打印(' cls。电子邮件。姓氏’)

print(cls.email，cls.firstname，cls.lastname)

U1=用户(电子邮件='abc@xyz '，名字='名字，姓氏='姓氏)

用户。打印变量(u1)

在上面的代码中，user类有3个全局变量，每个变量的值都是none。U1是通过实例化这个类创建的对象。print _var方法打印类users的类变量值和对象u1的对象变量。在下面的输出中，类变量user。电子邮件，用户。姓名和用户。每个姓氏都有值“none ”,而对象变量u1。邮箱，u1。和u1。姓氏的值都是abc@xyz '，'第一个'和最后一个。

电子邮件名称名称名称名称

(' abc@xyz '，' first '，' last ')

电子邮件cls.firstname

('无'，'无'，'无')