python-内置函数（搭配lambda使用）

2022-03-25 20:02:04 浏览数 (1)

目录

  • 常用的内置函数
    • 需要注意的知识点：
    • enumerate（）函数
    • map（）函数
    • zip（）函数
    • filter（）函数
    • reduce（）函数
    • sum（）函数
    • max（）/ min（）函数
    • sort（）函数
    • sorted（）函数
  • 内置函数一览表：

常用的内置函数

学习！

需要注意的知识点：

  • 大部分内置函数经常搭配lambda函数使用
  • 可迭代对象：字符串、列表、元组、字典、集合、文件对象
  • 注意！！！！
    • 在py3中部分函数的返回值是一个迭代器，不能多次遍历，（map、filter、zip、range）
    • 在py2中部分函数的返回值是一个列表/元组/字符串/列表套元组，可多次遍历

enumerate（）函数

  • enumerate（）函数是枚举的意思
  • 格式：enumerate（argument，start = 0)
    • argument可以是迭代器或可迭代对象（列表/字符串/元组···）
    • start是默认返回的索引值，默认从0开始，可以修改
  • 通常和for循环一起使用，可以获取遍历对象的索引和值，一一对应

实例如下：

代码语言：javascript复制
# 1、搭配字符串使用
str1 = 'python'
for index,value in enumerate(str1):
    print(f'{index}:{value}')
# 结果
0:p
1:y
2:t
3:h
4:o
5:n
# 2、搭配列表(元组一样）一起使用
l = ['Hammer','jason','tony']
for a,b in enumerate(l):
    print(f'{a},{b}')
# 结果
0,Hammer
1,jason
2,tony

#3、搭配集合使用
s = {"aline","Hammer",18,'199****1234'}
for index,value in enumerate(s):
    print(f'{index},{value}')
# 结果
0,Hammer
1,aline
2,18
3,199****1234

# 4、搭配字典使用
dic = {'name':'hammer','age':18,'number':'199***1234'}
for index,value in enumerate(dic):
    # 这样是直接输出了字典的键
    print(f'{index}:{value}')
# 结果
0:name
1:age
2:number
for index, value in enumerate(dic):
    # 输出字典的值
    print(f'{index}:{dic[value]}')
# 结果
0:hammer
1:18
2:199***1234
  • 注意枚举对字典和集合使用，可能索引的位置不能按顺序对应字典和集合的值，因为字典和集合的无序性所导致！

实例如下：

代码语言：javascript复制
# 集合举例
s={'one','two','three','four'}
for index,value in enumerate(s,start=1):
    print(f'{index}:{value}')
# 结果，1和one没有对应，因为集合的无序性
1:three
2:four
3:two
4:one
  • 图示如下：
  • 默认的输出的起始位置为0，可以修改默认起始位置
    • eg：start = 0 >>>> start = 1 / 直接写1

实例如下：

代码语言：javascript复制
lst = ['HammerZe','jason','tony']
# 起始位置默认为0
for index,value in enumerate(lst):
    print(f'{index}:{value}')

#修改默认位置为1，写start = 1 / 直接写1
for index,value in enumerate(lst,start=1):
    print(f'{index}:{value}')
# 结果，写一块了
0:HammerZe
1:jason
2:tony

1:HammerZe
2:jason
3:tony

map（）函数

  • map（）函数的意思是映射，根据提供的函数对指定的序列做映射处理
  • 格式：map(function,iterable) # iterable：可迭代对象
    • 第一个参数为函数名，第二个参数为可迭代对象
  • 过程：循环遍历可迭代对象中的每一个元素传递给function函数，保存返回值，返回一个新的可迭代对象，并没有修改原理的可迭代对象。

实例如下：

代码语言：javascript复制
# map函数的使用，搭配lambda函数使用
'''案例1'''：
# 定义一个可迭代对象
lst = [1,2,3,4,5]
# 用res接收map函数的返回值，转换成列表
# lambda函数作用：给lst列表中每一个元素加2
res = list(map(lambda x:x 2,lst))
print(res)
# 结果
[3, 4, 5, 6, 7]

'''案例2'''
# 面试题（提示：使用了map函数、lambda函数、列表解析)
# 一行代码实现，求10以内的偶数的平方和
print(sum(map(lambda x: x ** 2, [x for x in range(1, 10) if x % 2 == 0])))

#分步实现
# 1、遍历出1到10以内的偶数
even_num = [x for x in range(1,10) if x % 2 ==0] #[2, 4, 6, 8]
# 2、对每一个元素求平方用到映射和lambda计算公式
# print(even_num)
square_num = map(lambda x:x**2,even_num) # [4, 16, 36, 64]
#print(list(square_num))
# 3、最后求和
print(sum(square_num))

# 两个结果
120

zip（）函数

  • zip（）函数是从一个或多个迭代器获取元素，组合成一个新的迭代器，以列表套元组的形式返回。
  • 如果zip（）函数中传入的迭代对象长度不等，以长度最短的迭代器为基准。
  • 实在不理解可以把函数看作“拉链”，一条拉链是一般长的，或者想一下短板效应
  • 格式：
    • zip（iterable1，iterable2···iterablen)
    • iterable为可迭代对象

实例如下：

代码语言：javascript复制
l = [1,2,3,4]
# zip()函数传入一个参数
get_return = list(zip(l))
print(get_return)

# zip()函数传入两个等长的参数(列表和元组)
# 只要是可迭代对象不同类型也可以
l1 = [1,2,3,4]
l2 = ('HammerZe',18,'male','study')
get_return = list(zip(l1,l2))
print(get_return)

