例如，如果您试图共享一个静态变量，在其他实例之间增加它，则类似以下脚本的操作很正常：

# -*- coding: utf-8 -*-
class Worker:
    id = 1

    def __init__(self):
        self.name = ''
        self.document = ''
        self.id = Worker.id
        Worker.id += 1

    def __str__(self):
        return u"{}.- {} {}".format(self.id, self.name, self.document).encode('utf8')


class Workers:
    def __init__(self):
        self.list = []

    def add(self, name, doc):
        worker = Worker()
        worker.name = name
        worker.document = doc
        self.list.append(worker)


if __name__ == "__main__":
    workers = Workers()
    for item in (('Fiona', '0009898'), ('Maria', '66328191'), ("Sandra", '2342184'), ('Elvira', '425872')):
        workers.add(item[0], item[1])
    for worker in workers.list:
        print(worker)
    print("next id: %i" % Worker.id)

在类定义中声明但不在方法中声明的变量是类或静态变量：

>>> class MyClass:
...     i = 3
...
>>> MyClass.i
3 

正如@millerdev所指出的，这会创建一个类级别i变量，但这与任何实例级别i变量都不同，因此您可以

>>> m = MyClass()
>>> m.i = 4
>>> MyClass.i, m.i
>>> (3, 4)

这与C++和Java不同，但与C#没有太大区别，在C#中，不能使用对实例的引用来访问静态成员。

看看Python教程对类和类对象的主题有什么看法。

@Steve Johnson已经回答了静态方法的问题，也在Python库参考中的“内置函数”中进行了说明。

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

@beidy推荐classmethods而不是staticmethod，因为该方法随后会接收类类型作为第一个参数。

您可以使用列表或字典来获取实例之间的“静态行为”。

class Fud:

     class_vars = {'origin_open':False}

     def __init__(self, origin = True):
         self.origin = origin
         self.opened = True
         if origin:
             self.class_vars['origin_open'] = True


     def make_another_fud(self):
         ''' Generating another Fud() from the origin instance '''

         return Fud(False)


     def close(self):
         self.opened = False
         if self.origin:
             self.class_vars['origin_open'] = False


fud1 = Fud()
fud2 = fud1.make_another_fud()

print (f"is this the original fud: {fud2.origin}")
print (f"is the original fud open: {fud2.class_vars['origin_open']}")
# is this the original fud: False
# is the original fud open: True

fud1.close()

print (f"is the original fud open: {fud2.class_vars['origin_open']}")
# is the original fud open: False

为了避免任何潜在的混淆，我想对比静态变量和不可变对象。

一些基本对象类型，如整数、浮点数、字符串和元组，在Python中是不可变的。这意味着由给定名称引用的对象如果属于上述对象类型之一，则不能更改。可以将名称重新分配给不同的对象，但不能更改对象本身。

通过禁止变量名指向除当前指向的对象之外的任何对象，使变量成为静态变量更进一步。（注意：这是一个通用的软件概念，并不特定于Python；请参阅其他人的帖子，了解有关在Python中实现静态的信息）。

所以这可能是一个黑客，但我一直在使用eval（str）来获取一个静态对象，这有点矛盾，在python 3中。

有一个Records.py文件，除了用保存一些参数的静态方法和构造函数定义的类对象外，它什么都没有。然后从另一个.py文件导入Records，但我需要动态选择每个对象，然后根据读入的数据类型按需实例化它。

因此，在object_name=“RecordOne”或类名的情况下，我调用cur_type=eval（object_name），然后要实例化它，请执行cur_inst=cur_type（args）然而，在实例化之前，您可以从cur_type.getName（）调用静态方法，例如，类似于抽象基类实现或任何目标。然而，在后端，它可能是在python中实例化的，并不是真正静态的，因为eval返回一个对象。。。。必须已实例化。。。。这会产生类似静态的行为。

关于Python的属性查找，一个非常有趣的点是它可以用来创建“虚拟变量”：

class A(object):

  label="Amazing"

  def __init__(self,d): 
      self.data=d

  def say(self): 
      print("%s %s!"%(self.label,self.data))

class B(A):
  label="Bold"  # overrides A.label

A(5).say()      # Amazing 5!
B(3).say()      # Bold 3!

通常情况下，在创建它们之后，不会有任何分配给它们。请注意，查找使用self，因为尽管标签在不与特定实例关联的意义上是静态的，但值仍然取决于（的类）实例。