python中静态变量的作用_python中静态变量和实例变量之间的差异。它们是否存在？...

桃扇骨 2022-10-22 14:59 29阅读 0赞

随机类定义：

class ABC:

x = 6

先为ABC实例设置一些值，然后为静态变量设置：

abc = ABC()

abc.x = 2

ABC.x = 5

然后打印结果：

print abc.x

print ABC.x

哪些版画

现在，我真的不知道发生了什么，因为如果我在类定义x=6中替换"pass"，它将只输出相同的东西。我的问题是，在Python的类定义中定义一个变量的目的是什么？如果没有这样做，任何人都可以在任何时候设置任何变量？

另外，python知道实例变量和静态变量之间的区别吗？据我所见，我会这么说。

我认为，造成您困惑的部分原因是类ABC(和实例ABC)中的所有变量都是"公共的"。它们也是动态创建的。所以"abc.x=2"实际上在实例abc中创建了一个新的非静态成员变量…也就是说……"如果没有静态变量x，abc.x=2"就可以了。如果你尝试abc.y=2，这可能会更清楚。

@汤姆：请把你的答案贴出来作为答案，而不是评论。把答案贴成评论让人很困惑。

警告：下面是一个过于简单化的过程；我忽略了\_\_new\_\_()和其他一些特殊的类方法，并手工处理了很多细节。但是这个解释会让你在python中走得很远。

在python中创建类的实例时，例如在示例中调用abc()：

abc = ABC()

python创建一个新的空对象，并将其类设置为abc。如果有的话，它会叫\_\_init\_\_()。最后返回对象。

当您请求一个对象的属性时，它首先在实例中查找。如果找不到它，它将在实例的类中查找。然后在基类中，依此类推。如果它从未找到任何定义了属性的人，它就会抛出异常。

当分配给对象的属性时，如果对象还没有该属性，它将创建该属性。然后将属性设置为该值。如果对象已经有一个具有该名称的属性，它将删除对旧值的引用，并获取对新值的引用。

这些规则使你观察到的行为很容易预测。在这行之后：

abc = ABC()

只有abc对象(类)有一个名为x的属性。abc实例还没有自己的x，因此，如果您要求一个，您将得到abc.x的值。但是，您将在类和对象上重新分配属性x。当您随后检查这些属性时，您会观察到您放置的值仍然存在。

现在，您应该能够预测此代码的作用：

class ABC:

x = 6

a = ABC()

ABC.xyz = 5

print(ABC.xyz, a.xyz)

是的：它印两张五张的。您可能期望它抛出一个attributeError异常。但python在类中找到了属性——即使它是在创建实例之后添加的。

这种行为真的会给你带来麻烦。Python中的一个典型初学者错误：

class ABC:

x = \[\]

a = ABC()

a.x.append(1)

b = ABC()

print(b.x)

这将打印\[1\]。abc()的所有实例共享同一列表。你可能想要的是：

class ABC:

def \_\_init\_\_(self):

self.x = \[\]

a = ABC()

a.x.append(1)

b = ABC()

print(b.x)

这将按您的预期打印一个空列表。

要回答您的确切问题：

My question is, what is the purpose of defining a variable in the class definition in python if it seems like i can anyone set at any time any variable without doing so?

我假设这意味着"为什么我应该在类内而不是在\_\_init\_\_方法内分配成员？"

实际上，这意味着实例没有自己的属性副本(或者至少还没有)。这意味着实例较小；也意味着访问属性的速度较慢。它还意味着所有实例都为该属性共享相同的值，在可变对象的情况下，这可能是您想要的，也可能不是。最后，这里的赋值意味着值是类的一个属性，这是在类上设置属性的最简单的方法。

作为一个纯粹的风格问题，它是较短的代码，因为你没有所有的自我实例。到处都是。除此之外，没有什么区别。但是，在\_\_init\_\_方法中分配属性可以确保它们是明确的实例变量。

我自己也不太一致。我唯一确定要做的就是分配我不想在\_\_init\_\_方法中共享的所有可变对象。

Also, does python know the difference between instance and static variables? From what I saw, I'd say so.

Python类没有类静态变量，如C++。只有属性：类对象的属性和实例对象的属性。如果您请求一个属性，而实例没有该属性，那么您将从类中获得该属性。

python中类静态变量的最接近近似值是一个隐藏的模块属性，如下所示：

\_x = 3

class ABC:

def method(self):

global \_x

\# ...

从本质上讲，这不是课程的一部分。但这是一个常见的Python习惯用法。

class SomeClass:

x=6  \# class variable

def \_\_init\_\_(self):

self.y = 666  \# instance variable

