函数(一)

1.函数的定义

什么是函数

　　函数就是某个拥有具体功能的工具

为什么要使用函数

　　1.提高开发效率

　　2.减少代码冗余

　　3.提高程序的扩展性

怎样定义一个函数

　　def是定义一个函数的关键字

　　函数名:函数名的定义与变量名相同,函数名只能包含字符串、下划线和数字且不能以数字开头

　　　　1.不能以关键字命名,不能以数字开头

　　　　2.函数名也应做到见名知意

　　以下是简单的定义规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

def 函数名（参数列表）:
    函数体

需要注意的是,函数在定义的时候只会检查函数体的语法,不执行函数体代码

　　调用函数的固定格式

• 函数名+括号
• 函数名只要遇到括号会立即执行函数体代码
• 代码中遇到函数名加括号 优先级最高
• 先去执行函数 再看下面的代码

函数必须先定义在调用,定义好的函数能在任意位置调用

def func():
    print('hello world!')
func()

2.函数的返回值

函数内想要返回值给调用者,必须使用关键字return

1.不写return:函数的默认返回值就是none

def func():
    print('hello world!')
res = func()
print(res)  # 打印函数的返回值

2.只写return:函数的默认返回值就是none

def func():
    print('hello world!')
    return
res = func()
print(res)  # 打印函数的返回值

只写return不仅能返回值,也能结束整个函数体的运行

def func1():
    count = 0
    while True:
        while count < 10:
            print('啦啦啦啦啦啦啦啦')
            count += 1
            if count == 5:
                return  # 表示count = 5函数结束执行,相对于break只能结束当前循环
res = func1()
print(res)  # 打印函数的返回值

3.写return None,和只写return类似,返回的都是None

def func():
    print('hello world!')
    return None
res = func()
print(res)  # 打印函数的返回值

4.写return返回一个值,返回的这个值可以是python中的任意类型

# 数字类型
def func():
    return 1
res = func()
print(res)
# 字符串类型
def func1():
    return 'a'
res1 = func1()
print(res1)
# 列表类型
def func2():
    return [1,2,'k']
res2 = func2()
print(res2)
# 字典类型
def func3():
    return {'name':'sxc','age':18}
res3 = func3()
print(res3)
# 元组类型
def func4():
    return (1,2,3,4,5)
res4 = func4()
print(res4)
# 集合类型
def func4():
    return {1,2,3,4,5}
res4 = func4()
print(res4)
# 布尔类型
def func5():
    return True
res5 = func5()
print(res5)

5.写return返回多个值:return会自动将多个值以元组的形式返回给调用者

# 数字类型
def func():
    return 1,2,3,4,5
res = func()
print(res)
# 字符串类型
def func1():
    return 'a','b','c','d'
res1 = func1()
print(res1)
# 列表类型
def func2():
    return [1,2,'k'],['d',5,'dsa']
res2 = func2()
print(res2)
# 字典类型
def func3():
    return {'name':'sxc'},{'age':18},{'pwd':'sxc123'}
res3 = func3()
print(res3)
# 元组类型
def func4():
    return (1,2,3,4,5),('a','吃饭','睡觉',5)
res4 = func4()
print(res4)
# 集合类型
def func4():
    return {1,2,3,4,5},{'a','b','c','d'}
res4 = func4()
print(res4)
# 布尔类型
def func5():
    return True,False
res5 = func5()
print(res5)

注意:

1.所有的函数不管有没有return都有返回值,不写的情况下默认返回None

2.光写return或者return None不是在考虑返回值,而是在结束函数的运行

3.函数的参数概要

函数的两大类型

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

　　实参:在函数的调用阶段,括号内实际传入的值,叫做该函数的实际参数,简称实参

形参和实参的关系

　　形参相当于变量名,实参相当于变量的值

　　函数的调用传参的过程就相当于给变量名赋值的过程

注意:函数的实参和形参的绑定关系只要函数的运行阶段有效,函数结束关系自动解除,只在函数内部有效,外部无效

函数的简易结构
　　def 函数名(形参1,形参2...):
　　'''函数的注释 用来描述该函数的作用以及各个形参的类型'''
　　函数体代码1
　　函数体代码2
　　...
　　return 函数的返回值

函数注释的使用与调出

def func(x,y):
    '''
    该函数的作用
    :param x:对形参x的解释
    :param y:对形参y的解释
    :return: 对函数返回值的介绍
    '''
    print('哈哈哈')
    return 'xixixi'
print(help(func))  # 可以调出对该函数的注释,注意func不能加括号

4.位置参数

位置参数:函数定义阶段按照位置依次从左往右声明的变量名.

位置形参在函数调用的时候必须为其传值

一个比数字大小的函数

def w_max(x,y):
    if x > y:
        return x
    return y
res = w_max(10,20)
print(res)
# w_max(1)  # 少一个参数不行
# w_max(1,2,3)  # 多一个参数也不

