python函数

Posted 2021-03-24 blogbo

三、函数

　　1.调用函数

abs(100)
abs(-20)
max(1,2)
max(2,3,1,-5)

　　数据类型转换

int(‘123‘)
int(12.34)
float(‘12.34‘)
str(1.23)
str(100)
bool(1)

　　2.定义函数
　　return是返回值，一般放在函数的最后，一旦执行到return时，函数就执行完毕并将结果返回，且return语句块结束之后后面的代码是不执行的，即一旦遇到return结束整个函数。

def my_abs(x):
    if x>=0:
        return x
    else:
        return -x
my_abs(-1) #1

　　如果没有return语句，函数执行完毕后也会返回结果，只是结果为none

　　返回多个值

def ret_demo1():
    return 1,2,3,4
def ret_demo2():
     return 1,[‘a‘,‘b‘],3,4
ret1 = ret_demo1()
ret2 = ret_demo2()
print(ret1)
print(ret2)

(1, 2, 3, 4)
(1, [‘a‘, ‘b‘], 3, 4)

　

def ret_demo2():
     return 1,[‘a‘,‘b‘],3,4
a, b, c, d = ret_demo2()
print(a, b, c, d) #返回多个值，可以用一个或多个值来接收
print(a)

1 [‘a‘, ‘b‘] 3 4
1

　　

　　

　　

　　添加了参数检查的函数,数据类型检查可以用内置函数isinstance()实现

def my_abs(x):
    if not isinstance(x,(int,float)):
        raise TypeError(‘bad operand type‘)
    if x>=0:
        return x
    else:
        return -x

　　求根

import math
math.sqrt(10) 

　　3.函数的参数

　　位置参数

def power(x):
    return x*x

def power(x,n):#x的n次方
    s = 1
    while n>0:
        n = n-1
        s = s*x
    return s 

　　默认参数

def power(x,n=2): #其中n=2是默认参数，x的平方
    s = 1
    while n>0:
        n = n-1
        s = s*x
    return s

　　默认参数可以简化函数的调用：

　　1、必选参数在前，默认参数在后，否则python的解释器会报错

　　2、当函数有多个参数，把变化大的参数放前面，变化小的参数放后面，变化小的参数就可以作为默认参数

def enroll(name, gender, age=6, city=‘Beijing‘):
    print(‘name:‘,name)
    print(‘gender:‘,gender)
    print(‘age:‘,age)
    print(‘city:‘,city)
enroll(‘Bob‘,‘M‘,7)
enroll(‘Bob‘,‘M‘,city=‘tianjing‘)

name: Bob
gender: M
age: 7
city: Beijing
name: Bob
gender: M
age: 6
city: tianjing

def add_end(L=[]):
    L.append(‘END‘)
    return L
add_end()
add_end(L=[])
add_end(L=[1,2,3])
add_end([1,2,3,4])

[‘END‘]
[‘END‘]
[1, 2, 3, ‘END‘]

[1, 2, 3, 4, ‘END‘]

　　多次循环add_end()END会逐次增加，原因在于：Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。更改如下，要用None这个不可变对象来实现。

def add_end(L=None): #这里的None也可以是任何其他的东西
    if L is None:
        L = []
        L.append(‘END‘)
    return L
add_end(L=[]) 
def add_end(L=a): #比如，这里的None也可以是a
    if L is a:
        L = []
        L.append(‘END‘)
    return L
add_end()
add_end([])
add_end([1,2,3])

　　可变参数

　　可变参数就是传入的参数的个数是可变的，可以是1,2,3,4...还可以是0个

def calc(numbers): #同理，numbers可以用其他的东西代替
    sum = 0
    for n in numbers:
        sum = sum + n * n #n方相加
    return sum
calc([1,2,3])#参数里面没有加*，那么只能是list或参数calc([1,2,3]),calc((1,2,3)) #14

def calc(*numbers):
    sum = 0 
    for n in numbers:
        sum = sum + n*n
    return sum
calc(1,2,3)#加了参数，就可以直接是calc(1,2,3) #14

def calc(*numbers):
    sum = 0 
    for n in numbers:
        sum = sum + n*n
    return sum
num = [1,2,3]
calc(*num) #可以通过这样的方式直接将list的所有元素作为可变参数传进去 #14

　　可变参数都是加* 的，不加的话就要作为list或者tuple

　　关键字参数
　　可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple，而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

def person(name,age,**kw):
    print(‘name：‘,name,‘age:‘,age,‘other:‘,kw)
person(‘Michael‘,30)#name,age为必选参数，kw为关键字参数，在调用该函数时，可以值传入必选参数 #结果：name： Michael age: 30 other: {}

　　也可以传入任意个数的关键字参数

def person(name,age,**kw):
    print(‘name：‘,name,‘age:‘,age,‘other:‘,kw)
