Путание […] Список в Python: Что это?

Может также появиться, есть ли у Вас круговая структура со списком, указывающим на себя. Как это:

>>> a = [1,2]
>>> a.append(a)
>>> a
[1, 2, [...]]
>>> 

, Так как Python не может распечатать структуру (это был бы бесконечный цикл), это использует замещающий знак, чтобы показать, что существует рекурсия в структуре.

<час>

я не совсем уверен, был ли вопрос тем, на что, что продолжение или как зафиксировать его, но я попытаюсь исправить функции выше.

В них обоих, Вы сначала выполняете два рекурсивных вызова, которые добавляют данные к списку y и с другой стороны добавляют возвращенные данные к y. Это означает, что те же данные будут несколько раз присутствовать в результате.

Или просто собирают все данные, не добавляя ни к какому y, с чем-то как [1 111]

return [x[2]]+keys(x[0])+keys(x[1])

или просто делают добавление в вызовах, с чем-то как [1 112]

y += [x[2]]
keys(x[0], y) #Add left children to y...
keys(x[1], y) #Add right children to y...
return y

(Конечно, обоим этим отрывкам нужна обработка для пустых списков и т.д.)

, @Abgan также отметил, что Вы действительно не хотите y=[] в инициализаторе.

Я не понимаю Ваш код выше, но [...] я думаю, интерпретатор Python, пропускающий бесконечные структуры данных. Например:

>>> a = [0, 1]
>>> a[0] = a
>>> a
[[...], 1]

похоже, что Ваша древовидная структура становится циклично выполненной.

ответы об объектах части не относятся к делу.

я не полагаю, что это связано с объектом Эллипсиса, больше это, кажется, имеет некоторое отношение к циклу бесконечности (из-за мелкой копии Python?). Источник этого цикла бесконечности и почему это не становится расширенным при расширении при доступе является чем-то, что я полностью потерян, однако

Взгляд на следующий код:

>>> a = [0]
>>> a.append(a)
>>> print a
[0, [...]]

, Как Python, как предполагается, печатает a? Это - список, который содержит нуль и ссылку на себя. Следовательно это - список, который содержит нуль и ссылку на список

[0, [...]]

, который в свою очередь содержит нуль и ссылку на список

[0, [0, [...]]]

, который в свою очередь содержит нуль и ссылку на список, и так далее, рекурсивно:

[0, [0, [0, [...]]]]
[0, [0, [0, [0, [...]]]]]
[0, [0, [0, [0, [0, [...]]]]]]
...

нет ничего неправильно с самой рекурсивной структурой данных. Единственная проблема состоит в том, что это не может быть , отобразился , поскольку это будет подразумевать бесконечную рекурсию. Следовательно остановки Python в первой рекурсии ступают, и занимается проблемой бесконечности, печатающей только замещающий знак, как был указан в предыдущих ответах.

РЕДАКТИРОВАНИЕ: Как упомянуто выше, это не объект Эллипсиса, но результат циклично выполненного списка. Я забежал вперед здесь. Знание об объекте Эллипсиса является хорошим битом заднего знания полки, должен Вы находить Эллипсис в некотором фактическом коде, а не вывод.

<час>

объект Эллипсиса в Python используется для расширенной нотации части. Это не используется в текущих оперативных библиотеках Python, но доступно разработчикам для определения в их собственных библиотеках. Например, NumPy (или SciPy) используют это в качестве части их объекта массива. Необходимо будет посмотреть на документацию для дерева () для знания точно, как Эллипсис ведет себя в этом объекте.

От документация Python :

3.11.8 Объект Эллипсиса

Этот объект используется расширенной нотацией части (см. Справочник Python). Это не поддерживает специальных операций. Существует точно один объект замещающего знака, названный Эллипсисом (встроенное имя).

Это записано как Эллипсис.

Для различия между двумя версиями функциональных клавиш отметьте следующее различие:

