一、匿名函数

匿名函数lambda：没有名字的函数
特点：
临时存在，用完就销毁
匿名函数通常不会单独使用，配合内置函数一起使用

lambda x,y : x+y

解释：左边的相当于函数的形参，右边相当于函数的返回值

1.求和普通方法

def my_sum(x, y):
    return print(x+y)
my_sum(1, 2)

2.匿名函数配合内置求和：

res = (lambda x, y: x+y)(11, 20)
print(res)

二：比较薪资，返回人名：

k = {'jeff': 8000,
     'nick': 1000,
     'tank': 3000,
     'mary': 10000，
def index(name):

　　return k[name]
　　print(max(k, key=index)) # 函数返回什么比较什么


# max内置函数，第一步：拿到字典key（jeff）
                第二步，把key传给index函数
                第三步，执行index(jeff)，返回字典k[jeff],5000
                第四步，依次拿到5000，1000，3000，10000，进行比较
                第五步，返回最大值对应的人名
"""

2.把index写成匿名函数：

print(max(k, key=lambda name: k[name]))
print(min(k, key=lambda name: k[name]))

三、补充ascll码表：

"""
A-Z 65-90
a-z 97-122
"""
print(chr(122)) #查看ascll码对应的值

二、函数的递归

1.特点

1.函数在调用阶段直接或间接的又调用自己

2.递归函数不需要考虑循环的次数，只需把握结束的条件

# 查看递归深度：默认1000

import sys
print(sys.getrecursionlimit())  # 不是很精确

1.递归死循环：

def index():
    print("这是第一个函数")
    login()

def login():
    print("这是第二个函数")
    index()

index()

2.函数的递归分为两个阶段：

　　1.回溯：重复的过程，一层层降低难度

　　2.递推：一层层往回推导的过程

要求：
第一个人18岁，第二个人比第一个人大两岁，第三个人比第二个人大两岁，第四个人比第三个人大两岁。。。
age(5)=age(4)+2
age(4)=age(3)+2
age(3)=age(2)+2
age(2)=age(1)+2
age(1)=18

def age(n):
    if n == 1:
        return 18
    return age(n-1) + 2
res = age(5)   # 第五个人的年龄
print(res)

3.递归使用的例子：依次打印列表中的数据

复杂度降低：列表越来越短

递归函数：

l = [1 ,[2 ,[3 ,[4 ,]]]]
def main(l):
    for i in l:
        if type(i )is int:  # 判断是否为整型
            print(i)
        else:
            main(i)
main(l)

三、局部全局修改

global:局部修改全局，逗号隔开修改全局
nonlocal:局部修改局部，逗号隔开修改全局

1.局部修改全局

关键字 global 申明

# global 局部修改全局
x = 1
def func():
    global x  # 修改全局变量
    x = 2
func()
print(x)

2.局部修改局部

关键字 nonlocal 申明

# nonlocal 局部修改局部

def func():
    x = 1
    def func1():
        nonlocal x   # 声明修改局部
        x = 2
    func1()
    print(x)
func()

四、常用内置函数

1.map 映射基与for循环

k = [1, 2, 3, 4, 5, 6]
print(list(map(lambda x: x + 1, k)))  # map 基与for循环   每一个数+1

2.zip拉链基与for循环

取最短的拉

k1 = [1, 2, 3, 4, 5]
k2 = ['jeff', 'tank', 'jason']
k3 = ['a', 'b', 'c']
print(list(zip(k1, k2, k3)))
# 结果：[(1, 'jeff', 'a'), (2, 'tank', 'b'), (3, 'jason', 'c')]

3.filter 过滤基与for循环

k = [1, 2, 3, 4, 5]
print(list(filter(lambda x: x != 3, k)))   # 后面可以加条件

4.sorted 排序

k = ['jeff', 'tank', 'jason']
k.sort()   # 升序
k.sort(reverse=True)  # 降序
print(k)
print(sorted(k))  # 升序
print(sorted(k, reverse=True))  # 降序
k.reverse()              #逆序

5.reduce 额外的

from functools import reduce

from functools import reduce
k = [1, 2, 3]
print(reduce(lambda x, y: x+y, k, 10))   # 1+2+3+10   ,10是额外的
# 结果： 16

# 当初始值不存在的时候，按照下面的规律
# 第一次先获取两个元素 相加
# 之后每次获取一个与上一次相加的结果再相加

原文地址：https://www.cnblogs.com/WQ577098649/p/11887409.html

函数