函数知识点汇总

格式

def 函数名（[参数]）：

        代码

参数：向函数中传递值

默认参数： def 函数名（参数1，参数2，参数3=值，参数4=值）

无默认值的参数必须赋值，有默认值参数的可以不赋值

无默认值的参数一定要在有默认值的参数前方  

缺省参数在*args的后面

如果有多个默认值参数，又想修改指定的参数，可使用关键字参数赋值，例如：

def num(a, b, c=3, d=4):
    print(a, b, c, d)


num(1, 2, d=3)

1 2 3 3

可变参数

*args 将多个参数以元组形式传入函数中

def get_num(*args):
    print(args)


get_num(1, 2, 3, 4, 5)

(1, 2, 3, 4, 5)


list1 = [1, 3, 5, 123, 5, 123, 5]
get_num(*list1)  # 传参时可将参数拆包上传

(1, 3, 5, 123, 5, 123, 5)

**kwargs 关键字参数，将键值对传入函数中

def show_book(**kwargs):
    for k, v in kwargs.items():
        print(k, v)


show_book(name='青春', author='韩寒')  # kwargs类型需传入键值对
book_1 = {'name': '三重门', 'author': '韩寒'}
show_book(**book_1)  # 字典拆包

name 青春
author 韩寒
name 三重门
author 韩寒

返回值

使用return，会终止函数调用，可单独使用，不设置返回值默认输出None

格式

def 函数名（[参数]）：

        代码

        return 返回值

返回单个返回值举例

def get_sum(*args):
    total = 0
    for i in args:
        total += i
    return total


print(get_sum(1, 2, 3, 4, 5))

15

返回多个返回值（冒泡排序返回列表最大最小值）

返回多个值的时候默认返回值为元组，可自行定义元组、列表、字典。可使用多个变量来接收返回值

def maxandmin(numbers):
    for i in range(0, len(numbers) - 1):
        for j in range(0, len(numbers) - 1 - i):
            if numbers[j] > numbers[j + 1]:
                numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]
    min = numbers[0]
    max = numbers[-1]
    return min, max


list1 = [11, 21, 3, 43, 15, 90]
a, b = maxandmin(list1)
a_b = maxandmin(list1)
print(a, b)
print(a_b)

3 90
(3, 90)

全局变量&局部变量

声明在函数外的为全局变量（查看全局变量命令：globals()），声明在函数内部的为局部变量（查看局部变量：locals()）

1.调用函数时优先返回局部变量，举例：

a = 100

def test1():
    a = 0
    print('a=', a)

test1()

a= 0

2.如何在函数中修改全局变量

a = 100

def test1():
    global a
    a = 10
    print('a=', a)

test1()

a= 10

3.不可变的类型才需要添加global，可变的类型不需要加global

不可变类型有：内容发生改变，地址也发生改变

int str float bool tuple 

可变类型：内容发生改变，地址没有发生改变

list dict set 

a = 10
print(id(a))
a = 100
print(id(a))

list1 = [1, 2, 3, 4]
print(id(list1))
list1 += [2, 3, 4, 5]
print(id(list1))

140731742650928
140731742653808
2032750711304
2032750711304

函数注释：

在函数定义后加''' '''，系统会自带注释格式

def 函数名（参数）：

        基本注释 ‘注释内容’

        高级注释

        '''

        函数的说明

        参数说明：

        参数一：

        参数二：

        返回值说明：

        return：

        '''

引用

1.不在函数中引用，可以通过sys.getrefcount(变量)   查看引用次数

del 变量名    来删除引用

2.函数的引用，分清传递的参数是可变/不可变类型。可变类型会引起全局的改变，不可变类型则不影响

函数的嵌套和闭包

在函数中定义函数，如果内部函数需要外部函数中的变量，需要添加nonlocal

def outer():
    a = 100

    def inner():
        nonlocal a  # 修改outer内a的定义
        a += 50
        b = 200
        print('我是内部函数')

    inner()

    result = locals()
    print(result)


outer()

我是内部函数
{'inner': <function outer.<locals>.inner at 0x00000258FE7F7708>, 'a': 150}

函数检索顺序