# zip()函数传入多个不等长的参数
l1 = [1,2,3,4]
l2 = ['HammerZe',18,'male','study']
l3 = ['name','age','gender','hobby','number','height']
get_return = list(zip(l1,l2,l3))
print(get_return)  # l3的元素只输出了4个，以最短的列表为参考

# 三个示例结果：
[(1,), (2,), (3,), (4,)]
[(1, 'HammerZe'), (2, 18), (3, 'male'), (4, 'study')]
[(1, 'HammerZe', 'name'), (2, 18, 'age'), (3, 'male', 'gender'), (4, 'study', 'hobby')]

filter（）函数

  • filter（）函数用于过滤可迭代对象中的元素，过滤掉不符合条件的元素，返回符合条件的元素组织成新的列表。
  • 格式：
    • filter（function , iterable）
    • function为函数名，iterable为可迭代对象

实例如下：

代码语言：javascript复制
# 输出1-10以内的奇数
l = [1,2,3,4,5,6,7,8,9,10]
res = filter(lambda x:x%2==1,l)
print(list(res))
#结果
[1, 3, 5, 7, 9]

reduce（）函数

注意：在python 3.0.0.0以后, reduce已经不在built-in function里了, 需要from functools import reduce.

  • reduce（）函数的意思是累计操作
  • 格式：
    • reduce（function，sequence [ ,initial] )
    • function为函数名，function中必须是两个参数，sequence为序列，initial有指定的值相当于追加使用数据，或当sequence为空，作为返回值。

实例如下：

代码语言：javascript复制
# 实现列表元素的累加
from functools import reduce
l = [1,2,3,4,5]
res = reduce(lambda x,y:x y,l)
print(res)
# 结果
15
# 用列表解析 reduce实现
res = reduce(lambda x,y:x y ,[x for x in range(1,6)])
print(res)
# 结果
15
#实现6的阶乘
res = reduce(lambda x,y:x*y ,[x for x in range(1,6)])
print(res)

sum（）函数

  • sum函数是对序列里的数据进行加法操作，区别reduce函数
  • 格式：
    • sum（sequence，[,start ] ）
    • sum函数是对sequence里的数据进行加法操作，start默认为0，如果写入数据作为sequence的第一个数据传入

实例如下：

代码语言：javascript复制
# sum对列表求和
lst = [1,2,3,4]
print(sum(lst))
# 结果>>>>10

# 修改sum的默认值为1，作为列表的第一个元素传入
print(sum(lst,1))
# 结果>>>>11

max（）/ min（）函数

sort（）函数

  • sort（）函数应用到列表上，属于列表的内置方法，没有返回值，是对原列表进行排序操作
  • 格式：
    • sort( key=None, reverse=False)
    • key为需要排序的对象，reverse默认为False，升序，改为True为降序

实例如下：

代码语言：javascript复制
l = [1,5,6,9,7]
l.sort()
print(l)
# 结果
[1, 5, 6, 7, 9]

sorted（）函数

  • sorted（）函数可以对所有可迭代对象进行排序操作
  • 格式：
    • sorted（iterable，key = None ，reverse = False)
    • iterable：可迭代对象
    • 参数key用来指定一个函数，此函数的功能就是制定排序的规则，一般用lambda函数。
    • reverse = False为升序，=True为降序，默认升序。
    • 返回一个可迭代对象（列表）

实例如下：

代码语言：javascript复制
#搭配列表使用
l = [11,22,44,33,55]
res = sorted([i for i in l if i>30])
print(res,type(res))
# 结果
[33, 44, 55] <class 'list'>

# 搭配字典使用
dic = {1:"hammer",2:"jason",3:"tony"}
# 按key排序
print(sorted(dic))
print(sorted(dic.keys()))
# 按value排序，对比的是ASCII码
print(sorted(dic.values()))
#结果
[1, 2, 3]
[1, 2, 3]
['hammer', 'jason', 'tony']

# 搭配lambda使用
# 按照工资多少排序升序排列
lst = [{'salary':18000,'age':18,'name':'hammer'},
       {'salary':10000,'age':28,'name':'jason'},
       {'salary':20000,'age':38,'name':'tony'}]
print(sorted(lst, key=lambda x: x['salary']))
# 结果
[{'salary': 10000, 'age': 28, 'name': 'jason'},
 {'salary': 18000, 'age': 18, 'name': 'hammer'}, 
 {'salary': 20000, 'age': 38, 'name': 'tony'}]

内置函数一览表：

功能

描述

例子

abs()

求绝对值

abs(123) / abs(-123)

all()

所有元素返回值为True结果为True

all(0)>False/all(1)>>True

any()

有一个元素返回True结果为True

l = [1,2,0] print(any(l))>>True

bin()

二进制转换

bin(10)

oct()

八进制转换

oct(10)

hex()

十六进制转换

hex(10)

bytes()

编码

res = '牛逼' print(bytes(res, 'utf8'))

str()

字符串

str(1)>>‘1’

encode()

编码

print('牛逼'.encode('utf8'))

decode()

解码

print('牛逼'.encode('utf8').decode('utf8'))

callable()

是否可调用

def index(): pass print(callable(index))>>True

chr()

根据数字找ASCII对应的字符

chr(65)>>>A

ord()

根据字符找ASCII对应的数字

ord('A')>>>65

complex()

复数

complex(3 1j)>>>(3 1j)

dir()

查看当前对象可以调用的名字

dir(查看对象)

divmod()

分页

用余数判断是否分页divmod(101,10)

eval()

只能识别简单的语法

识别字符串中简单代码执行

exec()

可以识别复杂语法

识别字符串中复杂代码执行

isinstance()

判断是否属于某个数据类型

isinstance(123,int)>>>True

pow()

幂运算

pow(2,3)>>>8

round()

四舍五入

round(8.5)>>>8

mapreduce java 编程算法

0 人点赞