python - nltk.tree.Tree 对象如何生成树的字符串表示形式？

Question

我正在尝试理解 nltk.tree 模块。我很困惑为什么当打印 nltk.tree.Tree 对象时，它不打印出地址。相反，它打印出树的字符串表示形式。

我查看了 nltk.tree 中的源代码，但我知道哪部分代码将树格式化为字符串。

import nltk
from nltk.tree import Tree
print(Tree(1, [2, Tree(3, [4]), 5]))
print(type(Tree(1, [2, Tree(3, [4]), 5])))

输出

(1 2 (3 4) 5)
<class 'nltk.tree.Tree'>

如果定义一个示例类

class example():
    def __init__(self):
        ''
this_class = example()
print(this_class)
print(type(this_one))

输出:

<__main__.example object at 0x000001397F255668>
<class '__main__.example'>

我明白了。这是为什么？

Answer 1

要明确的是，我认为问题是问为什么 NLTK 中的 Tree 对象的输入是整数，但在打印时，表示打印出字符串而不会引发任何错误。

让我们深入研究一下代码。

以人类可读的括号解析格式打印出Tree的部分是https://github.com/nltk/nltk/blob/develop/nltk/tree.py#L820处的__str__()函数。

如果我们仔细观察，它会调用 pformat() 函数:

    def __str__(self):
        return self.pformat()

https://github.com/nltk/nltk/blob/develop/nltk/tree.py#L835处的pformat()函数:

def pformat(self, margin=70, indent=0, nodesep='', parens='()', quotes=False):
    """
    :return: A pretty-printed string representation of this tree.
    :rtype: str
    :param margin: The right margin at which to do line-wrapping.
    :type margin: int
    :param indent: The indentation level at which printing
        begins.  This number is used to decide how far to indent
        subsequent lines.
    :type indent: int
    :param nodesep: A string that is used to separate the node
        from the children.  E.g., the default value ``':'`` gives
        trees like ``(S: (NP: I) (VP: (V: saw) (NP: it)))``.
    """

    # Try writing it on one line.
    s = self._pformat_flat(nodesep, parens, quotes)
    if len(s) + indent < margin:
        return s

    # If it doesn't fit on one line, then write it on multi-lines.
    if isinstance(self._label, string_types):
        s = '%s%s%s' % (parens[0], self._label, nodesep)
    else:
        s = '%s%s%s' % (parens[0], unicode_repr(self._label), nodesep)
    for child in self:
        if isinstance(child, Tree):
            s += (
                '\n'
                + ' ' * (indent + 2)
                + child.pformat(margin, indent + 2, nodesep, parens, quotes)
            )
        elif isinstance(child, tuple):
            s += '\n' + ' ' * (indent + 2) + "/".join(child)
        elif isinstance(child, string_types) and not quotes:
            s += '\n' + ' ' * (indent + 2) + '%s' % child
        else:
            s += '\n' + ' ' * (indent + 2) + unicode_repr(child)
    return s + parens[1]

如果我们看看如何在 pformat 函数中创建字符串 s 变量，我们会看到 unicode_repr() 的多次使用.

打印时，输入将转换为 pformat 内的字符串，但 Tree 对象中的子项和值仍保持与输入时相同的类型。

现在，如果我们查看 nltk.tree.py 中的 unicode_repr，

from nltk.compat import python_2_unicode_compatible, unicode_repr

我们看到它来自 https://github.com/nltk/nltk/blob/develop/nltk/compat.py#L298 的 nltk.compat

def unicode_repr(obj):
    """
    For classes that was fixed with @python_2_unicode_compatible
    ``unicode_repr`` returns ``obj.unicode_repr()``; for unicode strings
    the result is returned without "u" letter (to make output the
    same under Python 2.x and Python 3.x); for other variables
    it is the same as ``repr``.
    """
    if PY3:
        return repr(obj)

    # Python 2.x
    if hasattr(obj, 'unicode_repr'):
        return obj.unicode_repr()

    if isinstance(obj, text_type):
        return repr(obj)[1:]  # strip "u" letter from output

    return repr(obj)

在 Python 3 中，nltk.compat.unicode_repr 仅返回默认情况下采用 unicode 格式的 repr，特别是 utf8 IIRC。

但在 Python 2 中，它首先检查对象是否具有 unicode_repr() Monkey-patch 函数。

然后它会检查它是否是 six 库中的 text_type 类型，如果是，它将打印出不带 u 的输出前缀，例如你“...”

最后，它是 Python 2，并且该对象没有 unicode_repr() 并且不是 six.text_type，它只会打印出 repr(obj).

回到问题，当对象是整数时，repr(int)将被转换为字符串。

>>> type(1)
<class 'int'>
>>> repr(1)
'1'
>>> type(repr(1))
<class 'str'>