programming - Usando self.xxxx como parámetro predeterminado-Python

recursive programming python

Question

Hola, intento simplificar uno de mis problemas de tarea y mejorar un poco el código. Con lo que estoy trabajando es con un árbol de búsqueda binario. En este momento tengo una función en mi clase Tree() que encuentra todos los elementos y los coloca en una lista.

tree = Tree()
#insert a bunch of items into tree

luego uso mi función makeList () para tomar todos los nodos del árbol y los pone en una lista. Para llamar a la función makeList() , hago tree.makeList(tree.root) . Para mí esto parece un poco repetitivo. Ya estoy llamando al árbol con el tree. por lo que tree.root es solo una pérdida de un poco de tipeo.

En este momento la función makeList es:

 def makeList(self, aNode):
if aNode is None:
return []
return [aNode.data] + self.makeList(aNode.lChild) + self.makeList(aNode.rChild)

Me gustaría hacer que la entrada aNodo sea un parámetro predeterminado como aNode = self.root (que no funciona) de esa forma podría ejecutar la función con esto, tree.makeList() .

La primera pregunta es, ¿por qué eso no funciona?
La segunda pregunta es, ¿hay alguna manera de que pueda funcionar? Como puede ver, la función makeList() es recursiva, por lo que no puedo definir nada al comienzo de la función o recibo un ciclo infinito.

EDITAR Aquí está todo el código solicitado:

class Node(object):
def __init__(self, data):
self.data = data
self.lChild = None
self.rChild = None
class Tree(object):
def __init__(self):
self.root = None
def __str__(self):
current = self.root
def isEmpty(self):
if self.root == None:
return True
else:
return False
def insert (self, item):
newNode = Node (item)
current = self.root
parent = self.root
if self.root == None:
self.root = newNode
else:
while current != None:
parent = current
if item < current.data:
current = current.lChild
else:
current = current.rChild
if item < parent.data:
parent.lChild = newNode
else:
parent.rChild = newNode
def inOrder(self, aNode):
if aNode != None:
self.inOrder(aNode.lChild)
print aNode.data
self.inOrder(aNode.rChild)
def makeList(self, aNode):
if aNode is None:
return []
return [aNode.data] + self.makeList(aNode.lChild) + self.makeList(aNode.rChild)
def isSimilar(self, n, m):
nList = self.makeList(n.root)
mList = self.makeList(m.root)
print mList == nList

Answer 1

No funciona porque los argumentos predeterminados se evalúan en el tiempo de definición de la función, no en el tiempo de la llamada:

def f(lst = []):
lst.append(1)
return lst
print(f()) # prints [1]
print(f()) # prints [1, 1]

La estrategia común es usar un parámetro predeterminado None . Si None es un valor válido, use un centinela singleton:

NOTHING = object()
def f(arg = NOTHING):
if arg is NOTHING:
# no argument
# etc.

Answer 2

larsmans answered tu primera pregunta

Para su segunda pregunta, ¿puede simplemente mirar antes de saltar para evitar la recursión?

def makeList(self, aNode=None):
if aNode is None:
aNode = self.root
treeaslist = [aNode.data]
if aNode.lChild:
treeaslist.extend(self.makeList(aNode.lChild))
if aNode.rChild:
treeaslist.extend(self.makeList(aNode.rChild))
return treeaslist