Python--内置函数

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Python--内置函数，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6027字，纯文字阅读大概需要9分钟。

内容图文

目录

让人又爱又恨的lambda
映射函数：map
拉链函数：zip
过滤函数：filter
累积函数：reduce
其他内置函数
返回Python目录

1：lambda：匿名函数

用法：用lambda创建函数，一般只是把函数赋值给变量，通过这个变量加括号执行lambda并获取结果，并不是得语句将函数赋值给变量。匿名是说在内存空间中只有函数内存地址没有函数名。

语法：lambda        arg1,arg2,......:expression
     声明函数        参数             表达式

1：支持多个函数 2：支持if/else语句
3：如果表达式为判别式，返回True或False
4：多层赋值函数，在多层嵌套函数里，先赋值给最外层。lambda也是一样的
5：lambda执行的功能有限

如果需要用函数实现简单的功能，lambda表达式就可以替代def语句形式：

def foo(x):  
    return x ** 2  
print(foo(2))  # 4  

l = lambda x: x ** 2  
print(l(3))  # 9  
print((lambda x: x ** 2)(3))  # 9  

l = (lambda x: (lambda y: x < y))
print(l)  # <function <lambda> at 0x00FA4B28>
l1 = l(10)  # 基准值 x:10
print(l1)  # <function <lambda>.<locals>.<lambda> at 0x00C26738>
print(l1(5))  # False
print(l1(20))  # True

优化：
print((lambda x: (lambda y: x < y))(10)(5))  # False
print((lambda x: (lambda y: x < y))(10)(20))  # True

** 2：map：映射函数**

语法：map（func，*iterables）
# func: 可执行的函数  
# iterables：迭代器，可迭代的序列      

导入：from collections import Iterable，在Python3.9后就不需要导入了

def f2(x):
    return x ** 2

map_obj = map(f2, range(1, 5))
print(map_obj)  # <map object at 0x000001FBA0311668>
print(isinstance(map_obj, Iterable))  # True
print(list(map_obj))  # [1, 4, 9, 16]

1：map将第二个参数的值交给第一个参数去计算，并将结果收集返回一个map对象(其本质是个可迭代对象)，数据需要显式的通过list强转或for循环取值
2：map也支持多个序列同时执行函数：print(list(map(lambda x, y: x ** y, [2, 3, 4], [3, 2, 2]))) # [8, 9, 16]
上例，map函数将两个列表元素根据索引——映射为key:value的格式传递给lambda的x，y参数，计算后返回结果。
3：map函数将多个序列内的元素以映射的方式交给函数执行，且无法映射的将会被丢弃

#用map来处理列表,把列表中所有人都变成xx_666，如张开_666,
#name = ["张开", "李开", "王开", "赵开"]


name = ["张开", "李开", "王开", "赵开"]
print(list(map(lambda x: x + '_666', name)))

"""
使用map来处理列表，将列表中每个人的名字都变成以xx_666，如张开_666
tmp_list = [{'name': '张开'}, {'name': '李开'}, {'name': '王开'}, {'name': '赵开'}]
"""
tmp_list = [{'name': '张开'}, {'name': '李开'}, {'name': '王开'}, {'name': '赵开'}]
print(list(map(lambda x: x['name'] + '_666', tmp_list)))

3:zip:拉链函数

zip函数用于将可迭代对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象。

语法：
zip(iterables,iterables2,...iterablesn)  
# iterables：可迭代对象

# 显示转化为列表的形式
l1=[1,2,3]
l2=["shimmer","winter","winner"]
zip_obj=zip(l1,l2)
print(list(zip_obj))



# 显示转化为字典的形式
l3=["大商股份","登记股份","贷款股份"]
tmp_list=[]
for l in (l1,l2):
    tmp_list.append(dict(zip(l3,l)))
print(tmp_list)

1：如果各个可迭代对象的元素个数不一致，则返回的对象长度与最短的可迭代对象相同
2：zip将两个可迭代对象中的元素按照索引进行映射为元组，如果显式转换为列表，结果就是列表套元组的形式；如果显式转换为字典，则结果就是字典。
3：如果显式转化为列表，结果就是列表套元祖的形式

