python - qué - que es la indentación de codigo y para que sirve

Crear un árbol/dict profundamente anidado de un archivo de texto sangrado en python

Question

Básicamente, quiero iterar a través de un archivo y poner el contenido de cada línea en un dictado profundamente anidado, cuya estructura se define por la cantidad de espacios en blanco al comienzo de cada línea.

Esencialmente, el objetivo es tomar algo como esto:

a
b
c
d
e

Y conviértalo en algo como esto:

{"a":{"b":"c","d":"e"}}

O esto:

apple
colours
red
yellow
green
type
granny smith
price
0.10

dentro de esto:

{"apple":{"colours":["red","yellow","green"],"type":"granny smith","price":0.10}

Para poder enviarlo al módulo JSON de Python y hacer algunos JSON.

Por el momento estoy tratando de hacer un dict y una lista en pasos como este:

1. {"a":""} ["a"]
2. {"a":"b"} ["a"]
3. {"a":{"b":"c"}} ["a","b"]
4. {"a":{"b":{"c":"d"}}}} ["a","b","c"]
5. {"a":{"b":{"c":"d"},"e":""}} ["a","e"]
6. {"a":{"b":{"c":"d"},"e":"f"}} ["a","e"]
7. {"a":{"b":{"c":"d"},"e":{"f":"g"}}} ["a","e","f"]

etc.

La lista actúa como "migas de pan" que muestra dónde colgué por última vez un dict.

Para hacer esto, necesito una manera de recorrer la lista y generar algo como dict["a"]["e"]["f"] para llegar a esa última frase. He echado un vistazo a la clase AutoVivification que alguien ha hecho y que parece muy útil, pero de lo que no estoy seguro es:

1. Si estoy usando la estructura de datos correcta para esto (estoy planeando enviarlo a la biblioteca JSON para crear un objeto JSON)
2. Cómo usar AutoVivification en esta instancia
3. Si hay una mejor manera en general para abordar este problema.

Se me ocurrió la siguiente función pero no funciona:

def get_nested(dict,array,i):
if i != None:
i += 1
if array[i] in dict:
return get_nested(dict[array[i]],array)
else:
return dict
else:
i = 0
return get_nested(dict[array[i]],array)

Agradecería ayuda!

(El resto de mi código extremadamente incompleto está aquí :)

#Import relevant libraries
import codecs
import sys
#Functions
def stripped(str):
if tab_spaced:
return str.lstrip(''/t'').rstrip(''/n/r'')
else:
return str.lstrip().rstrip(''/n/r'')
def current_ws():
if whitespacing == 0 or not tab_spaced:
return len(line) - len(line.lstrip())
if tab_spaced:
return len(line) - len(line.lstrip(''/t/n/r''))
def get_nested(adict,anarray,i):
if i != None:
i += 1
if anarray[i] in adict:
return get_nested(adict[anarray[i]],anarray)
else:
return adict
else:
i = 0
return get_nested(adict[anarray[i]],anarray)
#initialise variables
jsondict = {}
unclosed_tags = []
debug = []
vividfilename = ''simple.vivid''
# vividfilename = sys.argv[1]
if len(sys.argv)>2:
jsfilename = sys.argv[2]
else:
jsfilename = vividfilename.split(''.'')[0] + ''.json''
whitespacing = 0
whitespace_array = [0,0]
tab_spaced = False
#open the file
with codecs.open(vividfilename,''rU'', "utf-8-sig") as vividfile:
for line in vividfile:
#work out how many whitespaces at start
whitespace_array.append(current_ws())
#For first line with whitespace, work out the whitespacing (eg tab vs 4-space)
if whitespacing == 0 and whitespace_array[-1] > 0:
whitespacing = whitespace_array[-1]
if line[0] == ''/t'':
tab_spaced = True
#strip out whitespace at start and end
stripped_line = stripped(line)
if whitespace_array[-1] == 0:
jsondict[stripped_line] = ""
unclosed_tags.append(stripped_line)
if whitespace_array[-2] < whitespace_array[-1]:
oldnested = get_nested(jsondict,whitespace_array,None)
print oldnested
# jsondict.pop(unclosed_tags[-1])
# jsondict[unclosed_tags[-1]]={stripped_line:""}
# unclosed_tags.append(stripped_line)
print jsondict
print unclosed_tags
print jsondict
print unclosed_tags

Answer 1

Antes que nada, no uses array y dict como nombres de variables porque son palabras reservadas en Python y reutilizarlas puede terminar en todo tipo de caos.

De acuerdo, entonces si te encuentro correctamente, tienes un árbol en un archivo de texto, con la paternidad indicada por indentaciones, y quieres recuperar la estructura de árbol real. ¿Derecha?

