请选择 进入手机版 | 继续访问电脑版

笨鸟编程-零基础入门Pyhton教程

 找回密码
 立即注册

4.7. 深入 Python 函数定义

发布者: 三寸日光

在 Python 中,你也可以定义包含若干参数的函数。 这里有三种可用的形式,也可以混合使用。

4.7.1. 默认参数值

最常用的一种形式是为一个或多个参数指定默认值。 这会创建一个可以使用比定义时允许的参数更少的参数调用的函数,例如:

def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
    while True:
        ok = raw_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 IOError('refusenik user')
        print complaint

这个函数可以通过几种不同的方式调用:

  • 只给出必要的参数: 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()

将会输出 5

重要警告: 默认值只被赋值一次。这使得当默认值是可变对象时会有所不同,比如列表、字典或者大多数类的实例。例如,下面的函数在后续调用过程中会累积(前面)传给它的参数:

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. 关键字参数

函数可以通过 关键字参数 的形式来调用,形如 keyword = value 。例如,以下的函数:

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print "-- This parrot wouldn't", action,
    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 ?
TypeError: function() got multiple values for keyword argument 'a'

引入一个形如 **name 的参数时,它接收一个字典(参见 typesmapping ) ,该字典包含了所有未出现在形式参数列表中的关键字参数。这里可能还会组合使用一个形如 *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
    keys = sorted(keywords.keys())
    for kw in keys:
        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")

当然它会按如下内容打印:

-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
client : John Cleese
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch

注意在打印 关键字 参数字典的内容前先调用 sort() 方法。否则的话,打印参数时的顺序是未定义的。

4.7.3. 可变参数列表

最后,一个最不常用的选择是可以让函数调用可变个数的参数。这些参数被包装进一个元组。在这些可变个数的参数之前,可以有零到多个普通的参数。

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

通常,这些 可变 参数是参数列表中的最后一个, 因为它们将把所有的剩余输入参数传递给函数。任何出现在 *args 后的参数是关键字参数,这意味着,他们只能被用作关键字,而不是位置参数。

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


最新评论

Python3编程手册
  1. Python 入门指南

  2. 1. 开胃菜

  3. 2.1. 调用 Python 解释器

  4. 2.2. 解释器及其环境

  5. 3. Python 简介

  6. 3.1. 将 Python 当做计算器

  7. 3.2. 编程的第一步

  8. 4. 深入 Python 流程控制

  9. 4.1. if 语句

  10. 4.2. for 语句

  11. 4.3. range() 函数

  12. 4.4. break 和 continue 语句

  13. 4.5. pass 语句

  14. 4.6. 定义函数

  15. 4.7. 深入 Python 函数定义

  16. 4.8. 插曲:编码风格

  17. 5. 数据结构

  18. 5.1. 关于列表更多的内容

  19. 5.2. del 语句

  20. 5.3. 元组和序列

  21. 5.4. 集合

  22. 5.5. 字典

  23. 5.6. 循环技巧

  24. 5.7. 深入条件控制

  25. 5.8. 比较序列和其它类型

  26. 6. 模块

  27. 6.1. 深入模块

  28. 6.2. 标准模块

  29. 6.3. dir() 函数

  30. 6.4. 包

  31. 7. 输入和输出

  32. 7.1. 格式化输出

  33. 7.2. 文件读写

  34. 8. 错误和异常

  35. 8.1. 语法错误

  36. 8.2. 异常

  37. 8.3. 异常处理

  38. 8.4. 抛出异常

  39. 8.5. 用户自定义异常

  40. 8.6. 定义清理行为

  41. 8.7. 预定义清理行为

  42. 9. 类

  43. 9.1. 术语相关

  44. 9.2. Python 作用域和命名空间

  45. 9.3. 初识类

  46. 9.4. 一些说明

  47. 9.5. 继承

  48. 9.6. 私有变量

  49. 9.7. 补充

  50. 9.8. 异常也是类

  51. 9.9. 迭代器

  52. 9.10. 生成器

  53. 9.11. 生成器表达式

  54. 10. Python 标准库概览

  55. 10.1. 操作系统接口

  56. 10.2. 文件通配符

  57. 10.3. 命令行参数

  58. 10.4. 错误输出重定向和程序终止

  59. 10.5. 字符串正则匹配

  60. 10.6. 数学

  61. 10.7. 互联网访问

  62. 10.8. 日期和时间

  63. 10.9. 数据压缩

  64. 10.10. 性能度量

  65. 10.11. 质量控制

  66. 10.12. “瑞士军刀”

  67. 11. 标准库浏览

  68. 11.1. 输出格式

  69. 11.2. 模板

  70. 11.3. 使用二进制数据记录布局

  71. 11.4. 多线程

  72. 11.5. 日志

  73. 11.6. 弱引用

  74. 11.7. 列表工具

  75. 11.8. 十进制浮点数算法

  76. 12. 接下来?

  77. 13. 交互式输入行编辑历史回溯

  78. 13.1. 行编辑

  79. 13.2. 历史回溯

  80. 13.3. 快捷键绑定

  81. 13.4. 其它交互式解释器

  82. 14. 浮点数算法:争议和限制

  83. 14.1. 表达错误

Archiver|手机版|笨鸟自学网 ( 粤ICP备20019910号 )

GMT+8, 2024-6-20 23:42 , Processed in 0.025102 second(s), 18 queries .

© 2001-2020

返回顶部