# What does Python mean by printing "[...]" for an object reference?

I'm printing a value of a what I thought was a list, but the output that I get is:

```
[...]
```

What does this represent? How do I test for it? I've tried:

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

and

```
myVar.__repr_() != Ellipsis
```

but no dice...

Here's a cutdown of the code that's giving the issue:

```
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 contains a LOT of [...] supposedly recursive lists, but I can't see why. I've altered the test at #test to prevent this.

I've also tried:

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

in order to explicitly return `None`

for empty paths.

Depending on the context here it could different things:

# indexing/slicing with `Ellipsis`

I think it's not implemented for any python class but it *should* represent an arbitary number of data structure nestings ( *as much needed* ). So for example: `a[..., 1]`

should return all the second elements of the innermost nested structure:

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

and to check for this `...`

you compare it to an `Ellipsis`

(this is a singleton so recommended is using `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

The other case in which you see an `[...]`

in **your output** is if you have the sequence inside the sequence itself. Here it stands for an *infinite* deeply nested sequence (that's not printable). For example:

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

You can even replace it several times:

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

To test if you have any such recursion in your output you need to check if the data-structure itself is also one of the elements:

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

Another way to get a more meaningful output is using `pprint.pprint`

:

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

From: stackoverflow.com/q/36904351