person(‘Bob‘,35,city=‘Beijing‘)#必须是A = ‘B‘的形式，可以是多个
person(‘Adam‘,45,gender=‘M‘,city=‘Tianjin‘)

name： Bob age: 35 other: {‘city‘: ‘Beijing‘}
name： Adam age: 45 other: {‘gender‘: ‘M‘, ‘city‘: ‘Tianjin‘}

　　用处：比如做一个用户注册的功能，除了用户和年龄是必填，其他选填，利用关键字参数来定义就可以满足

def person(name,age,**kw):
    print(‘name：‘,name,‘age:‘,age,‘other:‘,kw)
#可以先组装出一个dict，然后把其转换成关键字参数传进去
extra = {‘city‘:‘Beijing‘,‘job‘:‘Engineer‘}
person(‘Jack‘,24,city=extra[‘city‘],job=extra[‘job‘]) #**必须是‘‘=‘‘的格式,之后变成了字典的形式

name： Jack age: 24 other: {‘city‘: ‘Beijing‘, ‘job‘: ‘Engineer‘}

　　简化方法

person(‘Jack‘,24,**extra)

name： Jack age: 24 other: {‘city‘: ‘Beijing‘, ‘job‘: ‘Engineer‘}

　　命名关键字参数

　　限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字段  

def person(name,age,*,city,job):
    print(name,age,city,job)
person(‘Jack‘,24,city=‘Beijing‘,job=‘Engineer‘) #Jack 24 Beijing Engineer #和上面的不一样，上面的是{}形式，这里只是字典的value值
person(‘Jack‘,24,city=‘Beijing‘,job=‘Engineer‘，sex=‘F‘) #SyntaxError: invalid character in identifier

　　如果函数定义中已经有了一个可变参数，后面跟着的就变成了命名关键字参数，此时就不再需要一个特殊分隔符*

def person(name,age,*args,city,job):
    print(name,age,args,city,job)
person(12,23,24,‘ddd‘,‘fff‘,city=‘Beijing‘,job=‘E‘)

12 23 (24, ‘ddd‘, ‘fff‘) Beijing E

　　由于命名关键字参数city具有默认值，调用时，可不传入city参数

def person(name,age,*,city=‘Beijing‘,job):
    print(name,age,city,job)
person(‘Jack‘,24,job=‘Engineer‘)

Jack 24 Beijing Engineer

　　

def f1(a,b,c=0,*args,**kw):
    print(‘a=‘,a,‘b=‘,b,‘c=‘,c,‘args=‘,args,‘kw=‘,kw)
def f2(a,b,c=0,*,d,**kw):
    print(‘a=‘,a,‘b=‘,b,‘c=‘,c,‘d=‘,d,‘kw=‘,kw)
f1(1,2)
f1(1,2,c=3)
f1(1,2,3,‘a‘,‘b‘)
f1(1,2,3,‘a‘,‘b‘,x=99)
f1(1,2,d=99,ext=‘None‘)

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= (‘a‘, ‘b‘) kw= {‘x‘: 99}
a= 1 b= 2 c= 0 args= () kw= {‘d‘: 99, ‘ext‘: ‘None‘}

args = (1,2,3,4)
kw = {‘d‘:99,‘x‘:‘#‘}
def f1(a,b,c=0,*args,**kw):
    print(‘a=‘,a,‘b=‘,b,‘c=‘,c,‘args=‘,args,‘kw=‘,kw)
f1(*args,**kw)
args = (1,2,3)
kw = {‘d‘:88,‘x‘:‘#‘}
def f2(a,b,c=0,*,d,**kw):
    print(‘a=‘,a,‘b=‘,b,‘c=‘,c,‘d=‘,d,‘kw=‘,kw)
f2(*args,**kw)

a= 1 b= 2 c= 3 args= (4,) kw= {‘d‘: 99, ‘x‘: ‘#‘}
a= 1 b= 2 c= 3 d= 88 kw= {‘x‘: ‘#‘}

　　4.递归函数

　　使用递归函数需要注意防止栈溢出，在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层帧，每当函数返回，栈就会减一层栈帧，由于栈的大小不是无限的，所以，递归函数用的次数过多，会导致栈溢出。

def fact(n):
    if n==1:
        return 1 #如果return 1，整个函数就结束了
    return n*fact(n-1) #因为引入了乘法表达式，所以不是尾递归

　　解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看作是一种特殊的尾递归也是可以的
　　尾递归是指，在函数返回的时候，调用自身本身，并且return语句不能包含表达式，这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次都只占用一个栈帧，不会出现溢出情况

def fact(n):
    return fact_iter(n,1)
def fact_iter(num,product):
    if num == 1:
        return product
    return fact_iter(num-1,num*product)#仅指递归函数本身，num-1和num*product在函数调用前就会被计算，不影响函数调用 #结果：阶乘