条件、控制及循环语句的用法(4)python入门教程

def ask_ok(prompt, retries=4, reminder='Please try again!'): 
    while True: 
        ok = input(prompt) 
        if ok in ('y', 'ye', 'yes'): 
            return True 
        if ok in ('n', 'no', 'nop', 'nope'): 
            return False 
        retries = retries - 1 
        if retries < 0:
            raise ValueError('invalid user response') 
        print(reminder)

可以通过多种方式调用此函数：

• 只给出强制参数： ask_ok('Do you really want to quit?')
• 给出可选参数之一： ask_ok('OK to overwrite the file?', 2)
• 甚至给出所有论点： ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')

这个例子也引入了in关键字。这将测试一个序列是否包含某个值。

默认值在定义范围内的函数定义点进行评估 ，因此

i = 5 
def f(arg=i):
    print(arg) 
i = 6 
f()

def f(a, L=[]): 
    L.append(a) 
    return L 
print(f(1)) 
print(f(2)) 
print(f(3))

这将打印

[1] 
[1, 2] 
[1, 2, 3]

def f(a, L=None): 
    if L is None: 
        L = [] 
    L.append(a) 
    return L

4.7.2. 关键字参数

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'): 
    print("-- This parrot wouldn't", action, end=' ') 
    print("if you put", voltage, "volts through it.") 
    print("-- Lovely plumage, the", type) 
    print("-- It's", state, "!")

接受一个必需参数 ( voltage) 和三个可选参数 ( state、action和type)。可以通过以下任何一种方式调用此函数：

parrot(1000) # 1 positional argument 
parrot(voltage=1000) # 1 keyword argument 
parrot(voltage=1000000, action='VOOOOOM') # 2 keyword arguments 
parrot(action='VOOOOOM', voltage=1000000) # 2 keyword arguments 
parrot('a million', 'bereft of life', 'jump') # 3 positional arguments 
parrot('a thousand', state='pushing up the daisies') # 1 positional, 1 keyword

parrot() # required argument missing 
parrot(voltage=5.0, 'dead') # non-keyword argument after a keyword argument 
parrot(110, voltage=220) # duplicate value for the same argument 
parrot(actor='John Cleese') # unknown keyword argument

>>>
>>> def function(a):
...     pass
...
>>> function(0, a=0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: function() got multiple values for keyword argument 'a'

当表单的最终形式参数**name存在时，它会收到一个字典（请参阅映射类型 – dict），其中包含所有关键字参数，除了与形式参数相对应的关键字参数。这可以与形式*name（在下一小节中描述）形式的形式参数相结合，该形式参数接收包含超出形式参数列表的位置参数的元组。（*name必须出现在 之前**name。）例如，如果我们定义这样的函数：

def cheeseshop(kind, *arguments, **keywords): 
    print("-- Do you have any", kind, "?") 
    print("-- I'm sorry, we're all out of", kind) 
    for arg in arguments: 
        print(arg) 
    print("-" * 40) 
    for kw in keywords: 
        print(kw, ":", keywords[kw])

cheeseshop("Limburger", "It's very runny, sir.",
           "It's really very, VERY runny, sir.", 
           shopkeeper="Michael Palin", 
           client="John Cleese", 
           sketch="Cheese Shop Sketch")

当然它会打印：

def write_multiple_items(file, separator, *args): 
     file.write(separator.join(args))

>>>
>>> def concat(*args, sep="/"):
...     return sep.join(args)
...
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'

>>>
>>> list(range(3, 6))            # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> list(range(*args))            # call with arguments unpacked from a list
[3, 4, 5]

>>>
>>> def parrot(voltage, state='a stiff', action='voom'):
...     print("-- This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

4.7.5 Lambda 表达式

可以使用lambda关键字创建小型匿名函数。此函数返回其两个参数的总和：. Lambda 函数可用于需要函数对象的任何地方。它们在语法上仅限于单个表达式。从语义上讲，它们只是普通函数定义的语法。与嵌套函数定义一样，lambda 函数可以引用包含范围内的变量：lambda a, b: a+b

>>> 
>>> def make_incrementor(n): 
...     return lambda x: x + n 
... 
>>> f = make_incrementor(42) 
>>> f(0) 42 
>>> f(1) 43

>>>
>>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
>>> pairs.sort(key=lambda pair: pair[1])
>>> pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

4.7.6 文档字符串

以下是有关文档字符串的内容和格式的一些约定。

第一行应始终是对象用途的简短摘要。为简洁起见，它不应该明确说明对象的名称或类型，因为它们可以通过其他方式获得（除非名称恰好是描述函数操作的动词）。此行应以大写字母开头并以句点结尾。

如果文档字符串中有更多行，则第二行应为空白，从视觉上将摘要与描述的其余部分分开。以下几行应该是描述对象的调用约定、副作用等的一个或多个段落。

Python 解析器不会从 Python 中的多行字符串文字中去除缩进，因此如果需要，处理文档的工具必须去除缩进。这是使用以下约定完成的。字符串第一行之后的第一个非空行 决定了整个文档字符串的缩进量。（我们不能使用第一行，因为它通常与字符串的开始引号相邻，因此它的缩进在字符串文字中不明显。）然后从字符串的所有行的开头去除与该缩进“等效”的空格. 缩进较少的行不应出现，但如果它们出现，则应去除所有前导空格。应在扩展制表符（通常为 8 个空格）后测试空格的等效性。

这是一个多行文档字符串的示例：

>>>
>>> def my_function():
...     """Do nothing, but document it.
...
...     No, really, it doesn't do anything.
...     """
...     pass
...
>>> print(my_function.__doc__)
Do nothing, but document it.

    No, really, it doesn't do anything.

>>>
>>> def f(ham: str, eggs: str = 'eggs') -> str:
...     print("Annotations:", f.__annotations__)
...     print("Arguments:", ham, eggs)
...     return ham + ' and ' + eggs
...
>>> f('spam')
Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
Arguments: spam eggs
'spam and eggs'