Oop 静态变量vs类变量vs实例变量vs局部变量

在发布之前，我在这个站点的搜索中阅读了超过六篇文章（python变量类静态实例本地）

我把一些结果放进书签，以备将来研究，但没有一个结果能向我澄清我的想法是对还是错，所以我觉得我可能缺少一些基本知识（见下文）

术语“类变量”和“静态变量”指的是同一件事吗？在谷歌搜索了大约三次，每次搜索我都能看懂6篇文章之后，我得出了一个结论：类和静态变量是一样的。但是，由于我只是在学习Python和OOP的基础知识，这个结论可能是错误的，所以我想在继续以错误的心态学习之前，找出我推理中的任何缺陷。在下面的代码中：

class Variables():
    scVar = 3

    def __init__(self, a, b):
        self.iVar1 = a
        self.iVar2 = b

    def getLocalVar3(self):
        localVar1 = 17
        localVar2 = 100
        localVar3 = localVar1 + localVar2
        return localVar3

“scVar”既是类变量又是静态变量（“类”和“静态”变量是同义词）

第二个问题是澄清我对区分类变量、实例变量和局部变量的理解。在上面的代码中，我认为scVar是一个类变量；iVar1和iVar2是实例变量；localVar1、localVar2和localVar3是局部变量。这是正确的说法，还是我遗漏了什么

---

谢谢cirosantilli，你链接到的那篇文章是我还没看过的。我要仔细看看。我想知道一点Python的vew观点，即类变量和实例变量之间没有区别。作为一个初学者，这是一个我应该首先尝试正确理解的观点，还是我应该把这个想法牢记在心，在我变得更有经验之前，不要太担心调和我目前的观点？这个问题似乎过于模糊，取决于我目前对Python的理解水平。大多数情况下，我一直在类示例上运行命令，类似于原始帖子中的命令；在按下[enter]键之前预测输出，然后在输出与我预测的不同时研究输出。由此，我开始了解Python中的工作原理。基本上，我最近才开始了解OO在Python中的工作原理——缓慢但肯定地向前推进

“然而，上述只是约定：从语言的角度来看，类变量和实例变量之间没有区别。”——为了帮助我更好地理解这一点，“从语言的角度来看…”部分是否暗示Python文档在其中的某个地方解释了这一观点？如果是这样的话，我将重新阅读这些文档，专门寻找这一部分，并尝试使我的思维过程符合它。“…在类变量和实例变量之间。”因此，即使“classobj”和“instance”以及Python在查看和访问类变量和实例变量的方式上存在差异 观点是它们之间没有区别吗？在以后的阅读中，我会把这个想法牢记在心，这样我就可以消除一些困惑。在最初的文章中运行*.py之后，我使用Python2.7.x（为了更好的可读性，只包括回溯错误的最后一行）以空闲方式获得以下输出：

>Variables.scVar
3.
>>>变量1.iVar1
AttributeError:类变量没有属性“iVar1”
>>>实例=变量（5，15）
>>>实例
>>>变数
>>>instance.scVar
3.
>>>instance.iVar1
5.
>>>instance2=变量（25,35）
>>>instance2.scVar
3.
>>>Variables.scVar=Variables.scVar*100
>>>变量.scVar
300
>>>instance.scVar
300
>>>instance2.scVar
300
>>>instance.scVar=9999
>>>变量.scVar
300
>>>instance.scVar
9999
>>>instance2.scVar
300
>>>类型（变量）
>>>类型（实例）

“然而，以上只是约定：从语言的角度来看，类变量和实例变量之间没有区别。”——通过使用原始帖子中的代码，是否有一系列命令可以说明这一点？我不怀疑你知道你在说什么；我只是觉得很难使我目前的思维方式与上述陈述相一致。但我有一种感觉，如果我能开始看到这两种观点之间的差异，那么一些重要的东西就会“点击”。 作为最后几句话的补充，我可能会看到更多与您关于“类变量和实例变量之间没有区别”的陈述相同的东西，但前提是我下面的假设是正确的。。。从原始post中的代码（类变量-12行）来看，该程序中是否只涉及全局和局部两个范围？由于我刚刚开始就如何将所有变量组合在一起形成结论，我认为我对范围的有限理解可能使我无法完全理解类变量和实例变量之间没有区别的概念。我现在唯一能理解的是（也许只是）-“Python在类变量和实例变量之间没有区别；但是全局范围和局部范围之间的差异可能会让新手觉得这两种变量之间存在区别。我不知道，这句话是否指出了我可能会遇到的潜在“障碍”

