python函数参数理解

1、位置参数

　　函数调用时，参数赋值按照位置顺序依次赋值。

　　e.g. 

def function(x):

3　　return x * x

5 print function(2)

　　　　输出结果： 4

def function(x, n):

　　return x / n

5 print function(4, 2)

　　　　输出结果： 2

2、默认参数

　　在函数定义时，直接指定参数的值。

　　e.g.

def function(x, n = 2):

    s = 1

    while n > 0:

        n = n -1

        s = s * x

    return s

print function(20)

　　　　输出结果：400

　　注意：

　　　　1）必选参数必须在前，默认参数在后。

　　　　2）当函数有多个参数时，把变化大的放在前面。

　　　　　　好处：降低调用函数的难度。

　　　　3）当有多个默认参数时，可以按顺序，也可使用参数名直接赋值。

　　　　　　e.g.

def enroll(name, gender, age = 6, city = 'beijing') :

　　print name

　　print gender

　　print age

　　print city

enroll('aaa', 'F', 7)

　　　　　　　　输出内容：

　　　　　　　　　　aaa

　　　　　　　　　　F

　　　　　　　　　　7

　　　　　　　　　　beijing

enroll('bbb', 'M', 9, city = 'tianjin')

　　　　　　　　输出内容：

　　　　　　　　　　bbb

　　　　　　　　　　M

　　　　　　　　　　9

　　　　　　　　　　tianjin

　　　　4）特别注意

　　　　　　e.g.

def add_end(L = []):

　　L.append('END')

　　return L

add_end([1,2,3,4,5])

　　　　　　　　输出内容：

　　　　　　　　　　[1,2,3,4,5,'END']

　　　　　　当多次调用add_end()时

add_end()

add_end()

　　　　　　　　输出内容：

　　　　　　　　　　['END', 'END']

　　　　　　　　　　这时就要对输入参数进行判断了：

def add_end(L = []):

    if L is None:

        L = []

    L.append('END')

    return L

add_end()

add_end()

　　　　　　　　　　输出内容：

　　　　　　　　　　　　['END']

　　　　5）能设计不变的对象就设计成不变的对象。

3、可变参数

　　传入的参数个数是可变的。可变参数在函数调用时，会自动组装一个tuple。

　　e.g.

def my_sum(numbers):
    result = 0
    for i in numbers:
        result += i
    return result
print my_sum(2)

　　　　输出内容：3

　　在调用my_sum函数时，是可以传入多个参数的，但是要使用list或者tuple

print my_sum([1,2,3])

print my_sum((1,2,3,4))

　　　　输出内容：6 ， 10

　　当函数的参数是一个list或者tuple时：

numbers = [1,2,3,4]
print my_sum(*numbers)

　　　　输出内容：10

　　*numbers表示把numbers这个list中的所有元素作为可变参数传入函数。

4、关键字参数

　　关键字参数可以传入任意个含参数名的参数，在函数调用时，自动组装成dict。

　　e.g.

def enroll(name, age, **kw):
    print 'name : %s, age : %d' %(name, age), 'other:', kw

enroll('test', 8, city = 'beijing', job = 'work')

　　　　输出内容：name : aaa, age : 8 other {'city': 'beijing', 'job': 'work'}

　　enroll函数除了接受必选参数外还可以指定关键字参数kw，形式：'key' = 'value'。

　　关键字参数的作用：

　　　　扩展函数，除了必选内容还要扩展其他内容，如上例中的city=’beijing'。

　　把一个dict转换成参数出入：

extra = {'city' : 'beijing', 'job' : 'work'}
enroll('test', 9, **extra)
# 或者
enroll('test', 9, city = extra['city'], job = extra['job'])

5、命名关键字参数

　　就是指定关键字名称。

　　e.g.

def persion(name, age, *, city, job):
    print name, age, city, job
persion('test', 9, city = 'beijing', job = 'work')

　　　　输出内容：test 9 beijing work

　　*不是参数，是特殊分隔符，*作用是分别位置参数和命名关键字参数。

6、参数组合

　　参数定义顺序：必须参数、默认参数、可变参数、命名关键字参数和关键字参数。

　　e.g.

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

function(1,2)
function(1,2,c=3)
function(1,2,3,'a','b')
function(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 = {'d' : 5, 'e' : 6, 'f' : 7}
 funciton(*args, **kw)

　　　　　输出内容：a: 1 b: 2 c: 3 args: (4,) kw: {'e': 6, 'd': 5, 'f': 7}

　　对于任何函数，无论参数是怎么定义的，都可以通过function(*args, **kw)的形式调用。

　　*args：是可变参数，args接收一个tuple。

　　**kw：是关键字参数，kw接收一个dict。

　　参数传递过程中存在俩个规则：

　　　　1）通过引用将参数复制到局部作用域的对象中，意味着被用来访问的函数参数的变量与提供给函数的对象无关，以为存在一个复制问题，修改局部变量不会修改原始数据。

　　　　2）可以在适当的位置修改可变对象。可变对象主要是list和dict，适当的位置主要是在修改局部对象不会改变list对象或者dict对象的ID，也就是存储位置。

#!/usr/bin/python

def modifier(number, string, list):
    number = 5 
    string = 'GOODBYE'
    list = [1,2,3]
    print 'inside:', number, string, list

num = 10
string = 'goodbye'
list = [4,5,6]
print 'before:', num, string, list

modifier(num, string, list)

print 'after:', num, string, list

　　　　　　输出内容：

　　　　　　　　before: 10 goodbye [4, 5, 6]

　　　　　　　　inside: 5 GOODBYE [1, 2, 3]

　　　　　　　　after: 10 goodbye [4, 5, 6]

　　　　　　从输出结果来看，数据交换前后数据并没有发生改变，虽然在函数局部区域传递进来的参数进行了相应的修改，但是仍然不能改变实参对象的内容。这和C语言十分相似。

　　　　　　因为传递进来的参数在函数内部进行了修改，也就是变量指向了不同的存储区（对象），这就相当于C语言中的实参与形参，只是对形参进行了修改，实参没有改变。

　　　　　　所以说明函数内部对参数重新赋了值，并不会改变实参对象。

#！/usr/bin/python
def modifier(list, dict):
    list[0] = 10
    dict['a'] = 10
    print 'inside: list = %s, dict = %s' %(list, dict)

list = [1,2,3,4,5]
dict = {'a' : 1, 'b' : 2, 'c' : 3}
print 'defore: list = %s, dict = %s' %(list, dict) 

modifier(list, dict)
print 'after: list = %s, dict = %s' %(list, dict)

　　　　　　　　输出结果：

　　　　　　　　　　defore: list = [1, 2, 3, 4, 5], dict = {'a': 1, 'c': 3, 'b': 2}
　　　　　　　　　　inside:, list = [10, 2, 3, 4, 5], dict = {'a': 10, 'c': 3, 'b': 2}
　　　　　　　　　　after: list = [10, 2, 3, 4, 5], dict = {'a': 10, 'c': 3, 'b': 2}

　　　　　　　　从输出结果可以看出，函数内部对传递进来的参数进行了修改，并且对实参对象也进行了修改，实际修改的是list和dict存储位置上的数据，变量指向并没有改变，所以实参对象也发生了变化。

 　　注：文章中所有代码没有验证，如有问题请告知。

　　　　 本文参照：廖雪峰python