在不实例化的情况下，将两个列表合并到_uinit__uu内。python

因此，问题是-有没有办法在不实例化

Foo

或将

list\u作为一个类级变量的情况下合并这些列表

也许有一种方法可以使用继承和
super（）
实现，但我不明白如何使用它访问方法中的变量。我还将非常感谢您回答如何在不使用继承的情况下实现这一点
 除了极端的字节码黑客攻击，不——从一个函数中提取一个值并在另一个函数中使用它是不可能的

此外，由于
Bar
不是
Foo
的子类，并且Python对使用显式
self
调用实例方法施加了相当任意的类型检查限制，因此您无法执行以下明智的操作：

class Foo(object):
    def __init__(self):
        self.list_one = [1, 2, 3]


class Bar(object):
    def init(self):
        self.list_two = Foo.list_one + [4, 5, 6] # I know this won't work unless I 
                                                 # make list_one a class level variable

也许你应该在
Foo
上创建一个类级getter，返回列表

class Bar(object):
    def __init__(self):
        Bar.__init__(self)
        self.list_one += [4, 5, 6]

除了极端的字节码黑客攻击，不——从一个函数中提取一个值并在另一个函数中使用它是不可能的

此外，由于
Bar
不是
Foo
的子类，并且Python对使用显式
self
调用实例方法施加了相当任意的类型检查限制，因此您无法执行以下明智的操作：

class Foo(object):
    def __init__(self):
        self.list_one = [1, 2, 3]


class Bar(object):
    def init(self):
        self.list_two = Foo.list_one + [4, 5, 6] # I know this won't work unless I 
                                                 # make list_one a class level variable

也许你应该在
Foo
上创建一个类级getter，返回列表

class Bar(object):
    def __init__(self):
        Bar.__init__(self)
        self.list_one += [4, 5, 6]

不可能做到你描述的那样
self
是对
Foo
实例的引用，在类实例化之前不存在；而
list\u one
是
self
的一个属性，在创建后分配给
self
。因此，在类被实例化之前，
list\u one
根本不存在

然而，使用继承来实现您的要求相当简单：

class Foo(object):
    def __init__(self):
        self.list_one = self.get_list_one()

    @classmethod
    def get_list_one(cls):
        return [1, 2, 3]

更一般地说，除了在方法或函数的执行过程中，或者在引用由函数创建的所谓闭包时，引用“方法中的变量”并没有真正的意义。每次调用函数时，都会创建一个新的名称空间，并在该名称空间内重新创建局部变量名

不过，一旦调用了函数，就可以引用它们。例如：

class Foo(object):
    def __init__(self):
        self.list_one = [1, 2, 3]

class Bar(Foo):
    def init(self):
        super(Bar, self).__init__()
        self.list_two = self.list_one + [4, 5, 6]
        # if you want to discard list_one, you can, but that seems wrong somehow
        # del self.list_one

请注意，
bar
的两个版本引用了
a
的不同值，每个值都是在调用
foo（5）
和
foo（6）
时创建的。
不可能完成您描述的确切操作
self
是对
Foo
实例的引用，在类实例化之前不存在；而
list\u one
是
self
的一个属性，在创建后分配给
self
。因此，在类被实例化之前，
list\u one
根本不存在

然而，使用继承来实现您的要求相当简单：

class Foo(object):
    def __init__(self):
        self.list_one = self.get_list_one()

    @classmethod
    def get_list_one(cls):
        return [1, 2, 3]

更一般地说，除了在方法或函数的执行过程中，或者在引用由函数创建的所谓闭包时，引用“方法中的变量”并没有真正的意义。每次调用函数时，都会创建一个新的名称空间，并在该名称空间内重新创建局部变量名

不过，一旦调用了函数，就可以引用它们。例如：

class Foo(object):
    def __init__(self):
        self.list_one = [1, 2, 3]

class Bar(Foo):
    def init(self):
        super(Bar, self).__init__()
        self.list_two = self.list_one + [4, 5, 6]
        # if you want to discard list_one, you can, but that seems wrong somehow
        # del self.list_one

请注意，
bar
的两个版本引用了
a
的不同值，每一个值都是在调用
foo（5）
和
foo（6）
时创建的。
您到底想实现什么？如果您不需要实例来避免它们，那么您根本不应该使用类—只需使用函数调用，并在参数中传递所需的状态。@JakobBowyer我想
列出两个
作为
列出一个
的扩展，将它们都放在各自类的
\uuuuu init\uuuu
中。如果你有更广泛的目标，那就最好了，因为从表面上看，你的要求没有意义，所以我们的答案也不会那么好。你到底想实现什么？如果你根本不需要实例来避免它们，你就不应该使用类——只需要使用函数调用，并在参数中传递所需的状态。@JakobBowyer我想
list_two
成为
list_one
的扩展，将它们都放在各自类的
\uuuuu init\uuuuuu
中。如果你有更广泛的目标，那就最好了，因为表面上你的要求没有意义，所以我们的答案也不会那么好。