python函数

1. 内置函数

int() #取整或转为整型

float() #转为浮点型

bool() #转为布尔型

str() #转为字符型

abs()

min()

max()

str.lower() str().upper() str.capitalize()

str.find()

len()长度

2. 函数定义

这就是位置参数

def a(x):
    if x>100:
        return ">100"
    else:
        return "<=100","返回多个值"
b,c  = a(50)
print(c)#返回多个值

return是返回值，把返回值赋值给b

也可以返回多个值，实质就是返回元组

3. 默认参数最好指向不变对象

#像一个原始列表不断添加
def add(new=None,ori=[]):
    ori_ = [3,2,1]
    if new != None:
        ori.append(new)
        ori = ori + ori_
    return ori
a = add("a")
print(a)
a = add("b")
print(a)

第一行：ori=[]是默认参数，也是变量，此时这个默认变量ori 已经指向一块内存

第二行：ori_指向一块内存

第四行：在ori原始那块内存添加元素

第五行：在ori那块原始内存中添加列表

如果第四行和第五行互换，则在每次调用函数时，都会把ori指向新的内存块

3.1

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

最后一行实际时给L开辟了新内存，存[1,2,3]

4. 可变参数

就是加个*，可变参数是元组形式传入函数

def sum(*num):
    s = 0
    for n in num:
        s = s + n * n
    return s
b = [1,2]
c = sum(*b)
a = sum(1,2)
print(a)
print(c)

如果要调用之前存在的列表，可以加个*号

 5. 关键字参数

def a(a,b,**kw):
    if 'city' in kw:
        print(a,b,kw)
a(1,2,city='Beijing')
extra = {'city': 'Beijing', 'job': 'Engineer'}
a(1,2,**extra)

**kw是关键字参数，必须以字典形式传入

检查传入的关键字，只能在程序内部检查

5.1 命名关键字参数

加个*，如果命名关键字参数前有可变参数*，就不再需要额外添加*，

def b(a,b,*args,city,job):
    print(a,b,args,city,job)
b(1,2,3,city=4,job=5)

6. 

def a(b,c=0,*d,e,**kw):
    print(b,c,d,e,kw)
a("b",e="f",d='d')

b 0 () f {'d': 'd'}

参数定义顺序必须是：必须参数，默认参数，可变参数，命名关键字参数，关键字参数

 

7. 递归函数

本身调用本身就是递归函数

每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧.

下述方式是尾递归

def _2(aim, result1):
    if aim == 1:
        return result1
    else:
        return _2(aim-1, aim * result1)
def _1(num):
    return _2(num, 1)
a = _1(5)