Python匿名函数、常见的内置函数、可迭代对象与迭代器对象等

A_baio

已于 2023-09-14 19:20:52 修改

阅读量116

点赞数 3

文章标签： python java 开发语言

于 2023-09-13 20:03:18 首次发布

本文链接：https://blog.csdn.net/shiyaopeng11/article/details/132855419

版权

文章目录

一、匿名函数
- - 语法
二、常见的内置函数
三、可迭代对象
- - 迭代：
  - 可迭代对象
四、迭代器对象
- - 迭代器：
  - 如何转为迭代器对象
五、for循环内部原理
六、异常捕捉
七、迭代器总结(迭代取值和索引取值的对比)

一、匿名函数

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

lambda 只是一个表达式，函数体比 def 简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
匿名函数就是没有名字的函数

语法

res = lambda x: X**2
print(res(2))  #4
#  lambda 参数列表：return [表达式] 变量
#  由于lambda返回的是函数对象（构建的是一个函数对象），所以需要定义一个变量去接收

'''用函数形式表达：'''
def index(x):
	return x**2
ret = (index(2)) #4

'''当有两个参数时'''
res = lambda x,y: x+y
# 调用res函数，相加后结果为6
print(res(2,4)) #6

二、常见的内置函数

1.map

map() 是 Python 中内置的函数之一。它的作用是将一个函数映射到一个可迭代对象上的所有元素，得到一个新的可迭代对象。
对于列表（或其他序列类型），如果希望对每个元素执行相同的操作，我们一般的做法是使用一个for循环遍历每个元素然后执行相同操作。

列表每个元素加10：

l = [1, 2, 3, 4, 5, 6]
l1 = []
for i in l:
    l1.append(i + 10)
print(l1)

上面操作非常常见，因此，Python内置了一个比较使用的工具函数：map,使用map函数使得代码变得更简洁：

l = [1, 2, 3, 4, 5, 6]
res = map(lambda l:l+10, l)
print(list(res))

map函数除了能让代码更优雅以外，还有一个更重要的好处：使用map比使用for循环速度更快。

2.zip (拉链)

zip()函数后面接收的是个可迭代对象，后面可接收多个可迭代对象。

l1 = [1, 2, 3, 4, 5]
l2 = ['a', 'b', 'c', 'd', 'e']
l3 = ['kevin', 'tank', 'jerry', 'jack']

res = zip(l1, l2, l3)
print(list(res)) #[(1, 'a', 'kevin'), (2, 'b', 'tank'), (3, 'c', 'jerry'), (4, 'd', 'jack')]
'''把第一个可迭代对象的第一个元素和第二个、第三个可迭代对象的第一个元素拿出来打包成一个元组'''

如果可迭代对象里面元素多少不一样（长短不一）怎么办？
代码中最短的一组：这里只有 3 个元素。

l1 = [1, 2, 3,]
l2 = ['a', 'b', 'c', 'd', 'e']
l3 = ['kevin', 'tank', 'jerry', 'jack']

res = zip(l1, l2, l3)
print(list(res)) #[(1, 'a', 'kevin'), (2, 'b', 'tank'), (3, 'c', 'jerry')]
'''只会保留最短的那一个'''

那么这里的话，只会分成 3 组。就算第二组和第三组有 5 个元素，只会拿第一个、第二个、第三个。多余的数据清除掉了，不要了。

3.max、min

max和min函数
对可迭代对象元素进行比较，找到最大/最小值
对传入的多个参数进行比较，找到最大/最小值

d = {
    'kevin': 1000,
    'jerry': 30000,
    'Tank': 200000,
    'Oscar': 100
}
'''max和min默认情况下返回的是字典的key，也是按照key值比较的'''


# print(max(d))
# print(min(d))

def index(x):
    return d[x] # 返回什么就安装什么进行比较


res=max(d, key=lambda x:d[x])
res1=min(d, key=lambda x:d[x])
print(res,res1)

4. filter (过滤序列)

filter()过滤序列。第一参数是函数；第二参数是可迭代对象。
filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

求得列表内大于30的元素：

res = [11, 22, 33, 44, 55, 66]
new_list = []
for i in res:
    if i > 30:
        new_list.append(i)

print(new_list)

用filter过滤序列书写：

def index(x):
    return x > 30

res1 = filter(lambda x: x>30,res)
print(list(res1))

三、可迭代对象

迭代：

是重复反馈过程的活动，其目的通常是为了逼近所需目标或者结果。每一次对过程的重复就是一次迭代，而每一次迭代得到的结果会作为下一次迭代的初始值。
大白话就是更新换代，每一次的更新都是基于上一次的结果

可迭代对象

字符串、列表、元组、字典、集合、满意以下条件的也可以成为可迭代对象

对象实现了 iter 方法
iter 方法返回了迭代器对象

print(s)
'''可迭代对象调用__iter__方法之后就是迭代器对象了'''
print(s.__iter__()) # <str_iterator object at 0x0000023F68F31100>
print(iter(s))

