第九天

r囧r小猫 2021-11-11 10:56 327阅读 0赞

今日所得

函数基本使用

函数的参数

函数的返回值

# 函数内要想返回给调用者值 必须用关键字return
    """
    不写return
    只写return
    写return None
    写return返回一个值
    写return返回多个值
    """
    # 不写return:函数默认返回值None
    def func():    
        print('hahaha')
    res = func()
    print(res)
    
    # 只写return,return除了可以返回值之外,还可以直接结束整个函数的运行
    # 只写return 返回的也是None(None就表示什么都没有)
    def func()
        l = ['jason','egon','tank']
        while True:
            for i in l:
                if i == 'egon':
                    return
                print(i)
    res = func()
    print(res)
    
    
    # 写returnNone,跟上面的只写return是一样的
    def func():
        return None
    res = func()
    print(res)
    
    
    
    # 写return返回一个值,这个值可以是Python的任意类型数据
    def func():
        return '123'
    def func1():
        return [1,2,3]
    def func2():
        return {
         'name':'jason'}
    def func3():
        return (1,)
    def func4():
        return {1,2,3,4,5}
    def func5():
        return True
    print(func(),func1(),func2(),func3(),func4(),func5())
    
    
    # 写return返回多个值,return会自动将多个值以元组的形式返回给调用者
    """
    1.为什么组织成元祖返回
        函数不希望自己处理的结果被修改
    2.如何不返回元祖
        
    """
    def func():
        return 1,2,3  # 返回结果是(1,2,3)
    res = func()
    print(res)
    
    
    def func1():
        return 'a','b','c'  # ('a','b','c')
    res1 = func1()
    print(res1)
    
    
    def func2():
        return[1,2,3],[1,2,3],[1,2,3]  # ([1, 2, 3], [1, 2, 3], [1, 2, 3])
    res2 = func2()
    print(res2)
    
    
    def func3():
        return {
         'name':'jason'},{
         'username':'tank'},{
         'user_name':'egon'}  # ({'name': 'jason'}, {'username': 'tank'}, {'user_name': 'egon'})
    res3 = func3()
    print(res3)
    
    
    # 返回多个值,并且不想让return帮你做处理,自己手动加上想返回的数据类型符号
    def func4():
        return[[1,2,3],[1,2,3],[1,2,3],[1,2,3]]
    res = func4()
    print(res)
    """
    1.所有的函数都有返回值,无论你写不写return
        python中所有的函数都有返回值 不写的情况下默认返回None
    
    2.光写return 或者return None并不是为了考虑返回值 而是为了结束函数的运行
    
    """

函数的参数概要

s = 'hello'
    l = [1.2,3,4]
    # print(len(s))
    # print(len(l))
    
    def my_len(args):  # 需要0个参数
        print(args)
        n = 0
        for i in args:
            n += 1
        return n
    # res = my_len()
    # print(res)
    my_len(l)  # 给my_len传了一个参数
    my_len('asda')
    print(my_len('hello'))
    print(my_len('hello world'))
    print(my_len([1,2,3,4,5]))
    
    """
    函数参数的两大类型
        形参:在函数的定义阶段 括号内写的变量名 叫做该函数的形式参数 简称 形参
        实参:在函数的调用阶段 括号内实际传入的值 叫做实际参数 简称 实参
        
        形参与实参的关系
            形参就相当于变量名,而实参就相当于变量的值
            函数调用传参的过程 就是给形参变量名赋值的过程
        
        注意:形参和实参的绑定关系只在函数的调用阶段有效,函数运行结束关系自动解除
        只在函数内部有效 函数外部无任何影响
        
        
        函数的简易结构
            def 函数名(形参1,形参2...):
                '''函数的注释 用来描述该函数的作用以及各个形参的类型'''
                函数体代码1
                函数体代码2
                ...
                return 函数的返回值
        
    """
    
    
    # def func(x,y):
    #     """
    #     该函数的作用
    #     :param x: 对形参x的解释
    #     :param y: 对形参y的解释
    #     :return: 对函数返回值的解释
    #     """
    #     print('hahaha')
    #     return 'heihei'
    #
    # print(help(func))
    # print(help(len))

位置参数

# 位置函数:在函数定义阶段按照位置从左到右依次书写的变量名,叫做函数位置形参
    # 位置形参在调用的时候,必须为其传值
    def my_max(x,y):
        print(x,y)
        if x > y:
            return x
        else:
            return y
    # res = my_max(1)  # 在调用函数的时候,少一个实参不行
    # res = my_max(1,2,3)  # 在调用函数的时候,多一个实参也不行
    # res = my_max(20,10)
    
    # 位置实参:在函数的调用阶段,传入的参数会按照位置一一对应形参
    
    
    # 第一种直接按照位置传 一一对应
    
    # 第二种指名道姓的传  >>>:关键字传参
    # my_max(y = 20,x = 10)
    # my_max(10,y = 20)  # 位置和关键字混合使用
    # my_max(20,y = 40)
    """
    注意:在函数的调用阶段,位置参数和关键字参数可以混合使用
    但是必须保证
        1.位置参数必须在关键字参数的前面(越短的越靠前,越长的越复杂的越靠后)
        2.同一个形参不能被多次赋值    
    """

