utiliza - ¿Qué quiere decir Python al imprimir "[...]" para una referencia de objeto?

qué función de python se utiliza para el resultado de la consola

Question

Estoy imprimiendo un valor de lo que pensé que era una lista, pero el resultado que obtengo es:

[...]

¿Qué representa esto? ¿Cómo lo pruebo? He intentado:

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

y

myVar.__repr_() != Ellipsis

pero no dados ...

Aquí hay un resumen del código que está dando el problema:

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 contiene MUCHAS [...] listas supuestamente recursivas, pero no puedo ver por qué. He alterado la prueba en #test para evitar esto.

También lo intenté:

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

para devolver explícitamente None para rutas vacías.

Answer 1

Dependiendo del contexto aquí podría haber cosas diferentes:

indexar / rebanar con Ellipsis

Creo que no está implementado para ninguna clase de python, pero debería representar una cantidad arbitraria de anidamientos de estructuras de datos ( tanto como sea necesario ). Entonces, por ejemplo: a[..., 1] debería devolver todos los segundos elementos de la estructura anidada más interna:

>>> 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]])

y para verificar esto ... lo comparas con una Ellipsis (este es un singleton, así que lo que se recomienda es usar 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

Recursive Datastructures

El otro caso en el que ve un [...] en su salida es si tiene la secuencia dentro de la secuencia misma. Aquí representa una secuencia infinita profundamente anidada (que no es imprimible). Por ejemplo:

>>> 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''

Incluso puedes reemplazarlo varias veces:

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

Para probar si tiene alguna recursión de ese tipo en su salida, debe verificar si la estructura de datos en sí misma también es uno de los elementos:

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

Otra forma de obtener un resultado más significativo es utilizando pprint.pprint :

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

Answer 2

Es una referencia recursiva ya que su lista se contiene a sí misma. Python no intenta imprimir esto recursivamente, lo que daría lugar a un ciclo infinito.

repr detecta esto. Entonces, si observas la representación interna de tu objeto de lista, verás (donde ocurren las elipsis) "Referencia al mismo objeto de lista en la dirección *" donde * es la dirección del objeto de lista original en la memoria. Por lo tanto, el bucle infinito.

Answer 3

Representa un ciclo infinito dentro de la estructura. Un ejemplo:

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

In [2]: l[0] = l

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

El primer artículo es en sí mismo. Es una referencia recursiva, por lo que Python no puede mostrar razonablemente su contenido. En cambio, muestra [...]

Answer 4

Si su lista contiene referencias automáticas, Python la mostrará como [...] lugar de tratar de imprimirla recursivamente, lo que daría lugar a un bucle 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, [...]]

indefinidamente.

Una situación similar surge con los diccionarios:

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