1. 函数简介

函数也是一个对象

函数用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次调用

语法def函数名([形参1,形参2,形参3....]):代码块

注意：

函数名必须符合标识符的规范(可以包含字母、数字、下划线但是不能以数字开头)

print是函数对象  print()是调用函数

2. 函数的参数

2.1 形参和实参

形参(形式参数) 定义形参就相当于在函数内部声明了变量，但是并不是赋值

实参(实际参数)指定了形参，那么在调用函数时必须传递实参，实参将会赋值给对应的形参，简单来说有几个形参就要有几个实参

2.2 函数的传递方式

定义形参时,可以为形参指定默认值。指定了默认值以后，如果用户传递了参数则默认值不会生效。如果用户没有传递，则默认值就会生效

位置参数：位置参数就是将对应位置的实参赋值给对应位置的形参

关键字参数 : 关键字参数可以不按照形参定义的顺序去传递，而根据参数名进行传递

混合使用位置参数和关键字参数的时候必须将         位置参数写到默认参数前面去

fn(a,b=1,c)报错

fn(a,b,c)  abc被认为是位置参数，有顺序，也可以给abc赋予初始值，这样就是默认参数

，形参里默认参数也要放在最后面，

比如

在传入实参的时候，fn（a=29，b=33，c=34）时  如果实参有值那就是关键字参数，关键字参数要放最后面。可以多个用，但是假如说

第一个位置对应的a 已经给了一个值，那么后面关键字参数不可以给把a给一个值进去。只能bc开始定义值。fn(23,b=33,c=23,)就可以  但是fn（23，a=33，b=23）就不行，为什么呢因为23已经位置给a，就有了argument  那么你后面不能再给a关键字实参

说来说去就是 形参和实参里 有等于号的一定是从后往前开始填，不能出现  非关键字实参或者默认值形参在后面掺杂，   而且当你实参前几个abc已经定位，后面的关键字实参不可以有歧义重复，而且全部都要一一对应，数量

带默认值参数必须在不带默认值参数之后,否则会报错SyntaxError      a,b=10  

#位置参数可以和关键字参数一起使用               a **

#当位置可变参数和关键字可变参数一起使用时候，可变位置参数必须在前                *   **

#普通参数可以和可变参数一起使用，但是传参的时候必须匹配      deffn(x,y,*args,**kwargs):

#默认参数可以在可变位置参数之前       def fn(x=5,*args):                            **一定在最后

位置可变参数可以在普通参数之前，但是在位置可变参数之后的普通参数变成可keyword-only 参数       *a，b=4，c=5    b后面的只能关键字

def fn2(a,b,d,*args,f=3,**kwargs,):

print (a,b,d,f,args,kwargs)

fn2(44,232,1,z=33,x=55,f=3,zx=222)

分析运行结果不难看出，在执行值传递时，改变形式参数的值，实际参数并不会发生改变；而在进行引用传递时，改变形式参数的值，实际参数也会发生同样的改变。

那么这是为什么呢？

######因为变量a=1 和a=【1】是不同的，整形元祖字符串是不可变对象，给到变量的时候，这个变量a可以完全代表他，a在函数就是a，他们都是1 ，python里 abcdefg只要你给到1，他就是1，他们都是一个东西啦，函数里函数外都是1，都是那个1啊亲，所有的函数里的abcde，函数外的defhjkl只要他是1，那就是1的多个名字而已，当你放在函数里给1做运算，那函数里的1就被运算掉了，可是外面的毫无波澜，但是可变对象不同，可变对象哪怕你2个一样的列表给到了a，b变量，在内存里都是2个东西，那么所以问题就来了，当你函数里对列表做运算，那么这个列表就会影响到函数外，

换句话说  函数里面传递过来的是列表这种可变的，那我函数里直接可以调用到这个列表的原始对象，来进行操作，因为你本来就是可变对象，我就用你原始内存地址里修改了，怎么了？       如果是传递过来一个整形一个字符串一个元祖这样的不可变类型，那我函数其实是在里面复制了一个副本，进行了操作，那么外面里面就不大噶了。

函数参数传递机制，传值和引用的是什么意思？

函数参数传递机制问题在本质上是调用函数（过程）和被调用函数（过程）在调用发生时进行通信的方法问题。基本的参数传递机制有两种：值传递和引用传递。

值传递（passl-by-value）过程中，被调函数的形式参数作为被调函数的局部变量处理，即在堆栈中开辟了内存空间来存放由主调函数放进来的实参的值，从而想成为了实参的一个副本。值传递的特点是被调函数对形势参数的任何操作都是作为局部变量进行，不会影响主调函数的实参变量的值。

引用传递（pass-by-reference）过程中，被调函数的形式参数虽然也作为局部变量在堆栈中开辟了内存空间，但这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址，即通过堆栈中存放的地址访问主调函数中的实参变量。正因为如此，被调函数对形参做任何的操作都影响了主调函数中的实参变量。

在python中，可以有多个引用同时指向一个内存。

python不允许程序员选择采用传值还是传引用。python参数传递采用的肯定是“传对象引用”的方式。这种方式相当于传值和传引用的一种综合。如果函数收到的是一个可变对象（字典、列表）的引用，就能修改对象的原始值--相当于‘传引用’来传递对象。如果函数收到的是一个不可变对象（数字、字符或元组）的引用，就不能直接修改原始对象--相当于通过‘值传递’来传递对象。

http://c.biancheng.net/view/2258.html

