Python之路day13-内置函数_lambda_闭包

Posted 2021-09-13 西园公子

前言时刻

这两天写文章写得快吐了，写完信息安全的读书笔记然后又写一个软件使用教程，难受了。不过坚持住就好，继续奋斗吧。

来来总结一波：

今天学习了lambda匿名函数、一些重要的内置函数如：abs、sum、max、min、zip、sorted、filter、map

一般性重要的是：bytes、int、chr、ord、bin、oct、hex、repr、all、any等

1、lambada函数

lambda 函数又称为匿名函数，从语法上看它就是一个函数，而且功能还很简单。

# 语法：
func = lambada 形参：结果

func1 = lambda a, b: a+b
func1(1, 2)   # 3

但是 Python 为什么还要单独搞一个匿名函数呢？答案是自有其道理的。一般 lambda 是与其他匿名函数组合使用，起到超重要的作用。

例如：和 sorted 函数配合使用，使用 lambda 可以将其成员中的一部分作为排序依据。

dic = {"name": "13", \'hobby\': \'6666\', \'age\': \'14\'}

# 1.默认排序
print(sorted(dic))     # [\'age\', \'hobby\', \'name\']
# 2.使用值作为排序依据，从小到大
sorted(dic, key=lambda a:int(dic[a]),reverse=False)   # [\'name\', \'age\', \'hobby\']

2、内置函数

内置函数是Python中最重要的亮点之一，有些函数真的可以让你一行低十行。

2.1 重要函数

1. sum(iterable)：求一个迭代对象的所有元素的和
2. max(iterable, key=lambda x:x)/min()：求迭代对象中的元素的最大值或最小值

# 今天写的内置函数都是非常重要的

lis = [1, 2, 3, 4, 5]
dic = {"name": "13", \'hobby\': \'6666\', \'age\': \'14\'}


# 1. sum

print(sum(lis))   # 15
print(sum((1, 2, 3, 4, 5)))   # 15

# 2. max min 

def max_test(x):
    return int(dic[x])
max(lis)    # 5
max(dic, key=lambda x:int(dic[x]))   # hobby
max(dic, key=max_test)   # hobby
# 可以看出，key也同样可以用一个函数替代lambda，也说明lambda就是简单的函数

1. zip([iterable,...])：又称拉链函数，将几个可迭代对象中的数据打包成一个元组，这个功能太实用了。
2. sorted(iteable, key=, reverse=True/False): 对里面的迭代对象进行排序，生成一个新的 list 列表对象，可以添加 key 控制排序依据。reverse=True则为从大到小，默认是False从小到大。

# 3. zip函数

lis1 = [1, 2, 3]
lis2 = (4, 5, 6)
lis3 = (7, 8, 9)
zip(lis1, lis2, lis3)


# 4.sorted函数
dic = {"name": "13", \'hobby\': \'6666\', \'age\': \'14\'}
lis = [23, 4, 5, 1, 9, 6]

print(sorted(dic, key=lambda x: int(dic[x])))
print(sorted(lis, reverse=True))

1. filter()函数，相当于是列表推导式中的筛选模式。map()函数，相当于是列表推导式中的循环模式，

# 5.filter函数
lis = [23, 4, 5, 1, 9, 6]
def func(x):
    return x>6

f1 = filter(lambda x:x>6, lis)
print(list(f1))                  # [23, 9]
print(list(filter(func, lis)))   # [23, 9]


# 6.map函数
f2 = map(lambda x: x+2, lis)
print(list(f2))                                    # [25, 6, 7, 3, 11, 8]

2.2 常用函数

1、int(x, base=6)，将x转成base进制的数

2、divmod(x, y)，返回x除以y的商和余数。

3、round(2.8, 1)，返回指定小数位数的浮点型

4、pow(base, index)，幂指数

# 1、int
int(3.5)             # 3   float转int型
int(\'0100\', base=2)  # 4   其他base进制字符串转整型

# 2、divmod
divmod(9, 2)      # (4, 1)

# 3、round
round(3.14, 1)    # 3.1
round(3.16, 1)    # 3.2

# 4、base
pow(2, 4)         # 16

5、repr("python")，返回带有引号的字符串。

6、all(iterable)，可迭代对象中全都是真则返回True。any(iterable)，若有真就返回True

# 5、repr
print(repr("python"))   # \'python\'


# 6、all、any
lis = [1, 2, \'666\', True]
lis2 = [1, 2, \'\', True]

all(lis)    # True
all(lis2)   # False

any(lis)    # True
any(lis2)    # True

7、bytes()， 将字符串指定编码方式进行编码，如不懂编码，可以看*

# 7、bytes

b1 = bytes(name, encoding=\'utf8\')
print(f"b1: {b1}, type: {type(b1)}")
# b1: b\'python\', type: <class \'bytes\'>

print(bytes("西", encoding=\'gbk\'))   # b\'\\xce\\xf7\'
print(bytes("西", encoding=\'utf8\'))  # b\'\\xe8\\xa5\\xbf\'

3、闭包

闭包是什么？闭包是嵌套在函数中的函数，且对外层函数中的变量的引用。

def func(age):
    name = \'python\'
    def inner():
        print(name)
        print("内层函数 inner 被调用")
        return \'inner\'
    return inner

res = func(17)
print(res)
print(res())

# <function func.<locals>.inner at 0x7fbfe22f9550>

# python
# 内层函数 inner 被调用
#inner

闭包可以避免函数中的一些非全局变量被销毁，可以直接在内层函数中使用。

我觉得闭包其实就是为了后面的装饰器打基础的。

总结：

今天的重点是掌握一些重要的内置函数以及 lambada 匿名函数的用法，还是多看多练多总结！