Python之迭代器及可迭代对象

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

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

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

 res = lambda x:x**2
 
方法一
 def index(x):
     return x**2
 index(2)
 
方法二
 
res = lambda x,y:x+y
print(res(1, 2))
2 常见的内置函数
一些配合匿名函数一起使用的内置函数:

map zip max min filter

2.1 map函数
        map函数是Python内置函数之一，它可以对一个序列中的每个元素应用一个函数，并返回一个结果列表。

# 定义函数
def square(x):
    return x ** 2
 
# 应用函数
result = map(square, [1, 2, 3, 4, 5])
 
# 输出结果
print(list(result))  # 输出 [1, 4, 9, 16, 25]
        在上面的示例中，map函数将square函数作用于列表[1, 2, 3, 4, 5]中的每个元素，得到一个结果列表[1, 4, 9, 16, 25]。注意，最后还需要使用list函数将结果转换为列表形式。

        配合匿名函数使用

ll = [1, 2, 3, 4, 5, 6, 7]
res = map(lambda x: x ** 2, ll)  
print(list(res))  # [1, 4, 9, 16, 25, 36, 49]
2.2 zip函数
zip()函数是一个内置函数，用于将多个可迭代对象打包成一个元组序列，例如将两个列表 

a = [1, 2, 3] 和 b = ['a', 'b', 'c'] 打包成一个元组序列

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

它的语法为：

zip(*iterables)
        其中，iterables 是可迭代对象，可以是多个列表、元组或其他可迭代对象。zip()函数将会返回一个zip对象，其中的元素是由每个传入可迭代对象的元素一一对应生成的元组。

a = [1, 2, 3]
b = ['a', 'b', 'c']
c = zip(a, b)
print(list(c))  # [(1, 'a'), (2, 'b'), (3, 'c')]
 
# 可以使用*将zip对象转换为元组序列
a, b = zip(*[(1, 'a'), (2, 'b'), (3, 'c')])
print(a)  # (1, 2, 3)
print(b)  # ('a', 'b', 'c')
        可以看出，zip()函数返回的是一个zip对象，需要使用list()函数将其转换为列表或使用*操作符将其转换为元组序列。

2.3 max函数
        max函数是Python的内置函数之一，用于返回给定参数中的最大值。可以接受多个参数，也可以传入一个可迭代对象。

语法：

max(iterable, *[, default=obj, key=func]) 或 

max(arg1, arg2, *args[, key=func])

        其中，iterable是一个可迭代对象，default是当可迭代对象为空时返回的默认值（默认为抛出ValueError异常），key是定义一个函数，用于从每个参数中提取比较关键字。如果省略，则默认使用每个参数本身进行比较。

# 对于数字形参
print(max(1, 2, 3, 4, 5, 6))  # 输出6
print(max([-5, -3, 0, 3, 5], key=abs))  # 输出-5
 
# 对于字符串形参
print(max("apple", "banana", "orange"))  # 输出"orange"
print(max("apple", "banana", "orange", key=len))  # 输出"banana"
        以上例子中，我们可以看到，通过max函数，我们可以找到数字或字符串列表中的最大值，并指定一个可选的关键字来进行比较。

2.4 min函数
  min()是Python内置函数之一，用于返回给定可迭代对象中的最小值。可以接受任何可迭代对象作为参数，包括列表、元组、集合和字典等。

语法: 

min(iterable[, key=func])

参数：

iterable: 要查找最小值的可迭代对象。
key: 可选参数，指定一个函数，用于计算可迭代对象中每个元素的排序值，然后根据这个排序值来查找最小元素。默认为None，表示直接比较可迭代对象中的元素。
# 查找列表中最小值
>>> my_list = [5, 3, 8, 4, 2]
>>> min(my_list)
2
 
# 查找元组中最小值
>>> my_tuple = (9, 1, 6, 3, 5)
>>> min(my_tuple)
1
 
# 查找集合中最小值
>>> my_set = {8, 4, 2, 6, 3}
>>> min(my_set)
2
 
# 指定 key 函数来查找最小值
>>> words = ['apple', 'banana', 'orange', 'pear']
>>> min(words, key=len)
'pear'

