Python——第四章：内置函数（下）

内置函数的使用方法：

locals：函数会以字典的类型返回当前位置的所有局部变量
globals：函数会以字典的类型返回全部局部变量
zip: 可以把多个可迭代内容进行合并
sorted: 排序
filter: 筛选
map:    映射

locals和globals

locals：函数会以字典的类型返回当前位置的所有局部变量:

globals：函数会以字典的类型返回全部局部变量：

locals：

下面这段代码:此时locals被写在了全局作用域范围内. 此时看到的就是当前作用域(全局)中的变量内容

a = 188

print(locals())  # 此时locals被写在了全局作用域范围内. 此时看到的就是当前作用域(全局)中的内容

#执行结果
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000166DC5150D0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:\\Python\\装饰器.py', '__cached__': None, 'a': 188}

下面这段代码:此时locals放在局部作用域范围, 看到的就是局部作用域的变量内容

a = 188

def func():
    b = 336
    print(locals())  # 此时locals放在局部作用域范围, 看到的就是局部作用域的内容
func()

#运行结果
{'b': 336}

globals

此时globcals虽然放在局部作用域范围, 但是看到的是全局作用域的变量内容

a=188

def func():
    b = 336
    print(globals())  # 此时globals虽然放在局部作用域范围, 但是看到的是全局作用域的内容
func()

#运行结果
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000166DC5150D0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:\\Python\\装饰器.py', '__cached__': None, 'a': 188, 'func': <function func at 0x00000166DC7EA020>}

globcals不论写在哪里都是全局作用于的变量内容

zip

zip: 可以把多个可迭代内容进行合并

我们想把每个列表的第1位、第2位、第3位打包放在一起，手写的操作方法如下：

#       0         1       2
lst1 = ["赵本山", "范伟", '苏有朋']
lst2 = [40, 38, 42]
lst3 = ["卖拐", "耳朵大有福", "情深深雨蒙蒙"]

result = []
for i in range(len(lst1)):
    first = lst1[i]
    second = lst2[i]
    third = lst3[i]
    result.append((first, second, third))
print(result)

#运行结果
[('赵本山', 40, '卖拐'), ('范伟', 38, '耳朵大有福'), ('苏有朋', 42, '情深深雨蒙蒙')]

在python中的zip函数可以直接实现这样的操作，下面我们用dir先来看下zip中有哪些功能,

result =zip(lst1,lst2,lst3)
print(dir(result))

#运行结果
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__']

从dir()中我们可以看到，通过zip内置函数得到的result函数内部是拥有__iter__证明是可迭代的；又有__next__代表它是迭代器。因此：我们用for循环，把里面的数都拿出来即可。

lst1 = ["赵本山", "范伟", '苏有朋']
lst2 = [40, 38, 42]
lst3 = ["卖拐", "耳朵大有福", "情深深雨蒙蒙"]

result = zip(lst1, lst2, lst3)
for item in result:
    print(item)

#运行结果
('赵本山', 40, '卖拐')
('范伟', 38, '耳朵大有福')
('苏有朋', 42, '情深深雨蒙蒙')

我们还能一步就拿到列表：前面讲过了list中是存在循环遍历的。

result =zip(lst1,lst2,lst3)
lst= list(result)
print(lst)

#运行结果
[('赵本山', 40, '卖拐'), ('范伟', 38, '耳朵大有福'), ('苏有朋', 42, '情深深雨蒙蒙')]

sorted: 排序

sorted()有三个参数,基本语法是:

sorted(__iterable, key=None, reverse=False)

其中：

1. iterable： 要排序的可迭代对象，例如列表、元组等。

2. key： 用于指定一个函数（或其他可调用对象），它将被用于提取比较键（排序关键字）的值。默认为 None，表示直接比较元素本身而不进行特殊的处理。

3. reverse： 一个布尔值，表示是否按逆序排序。默认为 False，表示升序排序；如果设置为 True，则按降序排序。

因为key的默认值是None并且reverse默认值是False,因此可以只写可迭代的对象:

lst = [4, 2, 7, 1, 9]

# 默认升序排序
s = sorted(lst)
print(s)  # 输出 [1, 2, 4, 7, 9]

key=abs是绝对值reverse=True是从大到小reverse=False是从小到大

# 按绝对值降序排序
s1 = sorted(lst, key=abs, reverse=True)
print(s1)  # 输出 [9, 7, 4, 2, 1]

注意：sorted() 函数返回一个新的已排序的列表，而不会修改原始的可迭代对象。如果你想要在原地排序（修改原始对象），可以使用列表的 sort() 方法。

思考：key应该怎么用

如果我有一个这样的列表，需要排序。他们不是数字，该如何操作呢？

lst = ["秋", "张二嘎", "比克", "卡卡罗特", "超级宇宙无敌大帅G"]

这里我们就要用到一个排序函数func来处理key的算法

sorted(iterable, key=func, reverse=False)

比如,我们想要以字母长度排序,就可以这样写

lst = ["秋", "张二嘎", "比克", "卡卡罗特", "超级宇宙无敌大帅G"]    #这里是实参

def func(item):  # item这里是形参,对应的就是列表中的每一项数据
    return len(item)

s = sorted(lst, key=func)
print(s)

#执行结果
['秋', '比克', '张二嘎', '卡卡罗特', '超级宇宙无敌大帅G']

