在 Python 中自动类型转换参数

Question

背景：
我主要从管道中的命令行运行 python 脚本，因此我的参数始终是需要类型转换为适当类型的字符串。我每天都会制作很多小脚本，并且为每个脚本对每个参数进行类型转换会花费比应有的时间更多的时间。

问题：
是否有一种规范的方法可以自动为函数键入强制类型转换参数？

我的方式：
如果没有更好的方法，我开发了一个装饰器来做我想做的事情。装饰器是下面的 autocast fxn。示例中，修饰后的 fxn 为 fxn2。请注意，在代码块的末尾，我将 1 和 2 作为字符串传递，如果您运行脚本，它会自动添加它们。这是一个好方法吗？

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')      

---

编辑：对于任何来到这里并想要更新且简洁的工作版本的人，请转到此处：

https: //github.com/sequenceGeek/cgAutoCast

这里也是基于上述的快速工作版本：

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')

Answer 1

如果您想自动转换值：

def boolify(s):
    if s == 'True':
        return True
    if s == 'False':
        return False
    raise ValueError("huh?")

def autoconvert(s):
    for fn in (boolify, int, float):
        try:
            return fn(s)
        except ValueError:
            pass
    return s

如果您愿意，可以调整 boolify 以接受其他布尔值。

Answer 2

如果您信任源，您可以只使用纯 eval 来输入字符串：

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

但是如果您不信任源，您可以使用 ast 模块中的literal_eval。

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

编辑：
正如 Ned Batchelder 的评论，它不接受非引号字符串，所以我添加了一个解决方法，也是一个关于带有关键字参数的 autocaste 装饰器的示例。

import ast

def my_eval(s):
    try:
        return ast.literal_eval(s)
    except ValueError: #maybe it's a string, eval failed, return anyway
        return s       #thanks gnibbler

def autocaste(func):
    def wrapped(*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 versions
        return func(*cp, **dp)

    return wrapped

@autocaste
def f(a, b):
    return a + b

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

Answer 3

我想你可以用函数装饰器创建一个类型签名系统，就像你所拥有的那样，只有一个需要参数的系统。例如：

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

这样的装饰器可以相当容易地构建。像这样的东西（编辑 - 有效！）：

def signature(*args, **kwargs):
    def decorator(fn):
        def wrapped(*fn_args, **fn_kwargs):
            new_args = [t(raw) for t, raw in zip(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

就像这样，您现在可以为函数注入类型签名！

@signature(int, int)
def foo(x, y):
    print type(x)
    print type(y)
    print x+y

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

基本上，这是 @utdemir 方法的类型显式版本。

Answer 4

如果您要从命令行解析参数，则应使用 argparse 模块（如果您使用的是 Python 2.7）。

每个参数都可以有一个预期的类型，因此知道如何处理它应该相对简单。您甚至可以定义自己的类型。

...很多时候命令行字符串应该被解释为另一种类型，例如 float 或 int。 add_argument() 的 type 关键字参数允许执行任何必要的类型检查和类型转换。常见的内置类型和函数可以直接用作类型参数的值：

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)

Answer 5

您的代码片段中有几个问题。

#first test bools
if var == 'True':
        return True
elif var == 'False':
        return False

这将始终检查 True，因为您正在针对字符串 'True' 和 'False' 进行测试。

python 中没有自动类型强制转换。当您通过 *args 和 **kwargs 接收时，您的参数可以是任何内容。首先将查找值列表（每个值可以是任何数据类型，原始数据类型和复杂数据类型），其次将查找映射（可能具有任何有效的映射）。因此，如果您编写一个装饰器，您最终将得到一个很好的错误检查列表。

通常，如果您希望以 str 形式发送，则在调用函数时，通过 (str) 将其类型转换为字符串并发送。

Answer 6

我知道我在这场比赛中迟到了，但是评估怎么样？

def my_cast(a):
try:
    return eval(a)
except:
    return a

或者（更安全）：

from ast import literal_eval

def mycast(a):
  try:
    return literal_eval(a)
  except:
    return a