内层函数 ---》外层函数 ---》全局 ---》系统builtins

闭包的定义

1.嵌套函数

2.内部函数引用了外部函数的变量

3.返回值是内部函数

目的：将内部函数抛出外部函数。通常配合装饰器使用。

def outer(n):
    a = 10

    def inner():
        b = a + n
        print('内部函数', b)

    return inner

r = outer(10)
print(r)
r()

<function outer.<locals>.inner at 0x0000016E1AE454C8>
内部函数 20

装饰器

遵循开放封闭原则，在不改变原函数的情况下，扩展了函数的功能。

功能：

1.引入日志

2.函数执行时间统计

3.执行函数前预备处理

4.执行函数后清理功能

5.权限校验

...

@装饰器名

def 原函数（）

       pass

举例

def decorater(func):
    def warpper():
        func()
        print('装修')
        print('入住')

    return warpper


@decorater
def house():
    print('毛坯房')


house()

毛坯房
装修
入住

如果原函数有参，则装饰器内部函数也需要添加参数，一般内部函数都会使用*args, **kwargs进行传参。举例

def decorater(func):
    def warpper(*args, **kwargs):
        func(*args, **kwargs)
        print('装修')
        print('入住')

    return warpper


@decorater
def house(address):
    print('毛坯房在{}'.format(address))


@decorater
def big_house(address, area, money=1500):
    print('毛坯房在{},有{}平米大,花了{}万'.format(address, area, money))


house('北京')
big_house('上海', area=200)

毛坯房在北京
装修
入住
毛坯房在上海,有200平米大,花了1500万
装修
入住

带返回值的装饰器，举例

def decorater(func):
    def warpper(*args, **kwargs):
        s = func(*args, **kwargs)
        re = s + 10
        return re
    return warpper

@decorater
def sum(a, b):
    s = a + b
    return s


result = sum(10, 20)
print(result)

40

递归函数

如果一个函数在内部不调用其他的函数，而是自己本身的话，这个函数就是递归函数

举例：利用递归函数打印1到10的值

def test(a):
    if a < 10:
        print(a)
        a += 1
        test(a)
    else:
        print(a)


test(1)

1
2
3
4
5
6
7
8
9
10

举例：利用递归函数完成1到10的累加和

def test1(i):
    if i == 10:
        return 10
    else:
        return i + test1(i + 1)


r = test1(1)
print(r)

55

举例：输出斐波那契数列的某一项

def fibonacci(n):
    if n <= 2:
        return 1
    else:
        return fibonacci(n - 2) + fibonacci(n - 1)


r = fibonacci(10)
print(r)

55

匿名函数

lambda关键词能创建小型函数，叫做匿名函数（使用较少，可以一致都使用def），可以接收多个参数但是只能返回一个值

lambda 参数列表：运算表达式（返回值）

举例

r = lambda a: a + 1
print(r(1))

2

高阶函数

一个函数的参数中存在另一个函数，或返回值为另一个函数

系统的高阶函数：max min sorted

dict1 = {'a': 10, 'b': 11, 'c': 22, 'd': 33}
m = max(dict1, key=lambda x: dict1[x])  # 使用高阶函数求字典value的最大值，返回对应key
print(m)
list1 = [('a', 10), ('b', 20), ('c', 30)]
m = max(list1, key=lambda x: x[1])  # 使用高阶函数求列表中元组下标为1的元素最大值，返回对应元组
print(m)
s = sorted(list1, key=lambda x: x[1], reverse=True)  # 使用sorted高阶函数排序
print(s)

d
('c', 30)
[('c', 30), ('b', 20), ('a', 10)]

filter  要求函数的返回值必须是bool类型，为Ture时符合过滤条件

list1 = [('a', 10), ('b', 20), ('c', 30)]
f = filter(lambda x: x[1] > 10, list1)  # 通过filter高阶函数实现筛选
print(list(f))

[('b', 20), ('c', 30)]

map

list1 = [('a', 10), ('b', 20), ('c', 30)]
m = map(lambda x: x[0].upper(), list1)  # 通过map高阶函数提取list中对应元素并加工输出
print(list(m))

['A', 'B', 'C']