除了名字以外，这些类之间有什么不同吗?
class WithClass ():
def __init__(self):
self.value = "Bob"
def my_func(self):
print(self.value)
class WithoutClass ():
value = "Bob"
def my_func(self):
print(self.value)
如果我使用或不使用__init__方法来声明变量值，会有任何区别吗?
我主要担心的是，我只会以一种方式使用它，而这会给我带来更多的问题。
当前回答
class User(object):
email = 'none'
firstname = 'none'
lastname = 'none'
def __init__(self, email=None, firstname=None, lastname=None):
self.email = email
self.firstname = firstname
self.lastname = lastname
@classmethod
def print_var(cls, obj):
print ("obj.email obj.firstname obj.lastname")
print(obj.email, obj.firstname, obj.lastname)
print("cls.email cls.firstname cls.lastname")
print(cls.email, cls.firstname, cls.lastname)
u1 = User(email='abc@xyz', firstname='first', lastname='last')
User.print_var(u1)
在上面的代码中，User类有3个全局变量，每个变量的值都是“none”。U1是通过实例化该类创建的对象。print_var方法输出User类变量的值和u1对象变量的值。在下面的输出中，每个类变量都是User。电子邮件、用户。firstname和User。Lastname的值为“none”，而对象变量为u1。电子邮件,u1。Firstname和u1。姓氏有值“abc@xyz”，“first”和“last”。
obj.email obj.firstname obj.lastname
('abc@xyz', 'first', 'last')
cls.email cls.firstname cls.lastname
('none', 'none', 'none')
其他回答
在__init__之外设置的变量属于类。它们由所有实例共享。
在__init__(以及所有其他方法函数)中创建并以self为前缀的变量。属于对象实例。
根据S.Lott的回答，类变量被传递给元类new方法，并且可以在定义元类时通过字典访问。因此，即使在创建和实例化类之前，也可以访问类变量。
例如:
class meta(type):
def __new__(cls,name,bases,dicto):
# two chars missing in original of next line ...
if dicto['class_var'] == 'A':
print 'There'
class proxyclass(object):
class_var = 'A'
__metaclass__ = meta
...
...
示例代码:
class inside:
def __init__(self):
self.l = []
def insert(self, element):
self.l.append(element)
class outside:
l = [] # static variable - the same for all instances
def insert(self, element):
self.l.append(element)
def main():
x = inside()
x.insert(8)
print(x.l) # [8]
y = inside()
print(y.l) # []
# ----------------------------
x = outside()
x.insert(8)
print(x.l) # [8]
y = outside()
print(y.l) # [8] # here is the difference
if __name__ == '__main__':
main()
在Python中，类带有成员函数(方法)、类变量、属性/实例变量(可能还有类方法):
class Employee:
# Class Variable
company = "mycompany.com"
def __init__(self, first_name, last_name, position):
# Instance Variables
self._first_name = first_name
self._last_name = last_name
self._position = position
# Member function
def get_full_name(self):
return f"{self._first_name} {self._last_name}"
通过创建对象的实例
my_employee = Employee("John", "Wood", "Software Engineer")
我们实际上触发了__init__，它将初始化新创建的Employee的实例变量。这意味着_first_name， _last_name和_position是特定my_employee实例的显式参数。
同样，成员函数返回信息或更改特定实例的状态。
现在，在构造函数__init__之外定义的任何变量都被认为是类变量。这些变量在类的所有实例之间共享。
john = Employee("John", "Wood", "Software Engineer")
bob = Employee("Bob", "Smith", "DevOps Engineer0")
print(john.get_full_name())
print(bob.get_full_name())
print(john.company)
print(bob.company)
>>> John Wood
>>> Bob Smith
>>> mycompany.com
>>> mycompany.com
您还可以使用类方法来更改类的所有实例的类变量。例如:
@classmethod
def change_my_companys_name(cls, name):
cls.company = name
现在输入change_my_companys_name()
bob.change_my_companys_name("mynewcompany.com")
将对类Employee的所有实例产生影响:
print(bob.company)
print(john.company)
>>> mynewcompany.com
>>> mynewcompany.com
我想对我在这个帖子和这个帖子(引用了这个帖子)中读到的回复添加一些东西。
免责声明:这些评论来自我进行的实验
__init__之外的变量:
实际上，这些是静态类变量，因此类的所有实例都可以访问它们。
__init__中的变量:
这些实例变量的值只能被手边的实例访问(通过自引用)
我的贡献:
程序员在使用静态类变量时必须考虑的一件事是，它们可能被实例变量所掩盖(如果您通过自引用访问静态类变量)。
解释:
以前，我认为声明变量的两种方式是完全相同的(我真傻)，这部分是因为我可以通过自我引用访问这两种变量。就是现在，当我遇到麻烦时，我研究了这个话题，并把它弄清楚了。
类访问静态类变量的问题 Self引用只在没有相同名称的实例变量时引用静态类变量，更糟糕的是，试图通过Self引用重新定义静态类变量是行不通的，因为创建的实例变量会掩盖先前可访问的静态类变量。
要解决这个问题，您应该始终通过类名引用静态类变量。
例子:
#!/usr/bin/env python
class Foo:
static_var = 'every instance has access'
def __init__(self,name):
self.instance_var = 'I am %s' % name
def printAll(self):
print 'self.instance_var = %s' % self.instance_var
print 'self.static_var = %s' % self.static_var
print 'Foo.static_var = %s' % Foo.static_var
f1 = Foo('f1')
f1.printAll()
f1.static_var = 'Shadowing static_var'
f1.printAll()
f2 = Foo('f2')
f2.printAll()
Foo.static_var = 'modified class'
f1.printAll()
f2.printAll()
输出:
self.instance_var = I am f1
self.static_var = every instance has access
Foo.static_var = every instance has access
self.instance_var = I am f1
self.static_var = Shadowing static_var
Foo.static_var = every instance has access
self.instance_var = I am f2
self.static_var = every instance has access
Foo.static_var = every instance has access
self.instance_var = I am f1
self.static_var = Shadowing static_var
Foo.static_var = modified class
self.instance_var = I am f2
self.static_var = modified class
Foo.static_var = modified class
我希望这对某些人有所帮助
