Python系列（5）- 函数、抛出错误、参数

- 日理万妓 2023-07-14 05:29 16阅读 0赞

### 文章目录 ###

*  前言
 *  一、函数
 *   *   *   *  1、函数的创建
             *  2、函数的别名
             *  3、空函数
             *  4、调用函数时的报错
             *  5、抛出错误
             *  6、return 的用法
             *  7、小结
 *  二、参数
 *   *   *   *  1、位置参数
             *  2、默认参数
             *  3、可变参数
             *  4、关键字参数
             *  5、命名关键字参数
             *  6、参数组合
             *  7、小结

# 前言 #

本人自学了廖雪峰老师编写的Python教程，将在学习过程中的一些心得、方法 成体系的写成 本Python系列，所举的部分例子可能会和廖雪峰老师举的例子一致，本Python系列仅供大家学习参考，也相当于本人的学习笔记。

# 一、函数 #

#### 1、函数的创建 ####

*  函数的创建使用 def 语句即可

def sum():		# sum为函数名，自定义的
        pass		# pass 语句是占位符，你可以在此写你要实现的功能

*  示例：创建一个与 abs() 函数功能相同的函数my\_abs()

def my_abs(num):
        if num < 0:
            return -num
        else:
            return num

*  在执行函数时，**只要函数遇到了 return 语句**，就会**立马返回** return 后面的参数（变量或常量或函数），这个时候，函数执行完毕
 *  如果**没有 return 语句**，函数执行完会**返回**一个结果，为**None**（空值）
 *  常常用 return 来返回某个想要的结果

既然会创建函数了，接下来就该调用函数了

print(my_abs(-9))		#运行结果是 9

#### 2、函数的别名 ####

我们自己创建的 my\_abs() 函数，my\_abs 为函数名

print(my_abs)
    
    #运行结果
    <function my_abs at 0x00000137F7BD9168>

那什么又是函数的别名呢？  
首先我们需要先知道什么是函数名，函数名就是指向函数对象的引用，他们有一个指向关系，通过函数名，能找到函数对象。那么函数的别名是啥，就是**把函数名赋值给一个变量，那么这个变量也能指向函数对象，就相当于取了一个别名**

print(my_abs)
    a = my_abs
    print(a,a(-9))
    
    # 运行结果
    <function my_abs at 0x00000222A07A9168>
    <function my_abs at 0x00000222A07A9168> 9

#### 3、空函数 ####

*  空函数就是啥功能都没有的一个函数，用 pass 语句作为占位符
 *  一般用于，还没想好怎么写这个函数，先用 pass 语句占位，让代码可以先运行起来

示例：

def my_abs():
        pass

#### 4、调用函数时的报错 ####

*  以自定义的 my\_abs() 函数为例：

def my_abs(num):
        if num < 0:
            return -num
        else:
            return num

参数个数错误：

print(my_abs(-1,2))
    
    # 报错
    TypeError: my_abs() takes 1 positional argument but 2 were given

数据类型错误：

print(my_abs('-1'))
    
    # 报错
    TypeError: '<' not supported between instances of 'str' and 'int'
    
    # 这种也是数据类型错误
    TypeError: bad operand type for abs(): 'str'

#### 5、抛出错误 ####

python可以自定义 抛出错误 的内容

def my_abs(num):
        if not isinstance(num,(int,float)):
            raise TypeError('please input the int of number! ')
        elif num < 0:
            return -num
        else:
            return num

*  isinstance() 可以判断变量的数据类型，not 表示非 ，连起来也就是 如果不是True，就抛出类型错误

运行一下看看：

my_abs('9')
    
    # 运行结果
    TypeError: please input the int of number!

#### 6、return 的用法 ####

def my_abs(num):
        if not isinstance(num,(int,float)):
            raise TypeError('please input the int of number! ')
        elif num < 0:
            return num,'小于零'
        else:
            return num,'大于零'
    
    a = my_abs(-9)
    print(a)
    
    # 运行结果
    (-9, '小于零')

可以看到 **return 返回的是一个元组**，那么我们怎么直接获取这些返回值呢？

a,b = my_abs(-9)
    print(a)
    print(b)
    
    # 运行结果
    -9
    小于零

*  可以看到用 多个变量 来接收返回值就行了

刚才我也说了，如果函数没有执行 return 语句 就结束了的，会返回一个空值

def my_abs(num):
        if not isinstance(num,(int,float)):
            raise TypeError('please input the int of number! ')
        elif num < 0:
            return num,'小于零'
        else:
            num = num			# 没有调用 return 语句
            
    a = my_abs(9)			
    print(a)
    
    # 运行结果
    None

#### 7、小结 ####

*  定于函数用 def 语句，例如： def 函数名(参数):
 *  必要时，可以先对参数做一个类型检查，isinstance() 函数
 *  在函数体，可以用 return 返回函数结果
 *  不写 return 语句，默认为 return none
 *  函数可以同时返回多个值，但实际上返回的是一个元组
 *  没想好写啥时，可以用 pass 语句，先让函数能够运行起来

# 二、参数 #

什么是参数呢？举个例子，刚才自定义的函数 my\_abs(num) 中的 num 就是参数，没错，**函数名后面那个括号里的变量就是参数**。

#### 1、位置参数 ####

*  从以下例子可以看出，-9 对应的是 a ,10 对应的是 b 。按参数位置一一对应，这就是位置参数。

def sum(a,b):
        s = a + b
        return s
    
    print(sum(-9,10))

#### 2、默认参数 ####

