Python 的内部/嵌套类让我感到困惑。有没有他们不能完成的事情?如果有,那是什么东西?
9 回答
引自http://www.geekinterview.com/question_details/64739:
内部类的优点:
- 类的逻辑分组:如果一个类仅对另一个类有用,那么将其嵌入该类并将两者保持在一起是合乎逻辑的。嵌套这样的“帮助类”使它们的包更加精简。
- 增加封装:考虑两个顶级类 A 和 B,其中 B 需要访问 A 的成员,否则这些成员将被声明为私有。通过将类 B 隐藏在类 A 中,可以将 A 的成员声明为私有,并且 B 可以访问它们。另外B本身可以对外界隐藏。
- 更具可读性、可维护性的代码:在顶级类中嵌套小类使代码更接近使用它的位置。
主要优点是组织。任何可以用内部类完成的事情都可以在没有它们的情况下完成。
有没有他们不能完成的事情?
不。它们绝对等同于在顶层通常定义类,然后将对它的引用复制到外部类中。
我不认为嵌套类被“允许”有任何特殊原因,除了明确地“禁止”它们也没有特别的意义。
如果您正在寻找一个存在于外部/所有者对象的生命周期内的类,并且始终具有对外部类实例的引用——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)”。)
有一些东西你需要绕着你的脑袋才能理解这一点。在大多数语言中,类定义是编译器的指令。也就是说,类是在程序运行之前创建的。在python中,所有语句都是可执行的。这意味着该声明:
class foo(object):
pass
是在运行时执行的语句,就像这样:
x = y + z
这意味着您不仅可以在其他类中创建类,还可以在任何地方创建类。考虑这段代码:
def foo():
class bar(object):
...
z = bar()
因此,“内部类”的概念并不是真正的语言结构。这是一个程序员的构造。Guido 很好地总结了这一切是如何发生的。但本质上,基本思想是这简化了语言的语法。
在类中嵌套类:
嵌套类使类定义膨胀,使其更难看到发生了什么。
嵌套类会产生耦合,使测试更加困难。
在 Python 中,您可以在文件/模块中放置多个类,这与 Java 不同,因此该类仍然接近顶级类,甚至可以在类名前加上“_”,以帮助表示其他类不应该是使用它。
嵌套类可以证明有用的地方是在函数中
def some_func(a, b, c):
class SomeClass(a):
def some_method(self):
return b
SomeClass.__doc__ = c
return SomeClass
该类从函数中捕获值,允许您在 C++ 中动态创建一个类,如模板元编程
我理解反对嵌套类的论点,但在某些情况下使用它们是有道理的。想象一下,我正在创建一个双向链表类,我需要创建一个节点类来维护节点。我有两个选择,在 DoublyLinkedList 类中创建 Node 类,或者在 DoublyLinkedList 类之外创建 Node 类。在这种情况下,我更喜欢第一种选择,因为 Node 类只在 DoublyLinkedList 类中才有意义。虽然没有隐藏/封装的好处,但是可以说 Node 类是 DoublyLinkedList 类的一部分,这是一个分组的好处。
有没有他们不能完成的事情?如果有,那是什么东西?
没有一些事情是不能轻易做到的:相关类的继承。
这是一个带有相关类的极简示例,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
。
当然,这种动态绑定可以在没有内部类的情况下重新创建,但代价是对类进行繁琐且容易出错的检测。
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
我使用它的主要用例是防止小模块的扩散,并在不需要单独的模块时防止命名空间污染。如果我正在扩展一个现有类,但该现有类必须引用另一个应该始终耦合到它的子类。例如,我可能有一个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
不是你会用于工厂函数的装饰器。
我已经使用 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 等等。