---

“一切都是一个对象，包括类和整数：”——我已经读了很多遍了。如此之多以至于我认为这是理解OO和Python的一个核心信念，但我还没有完全意识到它的含义（我认为）

class Foo（）：
整数=10
浮动=6.37
string='hello'
布尔=真
idkyet=None
定义初始化（自）：
self.a='iv_a'
self.b='iv_b'
self.c='iv_c'
>>> Variables.scVar
3
>>> Variables.iVar1
AttributeError: class Variables has no attribute 'iVar1'
>>> instance = Variables(5, 15)
>>> instance
<__main__.Variables instance at 0x02A0F4E0>
>>> Variables
<class __main__.Variables at 0x02A0D650>
>>> instance.scVar
3
>>> instance.iVar1
5
>>> instance2 = Variables(25, 35)
>>> instance2.scVar
3
>>> Variables.scVar = Variables.scVar * 100
>>> Variables.scVar
300
>>> instance.scVar
300
>>> instance2.scVar
300
>>> instance.scVar = 9999
>>> Variables.scVar
300
>>> instance.scVar
9999
>>> instance2.scVar
300
>>> type(Variables)
<type 'classobj'>
>>> type(instance)
<type 'instance'>

class Foo():
    integer = 10
    float = 6.37
    string = 'hello'
    boolean = True
    idkyet = None

    def __init__(self):
        self.a = 'iv_a'
        self.b = 'iv_b'
        self.c = 'iv_c'

    def Func(self):
        self.g = 'g'
        h = 'h'
        i = 'i'
        return 'g' + 'h' + 'i'

>>> Foo
<class __main__.Foo at 0x02A1D650>
>>> type(Foo.integer)
<type 'int'>
>>> type(Foo.float)
<type 'float'>
>>> type(Foo.string)
<type 'str'>
>>> type(Foo.boolean)
<type 'bool'>
>>> type(Foo.idkyet)
<type 'NoneType'>
>>> type(Foo)
<type 'classobj'>
>>> import os
>>> type(os.getcwd() + '\\Test.py')
<type 'str'>
>>> type(os)
<type 'module'>
>>> f = Foo()
>>> type(f)
<type 'instance'>
>>> type(f.Func)
<type 'instancemethod'>
>>> type(f.Func())
<type 'str'>
>>> f.Func
<bound method Foo.Func of <__main__.Foo instance at 0x02A25AF8>>
>>> Foo.Func
<unbound method Foo.Func>
>>> type(f.a)
<type 'str'>
>>> type(Foo.a)
AttributeError: class Foo has no attribute 'a'
>>> type(Foo.self.a)
AttributeError: class Foo has no attribute 'self'

 class C(object): pass
 print id(C)
 C.a = 1
 assert C.__dict__['a'] == 1

class C(object):
    i_static = 0
    def __init__(self):
        self.i = 1

# i is in the __dict__ of object c
c = C()
assert c.__dict__['i'] == 1
assert c.i == 1

# dot finds i_static because MRO looks at class
assert c.__class__.__dict__['i_static'] == 0
assert c.i_static == 0

# i_static is in the __dict__ of object C
assert C.__dict__['i_static'] == 0
assert C.i_static == 0

# __eq__ is in the dict of type, which is the __class__ of C
# By MRO, __eq__ is found. `C,C` because of bound vs unbound.
assert C.__class__.__dict__['__eq__'](C,C)
assert C == C

def f(): pass

class C(object): pass

class C(object):
    def __call__(self): pass