一、函数简介

    函数也是一个对象（对象是内存中专门用来存储数据的一块区域）。函数可以用来保存一些可执行的代码,并且可以在需要时,对这些语句进行多次的调用。

创建函数：

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

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

    函数中保存的代码不会立即执行，需要调用函数代码才会执行。定义函数一般都是要实现某种功能的。   

调用函数：

        函数对象()

例1：

# 定义一个函数
def fn() :
    print('这是我的第一个函数！')
    print('hello')
    print('今天天气真不错！')

# 打印fn
print(fn) <function fn at 0x03D2B618>
print(type(fn)) <class 'function'>

其中，fn是函数对象  fn()调用函数；

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

例2：

# 定义函数时指定形参
def fn2(a , b) :
    # print('a =',a)
    # print('b =',b)
    print(a,"+",b,"=",a + b)

# 调用函数时，来传递实参
fn2(10,20)
fn2(123,456)

二、函数的参数

    在定义函数时，可以在函数名后的()中定义数量不等的形参， 多个形参之间使用 , 隔开。

1、形参（形式参数）：定义形参就相当于在函数内部声明了变量，但是并不赋值。

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

2、实参（实际参数）
      如果函数定义时，指定了形参，那么在调用函数时也必须传递实参，实参将会赋值给对应的形参，简单来说，有几个形参就得传几个实参。

# 定义一个函数
# 定义形参时，可以为形参指定默认值
# 指定了默认值以后，如果用户传递了参数则默认值没有任何作用
#   如果用户没有传递，则默认值就会生效
def fn(a = 5 , b = 10 , c = 20):
    print('a =',a)
    print('b =',b)
    print('c =',c)

（1）实参的传递方式： 

  ① 位置参数：就是将对应位置的实参复制给对应位置的形参。

  第一个实参赋值给第一个形参，第二个实参赋值给第二个形参......

fn(1 , 2 , 3)

  ② 关键字参数：可以不按照形参定义的顺序去传递，而直接根据参数名去传递参数

fn(b=1 , c=2 , a=3)
print('hello' , end='') # 自动换行

注意：位置参数和关键字参数可以混合使用。混合使用关键字和位置参数时，必须将位置参数写到前面。

fn(1,c=30) # 1赋值给a

例1：

     函数在调用时，解析器不会检查实参的类型。也就是说，实参可以传递任意类型的对象。

def fn2(a):
    print('a =',a)

# 函数在调用时，解析器不会检查实参的类型
# 实参可以传递任意类型的对象
b = 123
b = True
b = 'hello'
b = None
b = [1,2,3]
fn2(b)
fn2(fn)  # 这里函数传递的参数可以是fn()函数，这时a = <function fn at 0x000001DAA86FA170>

 例2：

def fn4(a):
    # 在函数中对形参进行重新赋值，不会影响其他的变量
    # a = 20
    # a是一个列表，尝试修改列表中的元素
    a[0] = 30
    print('a =',a,id(a))

c = 10   
c = [1,2,3] 

# fn4(c)
# fn4(c.copy()) # 浅复制，这里传递的是c对应列表的副本
# fn4(c[:]) # 切片，从头到尾的把值留下

# print('c =',c,id(c))

注意：

 ① 在函数中对形参进行重新赋值，不会影响其他的变量，所以c还是10。

 ② 如果形参执行的是一个对象，当我们通过形参去修改对象时，会影响到所有指向该对象的变量。

3、不定长参数

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

 ① *a 会接受所有的位置实参，并且会将这些实参统一保存到一个元组中（装包）

def fn(*a):
    print("a =",a,type(a))

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

def fn2(a,b,*c):
    print('a =',a)
    print('b =',b)
    print('c =',c)
fn2(1,2,3,4,5)

  第一个参数给a，第二个参数给b，剩下的都保存到c的元组中。

 ③ 可变参数不是必须写在最后，但是注意，带*的参数后的所有参数，必须以关键字参数的形式传递。

def fn2(a,*b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)
fn2(1,2,3,4,c=5)

  第一个参数给a，剩下的位置参数给b的元组，c必须使用关键字参数

 ④ 所有的位置参数都给a，b和c必须使用关键字参数。

def fn2(*a,b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)
fn2(1,2,3,b=4,c=5)

 ⑤ 如果在形参的开头直接写一个*,则要求我们的所有的参数必须以关键字参数的形式传递。

def fn2(*,a,b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)
fn2(a=3,b=4,c=5)

 ⑥ *形参只能接收位置参数，而不能接收关键字参数。

def fn3(*a) :
     print('a =',a)
fn3(b=1,d=2,c=3) # 会报错

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

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

def fn3(b,c,**a) :
    print('a =',a,type(a))
    print('b =',b)
    print('c =',c)

fn3(b=1,d=2,c=3,e=10,f=20)

（3）参数的解包（拆包）

   ① 传递实参时，也可以在序列类型的参数前添加 * ，这样他会自动将序列中的元素依次作为参数传递。这里要求序列中元素的个数必须和形参的个数的一致。

def fn4(a,b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)

# 创建一个元组
t = (10,20,30)

fn4(*t)

② 通过 ** 来对一个字典进行解包操作。

# 创建一个字典
d = {'a':100,'b':200,'c':300}
# 通过 **来对一个字典进行解包操作
fn4(**d)