最近在查看Python 3.3语法规范时,我注意到一些有趣的事情:

funcdef: 'def' NAME parameters ['->' test] ':' suite

可选的“箭头”块在Python 2中不存在,我在Python 3中找不到关于它的含义的任何信息。事实证明这是正确的Python,它被解释器接受:

def f(x) -> 123:
    return x

我认为这可能是一种前提语法,但是:

我不能在这里测试x,因为它仍然没有定义, 无论我在箭头后面放什么(例如2 < 1),它都不会影响函数的行为。

熟悉这种语法风格的人能解释一下吗?


当前回答

->在python3中被引入。

简单地说,->后面的内容表示函数的返回类型。 返回类型是可选的。

其他回答

它只是告诉用户它期望什么或返回什么值

funcname。__annotations__将打印细节

like

def function(name:str ,age:int) -> "printing the personal details ":
    print(f"name is {name} age is {age}")

function("test",20)
print(function.__annotations__)

输出

name is test age is 20
{'name': <class 'str'>, 'age': <class 'int'>, 'return': 'printing the personal details '}

即使您返回值,它也不显示任何内容。

def f(x) -> 123:
    return x

我的总结:

Simply -> is introduced to get developers to optionally specify the return type of the function. See Python Enhancement Proposal 3107 This is an indication of how things may develop in future as Python is adopted extensively - an indication towards strong typing - this is my personal observation. You can specify types for arguments as well. Specifying return type of the functions and arguments will help in reducing logical errors and improving code enhancements. You can have expressions as return type (for both at function and parameter level) and the result of the expressions can be accessed via annotations object's 'return' attribute. annotations will be empty for the expression/return value for lambda inline functions.

它是一个函数注释。

更详细的,Python 2。X具有文档字符串,允许您将元数据字符串附加到各种类型的对象。这非常方便,所以Python 3扩展了这个特性,允许你将元数据附加到函数上,描述它们的参数和返回值。

没有先入为主的用例,但是PEP建议了几个用例。一个非常方便的方法是允许你用参数的预期类型来注释参数;这样就很容易编写一个装饰器来验证注释或将参数强制转换为正确的类型。另一种是允许特定于参数的文档,而不是将其编码到文档字符串中。

在以下代码中:

def f(x) -> int:
    return int(x)

-> int只是告诉f()返回一个整数(但它不强制函数返回一个整数)。它被称为返回注释,可以通过f.__annotations__['return']访问。

Python还支持参数注释:

def f(x: float) -> int:
    return int(x)

: float告诉阅读程序(以及一些第三方库/程序,例如pylint)的人x应该是浮点数。它被访问为f.__annotations__['x'],本身没有任何意义。更多信息请参阅文档:

https://docs.python.org/3/reference/compound_stmts.html#function-definitions https://www.python.org/dev/peps/pep-3107/

这些是PEP 3107中包含的函数注释。具体来说,->标记返回函数注释。

例子:

def kinetic_energy(m:'in KG', v:'in M/S')->'Joules': 
    return 1/2*m*v**2
 
>>> kinetic_energy.__annotations__
{'return': 'Joules', 'v': 'in M/S', 'm': 'in KG'}

注释是字典,所以你可以这样做:

>>> '{:,} {}'.format(kinetic_energy(12,30),
      kinetic_energy.__annotations__['return'])
'5,400.0 Joules'

你也可以有一个python数据结构,而不仅仅是字符串:

rd={'type':float,'units':'Joules',
    'docstring':'Given mass and velocity returns kinetic energy in Joules'}
def f()->rd:
    pass

>>> f.__annotations__['return']['type']
<class 'float'>
>>> f.__annotations__['return']['units']
'Joules'
>>> f.__annotations__['return']['docstring']
'Given mass and velocity returns kinetic energy in Joules'

或者,你可以使用函数属性来验证调用的值:

def validate(func, locals):
    for var, test in func.__annotations__.items():
        value = locals[var]
        try: 
            pr=test.__name__+': '+test.__docstring__
        except AttributeError:
            pr=test.__name__   
        msg = '{}=={}; Test: {}'.format(var, value, pr)
        assert test(value), msg

def between(lo, hi):
    def _between(x):
            return lo <= x <= hi
    _between.__docstring__='must be between {} and {}'.format(lo,hi)       
    return _between

def f(x: between(3,10), y:lambda _y: isinstance(_y,int)):
    validate(f, locals())
    print(x,y)

打印

>>> f(2,2) 
AssertionError: x==2; Test: _between: must be between 3 and 10
>>> f(3,2.1)
AssertionError: y==2.1; Test: <lambda>