python入门学习篇十五

结合匿名函数使用的一些内置方法

1. map   映射
# map的底层原理是for循环
l = [1, 2, 3, 4, 5]

# 传统方法：
# 定义一个新的变量，用来存储新的结果
# new_l = []
# for i in l:
#     new_l.append(i ** 2)
# print(new_l)

# 使用map
# def index(x):
#     return x ** 2


res = list(map(lambda x: x ** 2, l))
print(res)

2. zip 拉链
l1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
l2 = ['ly', 'jason', 'tom', 'kevin', 'tony', 'Pony']
l3 = ['a', 'v', 'b', 'c', 'd']
l4 = [111,222,333]
# [(1, 'ly'), (2, 'jason')...]
# 传统做法：
# 定义一个变量， 存储结果
# new_l = []
# for i in range(len(l1)):
#     new_l.append((l1[i], l2[i]))
# print(new_l)

# zip
res = list(zip(l1, l2, l3,l4))
print(res)

3. max最大，min最小

# max,min
# l = [1, 2, 3, 4, 66,77,8,99,]
# l.sort()
# print(l[-1])
# print(l[len(l)-1])

# print(max(l))
# print(min(l))

d = {
    'ly': 9999999,
    'jason': 1000,
    'kevin': 2000,
    'tom': 20
}
'''
    字典暴露的是k值，
    
    按照ASCII码对应的十进制比较
    A:65
    a:97
    0:48
'''


# def index(key):
#     return d[key]

# max函数返回什么值就按照什么值进行比较， 返回结果还是字段的k
# print(max(d, key=index))  # 底层也是for循环
print(max(d, key=lambda key:d[key]))  # 底层也是for循环
print(min(d, key=lambda key:d[key]))  # 底层也是for循环

4. filter  过滤
# 传统做法
new_l = []

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

# def index(k):
#     return k > 30


print(list(filter(lambda x: x > 30, l, )))

可迭代对象

# 迭代：即更新换代，每一次要依赖于上一次的结果

# 可迭代对象：
    内置有__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')  # 是
"""
    有__iter__()的数据类型：
        字符串，列表，元祖，字典，集合，文件
"""
print(c.__iter__())
print(h.__iter__())
print(d.__iter__())
# 另外一种简便写法
print(iter(c))
print(iter(h))
print(iter(d))


len(c)
c.__len__()

'''
    c.__iter__()方法也有另外一种简单写法 iter()
        所有的__开头的方法都有一个简单写法：函数名()
'''

迭代器对象

# 什么是迭代器对象
    内置有__iter__(),并且也要拥有__next__方法的才是迭代器对象
    
# 如何生成迭代器对象？
让可迭代对象调用__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__())
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())
# res2 = d.__iter__()
# print(res2.__next__())
# print(res2.__next__())
# print(res2.__next__())
# print(res2.__next__())
# print(res2.__next__())


# res1 = d.__iter__()
# res1.__next__()  # 迭代器对象

# res2 = k.__iter__()
# res2.__next__()

# k.__next__()


#练习题：1
# 对应一个可迭代对象，可以连续多次__iter__(),得到的结果还是本身
# res2 = 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__())

for循环的底层原理

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

for i in l:
    print(i)

'''
    for循环的原理：
        1. 先把in后面的可迭代对象__iter__()
        2. 调用__next__取值
        3. 当值取完之后，for内部自定帮你把异常处理了
'''

res = l.__iter__()
while True:
    # 检测的代码
    print(res.__next__())
    # 如果有错，处理掉

异常捕捉

# 什么是异常？
    异常就是错误发生的信号，如果不对该信号做处理，那么，之后的代码都不能正常执行
异常的分类：
    语法错误：
        print(123
        不允许出现，出现之后，立马修改
    逻辑错误
         l = [1, 2, 3]
        print(l[5])
         
         逻辑错误允许出现，但是，一般情况，逻辑错误要写到尽量完美
 异常的三大部分：
       Traceback：
              错误发生的位置
       xxxError:
               错误类型
       xxxError:后面的内容：
              错误发生的原因
              
# 如何解决异常信息呢？
  '''
      语法结构：
          try:
              被检测的代码
          except 错误类型:
              print('')
          except 错误类型:
              print('')
        except 错误类型:
              print('')
  '''  
    
try:
    # 写可能会报错的代码
    # l = [1,2,3,4]
    # l[6]
    # 1/0
    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