def iter(s):
    return s.__iter__()

print(len(s))
print(s.__len__())

def len(s):
    return s.__len__()
"""
__iter__开头的方法都有一个与之对应的简写：iter(s) 方法名()
"""

四、迭代器对象

迭代器：

内置有__iter__方法还内置有__next__方法

如何转为迭代器对象

有可迭代对象调用__iter__()方法转为迭代器对象

 # res=s.__iter__() # 迭代器对象
# print(res.__next__())  # next其实就是迭代取值的，而且不依赖于索引取值
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())
#
# res1 = l.__iter__()
# print(res1.__next__())
# print(res1.__next__())
# print(res1.__next__())
# print(res1.__next__())
# print(res1.__next__())  # 迭代取值，一旦值被取完，就会直接报错

# print(next(res1))
# print(next(res1))
# print(next(res1))
# print(next(res1))

"""
迭代器给我们提供了一种不依赖于索引取值的方式
"""
# 可迭代对象调用多次__iter__方法仍然是迭代器对象
# print(res.__iter__().__iter__().__iter__())

#### 易错题
l = [1, 2, 3, 4]
print(l.__iter__().__next__()) # 1
print(l.__iter__().__next__()) # 1
print(l.__iter__().__next__()) # 1
print(l.__iter__().__next__()) # 1

res = l.__iter__()
print(res.__next__())  # 1
print(res.__next__())  # 2
print(res.__next__())  # 3
print(res.__next__())  # 4

五、for循环内部原理

l = [1, 2, 3, 4, 5, 6, 7, 8, 9] # 循环打印出列表中每一个元素值，但是不能使用for循环

l = [1, 2, 3, 4, 5, 6, 7, 8, 9] # 循环打印出列表中每一个元素值，但是不能使用for循环

# count=0
# while True:
#     print(l[count])
#     count+=1
# res=l.__iter__()
# while True:
#     print(res.__next__())

'''for循环为什么不报错呢'''
# for i in l:
#     print(i)

res=l.__iter__()
while True:
    try:
        print(res.__next__())
    except:
        break
     
"""
	for循环内部的原理：
		1. 首先把关键字in后面的可迭代对象转为迭代器对象
		2. while循环取值__next__迭代取值，当next取值完毕的时候会报错
		3. 当内部报错的时候，for循环进行了异常捕捉
"""

六、异常捕捉

Traceback：追踪信息，异常发生的位置
File “D:/Python27/day17/05 for循环内部原理.py”, line 21, in
# 有时候错误发生的信息可能会有很多行，你就找最后一行，然后点击可以跳转到错误发生的位置
1. XXXError: 异常发生的类型
  NameError KeyError …
2. 错误发生的详细信息(最重要的：一般情况从这里就可以知道错位发生的原因)
  name ‘a’ is not defined

异常的分类：
1. 语法错误
# 是代码运行过程中一开始就不允许的，只要语法错误，代码一定是不能够运行的
# 通过代码提示就知道语法错误的原因
2. 逻辑错误
# 在编码过程中，逻辑错误是允许出现的
但是我们应该尽量避免逻辑错误出现的可能性

l = [1, 2, 3]
if i < len(l):
	print(l[i])

异常如何进行捕捉
try:
    l = [1, 2, 3]
    print(l[4]) # IndexError
    # d = {'a':1}
    # print(d['b'])
    # 1/0
# except NameError as e:
#     print(e)
# except KeyError as e:
#     print(e)
# except IndexError as e:
#     print(e) # list index out of range
# except ZeroDivisionError as e:
#     print(e)
except Exception as e:
    print(e)
else:
    # 当被检测的代码没有异常的时候会走这个语法
    print('这是else语法') # 这是else语法
finally:
    # 不管被监测的代码是否有异常都会走
    print('这是finally语法')
print(123)


"""
只能当你的被监测代码可能会出现，但是，又不想让它报错，这个时候使用异常捕捉是最合适的
异常捕捉的代码尽量少的写
"""

l = [1,2,3,4,5,6,7]
res= l.__iter__()
while True:
    try:
        print(res.__next__())
    except Exception:
        break

七、迭代器总结(迭代取值和索引取值的对比)

l = [1, 2, 3, 4]
res = l.__iter__()
res.__next__() # 1
res.__next__() # 2

res1 = l.__iter__()
res1.__next__()  # 1
res1.__next__()  # 2

迭代取值
1. 不依赖于索引取值的一种取值方式
2. 不能够重复取值，只能够从左往右固定取值
索引取值
1. 它能够重复取值(通过索引l[0])
2. 它需要是容器类型

A_baio

关注

3
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python匿名函数、常见的内置函数、可迭代对象与迭代器对象等

filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。每一次对过程的重复就是一次迭代，而每一次迭代得到的结果会作为下一次迭代的初始值。# 是代码运行过程中一开始就不允许的，只要语法错误，代码一定是不能够运行的。zip()函数后面接收的是个可迭代对象，后面可接收多个可迭代对象。
复制链接

扫一扫