*  **默认参数就是让某些参数有一个默认值**，这样用户在调用函数给参数赋初值时，可以**不**用**写**默认参数，此时**默认参数为默认值**，如果**写了，默认参数就为写的值**
 *  在定义函数时，必选参数必须写在前面，**默认参数写在后面**
 *  **定义多个默认参数**时，**经常变化的写在前面**，万年不变的写在后面
 *  **默认参数必须指向不可变对象**，否则默认参数所指向的内容有改变的风险

def sum(a,b=-1):
        s = a + b
        return s
        
    print(sum(-9))			# b 默认为 -1 了
    print(sum(-9,10))
    print(sum(-9,b=10))		# 当定义的默认参数多了，不知道在哪个位置
    						# 可以直接根据参数名来定义
    
    # 运行结果
    -10
    1
    1

#### 3、可变参数 ####

*  可变参数在形式上就是 在一个参数前加上一个星号，例如：有一个参数叫 num ，那么\**把 num 变成可变参数的形式就是 num*
 *  可变参数有什么作用呢？那就是把普通参数（只能接收一个参数）变成**可以接收任意个（可以是0个，也可以是1，2，3…）参数**的参数

def sum(*num):
        s = 0
        for i in num:		# 使用方法是循环
            s = s +i
        return s
    
    print(sum(1,2,3,4,5))
    
    # 运行结果
    15

#### 4、关键字参数 ####

*  关键字参数的形式是 ，在参数前加两个星号，通常用 \*\* **kwargs**来表示
 *  关键字参数和可变参数一样，**可以传入任意个参数**，不同的是这些参数**必须含有参数名**
 *  关键字参数 在调用函数时，**自动封装成一个字典**
 *  关键字参数的作用是，作为扩展函数功能，必要的信息必填，**选填的信息就用关键字参数来实现**

def info(name,age,**kwargs):
        print('name:%s \nage:%s\nother:%s' % (name,age,kwargs))
    
    info('lxn','21',job='student',sex='男')		# 含有参数名
    
    # 运行结果
    name:lxn 
    age:21
    other:{ 'job': 'student', 'sex': '男'}		# 字典

#### 5、命名关键字参数 ####

*  命名关键字参数的作用是**限定参数**，这些限定的参数必须传入，也不可多传，传入参数时根据关键字传入！

def info(name,age,*,job,where):		# 命名关键字参数job,where必须传入
        print('name:%s \nage:%s\njob:%s where:%s' % (name,age,job,where))
    
    info('lxn','21',job='student',where='ChongQing')
    
    # 运行结果
    name:lxn 
    age:21
    job:student where:ChongQing

*  命名关键字参数job,where必须传入，否则报错

def info(name,age,*,job,where):
        print('name:%s \nage:%s\njob:%s where:%s' % (name,age,job,where))
    
    info('lxn','21',job='student')
    
    # 运行结果
    TypeError: info() missing 1 required keyword-only argument: 'where'

*  也不能多传入其它参数，否则报错

def info(name,age,*,job,where):
        print('name:%s \nage:%s\njob:%s where:%s' % (name,age,job,where))
    
    info('lxn','21',job='student',where='ChongQing',test='None')
    
    # 运行结果
    TypeError: info() got an unexpected keyword argument 'test'

#### 6、参数组合 ####

*  在 Python 中，定义函数可以使用必选参数、默认参数、可变参数、关键字参数和命名关键字参数
 *  而且这五种参数类型可以混合使用，除了可变参数无法和命名关键字参数无法组合
 *  参数的顺序必须是： **必选 - 默认 - 可变/命令关键字 - 关键字参数**

def mux(a,b,c=3,*args,**kw):
        print('a-->',a,' b-->',b,' c-->',c,' args-->',args,' kw-->',kw)
    
    mux(1,2)
    mux(1,2,3,4,5,x=6,y=7)   # 位置参数必须写,如果要写后面的可变参数的话
    
    tuple=(1,2)
    dic={ 'x':6,'y':7}
    mux(*tuple,**dic)       # 字典对应的是关键字参数
                            # 元组是将所有元素一次匹配前面的参数类型
    # 运行结果
    a--> 1  b--> 2  c--> 3  args--> ()  kw--> { }
    a--> 1  b--> 2  c--> 3  args--> (4, 5)  kw--> { 'x': 6, 'y': 7}
    a--> 1  b--> 2  c--> 3  args--> ()  kw--> { 'x': 6, 'y': 7}

*  从结果可以看到：**可变参数**收到参数后会**封装成元组**，**关键字参数**收到参数后会**封装成字典**。
 *  \*tuple 或者 \*list 代表依此提取出元组或列表中的元素  
    示例：

li = [i for i  in range(10)]
    print(li)			# 显示列表
    print(*li)			# 只有元素
    
    # 运行结果
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    0 1 2 3 4 5 6 7 8 9

#### 7、小结 ####

*  **默认参数一定要用不可变对象**,如果是可选对象,程序运行时可能会有逻辑错误
 *  \*args 是**可变**参数, args 参数**接收的是一个 tuple**  
    \*\*kw 是 **关键字参数**, kw 参数 **接收的是一个字典**
 *  **必选参数**: **必须有的参数**,用于不可或缺的参数,必须输入
 *  **默认参数**: **给参数一个默认的值**,省得调用参数的时候每次都去写
 *  **可变参数**: 常**用于不知道有多少个参数**,很灵活,可以调用任意个参数,以元组或者列表的形式调用
 *  **关键字参数**: 以字典的形式调用,**常用于可选输入**
 *  **命名的关键字参数**: 是为了**限制调用者可以传入的参数名**,格式是 \*,参数名