函数进阶——内置方法补充、可迭代对象及迭代器对象

最新推荐文章于 2024-07-31 14:30:10 发布

Jakey_src

最新推荐文章于 2024-07-31 14:30:10 发布

阅读量143

点赞数

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

本文链接：https://blog.csdn.net/Jakey_src/article/details/122462951

版权

python基础专栏收录该内容

25 篇文章 1 订阅

订阅专栏

文章目录

内置方法补充（结合匿名函数使用）

map(func,iterable)：它会根据传入的函数func对指定的序列iterable做映射。

过程描述：循环第二个参数iterable中的每一个元素，传入第一个参数func中调用，返回包含每次调用结果的新列表。

示例：生成一个新列表，使其中的元素为原列表中各元素的平方。

# 传统方式：
l = [1, 2, 3, 4, 5]

new_l = []
for i in l:
    new_l.apppend(i ** 2)
    
print(new_l)


# 使用map方法,不使用匿名函数
def square(x):
    return x ** 2

new_l = list(map(square,l))
print(new_l)

# 使用map方法，使用匿名函数
new_l = list(map(lambda x: x ** 2, l))
print(new_l)

# 执行结果：[1, 4, 9, 16, 25]

zip(iterable, ...)：它会将可迭代对象中的元素打包成列表套元组的形式返回。

过程描述：将每个可迭代对象中对应的元素打包成一个个元组，然后将这些元组组成列表返回。如果各个可迭代对象中的元素数量不一致，则返回列表的长度与最短的可迭代对象元素数量一致。

示例：将两个列表之间的元素按照索引一一对应

l1 = [1, 2, 3, 4, 5]
l2 = ['huawei', 'vivo', 'oppo', 'redme', 'iphone']
l3 = ['a', 'v', 'b', 'c', 'd', 'e', 'f']
l4 = [111,222,333]
# 传统方式：
new_l = []

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

print(new_l)

# 使用zip方法
new_l = list(zip(l1,l2))
print(new_l)

# 上面两种执行结果：[(1, 'huawei'), (2, 'vivo'), (3, 'oppo'), (4, 'redme'), (5, 'iphone')]


# zip也可以实现多个参数同时对应，返回长度以最短的为准
res = list(zip(l1, l2, l3,l4))
print(res)
# 执行结果：[(1, 'huawei', 'a', 111), (2, 'vivo', 'v', 222), (3, 'oppo', 'b', 333)]

max()/min()：返回最大值/最小值。

示例一：打印列表中最大的元素。

l = [1,2,3,4,66,44,9,88]
# 方法一：
l.sort()
print(l[-1])
print(l[len(l)-1])

# 方法二：
l.sort(reverse=True)
print(l[0])

# 方法三：max/min
print(max(l))  # 返回最大的元素
print(min(l))  # 返回最小的元素

示例二：打印字典中value最大的key。

d = {
    'mark': 9999999,
    'mary': 1000,
    'smith': 2000,
    'tom': 20
}
# 注意：使用max的时候，内部循环比较的是字典的key值，不能直接比较返回，因此需要用到max方法的key参数

# 方式一：使用max方法，不使用匿名函数
def index(key):
    return d[key]

print(max(d, key=index))  
print(min(d, key=index))
# 底层也是for循环，index返回什么值就按照什么值进行比较，最终max的返回值依旧是字典的key值

# 方式二：使用max方法，使用匿名函数
print(max(d, key=lambda key: d[key]))
print(min(d, key=lambda key: d[key]))

# 执行结果均为：
mark
tom

filter(func, iterable)：用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的列表。

过程描述：将第二个参数iterable中的元素作为参数，逐个传入第一个函数func中进行判断，判断结果为True或False，最后将判断结果为True的元素放入一个新列表中返回。

示例：将列表中大于30的元素放入一个新的列表中

l = [1,2,3,4,66,44,9,88]

# 传统方式：
new_l = []

for i in l:
    if i > 30:
        new_l.append(i)
        
print(new_l)

# 使用filter方法，不使用匿名函数
def index(x):
    return x > 30