2.5 filter 函数

    filter() 函数是 Python 内置的高阶函数，用于过滤序列（例如列表、元组等）中的元素。它的基本语法是：

filter(function, iterable)
其中，function 是一个函数，可以是内置函数或者自定义函数；iterable 是一个可迭代对象，如列表、元组、字典、集合等。

filter() 函数会通过对可迭代对象中的每个元素应用 function 函数进行筛选，返回一个新的可迭代对象，其中仅包含应用 function 函数后结果为 True 的元素。

以下是一个使用 filter() 函数筛选出列表中所有偶数的示例：

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
def is_even(num):
    return num % 2 == 0
 
even_numbers = filter(is_even, numbers)
print(list(even_numbers))  # 输出 [2, 4, 6, 8, 10]
在上述示例中，我们定义了一个函数 is_even()，它接收一个数字作为参数，检查该数字是否为偶数并返回 True 或 False。我们将这个函数作为第一个参数传递给 filter() 函数，同时将列表 numbers 作为第二个参数传递给它。filter() 函数返回一个新的可迭代对象 even_numbers，其中仅包含应用 is_even() 函数后结果为 True 的元素，我们将其转换为列表并输出。

3 可迭代对象
迭代：更新换代，每一次的更新都是基于上一次的结果

可迭代对象：
    内置有__iter__方法的都可以称之为是可迭代对象
    '内置': 直接可以使用点出来的

可迭代对象：
    str、list、dict、set、tuple、文件类型
以上基本数据类型都是可迭代对象

s.__iter__()
l.__iter__()
t.__iter__()
se.__iter__()
d.__iter__()
# b.__iter
file = open('a.txt', 'w')
file.__iter__()
可迭代对象调用__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) 方法名()

4 迭代器对象
迭代器：
    内置有__iter__方法还内置有__next__方法
    
如何转为迭代器对象
    有可迭代对象调用__iter__()方法转为迭代器对象

# 可迭代对象调用多次__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 

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

l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
 
res=l.__iter__()
while True:
    try:
        print(res.__next__())
    except:
        break
6 异常捕捉
什么是异常：
    异常就是错误发生的信号，如果不对该信号做处理，那么，异常发生的位置之后的代码都不能正常运行
    
6.1 异常的信息：
    1. Traceback：追踪信息，异常发生的位置
         File "D:/Python27/day17/05 for循环内部原理.py", line 21, in <module>
        # 有时候错误发生的信息可能会有很多行，你就找最后一行，然后点击可以跳转到错误发生的位置
        
    2. XXXError: 异常发生的类型
        NameError  KeyError  ...
    3. 错误发生的详细信息(最重要的：一般情况从这里就可以知道错位发生的原因)
        name 'a' is not defined

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

6.3 异常如何进行捕捉：

        在Python中，异常处理是通过try和except语句实现的，可以在try块中放置可能会引发异常的代码，然后在except块中处理这些异常。以下是一个基本的语法格式：

try:
    # 可能会引发异常的代码
except ExceptionType:
    # 异常处理代码
        其中，ExceptionType是要捕获的异常类型，可以是Python内置的异常类型（如ValueError、TypeError等），也可以是自定义的异常类型。如果try块中的代码引发了指定类型的异常，程序将会跳转到对应的except块执行异常处理代码。

除了直接指定异常类型，还可以用多个except块处理不同类型的异常，或使用一个except块捕获所有异常。例如：

# 指定多个异常类型
try:
    # 可能会引发异常的代码
except (ValueError, TypeError):
    # 异常处理代码
 
# 捕获所有异常
try:
    # 可能会引发异常的代码
except Exception as e:
    # 异常处理代码，其中e是捕获到的异常对象
        在捕获到异常后，可以使用异常对象的属性和方法获取异常相关信息，例如错误消息等。常见的异常处理方式包括输出错误信息、重新抛出异常、执行特定的补救措施等。需要注意的是，在使用try-except语句处理异常时，应该尽量精确地指定异常类型，以免屏蔽掉其他未预料到的异常。

异常捕捉练习

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

————————————————
版权声明：本文为CSDN博主「森木在花开」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_38104453/article/details/132856821