目前网络上大部分博客的结论都是这样的：

Python不允许程序员选择采用传值还是传 引用。Python参数传递采用的肯定是“传对象引用”的方式。实际上，这种方式相当于传值和传引用的一种综合。如果函数收到的是一个可变对象（比如字典 或者列表）的引用，就能修改对象的原始值——相当于通过“传引用”来传递对象。如果函数收到的是一个不可变对象（比如数字、字符或者元组）的引用，就不能 直接修改原始对象——相当于通过“传值”来传递对象。

你可以在很多讨论该问题的博客里找到以上这一段话。

但是在实际操作中我却发现一个问题：

l=[1,2,3]

defa(x):

  x=x+[4]

a(l)

print(l)

这段代码的输出为：

1[1,2,3]

为什么是这样呢，list是可变对象，按照上面的结论来说传递方式是引用传递，我应该在函数里能对它进行修改呀？难道不应该输出[1,2,3,4]吗？

我觉得我上面引用的那段大多数博主的结论，其实非常不好理解，而且没有讲到本质，看的云里雾里的。

经过我后面的多次试验，得到以下结论：

其实在python中讨论值传递还是引用传递是没有意义的，要真正对这些情况作出解释，其实是应该搞明白python(对可变对象和不可变对象的)赋值过程中是如何分配内存地址的。

接下来，我们不讨论值传递和引用传递的问题。

让我们做一个非常简单的小实验，其中，id()可以查看变量在内存中的地址：

l1=[1,2,3]

l2=[1,2,3]

a=1

b=1

print(id(l1))

print(id(l2))

print(id(a))

print(id(b))

在我的电脑中的运行结果：

12856594504

12856915080

1643643344

1643643344

可以发现，对于可变对象list来说，即便列表内容一模一样，python也会给它们分配新的不同的地址。

然而，对于不可变对象int来说，内存里只有一个1。即便再定义一个变量c=1，也是指向内存中同一个1。换句话说，不可变对象1的地址是共享的。

接下来让我们看看在函数中调用可变对象和不可变对象，并修改他们的值，会是一个什么情况。

对于不可变对象int，我们来看看最简单的情况：

a=1

print(id(a))

defx(a):

  print(id(a))

  b=a

  print(id(b))

x(a)

运行得到：

1643643344

1643643344

1643643344

这看起来就是一个引用传递，函数外的a、函数里的a和b都指向了同一个地址。

但我们再来看一个极端情况：

a=1

print(id(a))

defx():

  b=1

  print(id(b))

x()

运行得到：

1643643344

1643643344

很神奇不是吗？函数外定义的a和函数内定义的b没有任何关系，但它们指向同一个地址！

所以你说如何判断它是值传递还是引用传递？讨论这个问题根本没有意义，因为内存里只有一个1。当我把值1传递给函数里的某一个变量的时候，我实际上也传递了地址，因为内存里只有一个1。

甚至于说我直接给函数里的b赋值1都可以让函数外的a和函数内的b指向同一个地址。

下面来看看传递可变对象list的情况：

l=[1,2,3]

print(id(l))

defa(x):

  print(id(x))

  x.pop()

  print(x)

  print(id(x))

  x=x+[3]

  print(x)

  print(id(x))

a(l)

运行得到

1

2

3

883142451528

[1, 2]

[1, 2, 3]

可以看到，当我们把函数外的列表L传递给函数后，x的地址和L是一样的，这看起来就是一个引用传递，没问题。

继续往下，我们调用x本身的方法pop后，x变成[1,2]，并且x的地址没变，这也没什么问题。

但是当我们给x赋值以后，x的地址就变了。

也就是说，只要创建一个新的可变对象，python就会分配一个新的地址。就算我们创建的新可变对象和已存在的旧可变对象完全一样，python依旧会分配一个新的地址（见本文上半部分那个‘非常简单的小实验'）

而pop并不是创建新的可变对象，pop是对已有的可变对象进行修改。

所以可以总结为：

在python中，不可变对象是共享的，创建可变对象永远是分配新地址

这个时候我们再回过头来思考值传递和引用传递的问题，就会发现在python里讨论这个确实是没有意义。

我们可以说：python有着自己的一套特殊的传参方式，这是由python动态语言的性质所决定的

https://blog.csdn.net/Solo95/article/details/78760453

3. 不定长参数

定义函数时，可以在形参前面加一个*,这样这个形参可以获取到所有的实参，它会将所有的实参保存到一个元组中

带*号的形参只能有一个，可以和其他参数配合使用

*形参只能接受位置参数，不能接受关键字参数,换句话说关键字要**

*后面所有参数都要以默认值形式放入 ，或者**

**形参可以接收其他的关键字参数,它会将这些参数统一保存到字典当中。字典的key就是参数的名字,字典的value就是参数的值

**形参只有一个，并且必须写在所有参数的后面

def fn2(a,b,d,*args,**kwargs,):

print (a,b,d,args,kwargs)

fn2(44,232,1,2,4,5,6,f=22,)

4. 参数的解包

传递实参时，也可以在序列类型的参数前添加星号，这样它会自动的将序列中元素依次作为参数传递

要求序列中的元素的个数必须和形参的个数一致

def    函数名（ 形参，可以给形参设定默认值）：

                                            函数体，可以放pass

                                            return  可以不放return（好像默认是none）

实参必须与形参数量一一对应，位置参数，也可以放入关键字形参，但是关键字实参和形参必须放在最后，