声明类范围的变量有一个优点：它是类范围变量的默认值。像您在其他一些语言中所想的"静态"变量一样，考虑类范围变量。

每个对象都有一个\_\_dict\_\_。类abc及其实例abc都是对象，因此每个类都有自己的单独\_\_dict\_\_：

In \[3\]: class ABC:

...:     x=6

注意：ABC.\_\_dict\_\_有一个"x"键：

In \[4\]: ABC.\_\_dict\_\_

Out\[4\]: \{'\_\_doc\_\_': None, '\_\_module\_\_': '\_\_main\_\_', 'x': 6\}

In \[5\]: abc=ABC()

In \[6\]: abc.\_\_dict\_\_

Out\[6\]: \{\}

注意，如果"x"不在ABC.\_\_dict\_\_中，那么将搜索ABC超类的\_\_dict\_\_。因此，abc.x是从ABC继承的：

In \[14\]: abc.x

Out\[14\]: 6

但是如果我们设置abc.x，那么我们将更改ABC.\_\_dict\_\_，而不是ABC.\_\_dict\_\_：

In \[7\]: abc.x = 2

In \[8\]: abc.\_\_dict\_\_

Out\[8\]: \{'x': 2\}

In \[9\]: ABC.\_\_dict\_\_

Out\[9\]: \{'\_\_doc\_\_': None, '\_\_module\_\_': '\_\_main\_\_', 'x': 6\}

当然，如果我们希望：

In \[10\]: ABC.x = 5

In \[11\]: ABC.\_\_dict\_\_

Out\[11\]: \{'\_\_doc\_\_': None, '\_\_module\_\_': '\_\_main\_\_', 'x': 5\}

类级变量(在其他语言中称为"static")归类所有，并由类的所有实例共享。

实例变量是类的每个不同实例的一部分。

然而。

您可以随时添加新的实例变量。

因此，获取abc.x需要首先检查实例变量。如果没有实例变量，它将尝试使用类变量。

设置abc.x将创建(或替换)一个实例变量。

python区分了这两者。目的可以是多个，但一个例子是：

class token(object):

id = 0

def \_\_init\_\_(self, value):

self.value = value

self.id = token.id

token.id += 1

在这里，类变量token.id在每个新实例上自动递增，这个实例可以同时获得一个唯一的ID，这个ID将放在self.id中。它们都存储在不同的地方——在类对象中，或者在实例对象中，您确实可以将它与一些类似于C++或C语言的OO语言中的静态和实例变量进行比较。

在该示例中，如果执行以下操作：

print token.id

您将看到下一个要分配的ID，但是：

x = token(10)

print x.id

将提供该实例的ID。

每个人都可以在实例或类中放置其他属性，这是正确的，但这并不有趣，因为类代码并不打算使用它们。上面一个例子的意思是类代码使用它们。

"static"或python中的"class属性"的好处是类的每个实例都可以访问同一个class属性。对于您可能知道的实例属性，这不是真的。

例如：

class A(object):

b = 1

A.b        \# => 1

inst = A()

inst2 = A()

inst.b     \# => 1

inst2.b    \# => 1

A.b = 5

inst.b     \# => 5

inst2.b    \# => 5

如您所见，类的实例可以访问class属性，该属性可以通过指定类名和class属性来设置。

棘手的部分是当你有一个类属性和实例属性命名相同的东西。这需要了解发动机罩下发生了什么。

inst.\_\_dict\_\_  \# => \{\}

A.\_\_dict\_\_     \# => \{..., 'b': 5\}

注意该实例如何没有b作为属性？上面，当我们调用inst.bpython时，实际上检查inst.\_\_dict\_\_的属性，如果找不到，那么它会搜索A.\_\_dict\_\_的属性。当然，当python在类的属性中查找b时，它会被找到并返回。

如果您随后使用相同的名称设置实例属性，则可能会得到一些令人困惑的输出。例如：

inst.b = 10

inst.\_\_dict\_\_  \#=> \{'b': 10\}

A.b         \# => 5

inst.b      \# => 10

您可以看到类的实例现在具有b实例属性，因此python返回该值。

python中静态变量的作用_python中静态变量和实例变量之间的差异。它们是否存在？...

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关理解Java中的静态变量和非静态变量

相关在Java中，静态变量和非静态变量的区别实例

相关 Java中静态变量和实例变量的区别

相关静态变量和实例变量的区别

相关 Java中类变量（static静态变量）和实例变量（非静态变量）的区别

相关 python 类中静态变量_Python中的类或静态变量

相关 python中静态变量的作用_python中静态变量和实例变量之间的差异。它们是否存在？...

相关 Java 中静态变量和实例变量区别

相关 Java中静态变量和实例变量的区别

相关静态变量和实例变量