Что означает Python, напечатав "[...]" для ссылки на объект?

Я печатаю значение того, что, как я думал, было списком, но вывод, который я получаю:

[...]

Что это означает? Как я могу проверить это? Я пробовал:

myVar.__repr__() != '[...]'

myVar.__repr_() != Ellipsis

но не кости...

Здесь вырезание кода, который дает проблему:

def buildPaths(graph, start, end, path=[], totalPaths=[]):
    """
    returns list of all possible paths from start node to the end node
    """
    path = path + [start]
    if start == end:
        return path
    for nextNode in graph.childrenOf(start):
        if nextNode not in path:
            newPath = buildPaths(graph, nextNode, end, path, totalPaths)
            if newPath != []: # test
                totalPaths.append(newPath)
    return totalPaths

totalPaths содержит много [...] предположительно рекурсивных списков, но я не понимаю, почему. Я изменил тест на #test, чтобы предотвратить это.

Я также пробовал:

def buildPaths(graph, thisNode, end, path=[], totalPaths=None):
    """
   returns list of all possible paths from start node to the end node
   """
    path = path + [thisNode]
    if thisNode == end:
        return path
    for nextNode in graph.childrenOf(thisNode):
        if nextNode not in path:
            newPath = buildPaths(graph, nextNode, end, path, totalPaths)
            if newPath != None:
                if totalPaths == None:
                    totalPaths = [newPath]
                else:
                    totalPaths.append(newPath)
    return totalPaths

чтобы явно возвращать None для пустых путей.

Ответ 1

В зависимости от контекста здесь могут быть разные вещи:

индексирование/нарезка с помощью `Ellipsis`

Я думаю, что он не реализован для какого-либо класса python, но он должен представлять собой произвольное количество вложений структуры данных (как это необходимо). Так, например: a[..., 1] должен возвращать все остальные элементы самой внутренней вложенной структуры:

>>> import numpy as np
>>> a = np.arange(27).reshape(3,3,3)  # 3dimensional array
>>> a[..., 1]  # this returns a slice through the array in the third dimension
array([[ 1,  4,  7],
       [10, 13, 16],
       [19, 22, 25]])
>>> a[0, ...]  # This returns a slice through the first dimension
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

и для проверки этого ... вы сравниваете его с Ellipsis (это синглтон, поэтому рекомендуется использовать is:

>>> ... is Ellipsis
True
>>> Ellipsis in [...]
True
# Another (more or less) equivalent alternative to the previous line:
>>> any(i is Ellipsis for i in [1, ..., 2]) 
True

Рекурсивные структуры данных

Другой случай, когда вы видите [...] в свой вывод, - это если у вас есть последовательность внутри самой последовательности. Здесь он обозначает бесконечную глубоко вложенную последовательность (которая не печатается). Например:

>>> alist = ['a', 'b', 'c']
>>> alist[0] = alist
>>> alist
[[...], 'b', 'c']

# Infinite deeply nested so you can use as many leading [0] as you want
>>> alist[0][1] 
'b'
>>> alist[0][0][0][0][0][1] 
'b'
>>> alist[0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][1] 
'b'

Вы можете даже заменить его несколько раз:

>>> alist[2] = alist
>>> alist
[[...], 'b', [...]]
>>> alist[1] = alist
>>> alist
[[...], [...], [...]]

Чтобы проверить, есть ли у вас такая рекурсия в вашем выводе, вам нужно проверить, является ли сама структура данных также одним из элементов:

>>> alist in alist
True
>>> any(i is alist for i in alist)
True

Другим способом получения более значимого результата является использование pprint.pprint:

>>> import pprint
>>> pprint.pprint(alist)  # Assuming you only replaced the first element:
[<Recursion on list with id=1628861250120>, 'b', 'c']

Ответ 2

Он представляет собой бесконечный цикл внутри структуры. Пример:

In [1]: l = [1, 2]

In [2]: l[0] = l

In [3]: l
Out[3]: [[...], 2]

l первый элемент сам по себе. Это рекурсивная ссылка, и поэтому python не может разумно отображать ее содержимое. Вместо этого он показывает [...]

Ответ 3

Если ваш список содержит собственные ссылки, Python отобразит это как [...], а не пытается его рекурсивно распечатать, что приведет к циклу infinte:

>>> l = [1, 2, 3]
>>> print(l)
[1, 2, 3]
>>> l.append(l)
>>> print(l)
[1, 2, 3, [...]]
>>> print(l[-1])        # print the last item of list l
[1, 2, 3, [...]]
>>> print(l[-1][-1])    # print the last item of the last item of list l
[1, 2, 3, [...]]

ad infinitum.

Аналогичная ситуация возникает со словарями:

>>> d = {}
>>> d['key'] = d
>>> print(d)
{'key': {...}}
>>> d['key']
{'key': {...}}
>>> d['key']['key']
{'key': {...}}

Ответ 4

Это рекурсивная ссылка, поскольку ваш список содержит сам. Python не пытается рекурсивно распечатать это, что приведет к бесконечному циклу.

repr обнаруживает это. Итак, если вы посмотрели на внутреннее представление вашего объекта списка, вы увидите (где возникает многоточие) "Ссылка на тот же объект списка по адресу *", где * - адрес исходного объекта списка в памяти. Следовательно, бесконечный цикл.