python之函数的定义、传参以及动态参数

函数的优点：
减少代码的重复率。
增强代码的可读性

函数到底是声明：
函数最主要的目的：封装一个功能

工作中，函数中尽量不要出现print

# def 关键字 函数名()：
# def my_len():
#     # 函数体
#     l = [2,3,5,5,6,7,77,8]
#     count = 0
#     for i in l:
#         count += 1
#     print(count)
# my_len() # 执行函数  函数名()

# 函数的返回值 return
1. 函数中如果遇到return，则直接结束函数。
2. 给函数的执行者返回值。 
return None
return 单个值 原封不动的返回
return 多个值 一个元组，所有的返回值作为元组的元素　

　

# 函数的返回值 return
#
# def func1():
#     print(111)
#     print(222)
#     return
#     print(333)
# func1()  # 整体是函数的执行者
# print(func1())

#
# def func1():
#     a = 1
#     b = 2
#     c = a + b
#     d = 'alex'
#     e = [1, 2, 3]
#     return c, d, e
# # print(func1())
# res1, res2, res3 = func1()
# print(res1)
# print(res1, res2, res3)
# print(res3)
# print(func1)  # <function func1 at 0x0000027F914399D8> 函数的内存地址

　　

函数的传参：
实参：
位置参数： 按照顺序，一一对应。
关键字参数: 可以不按照顺序，但是必须一一对应
混合参数： 关键字参数一定要在位置参数后面。
形参
位置参数： 按照顺序，一一对应。
默认参数: 给其传值，将原默认参数覆盖掉。不传值，不报错，使用默认值
应用场景：不经常改变的参数，

# l1 = [2.3,35,6]
# def my_len(argv):  # 形式参数 形参
#     # 函数体
#     # l = [2,3,5,5,6,7,77,8]
#     count = 0
#     for i in l:
#         count += 1
#     print(count)
# print(my_len(l1))  # 函数的执行者（实参），实际的参数


# def func1(a, b):
#     sum1 = a + b
#     return sum1
#
#
# print(func1(1, 5))
#
#
# def func2(a, b):
#     # the_max = a if a > b else b
#     # return the_max
#     return a if a > b else b
#
# print(func2(6, 3))

# 三元运算：只针对简单的if else这样的结构，才可以使用

　　

def name_list(n1,s1= '男'):
    with open('info',encoding='utf-8',mode='a') as f1:
        f1.write('{}|{}
'.format(n1, s1))

while 1:
    name,sex = input('请输入姓名，性别：以，隔开').strip().replace('，', ',').split(',')
    if name.upper() == 'Q':break
    if sex.strip():
        name_list(name,sex)
    else:
        name_list(name)

默认参数的陷阱

# 默认参数的陷阱
# 默认参数若是可变的数据类型，他始终使用的是同一个。内存地址是一样的
#
# def func1(x,l1 = []):
#     l1.append(x)
#     return l1
# res = func1(1)
# print(res, id(res))   #[1] 2301277921864
# res2 = func1(100)
# print(res2, id(res2))  #[1, 100] 2301277921864

　　

动态函数

你的函数，为了拓展，对于传入的实参数量不固定，就需要万能参数，动态参数：*args，**kwargs

def func1(argv):  #形参
    pass

def func2(*args):  #在函数的定义时，在*位置参数，聚合。
    pass            # *args 将所有的实参的位置参数聚合到一个元组，并将这个元组赋值给args

def func3(**args)    # kwargs接收的只是键值对的参数，并保存在字典中。


# def func1(**kwargs):
#     # print(args)
#     print(kwargs)
#
# func1(name = 'alex', age = 100)
#
# def cal(*args):
#     sum1 = 0
#     for i in args:
#         sum1 += i
#     return sum1
#
# print(cal(1,2,3,4))



* 的魔性用法
在函数的定义时，在*位置参数，**位置参数 聚合
在函数的调用（执行）的时候，在*位置参数 **位置参数，打散

l1 = [1,2,3]
l2 = [111,22,33,'alex']

def func2(*args):
    print(args)


func2(*l1,*l2)   # (1, 2, 3, 111, 22, 33, 'alex')

形参的顺序
位置参数 ，*args，默认参数，**kwargs

# def func1(a,b,*args,sex='male',**kwargs):
#     print(a,b)
#     print(args)
#     print(sex)
#     print(kwargs)
#
#
# func1(1000, 2000, 2, 3, 55, 6, sex='female', name='alex', age='33')