匿名函数、内置函数、迭代器

ζ浅安时光

已于 2023-10-13 17:03:29 修改

阅读量46

点赞数

文章标签： python 开发语言

于 2023-09-13 16:19:26 首次发布

本文链接：https://blog.csdn.net/qq_53842456/article/details/132853293

版权

一、匿名函数

匿名函数：其实就是没有名字的函数，匿名函数也是必须加括号才能使用。

语法格式：

lambda 形参:返回值

def index(形参)：
返回值

res = lambda x: x ** 2


def index(x):
	return x ** 2


index(2)

print(res)  # <function <lambda> at 0x0000024422FB7040>
ret = res(2)
print(ret)  # 4

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

二、常见的内置函数

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

map zip max min filter...

1、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]

2、zip拉链

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


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

3、max，min

max和min默认情况下返回的是字典的key，也是按照key值比较的

d = {
	'kevin': 1000,
	'jerry': 30000,
	'Tank': 200000,
	'Oscar': 100
}


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)  # Tank Oscar

4、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))  # [33, 44, 55, 66]

三、可迭代对象

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

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

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

s.__iter__()
l.__iter__()
t.__iter__()
se.__iter__()
d.__iter__()
# b.__iter
file = open('a.txt', 'w')
file.__iter__()

'''可迭代对象调用__iter__方法之后就是迭代器对象了'''

__iter__开头的方法都有一个与之对应的简写：iter(s) 方法名()

s = {1, 2, 3}
print(s.__iter__())  # <set_iterator object at 0x0000021EB19B4380>
print(iter(s))       # <set_iterator object at 0x00000273B04B4380>


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


print(len(s))  # 3
print(s.__len__())  # 3


def len(s):
	return s.__len__()

四、迭代器

迭代器：内置有__iter__方法还内置有__next__方法

如何转为迭代器对象：

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

s = {1, 2, 3}
ll = [11, 22, 33]
res = s.__iter__()  # 迭代器对象
print(res.__next__())  # next其实就是迭代取值的，而且不依赖于索引取值

res1 = ll.__iter__()
print(res1.__next__())  # 迭代取值，一旦值被取完，就会直接报错

print(next(res1))  # 22

迭代器给我们提供了一种不依赖于索引取值的方式

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

迭代取值与索引取值的对比：

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

五、for循环内部原理

for循环内部的原理：

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

循环打印出列表中每一个元素值，但是不能使用for循环

ll = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# count=0
# while True:
#     print(ll[count])
#     count+=1
# res=ll.__iter__()
# while True:
#     print(res.__next__())

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

res = ll.__iter__()
while True:
	try:
		print(res.__next__())
	except:
		break

# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9

六、异常捕捉

1、什么是异常

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

2、异常的信息

(1). Traceback：追踪信息，异常发生的位置
File "D:/Python27/day17/05 for循环内部原理.py", line 21, in <module>

有时候错误发生的信息可能会有很多行，你就找最后一行，然后点击可以跳转到错误发生的位置

(2). XXXError: 异常发生的类型
NameError KeyError ...

(3). 错误发生的详细信息(最重要的：一般情况从这里就可以知道错位发生的原因)
name 'a' is not defined

3、异常的分类

(1). 语法错误
   是代码运行过程中一开始就不允许的，只要语法错误，代码一定是不能够运行的
通过代码提示就知道语法错误的原因

(2). 逻辑错误
   在编码过程中，逻辑错误是允许出现的，但是我们应该尽量避免逻辑错误出现的可能性
l = [1, 2, 3]
if i < len(l):
   print(l[i])

4、异常如何进行捕捉

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

ζ浅安时光

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
匿名函数、内置函数、迭代器

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

扫一扫