python中的函数

函数

#什么函数
	函数就是有某个具体功能的工具
    函数必须先定义，后面才能调用，并且在任意位置调用

#为什么要用函数
	减少某一特定功能的代码冗余
    使函数的调用更加方便，提高开发效率
    提高程序的扩展性

#定义函数
	#使用关键字 def
    #函数名与变量名类似，命名规则相同
    #该过程不会执行代码，只会检测语法
def func(x,y):
    """
    函数的作用
    :param x: 对形参x的解释
    :param y: 对形参y的解释
    :return:  对函数的返回值类型的解释
    """
    函数体代码
res = func()
print(res)			#None
print(help(func))	#查看函数体内的注释

空函数，可用于构建项目架构
def func():
    pass
def func():
    ...
    
#调用函数，执行函数体代码
test()

#变量，可以通过变量名找到变量对应的值
#函数，可以通过函数名+括号，找到函数体所对应的代码，并执行
#注意调用函数的时候，到底要不要加括号

#递归深度
def index():
    print('index')
    index()
index()			#RecursionError:

自定义函数与内置函数

#自定义函数
l = [1,2,3,4,5]
def my_len():
    n = 0
    for i in l:
        n+=1
    print(n)
my_len()	#5
a = my_len()
print(a)	#None

#内置函数
l = [1,2,3,4,5]
print(len(l))	#5
a = len(l)
print(a)		#5

#区别：
	1.没有返回值，只能固定的执行打印操作
    2.只能固定的统计某一个容器类型的长度

函数的返回值

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

#函数内的print()打印出来的结果，不是函数的返回值，而是函数体代码执行的结果
def func():
    print('from func')
res = func()
print(res)
print(func())
    from func
    None
    from func
    None
    
def func():
    return 'from func'
res = func()
print(res)
print(func())
    from func
    from func

def func():
    print(func)
def index():
    return func
res1 = func()
print(res1)
res = index()
print(res)

<function func at 0x0000028F0BEC1EA0>
None
<function func at 0x0000028F0BEC1EA0>

#不写return
def func():
    print('哈哈')
a = func()		#哈哈
print(a)		#返回值为None

#只写return
def func():
    l = [1,2,3]
    while True:
        for i in l:
            if i == 2:
                break
            print(i)
        break
func()

def func():
    l = [1,2,3]
    while True:
        for i in l:
            if i == 2:
                return 		#结束整个函数，关键字return只能用于函数体内部，不执行同级别的其他代码
            print(i)
func()
a = func()
print(a)	#None，没有返回值

#只写return None，与只写return结果相同

#只写return，返回一个值，这个值可以是python的任意数据类型，还可以返回对象、变量名
def func():
    return 123
def func2():
    return 12.3
def func3():
    return '哈哈'
def func4():
    return [1,2,3]
def func5():
    return {'name':'syy'}
def func6():
    return (1,)
def func7():
    return {1,2,3}
def func8():
    return True
print(func(),func2(),func3(),func4(),func5(),func6(),func7(),func8())	#123 12.3 哈哈 [1, 2, 3] {'name': 'syy'} (1,) {1, 2, 3} True

#只写return，返回多个值，return会自动将多个值以元组的形式返回给调用者
def func():
    return 1,2,3
res = func()
print(res)		#(1, 2, 3)

def func2():
    return 'a','b','c'
res2 = func2()
print(res2)		#('a', 'b', 'c')

def func3():
    return [1,],[2,],[3,]
res3 = func3()
print(res3)		#([1], [2], [3])

def func4():
    return {'name':'syy'},{'name':'syy'}
res4 = func4()
print(res4)		#({'name': 'syy'}, {'name': 'syy'})

#为什么使用元组作为返回值
	函数不希望自己处理的结果被修改

#如何不使用元组作为返回值
	使用关键字return的时候指定数据类型

def func():
    return 2.2
res = func()
print(res)			#2.2
print(type(res))	#<class 'float'>

def func():
    return '[1,],[2.2],["3"]'
res = func()
print(res)			#[1], [2.2], ['3']
print(type(res))	#<class 'str'>

def func():
    return [[1,],[2.2],['3',]]
res = func()
print(res)			#[[1], [2.2], ['3']]
print(type(res))	#<class 'list'>

#python中所有的函数都有返回值，无论写不写return，不写的话默认返回None
#只写return或者return None，这个时候并不是为了考虑返回值，而是为了结束函数的运行
#解压赋值可以与函数连用
def func():
    return 1,2,3
a,b,c = func()
print(a,b,c)		#1 2 3
a,_,_ = func()
print(a,_)			#1 3
a,*_ = func()
print(a,_)			#1 [2, 3]

函数参数的两大类型

#自定义函数
l = [1,2,3]
def my_len():
    n = 0
    for i in l:
        n+=1
    return n
a = my_len()
print(a)

#参数
def my_len(args):	#args 为形参，在函数的定义阶段，括号写的'变量名'
    print(args)
a = my_len(123)		#123 为实参，在函数的调用阶段，括号内实际传入的'值'
print(a)

#形参与实参的关系;
	形参相当于变量名，而实参就相当于变量的值，形参 = 实参
    形参与实参的'绑定关系'只在函数的'调用阶段'有效，函数运行结束，该关系自动解除（只在函数体内部有效，函数外部无任何影响）

