课时16：序列

目录：

　　　　一、一些关于序列的常用BIF（共11个）

　　　　二、课时16课后习题及答案

********************************************

一、一些关于序列的常用BIF（共11个）

********************************************

把列表、元组和字符串放在一起学习是有道理的，因为它们有很多共同点：

　　---都可以通过索引得到每一个元素
　　---默认索引值总是从0开始
　　---可以通过分片的方法得到一个范围内的元素的集合
　　---有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）

我们把它们统称为:序列！下面介绍一些关于序列的常用BIF(内建方法)

1、list（[iterable]）

list（）方法用于把一个可迭代对象转换为列表，科普下迭代：所谓迭代，是重复反馈过程的活动，其目的通常是为了接近并到达所需的目标或结果。每一次对过程的重复被称为一次”迭代“，而每一次迭代会被用为下一次迭代的初始值....就目前来说，迭代还就是一个for循环，但今后会介绍到迭代器，那个功能，那叫一个惊艳！

这里说的list（）方法要么不带参数，要么带一个可迭代对象作为参数，而这个序列天生就是可迭代对象(迭代这个概念实际上就是从序列中泛化而来的)。举几个例子：

>>> #创建一个列表
>>> a = list()
>>> a
[]
>>> #将字符串的每个字符迭代存放到列表中
>>> b = list("FishC")
>>> b
['F', 'i', 's', 'h', 'C']
>>> #将元组中的每个元素迭代存放到列表中
>>> c = list((1,1,2,3,5,8,13))
>>> c
[1, 1, 2, 3, 5, 8, 13]

实现过程大概就是新建一个列表，然后循环通过索引迭代参数的每一个元素并加入列表，迭代完成后返回列表即可。

2、tuple（[ iterable]）

tuple（）方法用于把一个可迭代的对象转换为元组，具体的方法跟list（）一样。

3、str（obj）

str（）方法用于把obj对象转换为字符串，这个方法在前面结合int（）和float（）方法给大家讲过。

4、len（sub）

len（）方法用于返回sub参数的长度：

>>> str1 = "I love zww"
>>> len(str1)
10
>>> list1 = [1,1,2,3,5,8,13]
>>> len(list1)
7
>>> tuple1 ="这","是","一","个","元组"
>>> len(tuple1)
5

5、max（...）

max（）方法用于返回序列或者参数集合中的最大值，也就是说，max（）参数可以是一个序列，返回值是该序列中的最大值；也可以是多个参数，那么max（）将返回这些参数中最大的一个：

>>> list1 = [1,18,13,0,-98,34,54,76,32]
>>> max(list1)
76
>>> str1 = "I love zww"
>>> max(str1)
'z'
>>> max(5,8,1,13,5,29,10,7)
29

6、min（...）

min方法跟max（）用法一样，但效果相反：返回序列或者参数集合的最小值。这里需要注意的是，使用max（）和min（）方法都要保证序列或者参数的数据类型统一，否则会出错。

>>> min(123,'oo',456,'xx')
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    min(123,'oo',456,'xx')
TypeError: '<' not supported between instances of 'str' and 'int'
>>> list1 = [1,18,13,0,-98,34,54,76,32]
>>> list1.append("x")
>>> max(list1)
Traceback (most recent call last):
  File "<pyshell#11>", line 1, in <module>
    max(list1)
TypeError: '>' not supported between instances of 'str' and 'int'

人家说：外行看热闹，内行看门道。分析下这个错误信息。Python这里说”'>' not supported between instances of 'str' and 'int'“意思就是不能拿字符串和整型进行比较。

你看，str（）>int（）说明max（）和min（）方法的内部实现事实上类似于之前提到的，通过索引得到每一个元素，然后将各个元素进行对比。所以不妨根据猜想写出可能的代码：

#猜想下max(tuple1)的实现方式
temp = tuple[0]

for each in tuple1:
      if each > temp:
            temp = each

return temp

由此可见，Python的内置方法也没啥了不起的。

7、sum（iterable[,start]）

sum（）方法用于返回序列iterable的总和，用法跟max（）和min（）方法一样。但sum（）方法有一个可选参数（start），如果设置该参数，表示从该值开始加起，默认值是0：

>>> tuple1 = 1,2,3,4,5
>>> sum(tuple1)
15
>>> sum(tuple1,10)
25

8、sorted（iterable，key=None，reverse=False）

sorted（）方法用于返回一个排序的列表，大家还记得列表的内建方法sort（）吗？它们的实现效果是一样的，但列表的内建方法sort（）是实现列表原地排序；而sorted（）是返回一个排序后的新列表。

>>> list1 = [1,18,13,0,-98,34,54,76,32]
>>> list2 = list1[:]
>>> list1.sort()
>>> list1
[-98, 0, 1, 13, 18, 32, 34, 54, 76]
>>> sorted(list2)
[-98, 0, 1, 13, 18, 32, 34, 54, 76]
>>> list2
[1, 18, 13, 0, -98, 34, 54, 76, 32]

9、reversed（sequence）

