Que signifie Python en imprimant «» pour une référence d’object?

J’imprime une valeur de ce que je pensais être une liste, mais le résultat est le suivant:

[...] 

Qu’est-ce que cela représente? Comment puis-je le tester? J’ai essayé:

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

et

 myVar.__repr_() != Ellipsis 

mais pas de dés …

Voici une coupure du code qui donne le problème:

 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 listes […] supposées récursives, mais je ne vois pas pourquoi. J’ai modifié le test à #test pour éviter cela.

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 retourner explicitement None pour les chemins vides.

Selon le contexte, il peut y avoir différentes choses:

indexation / découpage avec Ellipsis

Je pense que ce n’est pas implémenté pour une classe de python mais cela devrait représenter un nombre arbitraire de nids de structures de données ( autant nécessaires ). Ainsi, par exemple: a[..., 1] devrait renvoyer tous les deuxièmes éléments de la structure nestede la plus interne:

 >>> 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 cela ... vous le comparez à un Ellipsis (ceci est un singleton si recommandé d’utiliser 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 récursives

L’autre cas dans lequel vous voyez un [...] dans votre sortie est si vous avez la séquence à l’intérieur de la séquence elle-même. Ici, il représente une séquence infinie profondément nestede (ce 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 le remplacer plusieurs fois:

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

Pour tester si vous avez une telle récursion dans votre sortie, vous devez vérifier si la structure de données elle-même est également l’un des éléments suivants:

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

Une autre façon d’obtenir une sortie plus significative consiste à utiliser pprint.pprint :

 >>> import pprint >>> pprint.pprint(alist) # Assuming you only replaced the first element: [, 'b', 'c'] 

Il 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 article 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 montre [...]

Si votre liste contient des auto-références, Python l’affichera comme [...] plutôt que d’essayer de l’imprimer récursivement, ce qui conduirait à 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': {...}} 

C’est une référence récursive que votre liste contient elle-même. Python n’essaie pas d’imprimer récursivement ce qui conduirait à une boucle infinie.

repr détecte cela. Donc, si vous regardiez la représentation interne de votre object liste, vous verriez (où les points de suspension apparaissent) “Référence au même object liste à l’adresse *” où * est l’adresse de l’object liste d’origine en mémoire. D’où la boucle infinie.