Python中的函数

1. 函数的定义与调用

2. 函数调用的参数传递（位置实参，关键字实参）

def calc(a, b):  # a,b形参
    c = a + b
    return c


result = calc(10, 20)  # 10,20实参
print(result)

res = calc(b=10, a=20)  # 等号左侧的变量的名称 称为 关键字参数
print(res)

3. 函数参数传递的内存分析

def fun(arg1, arg2):
    print('arg1', arg1)
    print('arg2', arg2)
    arg1 = 100
    arg2.append(10)
    print('arg1', arg1)
    print('arg2', arg2)
    # return


n1 = 11
n2 = [22, 33, 44]
print('n1', n1)
print('n2', n2)
fun(n1, n2)
print('n1', n1)
print('n2', n2)

'''
在函数调用过程中，进行参数的传递
如果是不可变对象，在函数体的修改不影响实参的值
如果是可变对象，在函数体的修改会影响实参的值
'''

函数调用的参数传递内存分析图

4. 函数的返回值

print(bool(0))  # False
print(bool(8))  # 非0的布尔值为True

def fun(num):
    odd = []  # 存奇数
    even = []  # 存偶数
    for i in num:
        if i % 2:
            odd.append(i)
        else:
            even.append(i)
    return odd, even


# 函数的调用
lst = [10, 29, 34, 23, 44, 53, 55]
print(fun(lst))

'''
函数的返回值
    （1）如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】 return可以省略不写
    （2）函数的返回值，如果是1个，直接返回类型
    （3）函数的返回值，如果是多个，返回的结果为元组
'''


def fun1():
    print('hello')
    # return


fun1()


def fun2():
    return 'hello'


res = fun2()
print(res)


def fun3():
    return 'hello', 'world'


print(fun3())

'''函数在定义时，是否需要返回值，视情况而定'''

5. 函数参数定义

5.1 默认值参数

def fun(a, b=10):  # b称为默认值参数
    print(a, b)


# 函数的调用
fun(100)
fun(20, 30)

print('hello', end='\t')
print('world')

5.2 个数可变的位置形参，个数可变的关键字形参

def fun(*args):  # 函数定义时的 可变的位置参数
    print(args)
    print(args[0])


fun(10)
fun(10, 30)
fun(30, 405, 50)


def fun1(**args):
    print(args)


fun1(a=10)
fun1(a=20, b=30, c=40)

print('hello', 'world', 'java')

'''
def fun2(*args, *a):
    pass
以上代码程序会报错，个数可变的位置参数，只能是1个
def fun2(**args, **a):
    pass
以上代码程序会报错，个数可变的关键字参数，只能是1个
'''


def fun2(*args1, **args2):
    pass


'''
def fun3(**args1, *args2):
    pass
在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求，个数可变的位置形参，放在个数可变的关键字形参之前
'''

5.3 函数的参数总结

def fun(a, b, c):
    print('a=', a)
    print('b=', b)
    print('c=', c)


# 函数的调用
fun(10, 20, 30)  # 位置传参
lst = [11, 22, 33]
fun(*lst)  # 在函数调用时，将列表中的每个元素都转换为位置实参传入
print('-------------------------')
fun(a=100, c=300, b=200)  # 关键字实参
dic = {'a': 111, 'b': 222, 'c': 333}
fun(**dic)  # 在函数调用时，将字典中的键值对都转换为关键字实参传入

def fun(a, b=10):  # b是在函数的定义处，所以b是形参，而且进行了赋值，所以b称为默认值形参
    print('a=', a)
    print('b=', b)


def fun2(*args):  # 个数可变的位置形参
    print(args)


def fun3(**args2):  # 个数可变的关键字形参
    print(args2)


fun2(10, 20, 30, 40)
fun3(a=11, b=22, c=33, d=44, e=55)


def fun4(a, b, *, c, d):  # 从*之后的参数，在函数调用时，只能采用关键字参数传递
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('d=', d)


# 调用fun4函数
# fun4(10, 20, 30, 40)  # 位置实参传递
fun4(a=10, b=20, c=30, d=40)  # 关键字实参传递
fun4(10, 20, c=30, d=40)  # 前两个参数位置实参传递，后两个参数关键字实参传递

'''函数定义时的形参的顺序问题'''


def fun5(a, b, *, c, d, **args):
    pass


def fun6(*args, **args2):
    pass


def fun7(a, b=10, *args, **args2):
    pass

6. 变量的作用域

def fun(a, b):
    c = a + b  # c是函数体内进行定义的变量，称为局部变量。a，b为函数的形参，作用范围也是函数内部，相当于局部变量
    print(c)


# print(c)  # 因为a，c超出了起作用的范围（超出了作用域）
# print(a)

name = '霍建华'  # name在函数的内部和外部都可以使用 --> 称为全局变量
print(name)


def fun2():
    print(name)


# 调用函数
fun2()


def fun3():
    global age  # 函数内部定义的变量，局部变量，局部变量使用global声明，这个变量实际上就变成了全局变量
    age = 20
    print(age)


fun3()
print(age)

7. 递归函数

• 什么是递归函数
  • 如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数
• 递归的组成部分
  • 递归调用与递归终止条件
• 递归的调用过程
  • 每递归调用一次函数，都会在栈内存分配一个栈帧
  • 每执行完一次函数，都会释放相应的空间
• 递归的优缺点
  • 缺点：占用内存多，效率低下
  • 优点：思路和代码简单

def fac(n):
    if n == 1:
        return 1
    else:
        return n * fac(n - 1)


print(fac(6))

8. 斐波那契数列

def fib(n):
    if n == 1 or n == 2:  # 逻辑或or，逻辑与and。|为按位或，&为按位与
        return 1
    else:
        return fib(n - 2) + fib(n - 1)


# def fib(n):
#     if n == 1:
#         return 1
#     elif n == 2:
#         return 1
#     else:
#         return fib(n - 2) + fib(n - 1)


# 斐波那契数列第6位上的数字
print(fib(6))

print('--------------------------------')

# 输出这个数列的前6位上的数字
for i in range(6):
    print(fib(i + 1), end='\t')