Que veut dire Python en imprimant "[...]" pour une référence d'objet?

Question

Je suis à l'impression de la valeur de ce que je pensais était une liste, mais le résultat que j'obtiens est:

[...]

Que représente t-il? Comment puis-je tester? J'ai essayé:

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

et

myVar.__repr_() != Ellipsis

mais pas de dés...

Voici un cutdown du code qui donne à la question:

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 contient BEAUCOUP de [...] soi-disant récursive des listes, mais je ne vois pas pourquoi. J'ai modifié le test à #test pour l'en empêcher.

J'ai aussi essayé:

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

afin de renvoyer explicitement None de vide chemins.

Answer 1

Cela représente une boucle infinie dans la structure. Un exemple:

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

In [2]: l[0] = l

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

Le premier élément de l est lui-même. C'est une référence récursive, et python ne peut donc pas afficher son contenu de manière raisonnable. Au lieu de cela, il affiche [...]

Answer 2

Selon le contexte d'ici, il pourrait différentes choses:

indexation/découpage avec Ellipsis

Je pense qu'il n'est pas mis en œuvre pour toute python classe, mais il doit représenter un nombre arbitraire de la structure de données d'emboîtements (autant nécessaire). Ainsi, par exemple: a[..., 1] devez retourner tous les deuxième éléments de l'intime structure imbriquée:

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

et pour vérifier cette ... vous comparer à un Ellipsis (ce qui est un singleton donc recommandé est à l'aide de 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

Structures De Données Récursives

L'autre cas dans lequel vous voyez un [...] de votre sortie , si vous avez la séquence à l'intérieur de la séquence elle-même. Ici, c'est un infini profondément séquence imbriquée (qui n'est pas imprimable). Par exemple:

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

Vous pouvez même remplacer plusieurs fois:

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

Pour tester si vous avez ces récursivité dans votre sortie, vous devez vérifier si la structure des données lui-même est également l'un des éléments:

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

Une autre façon d'obtenir une plus significatives de sortie est à l'aide de pprint.pprint:

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

Answer 3

Si votre liste contient des références propres, Python l'affichera sous forme de [...] plutôt que d'essayer de l'imprimer de manière récursive, ce qui entraînerait une boucle infinie:

 >>> 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, [...]]
 

À l'infini.

Une situation similaire se présente avec les dictionnaires:

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

Answer 4

C'est une référence récursive car votre liste se contient elle-même. Python n'essaye pas d'imprimer récursivement ceci, ce qui mènerait à une boucle infinie.

repr détecte. Ainsi, si vous examiniez la représentation interne de votre objet liste, vous verrez (où se trouvent les points de suspension) "Référence au même objet liste à l'adresse *" où * est l'adresse de l'objet liste original en mémoire. Par conséquent, la boucle infinie.