一、常用内置函数

首先先介绍几个常用的内置函数，以下几个函数的功能可以在后续的编写代码中帮助我们简洁、高效地处理一些数据问题，如下：

• map()：映射

  list1 = [1, 2, 3, 4, 5]
  res1 = map(lambda x: x ** 2, list1)
  print(list(res1))
  

  打印结果为：

  [1, 4, 9, 16, 25]
  

• zip()：拉链，当结合数据有多个且长度不等时，以最短的数据源为准：

  list2 = [111, 222, 333, 444]
  list3 = ['zhangsan', 'lisi', 'wangwu']
  res2 = zip(list2, list3)
  print(list(res2))
  

  打印结果为：

  [(111, 'zhangsan'), (222, 'lisi'), (333, 'wangwu')]
  

• max()与min()：最大与最小

  dic = {
      'jason': 3000,
      'Bevin': 1000000,
      'Ascar': 10000000000,
      'aerry': 88888
  }
  
  print(max(dic, key=lambda key: dic[key]))  
  print(min(dic, key=lambda key: dic[key]))  
  

  打印结果为：

  Ascar
  jason
  

• filter()：过滤

  list4 = [1, 2, 3, 4, 5, 6]
  res3 = filter(lambda x: x > 3, list4)
  print(list(res3))
  

  打印结果为：

  [4, 5, 6]
  

• reduce()：归总

  from functools import reduce
  
  list5 = [1, 2, 3, 4, 5, 6]
  res4 = reduce(lambda x, y: x * y, list5)
  print(res4)
  

  打印结果为：

  720
  

二、迭代器介绍

迭代器即用来迭代取值的工具，而迭代是重复反馈过程的活动，其目的通常是为了逼近所需的目标或结果；

每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值，单纯的重复并不是迭代：

while True:
    msg = input('>>: ').strip()
    print(msg)

下述while循环才是一个迭代过程，不仅满足重复，而且以每次重新赋值后的index值作为下一次循环中新的索引进行取值，反复迭代，最终可以取尽列表中的值：

goods = ['mac', 'lenovo', 'acer', 'dell', 'sony']
 
index = 0
while index < len(goods):
    print(goods[index])
    index += 1

2.1 可迭代对象

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

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

{'name': 'jason'}.__iter__
{7, 8, 9}.__iter__
……

2.2 迭代器对象

调用obj._ _ iter _ _ ()方法返回的结果是一个迭代器对象(Iterator)。迭代器对象是内置有_ _ iter_ _ ()和 _ _ next_ _ ()方法的对象，打开的文件本身就是一个迭代器对象，执行迭代器对象._ _ iter _ _ ()方法得到的仍然是迭代器本身，而执行迭代器._ _ next_ _ ()方法就会计算出迭代器中的下一个值。

_ _ iter _ _ ()和 _ _ next_ _ ()方法在调用的时候还有一个简便的写法：iter()和next()；
一般情况下所有的双下划线方法都会有一个与之对应的简化版本：方法名()；

迭代器是Python提供的一种统一的、不 依赖于索引的迭代取值方式，只要存在多个“值”，无论序列类型还是非序列类型都可以按照迭代器的方式取值：

>>> s = {1, 2, 3}  # 可迭代对象s
>>> i = iter(s)  # 本质就是在调用s.__iter__(),返回s的迭代器对象i
>>> next(i)  # 本质就是在调用i.__next__()
1
>>> next(i)
2
>>> next(i)
3
>>> next(i)  # 抛出StopIteration的异常，代表无值可取，迭代结束

三、for循环原理

有了迭代器后，我们便可以不依赖索引迭代取值了，使用while循环的实现方式如下：

goods = ['mac', 'lenovo', 'acer', 'dell', 'sony']
i = iter(goods)  # 每次都需要重新获取一个迭代器对象
while True:
    try:
        print(next(i))
    except StopIteration:  # 捕捉异常终止循环
        break

