2020.6.9 变量表示函数 自定义函数 空函数 自定义函数的错误检查 返回值 函数参数(普通参数 默认参数 可变参数 关键字参数 参数组合)

1、变量表示函数

将一个函数名赋给一个变量，之后可以用该变量表示原函数

A=abs
A(-100)
100

 

2、自定义函数

格式：

def 函数名(参1,参2):

　　函数体

用缩进代替C中的大括号{ }，在def下的缩进表明是同一个函数

def Sort1(A,B):
    if(A>B):
        print(A,'>',B)
    else:
        print(A,'<',B)

Sort1(5,10)
5 < 10

 

3、空函数

用途：还不清楚这个函数要怎么用，但为了保证程序正确，所以提前定义好的函数

格式：函数体写pass

def 函数名(参数……):

　　pass

 

4、自定义函数的错误检查

自定义函数可以通过在函数体中调用数据类型检查函数isinstance来进行参数类型检查和错误抛出

如果要检查多个参数，可以用一个for循环，分别对这多个参数进行类型检查

def Sort1(A,B):
    for i in (A,B):
        if not isinstance(i,(int,float)):
            raise TypeError('Bad Operated Type!')
            exit()
    if(A>B):
        print(A,'>',B)
    else:
        print(A,'<',B)

 

5、返回值

①多个返回值

return 返回值1，返回值2……

用一个变量承接时，会将所有返回值存入一个元组保存，用多个变量承接，则每个变量都对应一个返回值

def Test2(A):
    return A,-A
A=Test2(5)
B,C=Test2(5)
print(A)
print(B,C)

(5, -5) #A
5 -5    #B,C

②没有返回值

没有return而程序运行完毕后，返回空值None

 

6、参数

普通参数：Fun(X) #单变量

默认参数：Fun(X,n=2) #变量赋值

可变参数：Fun(X,n=2,*cal) #变量前加*

关键字参数：Fun(X,n=2,*cal,**kw) #只能是**kw

参数组合：四种参数都有，但是顺序必须按照上述从前到后的顺序依次排列。

 

①普通参数

直接写在括号中的一个变量，没有特别标识

def Fun(X):

　　pass

 

②默认参数

定义时给一个普通参数赋值，当调用函数而该参数缺省时起作用

def Fun(X,n=2):

　　pass

a、在调用函数Fun时，如果人为注明了两个参数的值，如

　　Fun(2,4)

则第二个参数n会采用传入的值4，而非定义时注明的默认值2

b、如果调用时只写了普通参数X的值，如

　　Fun(2)

则第二个参数n取定义时的默认值2

 

普通参数与默认参数间有几点需要注意：

1、普通参数必须在默认参数前

2、默认参数尽量是不可变对象，如果用List对象，可能在调用后改变List的值

3、调用函数时可以人为指明默认参数的值，即类似Fun(2,n=4)这种，但要注意，实参名必须与形参名相同，即不能是d=4,e=4……

 

③可变参数

传入的参数数量是可变的

格式:在参数前加星号*，这样程序在处理地时候，将该参数当做一个元组Tuple传入

在使用时，通常在函数内部，通过for循环迭代访问该可变参数中的每个值。

所以可以把可变参数理解为，传入了一个元组Tuple

例如：一个累加器的程序

def Sum2(*Num):
    sum=0
    for i in Num:
        sum+=i
    return sum
print(Sum2())
print(Sum2(1,3,5,7))

0
16

 

如果有一个List或者Tuple类型的数据想要传入该函数进行运算，可以在实参前加星号*，示例如下

L=[1,3,5,7]
T=(1,3,5,7)
print(Sum2(*L))
print(Sum2(*T))

16
16

或者 在定义函数时，形参前就不加*，此时实参也不用加*

def Sum2(Num):
……
print(Sum2(L))
print(Sum2(T))

16
16

但为了和普通参数区分，可变参数还是加*比较好

 

④关键字参数：

作用：保证前边收到想要参数的同时，不会因为输入者输入了多余的参数而受影响

工作方式：允许传入0或多个含参数名的参数，它们在函数内部自动组装为Dict(Key:Value)类型，Key为参数名，Value为参数值

def Person(name,age,**KW):
    print('name:',name,'age:',age,KW)
Person('Leo','23',City='Wuhan',Size='43')

#print
name: Leo age: 23 {'City': 'Wuhan', 'Size': '43'}

 

注意：1、关键字参数的传入方式一定是Key=Value这种，例如上段实参中的City=xxx，Size=xxx，不能单写一个Value。

2、传入的实参中的Key不加引号，但保存时，Key会自动加引号变为字符串str类型（如上段第3行实参中的City没加引号，第六行输出时自动加上了引号变为了'City'）

 

也可以提前构建好一个Dict对象，将之作为参数传入，但应注意传入时要加双星号**

Dict={'City':'Wuhan','Gender':'Male','Height':175,'Weight':70}
Person('Leo',23,**Dict)

#print
name: Leo age: 23 {'City': 'Wuhan', 'Gender': 'Male', 'Height': 175, 'Weight': 70}

 

⑤参数组合

Fun(X,n=2,*args,**KW)

参数顺序必须按照之前我们介绍时候的先后顺序：普通参数，默认参数，可变参数，关键字参数

其中实参中区别最大的是关键字参数，它按照Key=Value的格式传入，所以看到实参中存在Key=Value的情况，一定是关键字参数

def Fun(a,b=2,*args,**KW):
    print('a=',a,' b=',b,' args=',args,' KW=',KW)
    return
Fun(0)
Fun(0,1)
Fun(0,1,'a')
Fun(0,1,'a','b')
Fun(0,1,*('a','b'))
Fun(0,1,'a','b',A=1)
Fun(0,b=1,args=(1,2))

#print
a= 0  b= 2  args= ()  KW= {}
a= 0  b= 1  args= ()  KW= {}
a= 0  b= 1  args= ('a',)  KW= {}
a= 0  b= 1  args= ('a', 'b')  KW= {}
a= 0  b= 1  args= ('a', 'b')  KW= {}
a= 0  b= 1  args= ('a', 'b')  KW= {'A': 1}
a= 0  b= 1  args= ()  KW= {'args': (1, 2)}

注意第10行，虽然写了args=XXX，但是只有默认参数的参数名=参数才会被正确地传递给默认参数，其余的含有名=数(Key=Value)类型都会被归为关键字参数中。

补充：简易理解：

可变参数——*args——Tuple：当List或者Tuple对象传入时，前加单星号*

关键字参数——**kw——Dict：当Dict对象传入时，前加双星号**

 可变参数用*args，关键字参数用**kw是python的习惯，尽量保持这个习惯