Python之函数初识

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数的基本语法：

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

实例：

#定义函数
def get_len():
    lis = [1, 2, 3, 4, 5, 6]
    count = 0
    for i in lis:
        count += 1

get_len()  #函数名()-->执行此函数

注：函数是以功能为导向,函数内部尽量不要有print()函数

 一、函数的返回值

return

　　1、遇到return 此函数结束,不在向下进行

　　2、return 返回值

　　　　不写return 返回 None

　　　　return None 返回 None

　　　　return 单个值 返回此单个值

　　　　return 多个值 将多个值包在元组中,返回给调用此元组

 

2.1、return 程序结束

def my_test():
    print(1111)
    return      #程序结束
    print(2222) #没有输出

my_test()
#输出结果：
1111

2.2、return 返回单个值

def get_len():
    lis = [1, 2, 3, 4, 5, 6]
    return len(lis)

ret = get_len()
print(ret)
#输出结果：
6

2.3、return 返回多个值

def get_values():
    return 1,2,[111,222]

ret1,ret2,ret3 = get_values()
print(ret1,ret2,ret3)
#输出结果
1 2 [111, 222]

二、函数传参

def get_sum(x):     #形参：形式参数
    count = 10 + x
    return count
ret = get_sum(10)   #实参：实际参数
print(ret)          #20

1.1、从实参的角度：

　　1)、按位置传参

def mysum(x,y):
    #此时x=10,y=20
    return x + y

num = mysum(10,20)  #位置参数
print(num)          #30

　　2)、按关键字传参

def mymax(x,y):
    #此时x = 20,y = 10
    the_max = x if x > y else y
    return the_max

maxN = mymax(y=10, x=20)     #关键字传参
print(maxN)                  #20

　　3)、混合传参--关键字参数永远在位置参数后面

def mymax(x, y):
    #此时x = 10,y = 20
    the_max = x if x > y else y
    return the_max

maxN = mymax(10, y=20)  #10--位置参数，y=20--关键字参数
print(maxN)             #20

1.2、从形参的角度：

　　1)、位置参数必须传值

def mymax(x, y):
    the_max = x if x > y else y
    return the_max

maxN = mymax()  #此处不传参数
print(maxN)     
#直接报错：
TypeError: mymax() missing 2 required positional arguments: 'x' and 'y'

　　2)、默认参数（若不传递，会显示设置的默认值）

def stu_info(name, sex = "男"):
    print(name,sex)

stu_info('alex')        #alex 男
stu_info('eva','女')    #eva  女

1.3、动态传参

　　动态参数，也叫不定长传参，就是你需要传给函数的参数很多，不定个数，那这种情况下，你就用*args，**kwargs接收，args是元祖形式，接收除去键值对以外的所有参数，kwargs接收的只是键值对的参数，并保存在字典中。

1)、*args-->接收不定长的所有位置参数

#args可以接收不确定个数的参数
def func(*args):
    print(args,type(args))  #(1, 2, 'alex') <class 'tuple'>
func(1,2,'alex')
#输出结果
(1, 2, 'alex') <class 'tuple'>

#若将*args放在最前边，它会接收全部参数，a,b就没有对应的实参了
def func(*args,a,b):
    print(a)
    print(b)
    print(args,type(args))
func(1,2,'alex',3,4)  #直接出错：func() missing 2 required keyword-only arguments: 'a' and 'b'

#*args放在最后，是正确的写法
def func(a,b,*args):
    print(a)
    print(b)
    print(args,type(args))
func(1,2,'alex')
#输出结果
1   2   ('alex',) <class 'tuple'>

#有默认参数的时候，要放在*args后边
def func(a, b, *args, sex = '男'):
    print(a)
    print(b)
    print(sex)
    print(args,type(args))
func(1,2,'alex','wusir','ritian')
#输出结果
1   2   男   ('alex', 'wusir', 'ritian') <class 'tuple'>

#错误实例
def func(sex='男', *args):
    print(sex)          #1 直接把sex的默认值给覆盖了
    print(args)         #(2, 'alex')
func(1,2,'alex')
#输出结果
1   (2, 'alex')

 2)、**kwargs-->接收所有的关键字参数

#接收关键字参数
def func(**kwargs):
    print(kwargs)           #{'a': 1, 'b': 4, 'c': 3}
func(a = 1, b = 4, c = 3)
#输出结果：
{'a': 1, 'b': 4, 'c': 3}

#位置参数、*args、默认参数、**kwargs
def func(a,*args,sex = '男', **kwargs):
    print(a)                        #1
    print(sex)                      #女
    print(args,type(args))          #('alex', 'wusir', 'ritian ') <class 'tuple'>    
    print(kwargs, type(kwargs))     #{'name': 'taibai', 'age': 21} <class 'dict'>
func(1,'alex','wusir','ritian ',sex = '女',name = 'taibai',age = 21)
#输出结果
1
女
('alex', 'wusir', 'ritian ') <class 'tuple'>
{'name': 'taibai', 'age': 21} <class 'dict'>

#万能参数
def func(*args, **kwargs):
    print(args)         #(1,)
    print(kwargs)       #{'name': 'alex'}
func(1,name="alex")
#输出结果
(1,)
{'name': 'alex'}

总结

#参数摆放顺序：位置参数-->*args-->默认参数-->**kwargs

3)、魔法运算：打散后操作

#*魔法运算(列表):打散-->将列表里的每一个元素打散迭代添加到元组中
#求和
def func(*args):
    print(args)         #(1, 2, 3, 4, 5)
    sumN = 0
    for i in args:
        sumN += i
    return sumN
l1 = [1,2,3]
l2 = [4,5]
sumN = func(*l1,*l2)
print(sumN)             #15

#错误实例
l1 = [1,2,3]
def func(*args):
    print(args)     #([1, 2, 3],)
func(l1)            #不加*会将整个列表作为一个元素添加到元组中

#魔法元素(字典)
#将多个字典的键值对合并到一个字典中
def func(**kwargs):
    print(kwargs)         #{'name1': 'alex', 'name2': 'wusir'}
    return kwargs
dic1 = {'name1':'alex'}
dic2 = {'name2':'wusir'}
func(**dic1, **dic2)
#输出结果
{'name1': 'alex', 'name2': 'wusir'}