内置函数与迭代器

-wellplayed-

已于 2023-09-15 15:47:12 修改

阅读量183

点赞数 2

分类专栏： Python基础文章标签： python 开发语言

于 2023-09-13 15:08:28 首次发布

本文链接：https://blog.csdn.net/m0_71115526/article/details/132853399

版权

Python基础专栏收录该内容

31 篇文章 0 订阅

订阅专栏

内置函数

匿名函数

匿名函数：其实就是没有名字的函数

语法格式：
lambda 形参:返回值
def index(形参)：
返回值

# 匿名函数也是必须加括号才能使用

res = lambda x,y:x+y
print(res(1, 2))

常见的内置函数

配合匿名函数一起使用的内置函数：

map zip max min filter...

map(映射):

# map
ll = [1, 2, 3, 4, 5, 6, 7]


new_res = []
for i in res:
    new_res.append(i ** 2)

print(new_res)

def index(x):
    return x ** 2


# res=map(index, ll) #
res = map(lambda x: x ** 2, ll)  # 
print(list(res))  # [1, 4, 9, 16, 25, 36, 49]

zip(拉链):

# zip 拉链
l1 = [1, 2, 3,4,5,6]
l2 = ['a', 'b', 'c', 'd']
l3 = ['kevin', 'jerry', 'tank', 'oscar']
l4 = ['kevin1', 'jerry2', 'tank3', 'oscar4']

# [(1, 'a'), (2, 'b'), (3, 'c')]

new_list = []
for i in range(len(l1)):
    new_list.append((l1[i], l2[i]))

print(new_list) # [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f')]

res = zip(l1, l2, l3, l4) # [(1, 'a', 'kevin'), (2, 'b', 'jerry'), (3, 'c', 'tank')]
print(list(res)) # [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

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)

filter(过滤器):

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


def index(x):
    return x>30
# res1=filter(index, res) # 内部也是for循环
res1=filter(lambda x:x>30, res) # 内部也是for循环
print(list(res1))

迭代器

一迭代器介绍

迭代器即用来迭代取值的工具，而迭代是重复反馈过程的活动，其目的通常是为了逼近所需的目标或结果，每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值,单纯的重复并不是迭代

while True:
    msg = input('>>: ').strip()
    print(msg)

下述while循环才是一个迭代过程，不仅满足重复，而且以每次重新赋值后的index值作为下一次循环中新的索引进行取值，反复迭代，最终可以取尽列表中的值

goods=['mac','lenovo','acer','dell','sony']

index=0
while index < len(goods):
    print(goods[index])
    index+=1

1.1 可迭代对象

通过索引的方式进行迭代取值，实现简单，但仅适用于序列类型：字符串，列表，元组。对于没有索引的字典、集合等非序列类型，必须找到一种不依赖索引来进行迭代取值的方式，这就用到了迭代器。

要想了解迭代器为何物，必须事先搞清楚一个很重要的概念：可迭代对象(Iterable)。从语法形式上讲，内置有__iter__方法的对象都是可迭代对象，字符串、列表、元组、字典、集合、打开的文件都是可迭代对象：

{'name':'kevin'}.__iter__
{7,8,9}.__iter__
……

1.2 迭代器对象

调用obj.iter()方法返回的结果就是一个迭代器对象(Iterator)。迭代器对象是内置有iter和next方法的对象，打开的文件本身就是一个迭代器对象，执行迭代器对象.iter()方法得到的仍然是迭代器本身，而执行迭代器.next()方法就会计算出迭代器中的下一个值。迭代器是Python提供的一种统一的、不依赖于索引的迭代取值方式，只要存在多个“值”，无论序列类型还是非序列类型都可以按照迭代器的方式取值

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循环原理

有了迭代器后，我们便可以不依赖索引迭代取值了，使用while循环的实现方式如下

goods=['mac','lenovo','acer','dell','sony']
i=iter(goods) #每次都需要重新获取一个迭代器对象
while True:
    try:
        print(next(i))
    except StopIteration: #捕捉异常终止循环
        break

for循环又称为迭代循环，in后可以跟任意可迭代对象，上述while循环可以简写为

goods=['mac','lenovo','acer','dell','sony']
for item in goods:   
    print(item)

for循环内部的原理：
       1. 首先把关键字in后面的可迭代对象转为迭代器对象
       2. while循环取值__next__迭代取值，当next取值完毕的时候会报错
       3. 当内部报错的时候，for循环进行了异常捕捉

异常捕捉

什么是异常？
异常就是错误发生的信号，如果不对该信号做处理，那么，异常发生的位置之后的代码都不能正常运行

异常的信息：
   1. Traceback：追踪信息，异常发生的位置
   File "D:/Python27/day17/05 for循环内部原理.py", line 21, in <module>
# 有时候错误发生的信息可能会有很多行，你就找最后一行，然后点击可以跳转到错误发生的位置

2. XXXError: 异常发生的类型
   NameError KeyError ...
3. 错误发生的详细信息(最重要的：一般情况从这里就可以知道错位发生的原因)
   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

三迭代器的优缺点

基于索引的迭代取值，所有迭代的状态都保存在了索引中，而基于迭代器实现迭代的方式不再需要索引，所有迭代的状态就保存在迭代器中，然而这种处理方式优点与缺点并存：

3.1 优点：

1、为序列和非序列类型提供了一种统一的迭代取值方式。

2、惰性计算：迭代器对象表示的是一个数据流，可以只在需要时才去调用next来计算出一个值，就迭代器本身来说，同一时刻在内存中只有一个值，因而可以存放无限大的数据流，而对于其他容器类型，如列表，需要把所有的元素都存放于内存中，受内存大小的限制，可以存放的值的个数是有限的。

3.2 缺点：

1、除非取尽，否则无法获取迭代器的长度

2、只能取下一个值，不能回到开始，更像是‘一次性的’，迭代器产生后的唯一目标就是重复执行next方法直到值取尽，否则就会停留在某个位置，等待下一次调用next；若是要再次迭代同个对象，你只能重新调用iter方法去创建一个新的迭代器对象，如果有两个或者多个循环使用同一个迭代器，必然只会有一个循环能取到值。

-wellplayed-

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
内置函数与迭代器

迭代器即用来迭代取值的工具，而迭代是重复反馈过程的活动，其目的通常是为了逼近所需的目标或结果，每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值,单纯的重复并不是迭代print(msg)下述while循环才是一个迭代过程，不仅满足重复，而且以每次重新赋值后的index值作为下一次循环中新的索引进行取值，反复迭代，最终可以取尽列表中的值index=0index+=1。
复制链接

扫一扫