day09 -- 函数基础之函数的定义、返回值以及函数的参数

偏执的太偏执、 2021-11-29 13:02 555阅读 0赞

# 目  录 #

*  # 一、函数的定义 #
 *  # 二、函数的返回值 #
 *  # 三、函数的参数 #

## 　　　　　　位置参数 ##

## 　　　　　　默认值参数 ##

## 　　　　　　可变长参数 ##

##                          　　　 ##

# 一、函数的定义 #

## 函数定义的3中方式： ##

1、有参函数：定义时有参，调用时也要传入参数

def func(x,y):
        """求和"""
        n = x+y
        print(n)
    func(1,2)  # 函数名+括号，函数的调用

2、无参函数：函数定义时无参，即调用时也无需传入参数

def func():
        print('hello world!')
    func()  # 函数名+括号，函数的调用

3、空函数：当你知道需要写个函数实现某个功能，但是还不知道如何去写的时候，可以先写一个空函数占位。

def func():
        pass

## 知识点引入：自己制造的函数工具，存在的两个缺点。 ##

# s = 'just do it'
    list = [1,2,3,4]
    def my_len():
        count = 0
        for i in s:
            count += 1
        print(count)
    my_len()  # 10

总结：我们制造的函数有两个缺点

1、没有返回值，只能单纯地打印

2、调用时只对指定的字符串s执行，没有其他参数。

引出函数的两个知识点：函数的返回值和函数的参数。

# 二、函数的返回值 #

## 函数要想返回给调用者值，就要用到关键字return。 ##

对于关键字return有以下五种情况：

# 函数内要想返回给调用者值 必须用关键字return
    """
    不写return
    只写return
    写return None
    写return返回一个值
    写return返回多个值
    """

1、不写return：函数默认返回一个None

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

def func():
        n = '哈哈哈哈'
        #print(n)
    res = func()
    print(res)  # None

2、只写return：只写return会返回None，**同时return还可以结束函数体代码的执行**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

def func():
        l = ['jason','tank','egon','sean']
        while True:
            for i in l:
                if i == 'tank':
                    #break  # 会一直打印‘jason不是这个人’
                    return  # 只返回一句，‘jason不是这个人！’
                    print('打印返回！')  # 在return下这句话永远不会打印
                print("%s不是这个人！"%i)
    res = func()
    print(res)  # None

3、写return None：和上面只写return是一样的

4、写return 返回一个值：这个值可以是任意的数据类型

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# return只返回一个值,这个值可以是任意的数据类型
    def func():
        return [1,2,3,4]
    res = func()
    print(res)  # [1, 2, 3, 4]

5、写return返回多个值：return会将多个值以元组的形式返回给调用者

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# return返回多个值,return会将多个值以元组的形式返回给调用者
    def func():
        return 1,2,3,4
    res = func()
    print(res)  # (1, 2, 3, 4)
    
    def func():
        return 'a','b','c'
    res = func()
    print(res)  # ('a', 'b', 'c')

注意一下两种情况：

1、为什么当return返回多个值时，结果是以元组的形式？**函数不希望自己处理的值被修改**

**　　**2、返回多个值，并且不想让return帮你做修改 ----自己手动加上你想要的数据类型。

def func():
        return [[1,2],[1,2,3],[4,5,6]]  # 手动加入列表类型
    res = func()
    print(res)  # [[1, 2], [1, 2, 3], [4, 5, 6]]

### 函数返回值总结： ###

1、所有的函数都有返回值，无论你写不写return，不写return的情况下默认返回None

2、有时候写return 或return None并不是为了考虑返回值，而是为了**结束函数的运行**，终止函数体代码的执行。

# 三、函数的参数 #

函数的参数两大类型分为：**形参和实参。**

个人理解：形参就像变量名，实参就像是变量名对应的值，当调用函数的时候就将实参赋值给形参。

形参：当函数定义时，括号内的变量名就是函数的形式参数，简称形参。

实参：当函数进行调用时，括号内实际传入的值就是函数的实际参数，简称实参。

**注意**：形参和实参的绑定关系只在函数调用阶段有效，当函数执行完毕后自动解除；只在函数内部有效，函数外部无影响。

### 函数的简易结构如下： ###

# 函数的简易结构：
    def func(形参1,形参2...):
        """ 注释：函数的作用，形参的作用"""
        函数体代码1
        函数体代码2
        ...
        return  函数的返回值

## 1、位置参数 ##

位置参数：在函数定义阶段，在括号内从左到右依次传入的变量名就是位置参数。

位置形参在调用时必须为其传值；

位置实参传入的值必须与位置形参的值一一对应。

def func(x,y):
        if x > y:
            return x
        return y
    res = func(23,12)   # 位置实参传值时与形参一一对应
    print(res)  # 23

### (由上引出)参数的传入有以下3种方式： ###

1、位置传参：位置实参和位置形参要注意一一对应。

2、关键字传参：

def func(x,y):
        if x > y:
            return x
        return y
    res = func(y=23,x=100)   # 关键字传参
    print(res)  # 100

3、位置和关键字混合传参：

