函数简介及函数参数介绍

函数的基本定义

　　什么是函数？

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

　　为什么要用函数？

　　　　提高开发效率

　　　　减少代码冗余

　　　　提高程序的扩展性

　　如何定义一个函数？

　　　　def是定义函数的关键字

　　　　函数名：函数名的命名规则与变量名一致

　　　　　　1.不能以关键字命名

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

　　　　函数在定义的时候只检测函数体内的语法，不执行函数体代码

　　　　

def func()
    print('hello')

　　　　调用函数的固定格式：

　　　　　　函数名+括号     #func()

　　　　　　函数名只要遇到括号会立即执行函数体代码

　　　　　　代码中遇到函数名加括号，优先级最高

　　　　　　先去执行函数，再看下面的代码

函数的返回值

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

　　1.不写return

　　2.只写return

　　3.写return None

　　4.写return返回一个值

　　5.写return返回多个值

不写return：函数默认返回None

def func():
    print('hahaha')
res = func()
print(res)

只写return：return除了可以返回值之外 还可以直接结束整个函数的运行

只写return 返回的也是None(None就表示什么都没有)

def func():
    l = ['zhangsan','lisi','wangwu']
    while True:
        for i in l:
            if i == 'lisi':  # 当i为lisi的时候 直接结束函数运行
                break
                return
                print('asdasdkljlsjadl')  # 这一行代码拥有都不会运行
            print(i)
res = func()
print(res)

写return None:跟上面的只写return是一样的

def func():
    return None
res = func()
print(res)

写return返回一个值:这个值可以是python任意数据类型

def func():
    return '123'
def func1():
    return [1,2,3]
def func2():
    return {'name':'zhangsan'}
def func3():
    return (1,)
def func4():
    return {1,2,3,4,5}
def func5():
    return True
print(func(),func1(),func2(),func3(),func4(),func5())

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

def func():
    return 1,2,3,4  # 返回的是(1, 2, 3, 4)
res = func()
print(res)

def func1():
    return 'a','b','c'  # ('a', 'b', 'c')
res = func1()
print(res)


def func2():
    return [1,2,3],[1,2,3],[1,2,3]  # ([1, 2, 3], [1, 2, 3], [1, 2, 3])
res1 = func2()
print(res1)


def func3():
    return {'name':'zhangsan'},{'username':'lisi'},{'user_name':'wangwu'}  # ({'name': 'zhangsan'}, {'username': 'lisi'}, {'user_name': 'wangwu'})
res2 = func3()
print(res2)

　　函数返回的结果全部都是元组类型，因为函数不希望自己处理的结果被修改，那么应该如何返回一个非元组的结果呢？

def func4():
    return [[1,2,3,4],[1,2,3,4],[1,2,34]]
res = func4()
print(res)

# 把所有的结果当成一个结果返回，写成什么样的类型就返回什么样的类型

注意：

　　1.所有的函数都有返回值,无论你写不写return

　　　　python中所有的函数都有返回值 不写的情况下默认返回None

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

函数参数的介绍

函数参数的两大类型

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

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

形参和实参的关系

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

　　函数调用传参的过程 就是给形参变量名赋值的过程

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

函数的简易结构

　　def 函数名(形参1，形参2，形参3.....):

　　　　'''函数的注释，用来描述该函数的作用依旧各个形参的类型'''

　　　　函数体代码1

　　　　函数体代码2

　　　　....

　　　　return  函数的返回值

位置参数

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

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

求两个数的大小 返回大的那个（示例）

def my_max(x,y):
    print(x,y)
    if x > y:
        return x
    else:
        return y
res = my_max(1)  #在调用函数的时候 少一个实参不行(位置实参)
res = my_max(1,2,3)  #在调用函数的时候 多一个实参也不行（位置实参）
res = my_max(20,10)  #在函数调用的时候 传入和形参一一对应的参数（位置实参）