调用时传递的参数必须和定义时一致.

 

两种对应的传参方式

第一种,按照位置一一对应传参:位置传参

第二种,指名道姓的传参:关键字传参

res = w_max(56,51)  # 位置传参
print(res)
res1 = w_max(x = 85,y = 26)  # 关键字传参
print(res1)
res2 = w_max(479,y = 561)  # 位置传参和关键字传参混用
print(res2)

注意:在函数调用阶段,位置传参和关键字传参可以混用

　　1.同一个形参不能被多次赋值

　　2.位置传参必须在关键字传参的前面(越短的越靠前,越长的越靠后)

5.默认值参数

默认值参数:在函数定义阶段,形参就已经被赋值了

如果有了默认参数:在调用阶段不传值则表明使用默认的值,

　　　　　　　　 在调用阶段使用信的值传参则表明使用新的值

在定义阶段,默认参数需要放到位置参数后面

不默认参数时

def register(name,age,gender):
    print(name,age,gender)
register('sxc',18,'male')
register('zzj',18,'male')
register('zzp',18,'male')
register('zkj',18,'male')
register('cxk',18,'female')

默认参数时

def register(name,age,gender = 'male'):
    print(name,age,gender)
register('sxc',18)  # 当调用时的某个参数大部分都一样时可以使用默认参数
register('zzj',18)
register('zzp',18)
register('zkj',18)
register('cxk',18,'female')

默认值参数的应用场景
当形参接收的到值比较单一的情况下 通常可以考虑用默认值形参

 

当使用默认参数时需注意的点

def func(name,hobby,l =[]):
    l.append(hobby)
    print(name,l)
func('sxc','sing')
func('zzj','dance')
func('zzp','rap')

出现这个问题的原因是定义函数是输出的默认参数是一个控列表,这个列表是下方调用函数共用的

解决方法1

def func(name,hobby,l =[]):
    l.append(hobby)
    print(name,l)
func('sxc','sing',[])
func('zzj','dance',[])
func('zzp','rap',[])

在调用阶段传递了一个单独使用的列表

解决办法2

def func(name,hobby,l =None):
    if l ==None:
        l = []
    l.append(hobby)
    print(name,l)
func('sxc','sing')
func('zzj','dance')
func('zzp','rap')

在函数内部给每个调用函数都声明了一个单独的空列表

 

注意:

　　函数在定义阶段 内部所使用的变量都已经初始化完毕了
　　不会因为调用的位置的变化 而影响到内部的值(暂时可忽略)

　　函数无论在什么地方被调用
　　都会跑到函数定义阶段去执行代码
　　形参中用到的值都是往函数定义阶段代码往上找

6.可变长参数

站在调用函数传递实参的角度,实参的个数不固定的情况,也就意味形参也不固定
站在形参的角度 可以用*和**来接收多余的(溢出的)位置参数和关键字参数

1.站在形参的角度 看 *

形参中的*会将多余的(溢出的)位置实参 统一用元组的形式处理 传递给*后面的形参名

def func(x,y,*z):
    print(x,y,z)
func(1,2,3,4,5,6,7,9,7,9,6,5)

当超过2个参数时,会将溢出的位置实参用元组的形式出来

 

2.站着实参的角度看*

def func(x,y,z):
    print(x,y,z)
func(*[1,2,3])  # 将列表打散传入实参,传入123
func(*(2,3,4))  # 将元组打散传入实参,传入234
func(*{3,4,5})  # 将集合打散传入实参,传入345
func(*'456')  # 将字符串打散传入实参,传入456
func(*{5:1,6:2,7:3})  # 将字典打散传入实参,传入的是key567

注意:*只能将列表,元组,集合,字符串,字典等打散传入实参,但是字典只能传入他的key

　　*的内部可以看做for循环

 

3.站着形参的角度看**

def func(x,y,**z):
    print(x,y,z)
func(x = 1,y = 2 ,z = 3,a = 4,b = 5,c = 6)

**会接收所有多余的关键字参数 并将关键字参数 转换成字典的形式 字典的key就是关键字的名字

字典的value就是关键字的名字指向的值 将字典交给**后面的变量名

4.站着实参的角度看**

def func(x,y,z):
    print(x,y,z)
func(**{'x':1,'y':2,'z':3})  # **会将字典拆封成 key = value的形式

**会将字典打散成key = value 的形式

总结:*与**

*在形参中能够接受多余的位置参数 组织成一个元祖赋值给*后面的变量名
**在形参中能够接受多余的关键字参数 组织成一个字典赋值给**后面的变量名

*:在实参中 *能够将列表 元祖 集合 字符串 打散成位置实参的形式传递给函数(*就看成是for循环取值)
**:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数

注意python推荐形参*和**通用的写法

def func(*args,**kwargs):
    print(args,kwargs)
func(1,2,3,4,5,x = 6,y = 7,z = 8)

 9