Antecedentes
Principalmente ejecuto scripts de python desde la línea de comandos en tuberías y, por lo tanto, mis argumentos siempre son cadenas que deben teclearse al tipo apropiado. Hago muchas pequeñas secuencias de comandos cada día y escribo que la conversión de cada parámetro para cada secuencia de comandos lleva más tiempo del que debería.

Pregunta
Existe una forma canónica de escribir automáticamente parámetros de conversión para una función?

Mi manera
He desarrollado un decorador para hacer lo que quiero si no hay una mejor manera. El decorador es el autocast fxn a continuación. El fxn decorado es fxn2 en el ejemplo. Tenga en cuenta que al final del bloque de código pasé 1 y 2 como cadenas y si ejecuta el script, las agregará automáticamente. ¿Es esta una buena manera de hacer esto?

def estimateType(var):
    #first test bools
    if var == 'True':
            return True
    elif var == 'False':
            return False
    else:
            #int
            try:
                    return int(var)
            except ValueError:
                    pass
            #float
            try:
                    return float(var)
            except ValueError:
                    pass
            #string
            try:
                    return str(var)
            except ValueError:
                    raise NameError('Something Messed Up Autocasting var %s (%s)' 
                                      % (var, type(var)))

def autocast(dFxn):
    '''Still need to figure out if you pass a variable with kw args!!!
    I guess I can just pass the dictionary to the fxn **args?'''
    def wrapped(*c, **d):
            print c, d
            t = [estimateType(x) for x in c]
            return dFxn(*t)
    return wrapped

@autocast
def fxn2(one, two):

   print one + two 

fxn2('1', '2')      

EDIT: Para cualquiera que venga aquí y quiera la versión actualizada y concisa de trabajo, vaya aquí:

https: //github.com/sequenceGeek/cgAutoCas

Y aquí también hay una versión rápida de trabajo basada en lo anterior:

def boolify(s):
    if s == 'True' or s == 'true':
            return True
    if s == 'False' or s == 'false':
            return False
    raise ValueError('Not Boolean Value!')

def estimateType(var):
    '''guesses the str representation of the variables type'''
    var = str(var) #important if the parameters aren't strings...
    for caster in (boolify, int, float):
            try:
                    return caster(var)
            except ValueError:
                    pass
    return var

def autocast(dFxn):
    def wrapped(*c, **d):
            cp = [estimateType(x) for x in c]
            dp = dict( (i, estimateType(j)) for (i,j) in d.items())
            return dFxn(*cp, **dp)

    return wrapped

######usage######
@autocast
def randomFunction(firstVar, secondVar):
    print firstVar + secondVar

randomFunction('1', '2')