默认值参数

# 默认值参数:在函数的定义阶段,形参(变量名)就已经被赋值了
    # 在调试的时候可以不为默认值形参传值,默认使用定义阶段就已经绑定的值
    # 在调用的时候如果可以给默认值形参传值,那么就使用你传的值
    # 在定义阶段默认值形参必须放在位置形参的后面
    
    def my_max(x,y = 100):
        if x > y:
            return x
        return y
    res = my_max(200)
    res1 = my_max(200,1000)
    res2 = my_max(y = 200,x = 1000)
    
    
    def register(username,age,gender = 'male'):
        print(username,age,gender)
    register('jason',18)
    register('tank',18)
    register('egon',18)
    register('kevin',18)
    register('xiaohou',17,'female')
    
    # 默认值参数的应用场景
    # 当形参接收到的值比较单一的情况下,通常可以考虑用默认值形参
    
    
    面试问题:
    def info(username,hobby,l=None):
        if l == None:
            l = []
        l.append(hobby)
        print('%s 的爱好是 %s'%(username,l))
    info('jason','study')
    info('tank','生蚝')
    info('kevin','喝腰子汤')
    info('egon','女教练')
    
    # 解决方法1
    info('jason','study',[])
    info('tank','生蚝',[])
    info('kevin','喝腰子汤',[])
    info('egon','女教练',[])
    
    # 解决方法2
    info('jason','study')
    info('tank','生蚝')
    info('kevin','喝腰子汤')
    info('egon','女教练')
    
    
    """
    函数在定义阶段 内部所使用的变量都已经初始化完毕了
    不会因为调用的位置的变化 而影响到内部的值(暂时可忽略)
    
    
    函数无论在什么地方被调用
    都会跑到函数定义阶段去执行代码
    形参中用到的值都是往函数定义阶段代码往上找
    """

可变长参数

# 可站在调用函数传递实参的角度,实参的个数不固定的情况
    # 也就意味形参也不固定
    # 站在形参的角度,可以用*和**来接收多余的(溢出的)位置参数和关键字参数
    
    
    # 站在形参的角度看 *
    # 形参中的 * 会将多余的(溢出的)位置实参,统一用元组的形式处理.传递给 * 后面的形参名
    def func(x,y,*z):
        print(x,y,z)  # (3,45,6,7,8,9,5)
    func(1,2,3,45,6,7,8,9,5)
    
    
    # 站在实参的角度看 * 
    def func(x,y,z):
        print(x,y,z)
    l = [1,2,3]
    a,b,c = l  # 解压赋值
    func(a,b,c)
    func(*[1,2,3])  # * 会将列表打散成位置实参一一传入,等价于func(1,2,3)
    
    
    def func(x,*z):
        print(x,z)
    func(1,*{1,2,3})  # *在形参中只能接收多余的位置实参,不能接收关键字实参
    # *只能将列表 元组 集合 字符串
    # *的内部你可以看成是for循环
    
    
    # 站在实参角度看 **
    def func(x,y,z):
        print(x,y,z)
    func(12,3,4)
    func(x = 1,y = 2,z = 3)
    d = {
         'x':1,'y':2,'z':333}
    func(**d)  # 等价于func(x = 1,y = 2,z = 333)
    # **会将字典拆分成key = value的形式
    
    
    
    """
    总结 * 与 **
        *在形参中能够接受多余的位置参数 组织成一个元祖赋值给*后面的变量名
        **在形参中能够接受多余的关键字参数 组织成一个字典赋值给**后面的变量名
        
        
        *:在实参中 *能够将列表 元祖 集合 字符串 打散成位置实参的形式传递给函数
            (*就看成是for循环取值)
        **:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数
    """
    
    # 需求 你写的函数 无论调用者按照正确传参的方式无论怎么传 你的函数都能够正常执行
    # def func1(*x,**y):
    #     print(x,y)
    # func1(1,2,3,4,5,6,x=1,y=2,z = 3)
    
    """
    注意python推荐形参*和**通用的写法
    """
    # def func2(*args,**kwargs):
    #     print(args,kwargs)
    # func2(1,2,3,4,5,6,x=1,y=2,z = 3)

转载于:https://www.cnblogs.com/AbrahamChen/p/11158514.html