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

前言时刻

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

来来总结一波：

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

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

一、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']

二、内置函数

内置函数是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 经常使用函数

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

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

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

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

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

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

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

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

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

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

# 五、repr
print(repr("python"))   # 'python'


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

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

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

七、bytes()， 将字符串指定编码方式进行编码，如不懂编码，能够看*

# 七、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'

三、闭包

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

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 匿名函数的用法，仍是多看多练多总结！