然而，这里完全可以用匿名函数来处理

def func(item):    # item是形参
    return len(item)

#匿名函数来替代
func = lambda x:len(x)    # x也是形参

引入匿名函数，一步解决。这就是匿名函数的主要用处¹

lst = ["秋", "张二嘎", "比克", "卡卡罗特", "超级宇宙无敌大帅G"]

s = sorted(lst, key=lambda x:len(x), reverse=False)
print(s)

练习:

lst = [
    {"id": 1, "name": "周润发", "age": 18, "salary": 5200},
    {"id": 2, "name": "周星驰", "age": 28, "salary": 511100},
    {"id": 3, "name": "周海媚", "age": 78, "salary": 561230},
    {"id": 4, "name": "周伯通", "age": 12, "salary": 532100},
    {"id": 5, "name": "周大兴", "age": 35, "salary": 53210},
    {"id": 6, "name": "周什么", "age": 47, "salary": 520},
    {"id": 7, "name": "周扒皮", "age": 58, "salary": 12},
]

1.根据每个人的年龄排序

s = sorted(lst, key=lambda d: d['age'])
print(s)

2.根据工资进行排序. 从大到小

s = sorted(lst, key=lambda d: d['salary'], reverse=True)
print(s)

filter: 筛选

filter() 函数是 Python 内置函数之一，用于过滤序列中的元素，根据给定的函数（返回布尔值的函数，即谓词函数）决定是否保留元素。该函数的基本语法是：

filter(__function, __iterable)

其中：

• function： 一个用于筛选元素的函数，该函数应返回 True 或 False。
• iterable： 要过滤的可迭代对象，如列表、元组等。

filter() 返回一个由函数返回 True 的元素所组成的迭代器。

我们要把这个列表删选所有姓"张"的人找出来

lst = ["张无忌", "张三丰", "张翠山", "灭绝小师太", "小狐仙"]

使用filter进行筛选

#        T        T         T         F             F
lst = ["张无忌", "张三丰", "张翠山", "灭绝小师太", "小狐仙"]
f = filter(lambda x: x.startswith("张"), lst)
print(list(f))

lambda x: x.startswith("张") 是一个谓词函数，用于判断元素是否为"张"开头。filter() 将该函数应用于 lst 列表的每个元素，并返回一个由符合条件的元素组成的迭代器，最后通过 list() 转换成列表。

如果要拿到不是姓"张"的人,我们可以用not做调节

lst = ["张无忌", "张三丰", "张翠山", "灭绝小师太", "小狐仙"]
f = filter(lambda x: not x.startswith("张"), lst)
print(list(f))

注意事项：

1. 返回类型： filter() 返回的是迭代器，因此需要将其转换为列表或其他类型，以便查看或进一步处理结果。

2. 谓词函数： 谓词函数是一个返回布尔值的函数，用于判断元素是否应该被保留。

3. 可读性： 谨慎使用复杂的谓词函数，以保持代码的可读性。

map:映射

map() 函数是 Python 内置函数之一，用于将一个函数应用于可迭代对象的每个元素，返回一个由函数处理后的结果组成的迭代器。其基本语法如下：

map(__function, __iterable, ...)

其中：

• function： 用于处理每个元素的函数。
• iterable： 要处理的可迭代对象，如列表、元组等。
• ...： 可以传递多个可迭代对象，此时 function 函数必须接收对应数量的参数。

map() 返回一个迭代器，它产生将函数应用于每个元素后的结果。

map()和filter()的用法非常类似，他们的区别是filter()把筛选出来的值做只真假判断，真就返回，假就丢弃。map()是把筛选出来的值做运算，在运算后把运算结果返回。

map()存在的价值:

在后期如果需要做数据分析，对大量数据做批量的处理，传统的列表推导式无法实现，所以会用到map()的方法。

示例：

我们可以用列表的推导式来实现对lst的所有的数的平方

lst = [1,2,3,4,5,6,7,8,9]

result = [item * item for item in lst]
print(result)

#运行结果
[1, 4, 9, 16, 25, 36, 49, 64, 81]

我们可以用到map()直接操作

# 将列表中的每个元素都平方
lst = [1,2,3,4,5,6,7,8,9]
result = map(lambda x: x**2, lst)
print(list(r))  # 输出 [1, 4, 9, 16, 25, 36, 49, 64, 81]

在这个例子中，lambda x: x**2 是应用于 numbers 列表中每个元素的函数，map() 返回一个迭代器，其中包含了每个元素平方的结果。

多个可迭代对象的示例：

# 将两个列表对应位置的元素相加
list1 = [1, 2, 3]
list2 = [4, 5, 6]
sum_result = map(lambda x, y: x + y, list1, list2)
print(list(sum_result))  # 输出 [5, 7, 9]

在这个例子中，lambda x, y: x + y 函数接收两个参数，分别来自 list1 和 list2 的对应位置的元素，然后返回它们的和。

注意事项：

1. 返回类型： map() 返回的是迭代器，因此需要将其转换为列表或其他类型，以便查看或进一步处理结果。

2. 函数的参数： 函数必须接受与提供的可迭代对象相同数量的参数。如果提供了多个可迭代对象，则函数必须接受相应数量的参数。

3. 可读性： 谨慎使用复杂的函数，以保持代码的可读性。