Python函数

l = [1,2,3,4,5,6]

# count = 0
# for i in l:
#     count += 1
# print(count)
# print(len(l))

# len()   函数
# print(len([1,2,3,4,5]))


# 先前的可读性差，代码多

# 把下面这些信息封装起来
# def my_len():
#     l = [1, 2, 3, 4, 5, 6]
#     count = 0
#     for i in l:
#         count += 1
#     # print(count)
#
# # my_len()
# print(my_len())

# def len_l()

# len_l = len([1,2,3,4])
#
# print(len_l)


# 写函数的时候要尽量以功能为导向，结果最好不要在函数中打印

# def my_len1():                      #定义函数名称
#     l = [1, 2, 3, 4, 5, 6]
#     count = 0
#     for i in l:
#         count += 1
#     return count                   # 函数的返回值
#
# ret = my_len1()                     # 函数值的调用以及返回值的接收
#
# print(ret)
#  函数对的返回值有两种情况：1.返回一个值     2.没有值

# 一没有返回值的写法
# def my_fun():
#     # pass
#     # return None
#     # 没有返回值
#             # 第一种情况是不写return，
#             # 相当于写了一个return None
#     # return
#     #第二种情况只写return，
#         # 相当于写了一个return None
#
# #return 的作用   是返回一个值，并且终止函数的继续   返回多个值是以元祖类型
# ret1 = my_fun()
# print(ret1)

# def myfun():
#     for i in range(1,10):
#         if i % 3 == 0:
#             print(i)
#             return {'k':'v'},1
#         print(i)
# ret2,ret3 = myfun()
# print("ret2的值:",ret2,"ret3的值:",ret3)
#   返回值的个数应该跟接收变量个数完全一致


# 打印满足条件的  遇到return会终止   返回值可以是任意的类型
# 用一个变量接收返回值他接收到的是一个元祖





def my_fun(*args):
    print(args)

dic = {"abc":1,"def":2}
my_fun(*dic)

#魔性的用法：
#在调用函数的时候，可以打散：*l（按顺序打散）、**dic（打散）

# def func(*args,**kwargs):
#     print(args)
#     print(kwargs)
#
# func(1,2,3,4,5)


#动态参数
#*args  ：接收所有按照位置传的参数，接收到的是参数组成的元祖
#**kwargs   :接收所有按照关键字传的参数，接收到的是参数组成的字典

#所有的参数的顺序：位置参数，*args，默认参数，**kwargs

def func(*args,**kwargs):
    print(args)
    print(kwargs)

func(1,2,3,4,5,6)

def my_len(lst):                    #  参数：接收参数   ，形式参数  也叫形参
    print(lst)                       #传入的是列表的[1,2,3,4]
    count = 0
    for i in lst:
        count += 1
    return count
# my_len([1,2,3])                      # 参数： 传参数  （传参），是实际参数（实参）

l = [1,2,3,4]

# ret = my_len(l)
#
# print(ret)

# ret1 = len(l)
#
# print(ret1)

# ret3 = my_len("你好！今天天气不错")
# print(ret3)

#参数分为形参 和 实参    传参数可以传任意参数类型，传什么接收什么

# 传参角度看，有两种传参方式：
                #第一种是按照位置传参
                #第二种按照关键字传参



# def my_fun(lst):
#     count = 0
#     for i in lst:
#         count += 1
#     if count > 2:
#         return True
#     else:
#         return False

# def my_fun(lst):
#     if len(lst)>2:
#         return True
#     else:
#         return False
# l = my_fun([1,2,3,4,5])
# print(l)

# def demo(dem):
#     print(dem)
#
# demo(dem=10)            #这是关键字传参

#传多个参数:多个参数可以使用任意数据类型

# def lite(arg1,arg2,arg3):
#     print(arg1)
#     print(arg2)
#     print(arg3)
#
# lite(2,3,arg3=1)
# 按照关键字传参数  和  按照位置传参数是可以混用的
#首先必须先传位置传参 ，然后在按关键字传参，按照为值传完只能接受一个值，不能重复接受

# 形参的分类：1 位置参数：数量必须跟实参数量一致

# def classmate(name,sex="男"):
#     print("姓名：%s,性别：%s" %(name,sex))
#
# classmate("xiaoxiao","男")
# classmate("damao")

#默认参数是可以不传的参数，在不传参数的情况下可以使用默认值，如果传了使用传了的值


# 魔性写法
# def func(lst=[]):
#     lst.append(1)
#     print(lst)
#
#     # 默认参数尽量避免使用可变的类型
#
# func()
# func()
# func()
# func()
#
#
# lst = []
# def func(l=lst):
#     l.append(1)
#     print(l)
#
# func([])
# func([])
# func([])
# func([])

#  动态参数

# def func(a,b,c,k="k",*args):                #在参数前面加个※这个参数就变成动态参数
#                                 #args不能放在最前边，  放最后
#     print(a,b,c,args)                 #使用的时候所以接收过来的参数是元祖形式
#     print(k)
# func(1,2,3,4,5,6,7,[1,2,3,4,5],{"k":"v"})
# # print()

# def func(**kwargs):
#     print(kwargs)
#
# func(a="name",b=2,c=3,d=4)


# def func1(a,*args,k="k",**kwargs):
#     print('a:',a)
#     print('args:',args)
#     print('k:',k)
#     print('kwargs:',kwargs)
#
#
# func1(6,c=1,b=2)

# def my_sum(*args):
#     sum = 0
#     for i in args:
#         sum += i
#         # print(i)
#     return sum
#
# ret = my_sum([1,1,1,1])
# print(ret)



# def func(*args,**kwargs):
#     print(args,kwargs)
#
# func(1,2,3,4,key=5)


def my_sum(*args):
    sum = 0
    # for i in args:
    #     sum += i
    # return sum
    # print(args)
# l ={1,2,3,4}
# ret = my_sum(*l)                #※l  对l进行了拆包  打散  按顺序打散
# print(ret)