Python 的内部/嵌套类让我感到困惑。有没有他们不能完成的事情？如果有，那是什么东西？
Geo
问问题
65156 次
9 回答
93
引自http://www.geekinterview.com/question_details/64739：
内部类的优点：
- 类的逻辑分组：如果一个类仅对另一个类有用，那么将其嵌入该类并将两者保持在一起是合乎逻辑的。嵌套这样的“帮助类”使它们的包更加精简。
- 增加封装：考虑两个顶级类 A 和 B，其中 B 需要访问 A 的成员，否则这些成员将被声明为私有。通过将类 B 隐藏在类 A 中，可以将 A 的成员声明为私有，并且 B 可以访问它们。另外B本身可以对外界隐藏。
- 更具可读性、可维护性的代码：在顶级类中嵌套小类使代码更接近使用它的位置。
主要优点是组织。任何可以用内部类完成的事情都可以在没有它们的情况下完成。
于 2009-04-05T21:24:34.713 回答
55
有没有他们不能完成的事情？
不。它们绝对等同于在顶层通常定义类，然后将对它的引用复制到外部类中。
我不认为嵌套类被“允许”有任何特殊原因，除了明确地“禁止”它们也没有特别的意义。
如果您正在寻找一个存在于外部/所有者对象的生命周期内的类，并且始终具有对外部类实例的引用——Java 那样的内部类——那么 Python 的嵌套类就不是那个东西。但是你可以破解类似的东西：
import weakref, new
class innerclass(object):
"""Descriptor for making inner classes.
Adds a property 'owner' to the inner class, pointing to the outer
owner instance.
"""
# Use a weakref dict to memoise previous results so that
# instance.Inner() always returns the same inner classobj.
#
def __init__(self, inner):
self.inner= inner
self.instances= weakref.WeakKeyDictionary()
# Not thread-safe - consider adding a lock.
#
def __get__(self, instance, _):
if instance is None:
return self.inner
if instance not in self.instances:
self.instances[instance]= new.classobj(
self.inner.__name__, (self.inner,), {'owner': instance}
)
return self.instances[instance]
# Using an inner class
#
class Outer(object):
@innerclass
class Inner(object):
def __repr__(self):
return '<%s.%s inner object of %r>' % (
self.owner.__class__.__name__,
self.__class__.__name__,
self.owner
)
>>> o1= Outer()
>>> o2= Outer()
>>> i1= o1.Inner()
>>> i1
<Outer.Inner inner object of <__main__.Outer object at 0x7fb2cd62de90>>
>>> isinstance(i1, Outer.Inner)
True
>>> isinstance(i1, o1.Inner)
True
>>> isinstance(i1, o2.Inner)
False
（这使用了类装饰器，这是 Python 2.6 和 3.0 中的新功能。否则你必须在类定义之后说“Inner= innerclass(Inner)”。）
于 2009-04-06T16:23:21.763 回答
38
有一些东西你需要绕着你的脑袋才能理解这一点。在大多数语言中，类定义是编译器的指令。也就是说，类是在程序运行之前创建的。在python中，所有语句都是可执行的。这意味着该声明：
class foo(object):
pass
是在运行时执行的语句，就像这样：
x = y + z
这意味着您不仅可以在其他类中创建类，还可以在任何地方创建类。考虑这段代码：
def foo():
class bar(object):
...
z = bar()
因此，“内部类”的概念并不是真正的语言结构。这是一个程序员的构造。Guido 很好地总结了这一切是如何发生的。但本质上，基本思想是这简化了语言的语法。
于 2009-04-06T16:38:01.290 回答
15
在类中嵌套类：
嵌套类使类定义膨胀，使其更难看到发生了什么。
嵌套类会产生耦合，使测试更加困难。
在 Python 中，您可以在文件/模块中放置多个类，这与 Java 不同，因此该类仍然接近顶级类，甚至可以在类名前加上“_”，以帮助表示其他类不应该是使用它。
嵌套类可以证明有用的地方是在函数中
def some_func(a, b, c):
class SomeClass(a):
def some_method(self):
return b
SomeClass.__doc__ = c
return SomeClass
该类从函数中捕获值，允许您在 C++ 中动态创建一个类，如模板元编程
于 2009-04-06T15:43:54.027 回答
8
我理解反对嵌套类的论点，但在某些情况下使用它们是有道理的。想象一下，我正在创建一个双向链表类，我需要创建一个节点类来维护节点。我有两个选择，在 DoublyLinkedList 类中创建 Node 类，或者在 DoublyLinkedList 类之外创建 Node 类。在这种情况下，我更喜欢第一种选择，因为 Node 类只在 DoublyLinkedList 类中才有意义。虽然没有隐藏/封装的好处，但是可以说 Node 类是 DoublyLinkedList 类的一部分，这是一个分组的好处。
于 2012-04-29T22:52:04.600 回答
8
有没有他们不能完成的事情？如果有，那是什么东西？
没有一些事情是不能轻易做到的：相关类的继承。
这是一个带有相关类的极简示例，A并且B：
class A(object):
class B(object):
def __init__(self, parent):
self.parent = parent
def make_B(self):
return self.B(self)
class AA(A): # Inheritance
class B(A.B): # Inheritance, same class name
pass
这段代码导致了一个非常合理和可预测的行为：
>>> type(A().make_B())
<class '__main__.A.B'>
>>> type(A().make_B().parent)
<class '__main__.A'>
>>> type(AA().make_B())
<class '__main__.AA.B'>
>>> type(AA().make_B().parent)
<class '__main__.AA'>
如果B是顶级类，则不能self.B()在方法中编写，而make_B只需编写B()，从而失去对适当类的动态绑定。
请注意，在此构造中，您永远不应该在 classA的主体中引用 class B。parent这就是在 class 中引入属性的动机B。
当然，这种动态绑定可以在没有内部类的情况下重新创建，但代价是对类进行繁琐且容易出错的检测。
于 2020-05-14T20:19:44.317 回答
4
1.两种功能等效的方式
前面显示的两种方式在功能上是相同的。但是，存在一些细微的差异，并且在某些情况下您想选择一个而不是另一个。
方式一：嵌套类定义
（="Nested class"）
class MyOuter1:
class Inner:
def show(self, msg):
print(msg)
方式2：模块级内部类附加到外部类
（=“引用内部类”）
class _InnerClass:
def show(self, msg):
print(msg)
class MyOuter2:
Inner = _InnerClass
下划线用于跟随PEP8 “内部接口（包、模块、类、函数、属性或其他名称）应该 -- 以单个前导下划线作为前缀。”
2. 相似之处
下面的代码片段演示了“嵌套类”与“引用内部类”的功能相似之处；在检查内部类实例的类型时，它们的行为方式相同。不用说， 的m.inner.anymethod()行为与m1和m2
m1 = MyOuter1()
m2 = MyOuter2()
innercls1 = getattr(m1, 'Inner', None)
innercls2 = getattr(m2, 'Inner', None)
isinstance(innercls1(), MyOuter1.Inner)
# True
isinstance(innercls2(), MyOuter2.Inner)
# True
type(innercls1()) == mypackage.outer1.MyOuter1.Inner
# True (when part of mypackage)
type(innercls2()) == mypackage.outer2.MyOuter2.Inner
# True (when part of mypackage)
3. 差异
下面列出了“嵌套类”和“引用内部类”的区别。它们并不大，但有时您想根据这些选择其中一个。
3.1 代码封装
使用“嵌套类”可以比使用“引用内部类”更好地封装代码。模块命名空间中的类是全局变量。嵌套类的目的是减少模块中的混乱，并将内部类放在外部类中。
虽然没有人* 在使用from packagename import *，但少量的模块级变量可能会很好，例如在使用带有代码完成/智能感知的 IDE 时。
*对吗？
3.2 代码的可读性
Django 文档指示将内部类 Meta用于模型元数据。指示框架用户编写一个class Foo(models.Model)with inner会更清楚一些* class Meta；
class Ox(models.Model):
horn_length = models.IntegerField()
class Meta:
ordering = ["horn_length"]
verbose_name_plural = "oxen"
而不是“写一个class _Meta，然后class Foo(models.Model)用Meta = _Meta”写一个；
class _Meta:
ordering = ["horn_length"]
verbose_name_plural = "oxen"
class Ox(models.Model):
Meta = _Meta
horn_length = models.IntegerField()
使用“嵌套类”方法，代码可以读取嵌套的项目符号列表，但使用“引用内部类”方法，必须向上滚动
_Meta才能看到其“子项”（属性）的定义。如果您的代码嵌套级别增加或由于某些其他原因行很长，“引用的内部类”方法可能更具可读性。
* 当然，口味问题
3.3 略有不同的错误信息
这没什么大不了的，只是为了完整性：当访问内部类的不存在属性时，我们会看到略有不同的异常。继续第 2 节中给出的示例：
innercls1.foo()
# AttributeError: type object 'Inner' has no attribute 'foo'
innercls2.foo()
# AttributeError: type object '_InnerClass' has no attribute 'foo'
这是因为type内部类的 s 是
type(innercls1())
#mypackage.outer1.MyOuter1.Inner
type(innercls2())
#mypackage.outer2._InnerClass
于 2020-07-22T13:07:19.480 回答
2
我使用它的主要用例是防止小模块的扩散，并在不需要单独的模块时防止命名空间污染。如果我正在扩展一个现有类，但该现有类必须引用另一个应该始终耦合到它的子类。例如，我可能有一个utils.py模块，其中包含许多帮助类，它们不一定耦合在一起，但我想加强其中一些帮助类的耦合。例如，当我实现https://stackoverflow.com/a/8274307/2718295
: utils.py:
import json, decimal
class Helper1(object):
pass
class Helper2(object):
pass
# Here is the notorious JSONEncoder extension to serialize Decimals to JSON floats
class DecimalJSONEncoder(json.JSONEncoder):
class _repr_decimal(float): # Because float.__repr__ cannot be monkey patched
def __init__(self, obj):
self._obj = obj
def __repr__(self):
return '{:f}'.format(self._obj)
def default(self, obj): # override JSONEncoder.default
if isinstance(obj, decimal.Decimal):
return self._repr_decimal(obj)
# else
super(self.__class__, self).default(obj)
# could also have inherited from object and used return json.JSONEncoder.default(self, obj)
然后我们可以：
>>> from utils import DecimalJSONEncoder
>>> import json, decimal
>>> json.dumps({'key1': decimal.Decimal('1.12345678901234'),
... 'key2':'strKey2Value'}, cls=DecimalJSONEncoder)
{"key2": "key2_value", "key_1": 1.12345678901234}
当然，我们可以完全避免继承json.JSONEnocder而只覆盖 default()：
：
import decimal, json
class Helper1(object):
pass
def json_encoder_decimal(obj):
class _repr_decimal(float):
...
if isinstance(obj, decimal.Decimal):
return _repr_decimal(obj)
return json.JSONEncoder(obj)
>>> json.dumps({'key1': decimal.Decimal('1.12345678901234')}, default=json_decimal_encoder)
'{"key1": 1.12345678901234}'
但有时只是为了约定，您希望utils由类组成以实现可扩展性。
这是另一个用例：我希望在我的 OuterClass 中创建一个可变工厂，而不必调用copy：
class OuterClass(object):
class DTemplate(dict):
def __init__(self):
self.update({'key1': [1,2,3],
'key2': {'subkey': [4,5,6]})
def __init__(self):
self.outerclass_dict = {
'outerkey1': self.DTemplate(),
'outerkey2': self.DTemplate()}
obj = OuterClass()
obj.outerclass_dict['outerkey1']['key2']['subkey'].append(4)
assert obj.outerclass_dict['outerkey2']['key2']['subkey'] == [4,5,6]
我更喜欢这种模式，而@staticmethod不是你会用于工厂函数的装饰器。
于 2017-09-11T21:49:32.697 回答
0
我已经使用 Python 的内部类在 unittest 函数（即 inside def test_something():）中故意创建有错误的子类，以便接近 100% 的测试覆盖率（例如，通过覆盖某些方法来测试很少触发的日志语句）。
回想起来，它类似于 Ed 的回答https://stackoverflow.com/a/722036/1101109
一旦删除了对它们的所有引用，此类内部类应该超出范围并准备好进行垃圾收集。例如，获取以下inner.py文件：
class A(object):
pass
def scope():
class Buggy(A):
"""Do tests or something"""
assert isinstance(Buggy(), A)
我在 OSX Python 2.7.6 下得到以下奇怪的结果：
>>> from inner import A, scope
>>> A.__subclasses__()
[]
>>> scope()
>>> A.__subclasses__()
[<class 'inner.Buggy'>]
>>> del A, scope
>>> from inner import A
>>> A.__subclasses__()
[<class 'inner.Buggy'>]
>>> del A
>>> import gc
>>> gc.collect()
0
>>> gc.collect() # Yes I needed to call the gc twice, seems reproducible
3
>>> from inner import A
>>> A.__subclasses__()
[]
提示 - 不要继续尝试使用 Django 模型执行此操作，这似乎保留了对我的错误类的其他（缓存？）引用。
所以总的来说，我不建议将内部类用于这种目的，除非你真的重视 100% 的测试覆盖率并且不能使用其他方法。尽管我认为很高兴知道如果您使用__subclasses__()，它有时会被内部类污染。无论哪种方式，如果您遵循这一点，我认为我们在这一点上已经非常深入地了解 Python，私人 dunderscores 等等。
于 2015-02-18T10:37:54.607 回答