9.13 知识总结

最新推荐文章于 2024-07-17 21:04:45 发布

超困困困困狗

最新推荐文章于 2024-07-17 21:04:45 发布

阅读量86

点赞数

文章标签： python 开发语言

本文链接：https://blog.csdn.net/weixin_66010453/article/details/132853753

版权

一、匿名函数

1.1 概念

匿名函数是指没有名字的函数，它主要应用在需要一个函数、但是又不想费神去命名这个函数的场合。通常情况下，这样的函数只使用一次。

1.2 语法格式

lambda 形参:返回值
     def index(形参)：
         返回值

代码展示：

 res = lambda x:x**2

 def index(x):
     return x**2
 index(2)

 print(res)
 ret= res(2)
 print(ret) # 4

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

二、常见的内置函数（map、zip、filter、maxmin）

2.1 map

定义：将指定的函数，依次作用于可迭代对象的每个元素，并返回一个迭代器对象。这个可迭代对象，可以是一个也可以是多个。

代码展示：

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

2.2 zip

定义：zip 函数是可以接收多个可迭代对象，然后把每个可迭代对象中的第i个元素组合在一起，形成一个新的迭代器，类型为元组

代码展示：

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')]

2.3 filter

定义：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))

2.4 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)

三、可迭代对象

3.1 什么是可迭代对象？

内置有__iter__方法的都可以称之为是可迭代对象

3.2 满意以下条件的也可以成为可迭代对象

1.在内部对可迭代对象调用__iter__方法，获取到迭代器对象

2.再一次次通过迭代器对象调用__next__方法获取迭代结果

3.3 判断对象是否可以迭代？

使用函数 isinstance() isinstance(对象，Iterable)

代码展示：

from collections.abc import Iterable
# 这个Iterable再python3.3-python3.9中弃用了，所以需要添加collections.abc

print(isinstance(123, Iterable)) #判断123是否是可迭代对象
print(isinstance("python",Iterable)) #判断"python"是否为可迭代对象

四、 for循环内部原理

1. 首先把关键字in后面的可迭代对象转为迭代器对象
2. while循环取值__next__迭代取值，当next取值完毕的时候会报错
3. 当内部报错的时候，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

五、异常捕捉

5.1 什么是异常：

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

5.2 异常的信息：

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

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

5.3 异常如何进行捕捉

代码展示：

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