函数

1. 函数调用

abs()

max()

int(),float(),str(),bool()强转

函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：

a=abs
print(a(-2))  #2
1
2

2. 定义函数

   def my_abs(x):#def函数名，参数，冒号
       if x>=0:
           return x
       else:
           return -x
   
   print(my_abs(-3)) #3
   1
   2
   3
   4
   5
   6
   7

from abstest import my_abs来导入my_abs()函数 (abtest是py文件)

---

空函数

def nop():
    pass #占位符，什么都不做
1
2

---

参数检查

def my_abs(x):#def函数名，参数，冒号
    if not isinstance(x,(int,float)): #如果x不是整数或浮点数的话
        raise TypeError('bad operand type')
    if x>=0:
        return x
    else:
        return -x
1
2
3
4
5
6
7

---

返回多个值

其实就是返回的一个tuple

def move(x):
    return 1,2
x,y=move(1)
print(x,y)
1
2
3
4

函数的参数

def power(x,n=2) #默认参数

必选参数在前，默认参数在后。把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

调用函数时，也可以不按顺序提供默认参数，但需要指定命名。

enroll(‘Adam’, ‘M’, city=‘Tianjin’)

---

默认参数坑–可变对象list

定义默认参数要牢记一点：默认参数必须指向不变对象！

def add_end(L=[]):
    L.append('END')
    return L
print(add_end()) #['END']
print(add_end()) #['END', 'END']
1
2
3
4
5

修改，L指向不变对象None

def add_end(L=None):
    if L is None:
        L=[]
    L.append('END')
    return L
print(add_end()) #['END']
print(add_end()) #['END']
1
2
3
4
5
6
7

可变参数

传入的参数个数是可变的

def calc(*numbers): #传入的时候可以传入任意多个参数，在函数内部会默认numbers为一个元组
    sum=0
    for num in numbers:
        sum+=num*num
    return sum
print(calc(2,3,4))#可以直接传入多个参数
lss=(2,3,4)
print(calc(*lss)) #可以直接传进来list或tuple，在前面加*就可以
1
2
3
4
5
6
7
8

关键字参数

可以传任意个含参数名的参数

def person(name,age, **kw):
    print('name:', name,'age:',age,'other',kw)

person('mich',30,city='beijing',province='he') #可以指定参数名
person('mich',30,**dict) #或者直接传字典进去
1
2
3
4
5

---

命名关键字参数

def person(name,age,*,city,job): #命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数，调用的时候必须传入参数名
    print(name,age,city,job)
person('k',20,city='Bei',job='soft')#k 20 Bei soft
#person('k',20,'bei',job='soft') # TypeError: person() takes 2 positional arguments

def person(name,age,*args,city,job): #如果函数定义中已经有了一个可变参数,后面的命名关键字参数就不再需要一个特殊分隔符*了
    print(name,age,args,city,job)
person('x',1,'ss','ssw',city='xx',job='sss')
def person(name,age,*args,city='bei',job): #命名关键字参数可以缺省
    print(name,age,city,job)
person('k',20,'bei',job='soft') 

1
2
3
4
5
6
7
8
9
10
11
12

参数组合

参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

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)
1
2
3
4
5

对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。

args = (1, 2, 3, 4)
>>> kw = {'d': 99, 'x': '#'}
>>> f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
1
2
3
4

递归函数

对内存影响：栈，主要是用来存放栈帧的，每执行一个方法就会出现压栈操作，所以采用递归的时候产生的栈帧比较多，递归就会影响到内存，非常消耗内存。而使用循环就执行了一个方法，压入栈帧一次，只存在一个栈帧，所以比较节省内存。

def move(n,a,b,c):#a的盘子借助b移动到c
    if n==1:
        print(a,'--->',c)
    else:
        move(n-1,a,c,b)
        print(a,'--->',c)
        move(n-1,b,a,c)

move(3,'A','B','C')

def cal(num):
    if num==1:
        return num
    return num*cal(num-1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14