reversed（）方法用于返回逆向迭代序列的值。同样的道理，实现效果跟列表的内建方法reserse（）一致。区别是列表的内建方法是原地翻转，而reversed（）是返回一个翻转后的迭代对象。你没看错，它不是返回一个列表，是返回一个迭代对象：

>>> list1 = [1,18,13,0,-98,34,54,76,32]
>>> reversed(list1)
<list_reverseiterator object at 0x000001DAF03F15C0>
>>> for each in reversed(list1):
    print(each,end=',')

32,76,54,34,-98,0,13,18,1,

10、enumerate（iterable）

enumerate（）方法生成由二元组（二元组就是元素数量为二的元组）构成的一个迭代对象，每个二元组是由可迭代参数的索引号及其对应元素组成的。举个例子：

>>> str1 = "FishC"
>>> for each in enumerate(str1):
    print(each)

(0, 'F')
(1, 'i')
(2, 's')
(3, 'h')
(4, 'C')

11、zip（，iter2[...]）

zip（）方法用于返回由各个可迭代对象参数共同组成的元组，举个例子：

>>> list1 = [1,3,5,7,9]
>>> str1 = "FishC"
>>> for each in zip(list1,str1):
    print(each)

(1, 'F')
(3, 'i')
(5, 's')
(7, 'h')
(9, 'C')
>>> tuple1 = (2,4,6,8,10)
>>> for each in zip(list1,str1,tuple1):
    print(each)

(1, 'F', 2)
(3, 'i', 4)
(5, 's', 6)
(7, 'h', 8)
(9, 'C', 10)

*******************************

二、课时16课后习题及答案

********************************

测试题：

0. 我们根据列表、元祖和字符串的共同特点，把它们三统称为什么？
1. 请问分别使用什么BIF，可以把一个可迭代对象转换为列表、元祖和字符串？
2. 你还能复述出“迭代”的概念吗？
3. 你认为调用 max('I love FishC.com') 会返回什么值？为什么？
4. 哎呀呀，现在的小屁孩太调皮了，邻居家的孩子淘气，把小甲鱼刚写好的代码画了个图案，麻烦各位鱼油恢复下啊，另外这家伙画的是神马吗？怎么那么眼熟啊！？？

动动手：

0. 猜想一下 min() 这个BIF的实现过程
1. 视频中我们说 sum() 这个BIF有个缺陷，就是如果参数里有字符串类型的话就会报错，请写出一个新的实现过程，自动“无视”参数里的字符串并返回正确的计算结果

答案：

测试题答案：
0. 我们根据列表、元祖和字符串的共同特点，把它们三统称为什么？
序列，因为他们有以下共同点： 

1）都可以通过索引得到每一个元素
2）默认索引值总是从0开始（当然灵活的Python还支持负数索引）
3）可以通过分片的方法得到一个范围内的元素的集合
4）有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）

1. 请问分别使用什么BIF，可以把一个可迭代对象转换为列表、元祖和字符串？   

list([iterable]) 把可迭代对象转换为列表

tuple([iterable]) 把可迭代对象转换为元祖

str(obj)  把对象转换为字符串

2. 你还能复述出“迭代”的概念吗？
所谓迭代，是重复反馈过程的活动，其目的通常是为了接近并到达所需的目标或结果。每一次对过程的重复被称为一次“迭代”，而每一次迭代得到的结果会被用来作为下一次迭代的初始值。

>>> temp = 'I love FishC.com!'
>>> list(temp)
['I', ' ', 'l', 'o', 'v', 'e', ' ', 'F', 'i', 's', 'h', 'C', '.', 'c', 'o', 'm', '!']

3. 你认为调用 max('I love FishC.com') 会返回什么值？为什么？

会返回：'v'，因为字符串在计算机中是以ASCII码的形式存储（ASCII对照表：http://bbs.fishc.com/thread-41199-1-1.html），参数中ASCII码值最大的是'v'对应的118。

 

4. 哎呀呀，现在的小屁孩太调皮了，邻居家的孩子淘气，把小甲鱼刚写好的代码画了个图案，麻烦各位鱼油恢复下啊，另外这家伙画的是神马吗？怎么那么眼熟啊！？？

name = input('请输入待查找的用户名：')
score = [['迷途', 85], ['黑夜', 80], ['小布丁', 65], ['福禄娃娃', 95], ['怡静', 90]]
IsFind = False

for each in score:
    if name in each:
        print(name + '的得分是：', each[1])
        IsFind = True
        break
    
if IsFind == False:
    print('查找的数据不存在！')

动动手答案：
0. 猜想一下 min() 这个BIF的实现过程

def min(x):
    least = x[0]

    for each in x:
        if each < least:
            least = each

    return least

print(min('123456789'))

1. 视频中我们说 sum() 这个BIF有个缺陷，就是如果参数里有字符串类型的话就会报错，请写出一个新的实现过程，自动“无视”参数里的字符串并返回正确的计算结果

def sum(x):
    result = 0
    
    for each in x:
        if (type(each) == int) or (type(each) == float):
            result += each
        else:
            continue

    return result

print(sum([1, 2.1, 2.3, 'a', '1', True]))