《零基础入门学习》Python（16）--序列！序列！

前言

• 你可能发现了，元组，字符串放在一起讲是有道理的，它们有许多共同点。（当然前面没有看也能看这章）
• 都可以通过索引得到每一个元素
• 默认索引值总是从0开始
• 可以通过分片的方法得到一个范围内的元素的集合
• 有很多共同的操作符（* 重复操作符、+ 拼接操作符、in not in成员关系操作符）

我们把这三种类型统称为序列。

知识点

介绍下序列常见的BIF()

• list(iterable) 把一个可迭代对象转换为列表

• iterable——迭代对象——所谓迭代，就是重复反馈过程的活动，其目的通常是为了接近并达到所需的目标或结果，每一次对过程的重复，被称之为一次迭代。而每一次迭代的结果，都会变成下一次迭代的初始值。 
  所以呢，目前来说，迭代就是一个for循环。我们今后会介绍迭代器，那时迭代就不会仅仅是一个for了。

  >>> b = 'i love fishc.com'
  >>> b = list(b)
  >>> b
  ['i', ' ', 'l', 'o', 'v', 'e', ' ', 'f', 'i', 's', 'h', 'c', '.', 'c', 'o', 'm']
  #b本来是一个字符串，然后通过list方法,把字符串迭代，变成一个列表，然后赋值给回b。
  
  >>> c = (1,1,2,3,5,8,13,21,34)
  >>> c = list(c)
  >>> c
  [1, 1, 2, 3, 5, 8, 13, 21, 34]
  #c从元组变成了列表
  

   

• tuple([iterable]) 把一个可迭代对象转换为元组

• >>> a = ['123',['a','b'],4,5,'c']
  >>> tuple(a)
  ('123', ['a', 'b'], 4, 5, 'c')

   

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

  ​>>> a = ['123',['a','b'],4,5,'c']
  >>> type(a)
  
  
  >>> a = str(a)
  >>> a
  "['123', ['a', 'b'], 4, 5, 'c']"
  >>> type(a)
  
  
  ​

•  len(sub) 返回sub的长度

  >>> a
  ['123', ['a', 'b'], 4, 5, 'c']
  >>> len(a)
  5
  
  >>> a = str(a)
  >>> a
  "['123', ['a', 'b'], 4, 5, 'c']"
  >>> len(a)
  30

•  max()返回序列或者参数集合中的最大值

  >>> numbers = [1,18,13,0,-98,34,54,76,32]
  >>> max(numbers)
  76

•  min()返回序列或者参数集合中的最小值

  >>> numbers = [1,18,13,0,-98,34,54,76,32]
  >>> min(numbers)
  -98
  
  >>> chars = '1234567890'
  >>> min(chars)
  '0'
  
  >>> tupe1 = (1,2,3,4,5,6,7,8,9,0)
  >>> max(tupe1)
  9
  >>> min(tupe1)
  0
  
  #【注意】：使用max,min方法都要保证序列或者参数的数据类型都是一致的，否则会报错：
  >>> mix = ['a','c',1,32,'d']
  >>> max(mix)
  Traceback (most recent call last):
    File "", line 1, in 
      max(mix)
  TypeError: '>' not supported between instances of 'int' and 'str'
  

• sum(iterable[,start=0]) 返回序列iterable和可选参数start的总和

  >>> tuple2 = (3.1,2.3,3.4)
  >>> sum(tuple2)
  8.8
  >>> numbers
  [1, 18, 13, 0, -98, 34, 54, 76, 32]
  >>> numbers.append('a')
  
  >>> sum(numbers)
  Traceback (most recent call last):
    File "", line 1, in 
      sum(numbers)
  TypeError: unsupported operand type(s) for +: 'int' and 'str'
  
  >>> numbers.pop()
  'a'
  
  >>> numbers
  [1, 18, 13, 0, -98, 34, 54, 76, 32]
  >>> sum(numbers)
  130
  >>> sum(numbers,8)
  138
  >>> 
  

• sorted(iterable, key=None, reverse=False) 返回一个排序的列表，使用方法跟列表的内建函数（list.sort()）一致，注意，这个sorted()后边有“ed”哦。

  >>> numbers
  [1, 18, 13, 0, -98, 34, 54, 76, 32]
  >>> sorted(numbers)
  [-98, 0, 1, 13, 18, 32, 34, 54, 76]

   

• reversed(sequence)返回逆向迭代序列的值，一样道理，跟列表的内建函数（list.reverse()）一致，注意，这个reversed()后边也多了个“d”哦。

  >>> numbers
  [1, 18, 13, 0, -98, 34, 54, 76, 32]
  
  >>> reversed(numbers)
  
  
  >>> list(reversed(numbers))
  [32, 76, 54, 34, -98, 0, 13, 18, 1]
  

   

• enumerate(iterable) 生成由每个元素的index值和item值组成的元组

  >>> numbers
  [1, 18, 13, 0, -98, 34, 54, 76, 32]
  >>> enumerate(numbers)
  
  >>> list(enumerate(numbers))
  [(0, 1), (1, 18), (2, 13), (3, 0), (4, -98), (5, 34), (6, 54), (7, 76), (8, 32)]
  

   

zip(iter1 [,iter2 […]]) 返回由各个参数的序列组成的元组

>>> a = [1,2,3,4,5,6,7,8]
>>> b = [4,5,6,7,8]
>>> zip(a,b)

>>> list(zip(a,b))
[(1, 4), (2, 5), (3, 6), (4, 7), (5, 8)]

课后习题

测试题

• 我们根据列表、元组和字符串的共同特点，把它们统称什么？

序列

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

list([iterable])  转换为列表
tuple([iterable]) 转换为元组
str(obj)   转换为字符串

• 你还能复述出“迭代”的概念吗？

所谓迭代，就是重复反馈过程的活动，其目的通常是为了接近并达到所需的目标或结果，
每一次对过程的重复，被称之为一次`迭代`。而每一次迭代的结果，都会变成下一次迭代的初始值。

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

>>> max('I love FishC.com')
'v'

因为字符串在计算机中是以ASCII码的形式存储,参数中ASCII码值最大的是’v’ 对应118.

动动手

• **猜想一下min()这个BIF的实现过程

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

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

    return least

print(min('123456789'))
​​​​​​​

• 视频中我们说sun()这个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]))