Automatically Type Cast Parameters In Python

September 28, 2023 Post a Comment

Background: I mostly run python scripts from the command line in pipelines and so my arguments are always strings that need to be type casted to the appropriate type. I make a lot

Solution 1:

If you want to auto-convert values:

defboolify(s):
    if s == 'True':
        returnTrueif s == 'False':
        returnFalseraise ValueError("huh?")

defautoconvert(s):
    for fn in (boolify, int, float):
        try:
            return fn(s)
        except ValueError:
            passreturn s

You can adjust boolify to accept other boolean values if you like.

Solution 2:

You could just use plain eval to input string if you trust the source:

>>>eval("3.2", {}, {})
3.2
>>>eval("True", {}, {})
True

But if you don't trust the source, you could use literal_eval from ast module.

>>> ast.literal_eval("'hi'")
'hi'>>> ast.literal_eval("(5, 3, ['a', 'b'])")
(5, 3, ['a', 'b'])

Edit: As Ned Batchelder's comment, it won't accept non-quoted strings, so I added a workaround, also an example about autocaste decorator with keyword arguments.

import ast

defmy_eval(s):
    try:
        return ast.literal_eval(s)
    except ValueError: #maybe it's a string, eval failed, return anywayreturn s       #thanks gnibblerdefautocaste(func):
    defwrapped(*c, **d):
        cp = [my_eval(x) for x in c]
        dp = {i: my_eval(j) for i,j in d.items()} #for Python 2.6+#you can use dict((i, my_eval(j)) for i,j in d.items()) for older versionsreturn func(*cp, **dp)

    return wrapped

@autocastedeff(a, b):
    return a + b

print(f("3.4", "1")) # 4.4print(f("s", "sd"))  # ssdprint(my_eval("True")) # Trueprint(my_eval("None")) # Noneprint(my_eval("[1, 2, (3, 4)]")) # [1, 2, (3, 4)]

Solution 3:

I'd imagine you can make a type signature system with a function decorator, much like you have, only one that takes arguments. For example:

@signature(int, str, int)
func(x, y, z):
    ...

Such a decorator can be built rather easily. Something like this (EDIT -- works!):

defsignature(*args, **kwargs):
    defdecorator(fn):
        defwrapped(*fn_args, **fn_kwargs):
            new_args = [t(raw) for t, raw inzip(args, fn_args)]
            new_kwargs = dict([(k, kwargs[k](v)) for k, v in fn_kwargs.items()])

            return fn(*new_args, **new_kwargs)

        return wrapped

    return decorator

And just like that, you can now imbue functions with type signatures!

@signature(int, int)deffoo(x, y):
    printtype(x)
    printtype(y)
    print x+y

>>> foo('3','4')
<type: 'int'>
<type: 'int'>
7

Basically, this is an type-explicit version of @utdemir's method.

Solution 4:

If you're parsing arguments from the command line, you should use the argparse module (if you're using Python 2.7).

Each argument can have an expected type so knowing what to do with it should be relatively straightforward. You can even define your own types.

...quite often the command-line string should instead be interpreted as another type, like a float or int. The type keyword argument of add_argument() allows any necessary type-checking and type conversions to be performed. Common built-in types and functions can be used directly as the value of the type argument:

parser = argparse.ArgumentParser()
parser.add_argument('foo', type=int)
parser.add_argument('bar', type=file)
parser.parse_args('2 temp.txt'.split())
>>> Namespace(bar=<open file 'temp.txt', mode 'r' at 0x...>, foo=2)

Solution 5:

There are couple of problems in your snippet.

#first test boolsifvar == 'True':
        returnTrue
elif var == 'False':
        returnFalse

This would always check for True because you are testing against the strings 'True' and 'False'.

There is not an automatic coercion of types in python. Your arguments when you receive via *args and **kwargs can be anything. First will look for list of values (each of which can be any datatype, primitive and complex) and second will look for a mapping (with any valid mapping possible). So if you write a decorator, you will end up with a good list of error checks.

Normally, if you wish to send in str, just when the function is invoked, typecast it to string via (str) and send it.

Python Library