python之路day09--函数

￡神魔★判官ぃ 2021-12-24 17:05 236阅读 0赞

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

转载于:https://www.cnblogs.com/hanfe1/p/10385019.html