Python函数初识

函数

一、函数的基本使用

• 1.函数是什么？

    在程序中，函数是具备某一功能的工具，我们在准备工具的阶段就叫函数的定义，应用场景即为函数的调用，所以务必记住函数的使用必须遵循先定义后调用的原则。

• 2.为什么要使用函数？

    不使用函数会使得我们的程序冗长，扩展性差，可读性也差。

• 3.如何使用函数？

    函数的使用始终遵循先定义后调用的原则。

在python中，我们一般如下定义某个函数：

def  函数名(参数1,  参数2):

        '''

        函数功能描述信息

        :param  参数1：描述

        :param  参数2：描述

        :return  ： 返回值

        '''

        代码1

        代码2

        ...

        return  返回值

    例如：我们现在要实现一个小功能，比较两个值的大小，返回较大的那个值。

    def  bigger(a, b):  # 函数定义阶段会检测语法

            #comparison of two numbers

            if  a > b:

                return  a

            else:

                return b

    bigger(5, 8) # 函数的调用，会执行函数体里面的代码。

函数的定义必须遵循先定义，后使用的原则，没有事先定义函数而直接引用函数名，相当于在引用一个不存在的变量名

•     1.函数的定义阶段只检测函数体的语法，不执行函数体代码。

    def fun():

        print('hello world') #只检测语法，不执行

•     2.函数的调用阶段执行函数体代码

    fun()#执行已经定义好的函数体代码

二、函数定义的三种形式

•     1.无参函数

 在函数定义阶段括号内没有参数，也称无参函数。在定义时无参，意味着调用时也无需传入参数。如果函数体代码逻辑不需要依赖外部传值，就定义成无参函数。

    def func():

        print('this is a test')

    func()

•     2.有参函数

在函数定义阶段括号内有参数，称之为有参函数。定义时候有参，调用时就需要传入参数，如果函数体代码需要外部传值，就定义成有参函数。

def sum(x, y):

    res = x + y

    print(res)

sum(10, 20)

sum(15, 63)

•      3.空函数

def func():

    pass

相当于一个占位符号，先占一个位置，具体功能以后再补，就先定义为空函数。

三、函数的返回值

    1.什么是返回值：返回值即为函数的处理结果

    2.为什么有返回值：如果我们需要再程序中拿到函数的处理结果做进一步的处理，就需要函数的返回值

    3.函数的返回值的应用：函数的返回值用return 去定义格式为下：

    return  值

    注意：

        1.return是一个函数的结束标志，函数内可以有多个return，但只要执行一次，函数会马上结束运行

        2.return的值无类型限制，可以是任意数据类型

        3.return的值无个数限制，可以用逗号分隔开多个任意类型的值

        0个返回值：返回None   不写return默认会在函数的最后一行添加 return None

        1个返回值：返回的值就是该值本身

        多个返回值：返回一个元组类型的值

def max2(x, y):

    if x > y

        return x

    else:

        return y

res = max2(150, 300) #只有一个返回值

annual = res * 15

print(annual)

def foo():

    print(1)

    print(2)

    return [1,2,3], 'x', ('a', 'b'), {1,5,3,6} #返回多个值，会将多个值以元组的形式返回

res = foo()  #将函数的返回值赋值给一个变量

print(res)

def bar():

    print(33)

    print('a')

    return 

    print(456)

    print(786)

res = bar()  #该函数无返回值，即返回None，且不会执行return后面的代码块

print(res)

四、调用函数

1.什么是调用函数：函数名(...) 即调用函数（函数名加括号，括号内可以有参数，也可没有），会执行函数体代码，直到碰到return结束或运行完毕所有代码。

2.函数调用分为三种形式

def max2(x, y):

    if x > y

        return x

    else:

        return y

max2(1, 2)  #形式一

res = max2(35, 23) * 15  #形式二

res = max2(max2(1000, 1080), 2000)  #形式三

五、函数的参数（重点知识）

• （一）总的分类可以分为形式参数和实际参数两大类

    1.形参：在函数定义阶段括号内定义的参数，称之为形式参数，本质就是变量名。

def foo(x, y):  #x, y即为形参

    print(x)

    print(y)

    2.实参：在函数调用阶段括号内传入的值，称之为实际参数，本质就是变量的值。

foo(1, 2)  #1, 2即为实参

• （二）详细分类
•     1. 位置参数

    位置形参：在函数定义阶段，按照从左到右的顺序一次定义的形参，称之为位置形参。

    特点：但凡按照位置定义的形参，都必须被传值，多一个或少一个都不行。

def foo(x, y):

    print('x:' x)

    print('y': y)

    位置实参：在函数调用阶段，按照从左到右的顺序依次定义的实参，称之为位置实参。

    特点：按照位置为对应的形参一次传值

