python学习笔记8-函数

函数

定义函数

• 使用关键字def
• 确定函数名称、参数名称、参数个数、编写函数体（实现函数功能的代码）

def func():
	print('python')

函数的参数

• 形参：函数定义时小括号里的参数，是用来接受参数用的，在函数内部作为变量使用。
• 实参：函数调用的时候，小括号里的参数，是用来把数据传递到函数内部的。
• 函数可以没有形参和实参。

def sum_2(a, b):  # 形参
    print(a + b)


sum_2(3, 4)  # 实参

函数的返回值

• 返回值是函数完成工作后，最后给调用者的一个结果
• 在函数中使用return关键字可以返回结果
• 调用函数一方，可以使用变量来接收函数的返回结果

def sum_2(a, b):  # 形参
    return a + b


result = sum_2(3, 4)  # 实参
print(result)

函数的参数类型

• 位置参数

  • 要求实参书序必须和形参顺序完全一致，由形参顺序决定实参顺序。

  • def sum_2(a, b):  # 形参
        return a + b
    
    
    result = sum_2(3, 4)  # 实参
    print(result)
    

• 缺省参数

  • 定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就是缺省参数。

  • def power(x, n=2):
        return x ** n
    
    
    a = power(4)
    b = power(4, 3)
    print(a)#16
    print(b)#64
    

  • a = int('16', 8)
    b = int('16')
    print(a)  # 14 8是指八进制
    print(b)  # 16,不传默认为十进制
    

  • s = infos('mia', 24, '男')
    print(s)  # 我是mia，我24岁，男生
    lily = infos('lily')
    print(lily)  # 我是lily，我24岁，女生
    jack = infos('jack', gender='男')
    print(jack)  # 我是jack，我24岁，男生
    

• 可变参数

  • 传入的参数个数是可变的，0-任意个都可以。

  • def total(*args):# 可变参数，接收列表
        print(args)  # 元祖 (1, 2, 3, 4, 5, 64, 4)
        res = 0
        for i in args:
            res += i
        return res
    
    
    result = total(1, 2, 3, 4, 5, 64, 4)
    print(result)  # 83
    print(total(4, 5, 6))  # 15
    a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    print(total(*a))  # 45
    

  • def f(**kwargs):  # 可变参数，接收字典
        for k, v in kwargs.items():
            print(k, v)
    
    
    d = {'name': 'xiaoming', 'age': 18}
    '''
    name xiaoming
    age 18
    '''
    f(**d)
    

变量作用域

• 局部变量:是在函数内部定义的变量，只能在函数内部使用
• 全局变量：是在函数外部定义的变量，所有函数内部都可以使用这个变量。

# 全局变量
num1 = 10


def f():
    # 局部变量
    num2 = 20
    print(num2)  # 20
    print(num1)  # 10


f()
print(num1)  # 10

def f():
    # 局部变量
    num2 = 20
    num1 = 20
    print(num2)  # 20
    print(num1)  # 20


f()
print(num1)  # 10

# 全局变量
num1 = 10


def f():
    # 声明在f中使用的num1是全局变量num1
    global num1
    # 局部变量
    num2 = 20
    num1 = 20
    print(num2)  # 20
    print(num1)  # 20


f()
print(num1)  # 20

# 全局变量
num1 = 10  # 不可变数据类型
list1 = [1, 2, 3, 4, 5]  # 可变数据类型


def f():
    # 声明在f中使用的num1是全局变量num1
    global num1
    # 局部变量
    num2 = 20
    num1 = 20
    list1[2] = 8
    print(num2)  # 20
    print(num1)  # 20
    print(list1)  # [1, 2, 8, 4, 5]


f()
print(num1)  # 20
print(list1)  # [1, 2, 8, 4, 5]

匿名函数

• lambda函数是一种快速定义单行的最小函数，可以用在任何需要函数的地方
• 优点“让代码更加精简，不需要考虑命名的问题

# 常规写法
def f(a, b):
    return a + b


a = f(1, 2)
print(a)

# 匿名函数
fun = lambda c, b: c + b
res = fun(1, 2)
print(res)

a = [1, 2, 3, 4, 5]


def f(x):
    return x ** 2


result = map(f, a)
print(list(result))  # [1, 4, 9, 16, 25]
# 简写
result = map(lambda x: x ** 2, a)
print(list(result))  # [1, 4, 9, 16, 25]

# reduce 累积操作：累加；累乘。。。
from functools import reduce# 导入

reduce1 = reduce(lambda x, y: x + y, a)
print(reduce1)  # 15

# filter 过滤
filter1 = filter(lambda x: x % 2, a)  # 过滤偶数
print(list(filter1))  # [1, 3, 5]

内置函数

递归函数

• 函数调用自身称为递归调用
• 一个会调用自身的函数称为递归函数

递归的过程：

1. 写出临界条件
2. 找这一次和上一次的关系
3. 假设当前函数已经能用，调用自身计算上一次结果，在求出本次结果。当参数满足一个条件是，函数不再执行。

# 10阶楼梯，每次上一级或2级，问有多少种走法
'''
3
111
12
21

f(n+1) = f(n) + f(n-1)
f(n) = f(n-1) + f(n-2)
f(0) = 0
f(1) = 1
f(2) = 2
'''


def f(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    elif n == 2:
        return 2
    return f(n - 1) + f(n - 2)


print(f(3))
print(f(4))
法
'''
3
111
12
21

f(n+1) = f(n) + f(n-1)
f(n) = f(n-1) + f(n-2)
f(0) = 0
f(1) = 1
f(2) = 2
'''


def f(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    elif n == 2:
        return 2
    return f(n - 1) + f(n - 2)


print(f(3))
print(f(4))