1、位置参数
函数调用时，参数赋值按照位置顺序依次赋值。
e.g.
1 def function(x): 2 3 return x * x 4 5 print function(2)
输出结果： 4
1 def function(x, n): 2 3 return x / n 4 5 print function(4, 2)
输出结果： 2
2、默认参数
在函数定义时，直接指定参数的值。
e.g.
1 def function(x, n = 2): 2 3 s = 1 4 5 while n > 0: 6 7 n = n -1 8 9 s = s * x 10 11 return s 12 13 print function(20)
输出结果：400
注意：
1、必选参数必须在前，默认参数在后。
2、当函数有多个参数时，把变化大的放在前面。
好处：降低调用函数的难度。
3、当有多个默认参数时，可以按顺序，也可使用参数名直接赋值。
e.g.
1 def enroll(name, gender, age = 6, city = ‘beijing‘) : 2 3 print name 4 5 print gender 6 7 print age 8 9 print city 10 11 enroll(‘aaa‘, ‘F‘, 7)
输出内容：
aaa
F
7
beijing
1 enroll(‘bbb‘, ‘M‘, 9, city = ‘tianjin‘)
输出内容：
bbb
M
9
tianjin
4、特别注意
e.g.
1 def add_end(L = []): 2 3 L.append(‘END‘) 4 5 return L 6 7 add_end([1,2,3,4,5])
输出内容：
[1,2,3,4,5,‘END‘]
当多次调用add_end()时
1 add_end() 2 3 add_end()
输出内容：
[‘END‘, ‘END‘]
这时就要对输入参数进行判断了：
1 def add_end(L = []): 2 3 if L is None: 4 5 L = [] 6 7 L.append(‘END‘) 8 9 return L 10 11 add_end() 12 13 add_end()
输出内容：
[‘END‘]
5、能设计不变的对象就设计成不变的对象。
3、可变参数
传入的参数个数是可变的。
4、关键字参数
5、命名关键字参数
6、参数组合
总结：
参数传递过程中存在俩个规则：
1、通过引用将参数复制到局部作用域的对象中，意味着被用来访问的函数参数的变量与提供给函数的对象无关，以为存在一个复制问题，修改局部变量不会修改原始数据。
2、可以在适当的位置修改可变对象。可变对象主要是list和dict，适当的位置主要是在修改局部对象不会改变list对象或者dict对象的ID，也就是存储位置。
1 #!/usr/bin/python 2 3 def modifier(number, string, list): 4 number = 5 5 string = ‘GOODBYE‘ 6 list = [1,2,3] 7 print ‘inside:‘, number, string, list 8 9 num = 10 10 string = ‘goodbye‘ 11 list = [4,5,6] 12 print ‘before:‘, num, string, list 13 14 modifier(num, string, list) 15 16 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语言中的实参与形参，只是对形参进行了修改，实参没有改变。
所以说明函数内部对参数重新赋了值，并不会改变实参对象。
1 #！/usr/bin/python
2 def modifier(list, dict):
3 list[0] = 10
4 dict[‘a‘] = 10
5 print ‘inside: list = %s, dict = %s‘ %(list, dict)
6
7 list = [1,2,3,4,5]
8 dict = {‘a‘ : 1, ‘b‘ : 2, ‘c‘ : 3}
9 print ‘defore: list = %s, dict = %s‘ %(list, dict)
10
11 modifier(list, dict)
12 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存储位置上的数据，变量指向并没有改变，所以实参对象也发生了变化。