foo(1, 3)

foo(3, 1) 

•     2. 关键字参数

    关键字实参：在调用函数时，按照key = value的形式为指定的参数传值，称之为关键字实参。

    特点：可以不按照位置为指定的形参赋值

def foo(x, y):

    print('x:' x)

    print('y': y)

foo(y = 5, x = 7)

注意：可以混用位置实参与关键字实参，但位置实参必须放在关键字实参的前面; 且不能对一个形参重复赋值

foo(1, y = 2)

foo(y = 2, 1) #SyntaxError: positional argument follows keyword argument

foo(1, y = 2, x = 6)

•     3.默认参数

在函数定义阶段，就已经为形参赋值，该形参被称为默认形参。

特点：在定义阶段就已经被赋值，调用的时候不赋值即为默认值，赋值即为后面赋的具体的值

def fun(x, y = 10):

    print('x:', x)

    print('y:', y)

fun(1)

fun(1, 7)

注意：位置形参必须放在默认形参前面，否则报语法错误

def foo(x = 1, y):

    pass

默认参数的值只在定义阶段赋值一次，即默认参数的值在定义阶段就被固定。

m = 10

def fun(x = m, y = 11):

    print(x)

    print(y)

m = 798

fun()

默认参数的值通常应该定义为不可变类型

def info(name, hobby, hobbies = []):

    hobbies.append(hobby)

    print('info of %s'%name, end=':')

    print(hobbies)

info('zhangsan', 'read')

info('lisi', running)

info('liuxx', 'gamming')

试试以上程序会产生什么效果，可以改进如下：

def info(name, hobby, hobbies = []):

    if hobbies is None:

        hobbies = []

    hobbies.append(hobby)

    print('info of %s'%name, end=':')

    print(hobbies)

info('zhangsan', 'read')

info('lisi', running)

info('liuxx', 'gamming')

• 总结：

    实参的应用：取决于个人习惯

    形参的应用：

    位置形参：大多情况下调用值不一样，就应该将该参数定义成位置形参

    默认形参：大多情况下的调用值都一样，就应该将该参数定义成默认形参

•     4. 可变长参数

    指的是在掉用函数时，传入的参数可以不固定。调用函数传值的方式无非就两种，一种位置实参，一种关键字实参。所以对应着形参也有两种解决方案，分别接收溢出的位置实参(*)与关键字实参(**)

• 1.形参中某个参数带*

形参中的*会将位置实参全部接收，然后以元组的形式存储，然后把元组赋值给*后的变量名

def foo(x, y, *z):

    print(x)

    print(y)

    print(z)

foo(1,2,3,4,5,6,7,9)  #x = 1, y = 2, z = (3,4,5,6,7,9)

应用：

def my_sum(*sums):

    res = 0

    for num in nums:

        res += sum

        return res

print(my_sum(4,5,9,7,6,6))

• 2.实参中的参数也可以带*

实参中带*，*会将该参数的值循环取出，打散成位置实参，碰到实参中带*的就是位置实参。

def foo(x, y, z):

    print(x, y, z)

foo(1,*[2, 3]) #foo(1,2,3)

foo(1, *'he') #foo(1,'h','e')

foo(1, *(2, 3, 4))#foo(1,2,3,4)

def foo(x, y, z, *args):

    pirnt(x)

    pirnt(y)

    pirnt(z)

    pirnt(args)

foo(1, 2, 3, 4, 5, 6, 7, *[9, 10, 13, 16])

foo(1, 2, 3, 4, 5, 6, 7, 9, 10, 13, 16)

一般的，约定俗成形参中*变量名的写法都是： *args

• 3. 形参中某个参数带**

形参中带**的会将溢出的关键字实参全部接收，然后存储成字典的形式，把字典赋值给**后的变量名

def foo(x, y, **z):

    print(x)

    print(y)

    print(z)

foo(1, 2, a = 3, b = 4, c = 5)#x=1,y=2,z={'c':5,'b':4,'a':3}

实参中也可以带**，该参数必须是字典，实参中带**，**会将该参数的值循环取出，打散成关键字实参。

def foo(x, y, z):

    print(x)

    print(y)

    print(z)

foo(1, 2, **{'a':1, 'b':2, 'c': 3, 'z':3})  # foo(1,2, c = 3, b = 2, a = 1, z = 3)

foo(**{'z':3,'x':1,'y':2}) #foo(y=2,x=1,z=3)

一般地，约定俗成形参中的**变量名写法都为**kwargs

def index(name, age, sex):

    print('welecome %s:%s:%s to index page'%(name, age, sex))

def wrapper(*args, **kwargs):

    index(*args, **kwargs)

wrapper(name = 'zhangsan', sex = 'male', age = 18)

试试什么效果吧