¿El siguiente parece un bosquejo válido? Porque tengo problemas para poner tu código actual en contexto.

result = {}
last_indentation = 0
for l in f.xreadlines():
(c, i) = parse(l) # create parse to return character and indentation
if i==last_indentation:
# sibling to last
elif i>last_indentation:
# child to last
else:
# end of children, back to a higher level

OK, entonces tu lista son los padres actuales, eso es correcto, pero los mantendré apuntando al diccionario que has creado, no a la letra literal

acaba de comenzar algunas cosas aquí

result = {}
parents = {}
last_indentation = 1 # start with 1 so 0 is the root of tree
parents[0] = result
for l in f.xreadlines():
(c, i) = parse(l) # create parse to return character and indentation
if i==last_indentation:
new_el = {}
parents[i-1][c] = new_el
parents[i] = new_el
elif i>last_indentation:
# child to last
else:
# end of children, back to a higher level

Answer 2

El siguiente código tomará un archivo con sangría de bloque y se convertirá en un árbol XML; esta:

foo
bar
baz
ban
bal

... se convierte en:

<cmd>foo</cmd>
<cmd>bar</cmd>
<block>
<name>baz</name>
<cmd>ban</cmd>
<cmd>bal</cmd>
</block>

La técnica básica es:

1. Establecer sangría a 0
2. Para cada línea, obtenga la sangría
3. Si> actual, baje y guarde el bloque / ident actual en una pila
4. Si == actual, anexa al bloque actual
5. Si <actual, sal de la pila hasta que llegues a la sangría correspondiente

Asi que:

from lxml import builder
C = builder.ElementMaker()
def indent(line):
strip = line.lstrip()
return len(line) - len(strip), strip
def parse_blockcfg(data):
top = current_block = C.config()
stack = []
current_indent = 0
lines = data.split(''/n'')
while lines:
line = lines.pop(0)
i, line = indent(line)
if i==current_indent:
pass
elif i > current_indent:
# we''ve gone down a level, convert the <cmd> to a block
# and then save the current ident and block to the stack
prev.tag = ''block''
prev.append(C.name(prev.text))
prev.text = None
stack.insert(0, (current_indent, current_block))
current_indent = i
current_block = prev
elif i < current_indent:
# we''ve gone up one or more levels, pop the stack
# until we find out which level and return to it
found = False
while stack:
parent_indent, parent_block = stack.pop(0)
if parent_indent==i:
found = True
break
if not found:
raise Exception(''indent not found in parent stack'')
current_indent = i
current_block = parent_block
prev = C.cmd(line)
current_block.append(prev)
return top

Answer 3

Aquí hay una solución recursiva. Primero, transforma la entrada de la siguiente manera.

Entrada:

person:
address:
street1: 123 Bar St
street2:
city: Madison
state: WI
zip: 55555
web:
email: [email protected]

Resultado del primer paso:

[{''name'':''person'',''value'':'''',''level'':0},
{''name'':''address'',''value'':'''',''level'':1},
{''name'':''street1'',''value'':''123 Bar St'',''level'':2},
{''name'':''street2'',''value'':'''',''level'':2},
{''name'':''city'',''value'':''Madison'',''level'':2},
{''name'':''state'',''value'':''WI'',''level'':2},
{''name'':''zip'',''value'':55555,''level'':2},
{''name'':''web'',''value'':'''',''level'':1},
{''name'':''email'',''value'':''[email protected]'',''level'':2}]

Esto es fácil de lograr con la split('':'') y contando el número de pestañas iniciales:

def tab_level(astr):
"""Count number of leading tabs in a string
"""
return len(astr)- len(astr.lstrip(''/t''))

Luego, alimente la salida del primer paso a la siguiente función:

def ttree_to_json(ttree,level=0):
result = {}
for i in range(0,len(ttree)):
cn = ttree[i]
try:
nn = ttree[i+1]
except:
nn = {''level'':-1}
# Edge cases
if cn[''level'']>level:
continue
if cn[''level'']<level:
return result
# Recursion
if nn[''level'']==level:
dict_insert_or_append(result,cn[''name''],cn[''value''])
elif nn[''level'']>level:
rr = ttree_to_json(ttree[i+1:], level=nn[''level''])
dict_insert_or_append(result,cn[''name''],rr)
else:
dict_insert_or_append(result,cn[''name''],cn[''value''])
return result
return result

dónde:

def dict_insert_or_append(adict,key,val):
"""Insert a value in dict at key if one does not exist
Otherwise, convert value to list and append
"""
if key in adict:
if type(adict[key]) != list:
adict[key] = [adict[key]]
adict[key].append(val)
else:
adict[key] = val