从0.1开始学Python——[11]

现在开始学函数，程序里面的主角了属于是，最常用的东西，当然，函数也是 对象。

函数是什么

本质上讲，如上所说，是一种对象。但是函数除了存储数据之外，还有一个非常方便的地方，它可以保存一些可执行的代码，同时在需要的时候，多次使用这些代码，这就是函数最大的价值。函数有效避免了重复写多行代码还需要一处一处改的麻烦情况，让程序的修改和维护大大简化。注意，函数中的代码不会立即执行，只有调用函数才执行。语法如下：
def 函数名（[形参1，形,2，形参3，…形参n]）：
（缩进）代码块

def yf():
    print('我的第一个函数')

print(yf)
print(type(yf))

<function yf at 0x000001C61FBE6B88>
<class 'function'>

调用的方式：

yf()

我的第一个函数

注意，yf是函数对象，但是yf()是调用对象，区别就是执行不执行。不过上述函数没有实际功能。

定义有功能的函数

首先，函数的名字和标识符的命名原则基本一致。有用的函数一般需要用到参数，因为输入不同值的参数返回不同的结果才能让函数实现灵活的功能。所以函数应该设置需要的形参，以及使用到这些参数的表达式。形参就相当于是函数里面表达式要用的变量，但是没赋值，只有调用函数时打出具体形参数值的时候，也就是传输相应数量的实参时，才相当于赋值变量了。

def jiafa(a, b):  # 定义函数时设定形参
    print(a+b)

jiafa(456, 111)  # 传递实参的过程

567

关于参数

形参可以设置默认值，默认值只在没有输入该形参对应的实参时生效。

def chengfa(a, b, c = 2):
    print(a*b*c)
chengfa(2,3,4)
chengfa(2,3)

24
12

上述参数都是根据位置定位输入的实参是函数里面哪一个形参的，这种叫位置参数。除了这种之外还有一种参数直接根据参数名传递参数，称为关键字参数。

def shuchu(a,b,c):
    print(a)
    print(b)
    print(c)
shuchu(b = 1, c = 5, a = 9)

9
1
5

两种参数可以混合使用，但是只能位置参数在前，关键字参数在后，而且不可以用两种参数同时传递一个参数，就算传递实参值一样也会报错。例如：

def shuchu(a,b,c):
    print(a)
    print(b)
    print(c)
shuchu(1,2,3, a = 1)

尽管位置参数和关键字参数都输入a的实参为1，可还是会报错。
形参和函数外变量无关，可以重名，不是一个东西。

def shuchu(a,b,c):
    print(a)
    print(b)
    print(c)
a = 1
b = 2
c = 3
shuchu(a, b, c)

1
2
3

而且输入的实参可以是任意类型的对象，数值、字符串、布尔值、序列、函数对象都行。只不过有可能因为函数内涉及的语法等原因无法运行。在函数内部对形参重新赋值不会影响其他变量。但要注意，像列表这样的可以改对象而可以不改变量的变量，如果函数内进行改对象操作，则有可能同时影响函数外和形参同样指向一个对象的东西。

def shuchu(a,b,c):
    a[1] = 11  # 改对象不改变量,此时a对应的实参和a指向同一个对象
    print(a)
    print(b)
    print(c)
s = [1, 2]
b = 2
c = 3
shuchu(s, b, c)

[1, 11]
2
3

如果用某对象浅复制的副本，就不会有这种影响了，因为浅复制的副本是一个新对象。或者用[:]切片，切出来也是整个列表的副本。

不定长的参数

为了解决形参实参数量不对应的情况，要用到不定长参数，方法：在形参前面加一个*，这样它就能获取到所有实参，并把所有实参保存到一个元组里面。

def jiafa(*a):
    s = 0
    for i in a:
        s += i
    print(s)

jiafa(456, 111,222)

789

带星的参数可以和其他参数一起用，和元组的时候同理，也是只能有一个带星的。

def shuchu(a,b,*c):

    print(a)
    print(b)
    print(c)

shuchu(1, 2, 3, 4, 5)

1
2
(3, 4, 5)

注意，如果带星的参数没在最后，那它后面的参数都必须以关键字参数的形式输入，而且这个时候关键字参数位置必须和形参对应，但是带星号的参数自己的实参只接受位置参数。

def shuchu(*a,b,c):

    print(a)
    print(b)
    print(c)

shuchu(1, 2, 3, b = 4, c = 5)

(1, 2, 3)
4
5

上述例子，b和c就不能调换位置，否则仍会报错。
如果在形参前面单独加一个*，那就得所有实参都用关键字参数传递。

def shuchu(*, a, b, c):

    print(a)
    print(b)
    print(c)

shuchu(a = 2, b = 5, c = 7)

2
5
7

但是两个星号的，两个星号的形参可以接收关键字参数，而且关键字变量可以不和形参变量相同，所有关键字参数会被保存进字典里面，键是参数名，值是参数实参值。

def shuchu(**a):
    print(a)
    
shuchu(s = 2, b = 5, c = 7)

{'s': 2, 'b': 5, 'c': 7}

这种形参只负责没有对应形参的实参，而且只能放在形参的最后，其他有形参的关键字参数位置不受约束。

def shuchu(a, b, **c):
    print(a)
    print(b)
    print(c)
    
shuchu(s=2, b=5, a=7, n=11)

7
5
{'s': 2, 'n': 11}

参数解构

或叫解包，就是参数拆开然后输入函数。具体操作是在序列类型的实参前面加星号，这样将会自动将序列中的元素依次作为参数传递。

def shuchu(a,b,c):
    print(a)
    print(b)
    print(c)

f = (11, 23, 66)
shuchu(*f)

11
23
66

字典也能解构，用两个星号。

f = {'a':11,'b':23,'c':66}
shuchu(**f)

11
23
66