On Mon, Jan 26 2015, Gollum1 wrote:
> Il 26 gennaio 2015 08:08, Gollum1 <gollum1.smeag...@gmail.com> ha scritto:
> > Giorno Lista,
> >
> > oggi sono arrivato presto al lavoro, e visto che nessuno rompe, ho
> > ripreso in mano il mio programmino fermo da parecchio...
> >
> > attraverso il modulo requests riesco ad ottenere una stringa
> > contenente l'XML con tutti i parametri dell'utente loggato alla pagina
> > chiamata da requests.
> >
> > sto usando xml.parsers.expat per analizzarla, e vorrei fare in modo
> > che gli attributi che trovo per i vari tag xml vengano restituiti come
> > dizionario {nome_tag: attributo_uri}
> >
> > ho usato questo codice di esempio:
> > https://docs.python.org/3.4/library/pyexpat.html#example
> >
> > e fino a che nelle prove stampo i tag e gli attributi, tutto va bene,
> > ma come faccio a fare il return di una voce di dizionario?
> >
> > pensavo di mettere:
> >
> > def start_element(name, attrs):
> > if 'uri' in attrs.keys():
> > return{name: attrs['uri']}
> >
> > ma chi è il chiamante effettivo, visto che in realtà è come se io
> > avessi inettato la mia funzione all'interna della classe del parser?
> >
> > Byez
> > --
> > Gollum1 - http://www.gollumone.it
> > Tesssssoro, dov'é il mio tessssoro...
>
>
> naturalmente se uso una variabile esternda al def, la cosa funziona,
>
> urls = dict()
>
> def start_element(name, attrs):
> if 'uri' in attrs.keys():
> urls[name] = attrs['uri']
>
>
> personalmente però ho sempre cercato di evitare di usare delle
> variabili "globali" all'interno di definizioni di funzioni...
>
> se lo faccio solitamente è perché sono comunque all'interno di una
> classe, ma in questo caso non ho necessità di refernziare una nuova
> classe solo per l'analisi di questo file xml, una volta ottenuto
> questi uri non me ne faccio più nulla.
>
> mi sto facendo troppe pippe per nulla?
La funzione è richiamata dal parser stesso e quindi non puoi utilizzare
il valore returnato. Usare delle variabili globali non è vietato ma puoi
utilizzare altre soluzioni, per esempio i metodi di una funzione.
Infatti questi sono già legati all'oggetto stesso e quindi hanno già uno
stato comune. Ti allego un esempio, abbastanza ridicolo a dire il vero.
m.
from __future__ import print_function
class Parser(object):
def parse(self, obj):
if isinstance(obj, list):
self._parse_list(obj)
elif isinstance(obj, dict):
self._parse_dict(obj)
else:
self.parse_obj(obj)
def _parse_list(self, obj):
self.start_list()
for el in obj:
self.start_list_el()
self.parse(el)
self.end_list_el()
self.end_list()
def _parse_dict(self, obj):
self.start_dict()
for k, v in obj.iteritems():
self.start_dict_key()
self.parse(k)
self.end_dict_key()
self.start_dict_val()
self.parse(v)
self.end_dict_val()
self.end_dict()
parse_obj = lambda self, obj: None
start_dict_key = end_dict_key = start_list = end_list = \
start_list_el = end_list_el = start_dict_val = end_dict_val = \
lambda self: None
class Handler(object):
def __init__(self):
self._list_first = True
self._dict_first = True
def start_dict_val(self):
if self._dict_first:
self._dict_first = False
else:
print(", ", end="")
def start_list_el(self):
if self._list_first:
self._list_first = False
else:
print(", ", end="")
def end_dict_key(self):
print(": ", end="")
def start_list(self):
print("[", end="")
def end_list(self):
self._list_first = True
print("]", end="")
def start_dict(self):
print("{", end="")
def end_dict(self):
self._dict_first = True
print("}", end="")
def parse_obj(self, obj):
print(repr(obj), end="")
if __name__ == "__main__":
parser = Parser()
handler = Handler()
parser.start_list = handler.start_list
parser.end_list = handler.end_list
parser.start_dict = handler.start_dict
parser.end_dict = handler.end_dict
parser.parse_obj = handler.parse_obj
parser.start_dict_val = handler.start_dict_val
parser.end_dict_key = handler.end_dict_key
parser.start_list_el = handler.start_list_el
parser.parse([{"hello": "world"}])
_______________________________________________
Python mailing list
Python@lists.python.it
http://lists.python.it/mailman/listinfo/python