res = my_max(y=20,x=10)  #在函数调用的时候，使用关键字传参
res = my_max(10,y=20)  #位置参数和关键字参数混合使用，需要注意的是位置参数必须在前
print(res)

有上面的代码可以得出：位置实参在函数的调用阶段，传入的参数会按照位置一一对应给形参，而关键字参数则是依对函数形参的名称传的

但是必须保证：

　　1.位置参数必须在关键字参数的前面(越短的越靠前,越长的越复杂的越靠后)

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

默认值参数

定义：在函数的定义阶段，形参（变量名）就已经被赋值了

那么，在调用的时候可以不为默认值形参传值,默认使用定义阶段就已经绑定的值

在调用的时候如果可以给默认值形参传值 传了那么就使用你传的值

在定义阶段 默认值形参必须放在位置形参的后面

示例：

def my_max(x,y=100):
    if x > y:
        return x
    return y
res = my_max(200)  # 只给x传一个值为200
res1 = my_max(200,1000)  #给x传一个值为200，给y传一个值为1000（位置实参）
res2 = my_max(y=200,x=1000) #给x传一个值为200，给y传一个值为1000（关键字实参）
print(res2)

def register(username,age,gender='male'):   #默认值为male
    print(username,age,gender)
register('zhangsan',18)
register('lisi',28)
register('wangwu',84)
register('maliu',58)
register('xiaohong',17,'female')  #如果为gender传了参数，则用自己传的参数

迷人小示例一（猜结果）

def info(username,hobby,l=[]):
    l.append(hobby)
    print('%s 的爱好是 %s'%(username,l))
info('zhangsan','学习')
info('lisi','生蚝')
info('wangwu','跑步')
info('maliu','打拳')

答案

zhangsan 的爱好是 ['学习']
lisi 的爱好是 ['学习', '生蚝']
wangwu 的爱好是 ['学习', '生蚝', '跑步']
maliu 的爱好是 ['学习', '生蚝', '跑步', '打拳']

 这时我们获取的结果是错误的，有两种解决办法

第一种：

def info(username,hobby,l=[]):
    l.append(hobby)
    print('%s 的爱好是 %s'%(username,l))
info('zhangsan','学习',[])
info('lisi','生蚝',[])
info('wangwu','跑步',[])
info('maliu','打拳',[])

第二种：

def info(username,hobby,l=None):
    if l==None:
        l=[]
    l.append(hobby)
    print('%s 的爱好是 %s'%(username,l))
info('zhangsan','学习')
info('lisi','生蚝')
info('wangwu','跑步')
info('maliu','打拳')

迷人小示例二：

m = 100
def my_max(x,y=m):
    print(x,y)
m = 222
my_max(111)

答案

111 100

小总结：

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

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

可变长参数

站在调用函数传递实参的角度，实参的个数不固定的情况，也就意味形参也不固定

站在形参的角度 可以用*和**来接收多余的(溢出的)位置参数和关键字参数

站在形参的角度 看 *

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

def func(x,y,*z):
    print(x,y,z)  # z = (3, 4, 5, 6, 7, 8, 54, 43, 4, 5, 6, 6, 7, 8)
func(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)
l = [1,2,3]
a,b,c = l
func(a,b,c)
func(*[1,2,3,4,5,6])  # *会将列表打散成位置实参一一传入等价于func(1,2,3,4,5,6)
func(*(1,2,3))  # 等价于func(1,2,3)
def func(x,*z):
    print(x,z)
func(1,*{1,2,3})  # *在形参中只能接收多余的位置实参 不能接收关键字实参
  # *只能将列表 元组 集合 字符串
  # *的内部你可以看成是for循环

站在形参的角度看 **

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)
  # **会接收所有多余的关键字参数 并将关键字参数 转换成字典的形式 字典的key就是关键字的名字
  # 字典的value就是关键字的名字指向的值  将字典交给**后面的变量名

站在实参的角度看 **

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)
# **会将字典拆封成 key = value的形式

总结：* 与 **

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

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

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

　　**:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数

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

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