Python 3.x 什么'；最常用的计数器方法的底层实现是什么？

我发现了一个pyi文件，它具有以下定义

def most_common(self, n: Optional[int] = ...) -> List[Tuple[_T, int]]: ...

这怎么会发生？列表没有定义，也没有实现

---

请在此为关注者重点介绍一些有价值的建议：

列表是从打字模块导入的；这和列表不是一回事。pyi文件不需要导入它，因为存根文件从未执行过；它们必须是语法上有效的Python

---

如果使用fromfuture导入注释，则也不必导入类型以使用.py文件中的函数注释中的列表等，因为函数注释将被视为字符串文字。（从Python 4开始，这将是默认行为。有关详细信息，请参见PEP 563。）

您看到的是仅用于注释的

pyi

文件。Python解释器永远不会执行它。您可以通过阅读了解有关

pyi

文件的更多信息

使用调试器，在调用

most_common

的行上放置一个断点，然后进入该方法

Python 3.7实现

…\Lib\collections\\uuuuu init\uuuuu.py

：

def most_common(self, n=None):
    '''List the n most common elements and their counts from the most
    common to the least.  If n is None, then list all element counts.

    >>> Counter('abcdeabcdabcaba').most_common(3)
    [('a', 5), ('b', 4), ('c', 3)]

    '''
    # Emulate Bag.sortedByCount from Smalltalk
    if n is None:
        return sorted(self.items(), key=_itemgetter(1), reverse=True)
    return _heapq.nlargest(n, self.items(), key=_itemgetter(1))

\u heapq.nlagest

（在

..\Lib\heapq.py

中）实现：

def nlargest(n, iterable, key=None):
    """Find the n largest elements in a dataset.

    Equivalent to:  sorted(iterable, key=key, reverse=True)[:n]
    """

    # Short-cut for n==1 is to use max()
    if n == 1:
        it = iter(iterable)
        sentinel = object()
        if key is None:
            result = max(it, default=sentinel)
        else:
            result = max(it, default=sentinel, key=key)
        return [] if result is sentinel else [result]

    # When n>=size, it's faster to use sorted()
    try:
        size = len(iterable)
    except (TypeError, AttributeError):
        pass
    else:
        if n >= size:
            return sorted(iterable, key=key, reverse=True)[:n]

    # When key is none, use simpler decoration
    if key is None:
        it = iter(iterable)
        result = [(elem, i) for i, elem in zip(range(0, -n, -1), it)]
        if not result:
            return result
        heapify(result)
        top = result[0][0]
        order = -n
        _heapreplace = heapreplace
        for elem in it:
            if top < elem:
                _heapreplace(result, (elem, order))
                top, _order = result[0]
                order -= 1
        result.sort(reverse=True)
        return [elem for (elem, order) in result]

    # General case, slowest method
    it = iter(iterable)
    result = [(key(elem), i, elem) for i, elem in zip(range(0, -n, -1), it)]
    if not result:
        return result
    heapify(result)
    top = result[0][0]
    order = -n
    _heapreplace = heapreplace
    for elem in it:
        k = key(elem)
        if top < k:
            _heapreplace(result, (k, order, elem))
            top, _order, _elem = result[0]
            order -= 1
    result.sort(reverse=True)
    return [elem for (k, order, elem) in result]

def nlargest（n，iterable，key=None）：
“”“查找数据集中最大的n个元素。”。
等价于：排序（iterable，key=key，reverse=True）[:n]
"""
#n==1的捷径是使用max（）
如果n==1：
it=国际热核实验堆（iter）
sentinel=对象（）
如果键为“无”：
结果=最大值（it，默认值=sentinel）
其他：
结果=最大值（it，默认值=sentinel，键=键）
如果结果为sentinel else[结果]，则返回[]
#当n>=size时，使用sorted（）会更快
尝试：
尺寸=长度（可调）
除了（TypeError，AttributeError）：
通过
其他：
如果n>=大小：
返回排序（iterable，key=key，reverse=True）[:n]
#当key为none时，使用更简单的装饰
如果键为“无”：
it=国际热核实验堆（iter）
结果=[（elem，i）对于i，zip中的elem（范围（0，-n，-1），it）]
如果没有结果：
返回结果
希皮菲（结果）
top=结果[0][0]
顺序=-n
_heapreplace=heapreplace
对于其中的元素：
如果顶部<元素：
_heapreplace（结果（元素、顺序））
顶部，顺序=结果[0]
订单-=1
result.sort（reverse=True）
返回[结果中（元素、顺序）的元素]
#一般情况下，最慢的方法
it=国际热核实验堆（iter）
结果=[（键（elem），i，elem）表示i，zip中的elem（范围（0，-n，-1），it）]
如果没有结果：
返回结果
希皮菲（结果）
top=结果[0][0]
顺序=-n
_heapreplace=heapreplace
对于其中的元素：
k=键（元素）
如果顶部

怎么会发生这种情况？Python本身不使用存根文件，只有静态检查器，如

mypy

@Pythoner我在Pycharm中使用了调试器。在调用

最常用的
的行上放置一个断点，然后进入该方法。@Pythoner存根文件旨在与一起使用。@DeepSpace，非常好和详细的anwser，非常感谢<代码>列表
从
打字
模块导入；它与
列表
不同。
.pyi
文件不需要导入它，因为存根文件从未执行过；它们必须是语法有效的Python。如果您使用来自未来导入注释的
，那么您也不必导入
键入
来使用
列表
等
.py
文件中的函数注释，因为函数注释将被视为字符串文本。（从Python 4开始，这将是默认行为。有关详细信息，请参阅。）