python学习记录 函数

note:以下类容来源于网络,作为自己学习摘抄记录，方便以后查看

返回多个值

比如在游戏中经常需要从一个点移动到另一个点，给出坐标、位移和角度，就可以计算出新的新的坐标：

import math

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

这样我们就可以同时获得返回值：

x, y = move(100, 100, 60, math.pi / 6)
print x, y

结果如下：
151.961524227 70.0

但其实这只是一种假象，Python函数返回的仍然是单一值：

r = move(100, 100, 60, math.pi / 6)
print r

结果如下：

(151.96152422706632, 70.0)

原来返回值是一个tuple！但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。

 默认参数

默认值在函数 定义 作用域被解析，如下所示:

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
print f(1)
print f(2)
print f(3)

这将会打印:
[1]
[1]
[1]

关键字参数
函数可以通过 关键字参数 的形式来调用，形如 keyword = value。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

def printinfo( name, age ):
   print "Name: ", name;
   print "Age ", age;
   return;
 
printinfo( age=50, name="miki" );

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

在函数调用中，关键字的参数必须跟随在位置参数的后面。传递的所有关键字参数必须与函数接受的某个参数相匹配（例如 actor 不是 parrot 函数的有效参数），
它们的顺序并不重要。这也包括非可选参数（例如 parrot(voltage=1000) 也是有效的）。任何参数都不可以多次赋值。

可变参数列表

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。

def printinfo( arg1,arg2=20, *vartuple ):

   print "output: "
   print arg1
   print arg2
   print vartuple
   for var in vartuple:
      print var
   return;
 
printinfo( 10 );
printinfo( 70, 60, 50,40 );

结果如下：

output:
10
20
()
output:
70
60
(50, 40)
50
40

关键字参数

关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。请看示例：

def person(name, age, **kw):
    print 'name:', name, 'age:', age, 'other:', kw

person('Michael', 30)
person('Adam', 45, gender='M', job='Engineer')

结果如下：

name: Michael age: 30 other: {}
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

还可以这样调用

kw = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, city=kw['city'], job=kw['job'])
kw = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, **kw)

结果如下：

name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

参数组合
在Python中定义函数，可以用必选参数、默认参数、可变参数和关键字参数，这4种参数都可以一起使用，或者只用其中某些，但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数和关键字参数。
比如定义一个函数，包含上述4种参数：

def func(a, b, c=0, *args, **kw):
    print 'a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw

在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去。

func(1, 2)
func(1, 2, c=3)
func(1, 2, 3, 'a', 'b')
func(1, 2, 3, 'a', 'b', x=99)

结果如下

a = 1 b = 2 c = 0 args = () kw = {}
a = 1 b = 2 c = 3 args = () kw = {}
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}

最神奇的是通过一个tuple和dict，你也可以调用该函数：

args = (1, 2, 3, 4)
kw = {'x': 99}
func(*args, **kw)

结果如下

a = 1 b = 2 c = 3 args = (4,) kw = {'x': 99}