for循环又称为迭代循环，in后可以跟任意可迭代对象，上述while循环可以简写为：

goods = ['mac', 'lenovo', 'acer', 'dell', 'sony']
for item in goods:   
    print(item)

for循环在工作时，首先会调用可迭代对象goods内置的_ _ iter _ _ ()方法拿到一个迭代器对象，然后调用该迭代器对象的_ _ next _ _ ()方法将取到的值赋给item，执行循环体代码完成一次循环，周而复始，直到捕捉到StopIteration异常，结束迭代。

四、迭代器的优缺点

基于索引的迭代取值，所有迭代的状态都保存在了索引中，而基于迭代器实现迭代的方式不再需要索引，所有迭代的状态就保存在迭代器中，然而这种处理方式优点与缺点并存：

• 优点：

  1. 为序列和非序列类型提供了一种统一的迭代取值方式；
  2. 惰性计算：迭代器对象表示的是一个数据流，可以只在需要时才去调用next()来计算出一个值；就迭代器本身来说，同一时刻在内存中只有一个值，因而可以存放无限大的数据流，而对于其他容器类型，如列表，需要把所有的元素都存放于内存中，受内存大小的限制，可以存放的值的个数是有限的。

• 缺点：

  1. 除非取尽，否则无法获取迭代器的长度；
  2. 只能取下一个值，不能回到开始，更像是“一次性的”，迭代器产生后的唯一目标就是重复执行next()方法直到值取尽，否则就会停留在某个位置，等待下一次调用next()；若是要再次迭代同个对象，你只能重新调用iter()方法去创建一个新的迭代器对象，如果有两个或者多个循环使用同一个迭代器，必然只会有循环能取到值。

五、异常捕获

5.1 什么是异常

异常是程序发生错误的信号。程序一旦出现错误，便会产生一个异常，若程序中没有处理它，就会抛出异常，程序的运行也随之终止。

在Python中，错误触发的异常如下：

而错误分成两种，一种是语法上的错误SyntaxError，这种错误应该在程序运行前就修改正确：

>>> if  
File "<stdin>", line 1
   if
    ^
SyntaxError: invalid syntax

另一种就是逻辑错误，出现了之后尽快修改即可，常见的逻辑错误如：

# TypeError：数字类型无法与字符串类型相加
1 + ’2’  

# ValueError：当字符串包含有非数字的值时，无法转成int类型
num = input(">>: ")  # 输入hello
int(num)
 
# NameError：引用了一个不存在的名字x
x
 
# IndexError：索引超出列表的限制
lis = ['jason', 'tony']
lis[3]
 
# KeyError：引用了一个不存在的key
dic = {'name': 'jason'}
dic['age']
 
# AttributeError：引用的属性不存在
class Foo:
    pass

Foo.x
 
# ZeroDivisionError：除数不能为0
1 / 0

5.2 异常处理

为了保证程序的容错性与可靠性，即在遇到错误时有相应的处理机制不会任由程序崩溃掉，我们需要对异常进行处理，处理的基本语法格式如下：

try:
    被检测的代码块
except 异常类型：
    检测到异常，就执行这个位置的逻辑

如果我们想分别用不同的逻辑处理，需要用到多分支的except（类似于多分支的elif，从上到下依次匹配，匹配成功一次便不再匹配其他）：

try:
    被检测的代码块
except NameError:
    触发NameError时对应的处理逻辑
except IndexError:
    触发IndexError时对应的处理逻辑
except KeyError:
    触发KeyError时对应的处理逻辑

如果我们想捕获所有异常并用一种逻辑处理，Python提供了一个万能异常类型Exception：

try:
    被检测的代码块
except NameError:
    触发NameError时对应的处理逻辑
except IndexError:
    触发IndexError时对应的处理逻辑
except Exception:
    其他类型的异常统一用此处的逻辑处理

• 有可能会出现错误的代码才需要被监测；
• 被监测的代码一定要越少越好；
• 异常捕获使用频率越低越好；