print(list(filter(index,l))
# 执行结果：[66, 44, 88]
      
      
# 使用filter方法，使用匿名函数
print(list(filter(lambda x: x > 30, l)))
# 执行结果：[66, 44, 88]

迭代器

迭代器即用来迭代取值的工具，每一次取值都要依赖上一次的结果，而不是单纯的重复，但是前提条件是不能使用索引取值。

举例：

phone = ['huawei', 'vivo', 'oppo', 'redme', 'iphone']
 
index=0
while index < len(phone):
    print(phone[index])
    index+=1

可迭代对象

python中，内置有__iter__()方法的对象都是可迭代对象，通俗讲，内置的意思就是可以通过.查看。调用iter()方法返回的结果就是可迭代对象。

示例：

a = 1  # 不是
b = 1.22  # 不是
c = 'hello'  # 是
d = [1, 2, 3, 4]  # 是
f = (1, 2, 3, 4)  # 是
h = {'username': 'ly'}  # 是
i = {1, 2, 3, 4}  # 是
j = True  # 不是
k = open('a.txt', 'w', encoding='utf-8')  # 是

总结：属于可迭代对象的数据类型有：字符串，列表，元祖，字典，集合，文件

补充：所有以双下划线开头并且以双下划线结尾的方法，都可以以一种简单的方法调用，即函数名()

print(c.__iter__())
print(h.__iter__())
print(d.__iter__())
# 另外一种简便写法
print(iter(c))
print(iter(h))
print(iter(d))

len(c)
c.__len__()

迭代器对象

在python中，内置有__iter__()方法，并且内置有__next__()方法的对象才是迭代器对象。调用iter()方法返回的结果就是可迭代对象，用可迭代对象再调用next()方法返回的结果才是迭代器对象。

迭代器的作用：提供了一种不依赖于索引取值的方式。

示例：

c = 'hello'  # 是
d = [1, 2, 3, 4]  # 是
f = (1, 2, 3, 4)  # 是
h = {'username': 'ly'}  # 是
i = {1, 2, 3, 4}  # 是

# 文件对象本省就是可迭代对象和迭代器对象
k = open('a.txt', 'w', encoding='utf-8')  # 是

res = c.__iter__()
res.__next__()  # 迭代器对象

print(res.__next__())
print(res.__next__())

练习题：

#练习题1：
# 对应一个可迭代对象，可以连续多次__iter__(),得到的结果还是本身
d = [1, 2, 3, 4]
res = d.__iter__()
print(res2.__next__())

# 练习题2：
a = d.__iter__()
print(a.__next__())
a = d.__iter__()
print(a.__next__())

print(d.__iter__().__next__())
print(d.__iter__().__next__())
print(d.__iter__().__next__())
print(d.__iter__().__next__())
# 执行结果均为1，而非1,2,3,4

异常捕获

引出：for循环内部原理

在使用for循环的时候，我们想一个问题，如果没有值可循环的时候，那应该怎么办，理应会抛出异常，但实际上没有，说明for循环内部帮助我们做了处理。下面是for循环内部原理：

先把in后面的可迭代对象调用__iter__()
再调用__next__取值
当值取完之后，for内部自动进行异常处处理

l = [1, 2, 3, 4, 5]
# 循环打印出每一个元素，不能使用for循环
res = l.__iter__()
while True:
    print(res.__next__())

for i in l:
    print(i)


# 我们猜想的异常处理应该需要对代码进行检测，如果有错，我们应该有所措施对应
res = l.__iter__()
while True:
    # 检测的代码
    print(res.__next__())
    # 如果有错，处理掉

异常捕获

异常就是错误发生的信号，如果不对该信号做处理，那么，之后的代码都不能正常执行。异常捕获就是对于该信号进行检测。

异常的分类

语法错误：是人为错误，不应该出现，应该在出现之前就处理掉。

逻辑错误：允许出现，但是一般情况下需要做到尽量完美。
异常的三大部分：

Traceback ：表示错误发生的位置

xxxError：表示错误类型

xxxError:后面的内容：表示错误发生的原因

举例：

异常处理

语法结构

try:
    被检测的代码
    except 错误类型:
        处理操作
    except 错误类型:
        处理操作
    except 错误类型:
        处理操作

示例：

try:
    # 写可能会报错的代码
    # l = [1,2,3,4]
    # l[6]  # IndexError
    # 1/0  # ZeroDivisionError
    d = {'username': 'aaa'}
    d['aaa']  # KeyError
except IndexError as e:
    print(e)
# except ZeroDivisionError as e:
#     print(e)
# except KeyError as e:
#     print(e)
except Exception as e:  # 捕获所有异常
    print(e)

练习题：

l = [1, 2, 3, 4, 5]
# 循环打印出每一个元素，不能使用for循环,使用__next__
res = l.__iter__()
while True:
    try:
        print(res.__next__())
    except Exception as e:
        break

Jakey_src

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
函数进阶——内置方法补充、可迭代对象及迭代器对象

文章目录内置方法补充（结合匿名函数使用）迭代器可迭代对象迭代器对象异常捕获引出：for循环内部原理异常捕获异常处理内置方法补充（结合匿名函数使用）map(func,iterable)：它会根据传入的函数func对指定的序列iterable做映射。过程描述：循环第二个参数iterable中的每一个元素，传入第一个参数func中调用，返回包含每次调用结果的新列表。示例：生成一个新列表，使其中的元素为原列表中各元素的平方。# 传统方式：l = [1, 2, 3, 4, 5]new_l = []
复制链接

扫一扫

专栏目录