python函数参数理解

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、可变参数

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

  e.g.

1 def my_sum(numbers):
2     result = 0
3     for i in numbers:
4         result += i
5     return result
6 print my_sum(2)

    输出内容:3

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

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

    输出内容:6 , 10

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

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

    输出内容:10

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

4、关键字参数

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

  e.g.

1 def enroll(name, age, **kw):
2     print 'name : %s, age : %d' %(name, age), 'other:', kw
3 
4 enroll('test', 8, city = 'beijing', job = 'work')

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

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

  关键字参数的作用:

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

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

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

5、命名关键字参数

  就是指定关键字名称。

  e.g.

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

    输出内容:test 9 beijing work

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

6、参数组合

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

  e.g.

1 def function(a, b, c = 0, *args, **kw):
2     print 'a:', a, 'b:', b, 'c:', c, 'args:', args, 'kw:', kw
3 
4 function(1,2)
5 function(1,2,c=3)
6 function(1,2,3,'a','b')
7 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传递:

1  args = (1,2,3,4)
2  kw = {'d' : 5, 'e' : 6, 'f' : 7}
3  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,也就是存储位置。

 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存储位置上的数据,变量指向并没有改变,所以实参对象也发生了变化。

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

     本文参照:廖雪峰python

转载于:https://www.cnblogs.com/coolYuan/p/7593527.html

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值