函数参数

数据类型

• 不可变数据：Number,String,Tuple(元组)

• 可变数据：List,Dictionary(字典)，Set(集合)

• 不可变类型：变量赋值a=5后在赋值a=10,这里实际是新生成了一个int对象10，再让a指向它，而5被丢弃，不是改变a的值，相当于新生成了a

• 可变类型:变量赋值a=[1,2,3],后在赋值a[2]=5，则是将list a的第三个元素值更改，本身a没有动，只是其内部的一部分值被修改了。

python函数的参数传递:

• 不可变类型：类似c++的值传递，如number,string,tuple。如function(a),传递的只是a的值，没有影响a对象本身。比如在function(a)内部修改a的值，只是修改另一个复制的对象，不会影响a本身。
• 可变类型： 类似c++的引用传递，如list,dict,set。如function(a),则是将a真正传过去，修改后function外部的a也会受影响

python中一切都是对象，严格意义上我们不能说值传递还是引用传递，我们应该说传不可变对象和可变对象。

可变对象：

def chagelist(a):
    a.append(7)
    print(a)

b = [4,5,6]
chagelist(b)    #chagelist(b[:]) 传递副本给函数，目的禁止函数修改列表
[4, 5, 6, 7]
print(b)
[4, 5, 6, 7]

因为传入的是可变对象list，所以在append后，其实是对同一个对象进行了操作。故b为[4, 5, 6, 7]。

不可变对象：

def chagenot(a):
    a='test'
    print(a)

b = 'dm'
chagenot(b)
test

print(b)
dm

传入的是不可变对象string,所在函数内重新赋值的操作是重新复制了对象b后发生的，所以原b字符串没有发生改变。

不可改变的好处：

因为不变对象一旦创建，对象内部的数据结构就不能修改，这样就减少了由于修改数据情导致的错误。此处，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读。在编写程序时，如果可以设计一个不变对象，那主尽量设计成不变对象。

参数：

名称	描述	定义方式
位置参数	函数定义了多少个传入参数，在调用时就需要传入多少个参数	def functionname(args1,args2,...)
默认参数	函数定义了一个或多个拥有默认值的参数，在传入参数时，如未传输，则使用默认值。如传输则覆盖	def functionname(args1,args2=xxx,args3=xxx)
可变参数	函数定义时有单个*在args前，参数以元组方式传入。	def functionname([formal_args,] *var_args_tuple ):
关键字参数	函数定义时有两个**在args前，参数以字典方式传入。	def functionname([formal_args,] **var_args_dict ):
命名关键字参数	对关键字进行命名，传入时必须按函义的key传入值，*,args	#def functionname([formal_args,] *, [formal_args]):
组合参数	上述五种参数的组合定义方式	def functionname(args1,args=xx,*args3,**args4) #可变参数不能与命名关键字参数一起定义

一、位置参数、默认参数

定义一个阶乘函数，x是位置参数。n是默认参数，如果不传n，则默认为2

def power(x,n=2):
    s = 1
    while n > 0:
        n -= 1
        s = s * x
    return s

power(2)
4
power(2,3)
8

位置(必选)参数在前，默认参数在后。这样才能保证传参不会违背正常逻辑
当函数有多个参数时，把变化大参数放在前面，变化小的放在后面。这样变化小的就可以设置成默认参数

当有多个默认值的时候，可以自定义传入参数，而非全部按照顺序填入

power(5,n=3)
125

二、可变参数：

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

def calc(numbers):
    sum = 0
    for x in numbers:
        sum = sum + x * x
    return sum

calc((1,2,3))
14
calc([1,2,3])
14
calc(1,2,3)
TypeError: calc() takes 1 positional argument but 3 were given   #函数定义时，就只是一个变量，所以不能将数据单独的发送给函数，而是需要将数据封装成list,tuple,set数据类型后成为一个变量，这样就可以发送给函数。

def calc(*numbers):    #这里在numbre前加一个‘*’
    sum = 0
    for x in numbers:
        sum = sum + x * x
    return sum

calc(1,2,3)
14

定义一个可变参数，仅仅在参数前加一个*号

num=[1,2,3]
calc(num[0])
1

calc(*num)  #在list，tuple变量前加上'*'号，就把其中元素变成可变参数传进去。
14

*num表示把num这个list的所有元素作为可变参数传进去。

三、关键字参数

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

def person(name,age,**other):      #除了必须的name,age参数，还接受关键字参数other
    print('name:',name,'age:',age,'other:',other)

person('dm',18)
name: dm age: 18 other: {}

person('dm',18,city='nanjing')
name: dm age: 18 other: {'city': 'nanjing'}

关键字参数可以扩展函数的功能，比如在注册时，除了用户名和年龄是必填项外，其他都是可选项，如果用户愿意提供更多的参数，我们也能收到。

extra = {'city': 'Beijing', 'job': 'Engineer'}
person('dm',18,**extra)
name: dm age: 18 other: {'job': 'Engineer', 'city': 'Beijing'}

**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的other参数，other将获得一个dict，注意other获得的dict是extra的一份拷贝，对other的改动不会影响到函数外的extra。

四、命名关键字参数

只允许传入函数定义的参数

def changdict(name,*,age=18,city):
    print(name,age,city)

a={'name':'dm','age':19,'city':'nanjing'}     #所有特定的参数都给值
changdict(**a)
dm 19 nanjing

a={'name':'dm','age':19}    #少提供特定city的值，报错
changdict(**a)
TypeError: changdict() missing 1 required keyword-only argument: 'city'

a={'name':'dm','city':'nanjing'}    #默认age参数没有提供
changdict(**a)
dm 18 nanjing

changdict(name='dm',city='nanjing',school='caijing')    #多插入参数，报未识别
TypeError: changdict() got an unexpected keyword argument 'school'

五、组合参数：

组合参数就是对上述五种参数的组合使用。
参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数、关键字参数

def f1(a,b,c=0,*args,**kw):
    print(a,b,c,args,kw)
def f2(a,b,c=0,*,d,**kw):
    print(a,b,c,d,kw)    

f1(1,2)    #args和kw为空
1 2 0 () {}

f1(1,2,3,'a','b')  #dict为空
1 2 3 ('a', 'b') {}

f1(1,2,3,'a','b',d='e') 
1 2 3 ('a', 'b') {'d': 'e'}

f1(1,2,d=4,e='f')   #tuple为空
1 2 0 () {'e': 'f', 'd': 4}

f2(1,2,d=4,e='f')    #对应f2函数中的参数
1 2 0 4 {'e': 'f'}

对于函数，可以通过类似func(*args,**kw)的形式调用它，无论它的参数是如何定义的。

args=[1,2,3,4]
kw={'x':'y','i':'o'}
f1(*args,**kw)      
1 2 3 (4,) {'i': 'o', 'x': 'y'}

args=(1,2,3)
kw={'x':'y','i':'o'}
f1(*args,**kw)
1 2 3 () {'i': 'o', 'x': 'y'}

args=(1,2,3)
kw={'d':'y','i':'o'} 
f2(*args,**kw)
1 2 3 y {'i': 'o'}

疑问：

正确的定义参数：

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

def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

def com1(a,b,c=1,*e,**d):
    print(a,b,c,d,e,f)

错误的定义参数:

def f3(a,b,c=1,*e,*,d):   
    print(a,b,c,d,e,f)
SyntaxError: invalid syntax

可变参数为什么不能和命名关键字一起使用,哪位大神知道为什么，请一定告知！

本章学习内容，参考：廖雪峰老师的python课程