# 混合传参要注意的问题
    def func(x,y):
        if x > y:
            return x
        return y
    # res = func(23,y=100)   # 混合传参  100
    # res = func(23,x=100)  # 报错，位置参数x被重复赋值
    res = finc(x=23,100)  # 报错，位置参数要排在关键字参数的前面
    print(res)  # 100

关于混合传参的总结：

"""
    注意:在函数的调用阶段 位置参数和关键字参数可以混合使用
    但是必须保证
        1.位置参数必须在关键字参数的前面(越短的越靠前,越长的越复杂的越靠后)
        2.同一个形参不能被多次赋值
    """

## 2、默认值参数 ##

### 默认值参数：在函数定义阶段，括号内的形参就已经被赋值，这样的参数就是默认值参数 ###

注意：1、函数调用时可以不用给默认值形参传值，默认值参数使用已经绑定好的值。

2、函数调用时如果给默认形参传值，默认参数句改变你赋给它的值。

3、在函数定义阶段，默认值形参必须放在位置形参的后面。

### 面试题坑点： ###

# 要求分别打印出每个人的姓名和爱好
    def info(name,hobby,l=[]):  # 默认值参数 l=[]
        l.append(hobby)
        print('%s 的爱好是：%s'%(name,l))
    info('jason','study')
    info('tank','生蚝')
    info('kevin','喝腰子汤')
    info('egon','女教练')
    
    >>>:结果变成每个人‘爱好’的叠加
    
    jason 的爱好是：['study']
    tank 的爱好是：['study', '生蚝']
    kevin 的爱好是：['study', '生蚝', '喝腰子汤']
    egon 的爱好是：['study', '生蚝', '喝腰子汤', '女教练']

### 出错原因： ###

因为函数默认形参是列表 l = \[\] ,每一个name都会指向该列表 l ，当一个人的爱好添加进 l ，列表 l 发生改变之后所有name对应的 列表 l都会发生改变。

### 解决办法有以下两种： ###

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

# 解决方法
    def info(name,hobby,l=None):  # 将默认参数l设定为None
        if l == None:  # 如果l== None，就将其赋值为空列表，再依次添加元素
            l = []
            l.append(hobby)
            print('%s 的爱好是：%s'%(name,l))
    info('jason','study')
    info('tank','生蚝')
    info('kevin','喝腰子汤')
    info('egon','女教练')
    >>>:
    jason 的爱好是：['study']
    tank 的爱好是：['生蚝']
    kevin 的爱好是：['喝腰子汤']
    egon 的爱好是：['女教练']

第一种方法

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

def info(name,hobby,l=[]):  # 将l默认设定空列表
        l.append(hobby)
        print('%s 的爱好是：%s'%(name,l))
    info('jason','study',[])  # 为每一个函数传入实参空列表
    info('tank','生蚝',[])
    info('kevin','喝腰子汤',[])
    info('egon','女教练',[])
    >>>:
    jason 的爱好是：['study']
    tank 的爱好是：['生蚝']
    kevin 的爱好是：['喝腰子汤']
    egon 的爱好是：['女教练']

第二种方法

## 3、可变长参数 ##

可变长参数站在调用函数**实参的角度来看**，有时候实参传入的个数不固定，因此形参的个数也就不固定；

站在形参的角度来看：可以接收多余的（溢出的）位置参数和关键字参数。

### 站在形参的角度来，看 \* ###

# 形参中的*会将多余的(溢出的)位置实参 统一用元组的形式处理 传递给*后面的形参名
    def func(x,y,*z):
        print(x,y,z)
    
    func(1,2,3,4,5,6,7,8,9)  # 1 2 (3, 4, 5, 6, 7, 8, 9)

### 站在实参的角度来，看 \* ###

# 站在实参的角度 看 *
    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,4,5,6])  # *会将列表打散成位置实参一一传入等价于func(1,2,3,4,5,6)
    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(1,3, a=11,b=12,c=23)  # 1 3 {'a': 11, 'b': 12, 'c': 23

### 站在实参的角度来，看 \*\* ###

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(x=1,y=2,z=3)
    # func(**d)  # 等价于func(x=1,y=2,z=333)
    # **会将字典拆封成 key = value的形式

坑点：

# **:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数
    
    def func(x,y,z):
        print(x,y,z)
    #d = {'name':'jason','age':19,'hobby':'run'}  # 报错，**是将字典打散按关键字传参
    d = {
        'x'：'jason','y':19,'z':'run'}
    func(**d)  # jason 19 run

### 总结：\* 和 \*\* ###

"""
    总结 * 与 **
        *在形参中能够接受多余的位置参数 组织成一个元祖赋值给*后面的变量名
        **在形参中能够接受多余的关键字参数 组织成一个字典赋值给**后面的变量名
        
        
        *:在实参中 *能够将列表 元祖 集合 字符串 打散成位置实参的形式传递给函数
            (*就看成是for循环取值)
        **:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数
    """

###  需求：无论调用者按照正确的方式怎样传参，函数都可以正常运行 ###

Python推荐的\* 和 \*\* 的使用方式：

"""
    注意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/qinsungui921112/p/11159715.html

[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20211129/9a013b8835654e2a8f9ba6503ea257b2.png