Trova su quali altri tipi di python può essere convertito un oggetto?

Question

Come semplice esempio, assumere una metodo di utilità, che accetta un oggetto pitone input_obj e out_type, un pitone type per convertire (typecast) l'oggetto in

def convert_obj(input_obj,out_type): 

-Esempi

convert_obj('2','int') 
#returns 2 
convert_obj([1,2,3],'tuple') 
#returns (1,2,3) 

L' il metodo supporta solo oggetti di tipi specifici come str, list, tuple e quindi verifica se è possibile convertirli in out_type specificato. Questo è libro delle regole presente nel metodo:

supported_conversions = { 
     tuple: [str, list, set], 
     str: [tuple, float, list, long, int, set], 
     float: [str, long, int], 
     list: [tuple, str, set], 
     long: [str, float, int], 
     dict: [tuple, str, list, set], 
     int: [str, float, long], 
     set: [tuple, str, list], 

    } 

I tasti della supported_conversions sono i tipi consentiti per input_obj.

Domanda: Oltre ad utilizzare try/tranne nel corso di un elenco di tutti i possibili tipi di Python per convertire un oggetto campione di ogni tipo, e poi vedere che cosa sono validi, per esempio controllando la conversione da str a [lista, dict, tuple, int, tuple, set] c'è un modo migliore in python per generare il dict supported_conversions, dato le sue chiavi?

Nota: l'altra eccezione per la conversione del tipo deve essere ignorata. ad esempio "1" può essere convertito in intero 1, ma "XYZ" non può essere. Ma questo ancora significa che str-> int è una conversione valida possibile.

Answer 1

Penso che lo spazio del problema non sia sufficientemente definito per un tale metodo. Alcune conversioni saranno distruttive e alcune potrebbero aver luogo in più di un modo. Alcuni esempi:

>>> list(set([1,2,2,3])) 
[1, 2, 3] 
>>> list("hello") 
['h', 'e', 'l', 'l', 'o'] 
>>> ["hello"] 
['hello'] 
>>> list({'a':1, 'b': 2}) 
['a', 'b'] 
>>> list({'a':1, 'b': 2}.iteritems()) 
[('a', 1), ('b', 2)] 

Per l'amor di discussione, è anche possibile convertire una stringa in pratica qualsiasi tipo Python, utilizzando eval().

Quindi, in pratica, tutto dipende dal vostro caso d'uso.

Se si desidera eseguire una ricerca più esaustiva, è possibile utilizzare il modulo types per ottenere un elenco di tipi predefiniti e quindi provare a eseguire la conversione incrociata (presupponendo di ottenere istanze di ciascuno di questi):

>>> import types 
>>> [types.__dict__.get(t) for t in dir(types) if t.endswith('Type')] 
[<type 'bool'>, <type 'buffer'>, <type 'builtin_function_or_method'>, <type 'builtin_function_or_method'>, <type 'classobj'>, <type 'code'>, <type 'complex'>, <type 'dictproxy'>, <type 'dict'>, <type 'dict'>, <type 'ellipsis'>, <type 'file'>, <type 'float'>, <type 'frame'>, <type 'function'>, <type 'generator'>, <type 'getset_descriptor'>, <type 'instance'>, <type 'int'>, <type 'function'>, <type 'list'>, <type 'long'>, <type 'member_descriptor'>, <type 'instancemethod'>, <type 'module'>, <type 'NoneType'>, <type 'NotImplementedType'>, <type 'object'>, <type 'slice'>, <type 'str'>, <type 'traceback'>, <type 'tuple'>, <type 'type'>, <type 'instancemethod'>, <type 'unicode'>, <type 'xrange'>] 

non so se è necessario generare il dizionario supported_conversions anticipo, però. Supponendo che tu abbia sempre convertito intype in outtype per outtype(intype_value), puoi tentare di farlo e quindi aggiornare un dizionario che mappa (intype, outtype) -> bool, e così non tenterà più la conversione se fallisce la prima volta.