day9_7.9 函数的定义

一。基础

　　1.什么是函数？

　　函数就是工具，方便开发人员开发软件，非常简洁的工具。

　　函数的关键字是def

　　在函数的编写阶段，只检验其语法是否正确，不检验代码。

　　在函数的调用阶段，可以通过函数名+（）来调用函数，执行代码，其中括号的优先级很高，只要有（）的地方就会先执行函数。

　　函数名的定义规范和变量名的定义一样。

　　函数所要遵循的准则是需要先定义后调用。

　　2.为什么要用函数

　　1.提高开发效率

　　2.减少代码冗余

　　3.提高程序的扩展性

　　函数分为内置函数和自定义函数，内置函数就是程序提前写好的函数，可以直接拿来调用。

二。返回值

　　在函数的编写中，，所有函数都有返回值，其值取决与你函数所return的值，分为以下几种情况：

　　1.不写返回值

　　如果函数不写返回值会默认返回None：

def test01():
    a=1
    b=1
    c=2
    d=3
print(test01())
#输出结果>>>None

　　2.只写return

　　只写return的情况下也会返回None

def test01():
    a=1
    b=1
    c=2
    d=3
    return
print(test01())
#输出结果>>>None

　　3.返回值为None

def test01():
    a=1
    b=1
    c=2
    d=3
    return None
print(test01())
#输出结果>>>None

　　4.返回值返回一个值。

def test01():
    a=1
    b=1
    c=2
    d=3
    return a
print(test01())
#输出结果>>>1

　　返回一个值是，返回的是什么就是什么。

　　5.返回多个值

　　在函数中，如果返回了多个值，会以元组的形式返回该值。

def test01():
    a=1
    b=1
    c=2
    d=3
    return a,b,c,d
print(test01(),type(test01()))
#输出结果>>>(1, 1, 2, 3) <class 'tuple'>

　　当然，如果需需要返回的值的类型进行转变，就直接在返回的值中定义该数据类型

def test01():
    a=1
    b=1
    c=2
    d=3
    return [a,b,c,d]
print(test01(),type(test01()))
#输出结果>>>[1, 1, 2, 3] <class 'list'>

　　返回的数据类型为元组的原因是因为元组的不可变性。可以保证函数的结果不可改变。

　　在函数的应用中，所有的函数都有返回值，无论你是写或不写，而当函数遇到return语句时会立即跳出函数，所以，有时候写return是为了终止语句。

三。函数的参数。

　　函数参数的两大类型有

　　1.形参。

　　2.实参。

　　形参是在函数的定义阶段，括号内写的变量名，叫做该函数的形式参数简称形参。

　　而实参是在函数的调用阶段，括号的实际传入值，叫做实际参数，简称实参。

　　形参相当于变量名，实参相当于变量的值，函数调用传参的过程就是形参变量名赋值的过程。

　　注意：形参与实参的关系只在函数的调用阶段有效，函数运行结束关系自动解除，而且只在函数内部有效，函数外部无任何影响。

　　在定义函数时通常使用以下形式定义

def 函数名(形参1，形参2，形参3......):
    代码1
    代码2
    ......
    return 返回值

　　在大型函数里，需要对函数的作用，函数的形参和返回值进行说明与讲解。

def test01(a,b):
    """

    :param a: 形参a的作用
    :param b: 形参b的作用
    :return: 函数的返回值
    """
    a=1
    b=1
    c=2
    d=3
    return [a,b,c,d]

　　如果需要知道该函数的注释，可以使用help（test01）的方式获得。

test01(a, b)
    :param a: 形参a的作用
    :param b: 形参b的作用
    :return: 函数的返回值

四。位置参数

　　在函数的定义阶段，按照位置从左往右依次书写的变量名，叫做函数位置的形参。

　　在调用的时候，必须给每个位置参数赋值

　　传参的方式有第一种，一一传递，对应传参，

　　第二种时指名道姓的传参，也叫关键字传参。

my_fun(1,2)
my_fun2(y=10,x=20)

　　也有两种方法的综合，混合使用

my_fun3(10,y=20)

　　在函数的定义阶段，形参的变量名可以指定赋值，这样函数中该值就已经是被定义的值，这种参数被称为默认值参数。

　　默认值参数的使用规则有：

　　可以不为默认值参数传参，在参数的使用中就使用默认值。　　

　　在调用的时候，如果给我默认值参数传递参数，那么就是用传递的参数值。

　　默认值参数通常使用在需要单一的传递相同的值时，比如：

def text01(name,age,gender='male'):
    print(name,age,gender)
text01('lzx',18)
text01('yzy',18)
text01('zzp',18)
text01('zzj',18)
text01('sxc',18,'female')
#输出结果>>>lzx 18 male
yzy 18 male
zzp 18 male
zzj 18 male
sxc 18 female

例题：

def info(username,hobby,l=[]):
    if l == None:
        l = []
    l.append(hobby)
    print('%s 的爱好是 %s'%(username,l))
info('lzx','study')
info('zzp','zzz')
info('zzj','jjjj')
info('sxc','ddd')
#输出结果>>>lzx 的爱好是 ['study']
#zzp 的爱好是 ['study', 'zzz']
#zzj 的爱好是 ['study', 'zzz', 'jjjj']
#sxc 的爱好是 ['study', 'zzz', 'jjjj', 'ddd']

五。可变长参数

　　站在调用函数传递实参的角度，实参的个数不固定的情况也就意味着形参的不稳定，如何表达一个不稳定长度的形参呢。

　　所以，站在形参的角度，可以用*和**来接受多余的（溢出的）位置参数和关键字参数。

　　在形参的角度看*符号，是可以接受多余的参数，打包成元组形式：

def func(x,y,*z):
    print(x,y,z)
func(1,2,3,4,5,6,7,8,54,43,4,5,6,6,7,8,)
#输出结果>>>1 2 (3, 4, 5, 6, 7, 8, 54, 43, 4, 5, 6, 6, 7, 8)

　　在实参的角度看*符号

　　*符号可以在函数调用时用来给一个列表中的值赋值给函数的参数：

def func(x,y,z):
    print(x,y,z)
tuple1=(1,2,3)
func(*tuple1)
#输出结果>>>1 2 3

　　注意，传入的列表长度不能超过或少于函数的形参个数。

　　*字符适用于列表，元组，集合，字符串，相当于一个for循环。

　　在形参中*只能接受多余的位置参数，不能接关键字参数，所以要想接受关键字参数，需要使用**符号。

　　在形参的角度看**

　　在形参的定义中，定义**形参可以将函数调用时传入的多余的关键字参数，转换成字典的类型，参数名字就是key值，参数的默认值就是value值。

def func(x,y,**z):
    print(x,y,z)  # z = {'z': 1, 'a': 1, 'b': 2, 'c': 3}
func(x=1,y=2,z=1,a=1,b=2,c=3)
#输出结果>>>1 2 {'z': 1, 'a': 1, 'b': 2, 'c': 3}

　　在实参的角度看**

　　在函数的调用阶段，可以使用**调用字典给函数形参，相当于关键字传参：

def func(x,y,z):
    print(x,y,z)
# func(12,3,4)
# func(x=1,y=2,z=3)
d = {'x':1,'y':2,'z':333}
func(x=1,y=2,z=3)
func(**d)  # 等价于func(x=1,y=2,z=333)
#输出结果>>>1 2 3
#1 2 333

　　python推荐的形参*和实参**的写法

def func2(*args,**kwargs):