当然是的，Python本身没有任何静态数据成员，但我们可以这样做

class A:
    counter =0
    def callme (self):
        A.counter +=1
    def getcount (self):
        return self.counter  
>>> x=A()
>>> y=A()
>>> print(x.getcount())
>>> print(y.getcount())
>>> x.callme() 
>>> print(x.getcount())
>>> print(y.getcount())

输出

0
0
1
1

解释

here object (x) alone increment the counter variable
from 0 to 1 by not object y. But result it as "static counter"

@Blair Conrad表示，在类定义中声明的静态变量，而不是在方法中声明的是类或“静态”变量：

>>> class Test(object):
...     i = 3
...
>>> Test.i
3

这里有几家餐厅。从以上示例继续：

>>> t = Test()
>>> t.i     # "static" variable accessed via instance
3
>>> t.i = 5 # but if we assign to the instance ...
>>> Test.i  # we have not changed the "static" variable
3
>>> t.i     # we have overwritten Test.i on t by creating a new attribute t.i
5
>>> Test.i = 6 # to change the "static" variable we do it by assigning to the class
>>> t.i
5
>>> Test.i
6
>>> u = Test()
>>> u.i
6           # changes to t do not affect new instances of Test

# Namespaces are one honking great idea -- let's do more of those!
>>> Test.__dict__
{'i': 6, ...}
>>> t.__dict__
{'i': 5}
>>> u.__dict__
{}

请注意，当直接在t上设置属性i时，实例变量t.i如何与“static”类变量不同步。这是因为我在t命名空间中重新绑定，这与Test命名空间不同。如果要更改“静态”变量的值，必须在其最初定义的范围（或对象）内更改它。我把“static”放在引号里，因为Python实际上没有C++和Java那样的静态变量。

尽管Python教程没有具体说明静态变量或方法，但它提供了一些关于类和类对象的相关信息。

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

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

@beid还提到了classmethod，它类似于staticmethod。类方法的第一个参数是类对象。例子：

class Test(object):
    i = 3 # class (or static) variable
    @classmethod
    def g(cls, arg):
        # here we can use 'cls' instead of the class name (Test)
        if arg > cls.i:
            cls.i = arg # would be the same as Test.i = arg1

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

# -*- 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)

@数据类定义提供用于定义实例变量和初始化方法__init__（）的类级名称。如果要在@dataclass中使用类级变量，则应使用typeing.ClassVar类型提示。ClassVar类型的参数定义类级别变量的类型。

from typing import ClassVar
from dataclasses import dataclass

@dataclass
class Test:
    i: ClassVar[int] = 10
    x: int
    y: int
    
    def __repr__(self):
        return f"Test({self.x=}, {self.y=}, {Test.i=})"

用法示例：

> test1 = Test(5, 6)
> test2 = Test(10, 11)

> test1
Test(self.x=5, self.y=6, Test.i=10)
> test2
Test(self.x=10, self.y=11, Test.i=10)

用这种方式，静态变量是在用户定义的类出现时创建的，

class Student:

    the correct way of static declaration
    i = 10

    incorrect
    self.i = 10

与@staticmethod不同，但类变量是类的静态方法，并与所有实例共享。

现在您可以像这样访问它

instance = MyClass()
print(instance.i)

or

print(MyClass.i)

必须为这些变量赋值

我在努力

class MyClass:
  i: str

并在一个方法调用中赋值，在这种情况下，它将不起作用，并将抛出错误

i is not attribute of MyClass