我们以自定义一个求绝对值name的函数为例：

def name(x):
    if x >= 0:
        return x
    else:
        return -x

函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。
如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。
return None可以简写为return。

空函数

如果想定义一个什么事也不做的空函数，可以用pass语句：

def nop():
    pass

位置参数

我们先写一个计算x2的函数：

def power(x):
    return x * x

对于power(x)函数，参数x就是一个位置参数。
可以把power(x)修改为power(x, n)，用来计算xn

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

默认参数

新的power(x, n)函数定义没有问题，但是，旧的调用代码失败了，原因是我们增加了一个参数，导致旧的代码因为缺少一个参数而无法正常调用，这个时候，默认参数就排上用场了。由于我们经常计算x2，所以，完全可以把第二个参数n的默认值设定为2：

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

默认参数很有用，但使用不当，也会掉坑里。默认参数有个最大的坑
先定义一个函数，传入一个list，添加一个END再返回：

def add_end(L=[]):
    L.append('END')
    return L

当你正常调用时，结果似乎不错

>>> add_end([1, 2, 3])
[1, 2, 3, 'END']
>>> add_end(['x', 'y', 'z'])
['x', 'y', 'z', 'END']

当你使用默认参数调用时，一开始结果也是对的：

>>> add_end()
['END']

但是，再次调用add_end()时，结果就不对了：

>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']

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

要修改上面的例子，我们可以用None这个不变对象来实现：

def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    return L

现在，无论调用多少次，都不会有问题：

>> add_end()
['END']
>>> add_end()
['END']

命名关键字参数

对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过kw检查。
我们希望检查是否有city和job参数：

def person(name, age, **kw):
    if 'city' in kw:
        # 有city参数
        pass
    if 'job' in kw:
        # 有job参数
        pass
    print('name:', name, 'age:', age, 'other:', kw)

函数返回值

def 函数名() ， 函数体 ， return 数据

def mySum(a, b):
    result = a + b
    return result
res = mySum(4, 5)
print(res)

注意事项：

1.return后续代码不会被执行
2.只能返回一次
3.如果要返回多个数据，可先把多个数据包装成一个集合。整体返回（列表、元组、字典.......）

def caculate(a, b):
    he = a + b
    cha = a - b
    return (he, cha)
res = caculate(4, 5)
print(res)

函数的嵌套

def outFun():   
    def innerFun_0():#1.在内部定义一个函数
        print("i am first innerFun")
        return    
    
    def innerFun_1():#2.在内部定义另外一个函数
        print("i am second innerFun")
        return      
    
    innerFun_0()   #3.使用innerFun_0
    innerFun_1()   #4.使用innerFun_2
    
    return

outFun()#5.调用outFun函数