2019.7.20 函数

1、类型转换函数

　　

>>> int('123')
123
>>> int(12.4)
12
>>> float(12)
12.0
>>> str(1.2)
'1.2'
>>> bool(5)
True
>>> bool(0)
False

2、函数名

　　将函数名赋予一个变量，可以通过变量名调用函数

>>> a=abs
>>> b=a(-12)
>>> b
12

3、自定义函数

def 函数名（参数a,参数b）:

　　函数体

函数体与其他语句区分的方式是缩进——函数名下的所有缩进都属于该函数，反之则不是该函数的一部分

>>> def Fun(A,B):
...  if A>B:
...   print('A>B')
...  else:
...   print('A<B')
...
>>> Fun(4,5)
A<B

4、空函数

用途：该函数还未知怎么写，需要检验其他程序正确性的时候，就可以用空函数

def nop():
    pass

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

自定义函数在输入参数类型不对的情况下，可以通过在函数体中调用数据类型检查函数isinstance进行类型检查与错误抛出

举个例子：

def FunAbs(x)
    if not isinstance(x,(int ,float)):
        raise TypeError('bad operand type!')
    if x>0:
        return x
    else:
        return -x

FunAbs('A')
TypeError: Bad operand type

6、多个返回值

可以return多个返回值，可以用相同数量的变量去承接这些返回值，这些变量与返回值按位置一一对应，也可以只用一个变量去承接，因为Python返回多个值时是以元组(tuple)形式返回的

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

(5, -5)
5 -5

 

7、没有返回值

没有返回值而程序又运行完毕时，自动返回空值None

 

8、函数参数

默认参数——在某个参数缺省时起作用

现编写一个求指数的函数，参数为底数和指数，默认情况下指数为2，即求平方

def power(x,n=2):
    s=1;
    while n>0:
        s=s*x
        n=n-1
    return s
A=power(4)
B=power(4,4) 
print A
print B

16
256

注：①、必选参数在前，默认参数在后，不然会出错；可以有多个默认参数

②、尽量不要用List对象作为默认参数，或者说，默认参数尽量是不可变对象；多次调用默认参数为List对象的函数时，默认参数List的值会发生变化。

③、也可以用默认参数名=value的写法调用，如上文可以写为B=power(4,n=4)，但是这里的参数名必须与默认参数名一致，即不能写成e=4或者f=4……的形式而必须是n=4

https://www.liaoxuefeng.com/wiki/897692888725344/897693568201440

 

可变参数——传入参数的数量是可变的

方式：在参数前加*号，这样程序运行时默认传出的是元组tuple，举例如下

def cal(*number):
    sum=0
    for i in number:
        sum+=i
    return sum
print ('cal():',cal())
print ('cal(2)',cal(2))
print ('cal(1,3,5,7)',cal(1,3,5,7))

#输出
cal(): 0
cal(2) 2
cal(1,3,5,7) 16

但是这样写的话，传入参数就不能是List对象了，要想传入List或者Tuple对象，就要在主函数调用该函数时，在List或者Tuple前加*号

def cal(*number):
    sum=0
    for i in number:
        sum+=i
    return sum
print ('cal():',cal())
print ('cal(2)',cal(2))
print ('cal(1,3,5,7)',cal(1,3,5,7))
print ('cal([1,3,5,7])',cal(*[1,3,5,7]))

 结果：

cal(): 0
cal(2) 2
cal(1,3,5,7) 16
cal([1,3,5,7]) 16

 

或者在一开始定义函数时，就不加*号，这种情况如下

def cal(number):
    sum=0
    for i in number:
        sum+=i
    return sum
print ('cal([1,3,5,7])',cal([1,3,5,7]))

结果：

cal([1,3,5,7]) 16

 

关键字参数：允许传入0个或者任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict(Key-Value)，举例如下

def person(name,age,**KW):
    print ('name:',name,'  age:',age,'  other:',KW)
person('Bob',17,City='Wuhan')
person('Leo',20,Gender='Male',Height=176)

结果：

name: Bob   age: 17   other: {'City': 'Wuhan'}
name: Leo   age: 20   other: {'Gender': 'Male', 'Height': 176}

 

用途：保证收到想要参数的同时，不影响调用者输入其他参数

 

也可以在函数调用前创建好一个dict对象，用该dict对象作为输入的关键字参数，举例如下：

def person(name,age,**KW):
    print ('name:',name,'  age:',age,'  other:',KW)
KW={'City':'Wuhan','Gender':'Male','Height':176}
person('Bob',17,city=KW['City']) #关键字参数的格式一定是Key=Value这种，不能只写Value
person('Leo',20,**KW)

结果：

name: Bob   age: 17   other: {'city': 'Wuhan'}
name: Leo   age: 20   other: {'City': 'Wuhan', 'Gender': 'Male', 'Height': 176}

 

与可变参数的区别在于，在调用函数时，关键字参数的形式一定是Key=Value，而且这个Key多是str字符串

 

 

参数组合

参数包括必选参数，默认参数，可变参数和关键字参数，我们用一个例子把它们组合到一个函数中去

组合时，排列顺序一定是按照上一行说的顺序排列，不然会出错

def FunTest(A,B,C=0,*args,**kw):
    print ('A:',A,'  B:',B,'  C:',C,'  args:',args,'  KW:',kw)
FunTest(1,2)
FunTest(1,2,3)
FunTest(1,2,3,'a','b')
FunTest(1,2,3,args=('a','b'))
FunTest(1,2,3,'a','b',x=99) #这里的x不带引号

结果：

A: 1   B: 2   C: 0   args: ()   KW: {}
A: 1   B: 2   C: 3   args: ()   KW: {}
A: 1   B: 2   C: 3   args: ('a', 'b')   KW: {}
A: 1   B: 2   C: 3   args: ()   KW: {'args': ('a', 'b')}
A: 1   B: 2   C: 3   args: ('a', 'b')   KW: {'x': 99}

 

也可以构建tuple类型的args和dict类型的kw

args=(1,2,3,4)
kw={'x':99}
FunTest(*args,**kw)

#结果：
A: 1   B: 2   C: 3   args: (4,)   KW: {'x': 99}

 

对于任何函数，都可以通过类似fun(*args,**kw)的形式调用它无论其参数是如何定义的，其中args中存放的是必选参数，默认参数和可变参数，kw中存放的是关键字参数

注：args接收的是tuple，kw接收的是dict

 

可变函数既可以直接传入：

func(1,2,3)

也可以先组装list或者tuple，再通过*args传入：

func(*[1,2,3])
  
func(*(1,2,3))

　

关键字参数既可以直接传入：

func(a=1,b=2)

也可以先组装成dict，再通过**kw传

func(**{'a':1,'b':2})

直接传入时，key不带引号，组装为dict时，key要带引号