title = ["股票名称", "股票代码", "最新价"]
value1 = ["顺威股份", 2676, 3.69]
value2 = ["嘉泽新能", 601619, 4.91]
value3 = ["东方园林", 2310, 5.57]
print(list(zip(title, value1)))
print(list(zip(title, value1, value2)))
print(list(zip(title, value1, value2, value3)))
"""
[('股票名称', '顺威股份'), ('股票代码', 2676), ('最新价', 3.69)]
[('股票名称', '顺威股份', '嘉泽新能'), ('股票代码', 2676, 601619), ('最新价', 3.69, 4.91)]
[('股票名称', '顺威股份', '嘉泽新能', '东方园林'), ('股票代码', 2676, 601619, 2310), ('最新价', 3.69, 4.91, 5.57)]
"""

4：filter：过滤函数

filter函数根据条件过滤序列，将符合条件的元素返回。

语法：
filter(func, *iterables)  
func: 可执行的函数  
iterables：可迭代对象，可迭代的序列  

用filter来处理,得到股票价格大于20的股票名字

shares={
‘IBM’:36.6,
‘Lenovo’:23.2,
‘oldboy’:21.2,
‘ocean’:10.2,
}

 
shares={
    'IBM':36.6,
    'Lenovo':23.2,
    'oldboy':21.2,
    'ocean':10.2,
}
 
m=filter(lambda key:shares[key]> 20,shares)  #匿名函数的用法，题目一有详细注释
#filter函数的用法和map（）函数类似，但filter返还的是key值。参考题目一
print(list(m))
---->['IBM', 'Lenovo', 'oldboy']

用filter过滤出，单价大于100的股票有哪些

portfolio = [
    {'name': 'IBM', 'shares': 100, 'price': 91.1},
    {'name': 'AAPL', 'shares': 50, 'price': 543.22},
    {'name': 'FB', 'shares': 200, 'price': 21.09},
    {'name': 'HPQ', 'shares': 35, 'price': 31.75},
    {'name': 'YHOO', 'shares': 45, 'price': 16.35},
    {'name': 'ACME', 'shares': 75, 'price': 115.65}
]
 
m=filter(lambda k:k['price'] > 100 ,portfolio)
print(list(m))
----->[{'name': 'AAPL', 'shares': 50, 'price': 543.22}, {'name': 'ACME', 'shares': 75, 'price': 115.65}]

1：filter函数中的第一个参数为None的话，则将为真的元素返回，如果返回的是不可调用对象的话，会报错。
2：filter函数根据条件过滤序列，将符合条件元素返回
3：filter也需要强装换才能返回数据
4：元素键名相同时：filter(lambda x:x[键名]条件，字典名)
5：键名不同时：filter(lambda k:字典名[k]条件，字典名)

5：reduce：累积函数

注意：Python3中 reduce() 已经被移到 functools 模块里，如果我们要使用，需要引入 functools 模块来调用 reduce() 函数：需要先导入：from functools import reduce

reduce函数语法如下：

reduce(func, sequence, initializer)  
func: function  
sequence: 序列  
initializer： 初始值，可选参数 

1：如果序列为空，则将initializer值返回。

6：其他内置函数:

1:max/min

print(max(['b', 'c', 'e']))  # e
print(min(['b', 'c', 'e']))  # b
print(max([1, 'b', 3, 5, 'd']))  # TypeError: '>' not supported between instances of 'str' and 'int'

max/min返回序列的最大值和最小值，但要求是序列中的数据类型必须一致，不然无法比较

2:range

from collections import Iterable
res = range(3)
print(res)  # range(0, 3)
print(isinstance(res, Iterable))  # True
print(list(res))  # [0, 1, 2]

print(chr(97))  # a
print(ord('a'))  # 97
print(chr(1000))  # ?
print(chr(1114111))  # 
 

 
标签：__,10,内置,name,Python,--,print,函数	

来源： https://blog.csdn.net/qq_45656077/article/details/114181050