y+=[x[2]]+Keys(x[0],y)+Keys(x[1],y)

значение правой стороны в этом операторе является списком, который содержит x [2], плюс ЭЛЕМЕНТЫ Ключей (x [0], y) и ЭЛЕМЕНТЫ Ключей (x [1], y)

y+=[x[2],Keys(x[0],y),Keys(x[1],y)]

, значение правой стороны в этом операторе является списком, который содержит x [2], плюс Ключи СПИСКА (x [2], y) и Ключи СПИСКА (x [1], y).

, Таким образом, использование версии [a, b] будет, вызывая y содержать себя как его элементы.

Некоторые другие примечания:

1. С тех пор в Python, объект значения по умолчанию создается однажды, когда функция будет определена, первая версия не будет работать как шоу в качестве примера. Это будет содержать несколько копия некоторых ключей. Трудно объяснить короче говоря, но можно получить некоторое представление путем печати значений x, y на каждом вызове Ключей.

   Это подтверждено путем выполнения функции на моей машине с Python 2.5.2.

2. Также, потому что значение по умолчанию определяется только однажды в функциональное время определения, даже функциональные работы, корректные впервые, оно не будет работать при вызове с другим a, так как ключи в первом двоичном дереве останутся в y.

   Вы видите это путем вызова Ключей (a) дважды или вызова его в двух различных списках.

3. второй параметр не требуется для этой проблемы. Функция может быть похожей на это:

   Ключи определения (a): если = []: еще возвратитесь []: возвратитесь [[2]] +Keys ([0]) +Keys ([1])

   , Определение рекурсивной функции в основном содержит две части, решите подпроблемы, и объединил результаты. В Вашем коде объединяющаяся часть результатов повторяется дважды: один путем накопления их в y, один путем добавления списка вместе.

Я полагаю, что Ваше 'дерево' содержит себя, поэтому оно содержит циклы.

Попытка этот код:

   a = [1,2,3,4]
   print a
   a.append(a)
   print a

первые выводы печати:

  [1,2,3,4]

, в то время как второе:

  [1,2,3,4, [...]]
 

причина использует

 def Keys(x,y=[]):
 

, Это является неправильным и злым. Список является изменяемым объектом, и при использовании в качестве параметра по умолчанию он сохраняется между вызовами функции. Так каждый y + = "что-либо" операция добавляет к тому же списку (во всех вызовах функции, и так как функция является рекурсивной...) <час>

Видят Effbot или , Devshed для получения дополнительной информации об изменяемых объектах передал как значения по умолчанию для функций.

Хорошо, таким образом, в точках:

1. Вы создаете бесконечную структуру данных:

   def Keys(x,y=[])

   будет использовать тот же 'y' в каждом вызове. Это просто не корректно.

2. print оператор, однако, достаточно умен, чтобы не распечатать бесконечные данные, но отметить самоссылку с [...] (известный как Эллипсис )

3. , Python позволит Вам обращаться к такой структуре правильно, таким образом, можно будет записать

   a.keys()[1][1][1]

   и так далее. Почему не был должен Вы?
4. y = y[:] оператор просто копирует список y. Может быть сделан более обоснованно с y = list(y)

Попытка с помощью следующего кода:

def Keys(x,y=None):
    if y is None:
        y = []
    if len(x):
        y += [x[2], Keys(x[0],y), Keys(x[1],y)]
    return y

, Но тем не менее я предполагаю, что это может укусить Вас. Вы все еще используете ту же переменную y (я имею в виду тот же объект) в трех местах в одном выражении:

 y += [x[2], Keys(x[0], y), Keys(x[1], y)] 

это, чего Вы действительно хотите достигнуть? Или возможно необходимо попробовать:

def mKeys(x,y=None):
    if y is None:
        y = []
    if len(x):
       z = [x[2], mKeys(x[0], y), mKeys(x[1],y)]
       return z
   return []