s='金老板啊'
print(len(s))  #内置函数

s='金老板啊'
# def my_len():
#     i=0
#     for k in s:
#         i+=1
#     # print(i)
# print(my_len()) #None
#
#
# s='金老板啊'
# def my_len():  #自定义函数
#     i=0
#     for k in s:
#         i+=1
#     # print(i)
#     return i #返回值
# length=my_len()
# print(length) #4

#函数
# 定义了之后可以在任意需要他的时候调用
# 没有返回长度，只是单纯的打印 为NONE

#返回的重要性(便于后续计算，使用)

#返回值的3种情况
    #没有返回值
        # 不写return
        # 只写return，也是none （return代表结束，跳出循环，也结束这个函数）
        # return None -不常用,和不写一样
    #返回一个值
        #可以返回任何数据类型
        #只要返回就可以接受到
        #如果在一个程序中有多个return，那么只执行第一个。（在控制语句中可以使用多个return）

# def func():
#     return [1,2,3,]
#     return 1
#
# print(func()) #[1, 2, 3]

    #返回多个值
#         #有多少返回值，就用多少变量来接收
# def func2():
#     return 1,2
#
# r1,r2 = func2() #接收
# print(r1,r2) #1 2
#
# def func2():
#     return (1,2)
# # ps：元组是可以解包的
# r1,r2 = func2() #接收
# print(r1,r2) #1 2
        #用一个变量来接收，返回的是一个元组

# def func2():
#     return 1,2
# r3 = func2() #接收
# print(r3) #(1,2)

# 什么是参数？
# def my_length(s): #s：自定义函数只需要0个参数，接收参数，形式参数，简称形参
#     i=0
#     for k in s:   #形式参数s 必须和这里的函数体中的s一致
#         i+=1
#     return i
#
# ret = my_length('asdfg') #传递参数：传参，实际参数，实参
# print(ret) #5

#参数
    #没有参数

    #有一个参数
        #传很什么就是什么
    #有多个参数
        #位置参数

#站在实参（传递参数）的角度上：
    #按照位置传参
    #按照关键字传参
    #可以混着用：但是必须先按照位置传参，再按照关键字传参
                #不能给同一个变量传多个值

# 站在形参的角度上
    #位置参数：必须传，且有几个就传几个
    #默认参数：可以不传，若果不传就是用默认的参数，传了就用传的参数

#只有调用函数的时候
    #按照位置传：直接写参数的值
    #按照关键字：关键字 = 值

#定义函数的时候
    #位置参数:直接定义参数
    # 默认参数，关键字参数：参数名=‘默认的值’
    # 动态参数：可以接收任意多个参数
                #*args：只能接收按位置传参的值，组织成一个元组，参数名之前加*，习惯参数名为args。
                #**kwargs：接收的是按关键字传参的值，组织成一个字典

    #顺序： 位置参数  *args  关键字参数  **kwargs

# def sum(*args):
#     n=0
#     for i in args:
#         n+=1
#     return n
#
# print(sum(1,2,3,4,5,6,8)) #7
    #顺序：必须先定义位置参数，在定义默认参数

# ps：
# 动态参数的另一种传参方式
def func(*args): #站在形参的角度上，给变量加上*，就是组合所有传来的值
    print(args)

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

l=[1,2,3,4,5]
func(*l) #(1, 2, 3, 4, 5) #站在实参的角度上，给序列加上*，就是将这个序列（元组，列表）按照顺序打散。

def func(**kwargs): #站在形参的角度上，给变量加上*，就是组合所有传来的值
    print(kwargs)

func(a=1,b=2)
d={'a':1,'b':2} #定义一个字典d
func(**d)

#函数的注释
def func():
    '''
    这个函数实现了什么功能
    参数1：
    参数2：

    :return:是字符串或者列表的长度
    '''
    pass
　　　　

#默认参数的陷阱问题
    # 如果默认参数的值是一个可变数据类型，
    # 那么每一次调用函数的时候，
    # 如果不传值就公用这个数据类型的资源

# 函数：
# 1、函数的定义
# 2、函数的调用
# 3、函数的返回值 return