函数基础

Posted 2020-10-12 一只小蚊子

 

 

什么是函数？

　　函数是指将一段代码通过函数名封装起来，具备某一功能的工具

　　函数是逻辑结构化和过程化的一种编程方法

 

 

 

使用函数的好处：

1. 　　代码的组织结构清晰，可读性强
2. 　　减少代码的重复性
3. 　　方便管理，维护简单

 

 

 

函数的分类：

1. 　　内置函数：python解释器定义好的，自带的函数　　例如：len() ; max() ; min()
2. 　　自定义函数：内置函数所提供的功能是有限的，我们需要根据自己的要求，定义一些具有特定功能的函数　　　　

函数的使用原则：先定义，再调用

函数的定义：只检测语法，不执行代码（语法错误会在函数定义时检测出来；而代码的逻辑错误只有在执行时才会被检测出来）
　　　　1.有参函数：需要接收函数调用时传来的参数，才能执行相应的逻辑
　　　　　　　　　　　　def 函数名（形式参数1，形式参数2...）：
　　　　　　　　　　　　　　 ‘‘‘注释‘‘‘
　　　　　　　　　　　　　　 函数体
　　　　　　　　　　　　return 返回值
　　　　　　　　　　　　函数名（实际参数1，实际参数2...）
　　　　2.无参函数：函数调用时，不需要传参，执行相应的逻辑
　　　　　　　　　　　　def 函数名（）：
　　　　　　　　　　　　　　 ‘‘‘注释‘‘‘
　　　　　　　　　　　　　　 函数体
　　　　　　　　　　　　return 返回值
　　　　　　　　　　　　函数名（）
　　　　3.空函数：写项目时，设计代码的逻辑结构
　　　　　　　　　　　　def 函数名（形式参数1，形式参数2...）：
　　　　　　　　　　　　　　 ‘‘‘注释‘‘‘
　　　　　　　　　　　　　　 pass

函数的调用：通过函数名找到内存地址，再对函数进行调用

1. 　　　　语句形式：函数名（实际参数1,实际参数2...)
2. 　　　　表达式形式：3*len（‘hello’）
3. 　　　　当做另一个函数的参数：range（len（‘hello’））

函数的返回值：return
　　调用函数时，遇到return，立即终止函数的执行，并return返回值
　　函数体内，可以有多个返回值，但只能执行一次（类似于if判断）

1. 　　　　无return　　　　返回None
2. 　　　　return一个值　　返回原值
3. 　　　　return多个值　　以元组形式返回多个值

　　什么时候应该有返回值：
　　　　调用函数，经过一系列的操作，最后要拿到一个明确的结果，则必须要有返回值
　　　　通常有参函数需要有返回值，输入参数，经过计算，得到一个最终的结果
　　什么时候不应该有返回值：
　　　　调用函数，仅仅只是执行一系列的操作，最后不需要得到什么结果，则无需有返回值
　　　　通常无参函数不需要有返回值





函数的参数：（形式参数，实际参数）

形参：在定义函数时，括号内的参数为形参，相当于变量名
实参：在调用函数时，括号内的参数为实参，相当于变量值
在调用阶段，实参才会绑定给形参；调用结束，解除绑定

排序：位置参数，默认参数，*args，命名关键字参数，**kwargs

一。位置参数：按照从左到右的顺序依次定义的参数
    位置形参：必须被传值的参数，多一个不行，少一个也不行
    位置实参：与形参按照位置一一对应
def foo(x,y):
    print(x,y)
foo(1,2)


二：关键字参数：在函数调用阶段，按照key=value的形式定义实参
    可以不依赖位置而指名道姓地给形参传值
    需要注意的问题（可以与位置实参混用，但是）：
        1. 位置实参必须在关键字实参的前面
        2. 不能为一个形参重传值
def foo(x,y):
    print(x,y)
print(foo(1,2,y=20))


三：默认参数：在定义函数阶段，已经为形参赋值了，
    意味着在调用阶段可以不传值；也可以传值，但以所传的值为准
    注意的问题：
        1 默认参数的值，只在定义时赋值一次
        2 位置形参应该在默认参数的前面
        3 默认参数的值应该是不可变类型
def foo(x,y=11):
    print(x,y)
foo(1,y=2)


四。可变长参数
实参可变长度指的是：实参值的个数是不固定
而实参的定义形式无非两种：1、位置实参，2、关键字实参
针对这两种形式的实参个数不固定，相应的，形参也要有两种解决方案
*
**

针对按照位置定义的溢出的那部门实参，形参：*args
*将溢出的位置实参，以元组的形式，赋值给args；如果没有溢出，args=None
def func(x,y,z,*args):
    print(x,y,z)
    print(args)
func(1,2,3,4,5,6)
    func(1,2,3,*[4,5,6])/func(1,2,3,*(4,5,6))/func(*[1,2,3,4,5,6]   ===》 func(1,2,3,4,5,6)
    实参中出现*，将[]或()打散，变为func(1,2,3,4,5,6)形式

针对按照关键字定义的溢出的那部分实参，形参：**kwargs
**将溢出的关键字实参，以字典的形式，赋值给kwargs；如果没有溢出，kwargs=None
def foo(x,y,**kwargs):        # kwargs={‘a‘:1,‘z‘:3,‘b‘:2}
    print(x,y)
    print(kwargs)
foo(y=2,x=1,z=3,a=1,b=2)
foo(1,2,z=3,a=1,b=2)
    foo(y=1,x=2,**{‘a‘:1,‘b‘:2,‘c‘:3})    #foo(x=2,y=1,c=3,b=2,a=1)
    foo(**{‘x‘:1,‘a‘:1,‘b‘:2,‘c‘:3})  #foo(x=1,c=3,b=2,a=1)
    实参中出现**，将{}打散，变为foo(x=1,c=3,b=2,a=1)形式


五。命名关键字参数（了解）:形参中，在*后定义的参数
    特性：必须按照关键字实参的形式传值
def foo(x,y,*,a,b):
    print(x,y,a,b)
foo(1,2,a=3,b=4)

def foo(x,y,*args,a,b):
    print(args)
    print(x,y,a,b)
foo(10,22,33,44,a=2,b=3)

def foo(x,y=20,*args,a=1,b):
    print(args)
    print(x,y,a,b)
foo(10,b=3)
foo(10,22,33,44,a=2,b=3)