#优化自定义函数
l = [1,2,3]
def my_len(args):
    n = 0
    for i in args:
        n+=1
    return n
a = my_len('hahaha')
print(a)	#6

位置参数

#函数定义阶段，按照位置从左向右，依次列出的变量名，叫做函数的位置参数（形参）
	#在函数的调用阶段，位置参数少一个不行，多一个也不行（实参）
def my_max(x,y):
    if x > y:
        return x
    else:
        return y
res = my_max(2,3)	#按位置传参
print(res)

def my_max(x,y):
    return x,y
res = my_max(y=1,x=3)	#指名道姓的传参（关键字参数）
print(res)

def my_max(x,y):
    return x,y
res = my_max(1,y=3)		#混用的方式传参（位置参数必须在关键字参数前面，且不能重复赋值）
print(res)

默认值参数

#在函数的定义阶段，形参（变量名）就已经被赋值了
	#在函数的调用阶段，可以不给该形参赋值，默认使用该函数在定义阶段就已经绑定的值
    #在函数的调用阶段，也可以给该形参赋值，如果赋值就是用新的赋值

#位置参数的格式 
def my_max(x,y=100):
    if x > y:
        return x
    else:
        return y
res = my_max(10)
print(res)
-------------------------------------------------------------------------
#位置参数的实际使用
def register(username,age,gender):
    print(username,age,gender)
register('syy',18,'male')
register('kk',28,'male')
register('ee',58,'male')
register('xiaohou',17,'female')

代码优化，减少代码冗余
def register(username,age,gender='male'):
    print(username,age,gender)
register('syy',18)
register('kk',28)
register('ee',58)
register('xx',17,'female')

-------------------------------------------------------------------------
def info(username,hobby,l=[]):
    l.append(hobby)
    print('%s的爱好是: %s'%(username,l))
info('syy','run')
info('ee','女教练')
info('hh','逗比')

代码优化1
def info(username,hobby,l=[]):
    l.append(hobby)
    print('%s的爱好是: %s'%(username,l))
info('syy','run',[])
info('ee','女教练',[])
info('hh','逗比',[])

代码优化2
def info(username,hobby,l):
    if l == None:
        l = []
    l.append(hobby)
    print('%s的爱好是: %s'%(username,l))
info('syy','run',[])
info('ee','女教练',[])
info('hh','逗比',[])
-------------------------------------------------------------------------
#函数在定义阶段，内部所有使用的变量都已经初始化完毕了，不会因为调用的位置的变化，而影响到内部的值
#函数无论在什么位置被调用，都会到函数定义阶段去执行代码，形参中用到的值都是从函数定义阶段向上找
m = 999
def my_max(x,y=m):
    if x > y:
        print(x)
    else:
        print(y)
m = 888
my_max(10)	#999

可变长参数（动态参数）

*

#在形参中，可以使用*来接收多余的位置参数
	#形参中的*，会将多余的实参，统一用元组的形式处理，传递给*后面的形参
def func(x,y,*z):
    print(x,y,z)
func(1,2,3,4,5)		#1 2 (3, 4, 5)

def func(x,y,*z):
    print(x,y,z)
func(1,2,z=3)		#TypeError: 

#在实参中，*会将列表打散成实参中的位置参数
	#*相当于是一个 for循环
def func(x,y,z):
    print(x,y,z)
func(1,2,3)		#1 2 3

def func(x,y,z):
    print(x,y,z)
func(*[1,2,3])	#1 2 3

def func(x,y,z):
    print(x,y,z)
func(*{'name':'syy','age':18,'hobby':'run'})	#name age hobby

**

#在形参中，**会接收多有多余的关键字参数，并将关键字参数转换成字典的形式
	#变量名就是字典中的key，变量值就是字典中的value,再将字典复制给**后面的变量名
def func(x,y,**z):
    print(x,y,z)
func(1,2,z=1,a=2,b=3)	#1 2 {'z': 1, 'a': 2, 'b': 3}

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

*和**的总结

#*和**的总结
	1.*在形参中，能接收多余的'位置参数'，组织成一个'元组'，赋值给*后面的变量名
    2.**在形参中，能接收多余的'关键字参数'，阻止成一个'字典'.赋值给**后面的变量名
    3.*在实参中，能将'字符串、 列表、元组、集合'打散成实参中的位置参数（*相当于for循环）
    4.**在实参中，能将'字典'打散成 'key=value' 的形式
    
def func(*args,**kwargs):
    print(args,kwargs)
func(1,2,3,x=1,y=2,z=3)		#(1, 2, 3) {'x': 1, 'y': 2, 'z': 3}

命名关键字参数

#在函数定义阶段，写在可变长参数*与**之间的形参
	#只能使用关键字参数给命名关键字参数传值
    #下面的z=3,m 不是默认参数、位置参数，而是命名关键字参数
def func(x,y,*args,z=3,m,**kwargs):
    print(x,y)		#1 2
    print(args)		#(1, 2, 3, 4, 5)
    print(z,m)		#333 444
    print(kwargs)	#{'k': 111, 'v': 222}
func(1,2,1,2,3,4,5,z=333,m=444,k=111,v=222)