列表，元组，字符串，bytes，bytearray这些都有什么特点呢？

他们都是顺序存储，顺序访问的，都是可迭代的对象，都可以通过索引访问，这些就是线性结构

线性结构

线性结构的特点：

• 可迭代
• len可获得长度
• 可以使用下标操作符通过索引访问
• 可以切片

enumerate

举个小例子来看下

>>> enumerate([1,2,3])   我们直接使用enumerate的话，会得到一个enumerate的可迭代对象
<enumerate object at 0x000001099AD37678>
>>> list(enumerate([1,2,3]))   既然是可迭代的，那我们也可以enumerate的对象，转换成list
[(0, 1), (1, 2), (2, 3)]

来看下enumerate的原型函数

def enumerate(iterator):
    i = 0
    for v in iterator:
        yield i, v
        i += 1
yield 后面会说这个用法，若是看不懂这个，我们来看下Python2中的实现方法

def enumerate(iterator):
    ret = []
    i = 0
    for v in iterator:
        ret.append(i, v)
        i += 1
    return ret

对于可迭代对象可以使用len来获取长度

len(range(5))

next(iter(range(5)))
next 是获取一个迭代器的下一个值， iter可以将一个可迭代对象转成迭代器

可迭代想可以通过 iter 函数转化为迭代器

切片操作

来用list来说下切片操作，上面的其他的可迭代对象都是一样的

>>> lst = list(range(10))
>>> lst
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

根据索引来获取数据，就不说了吧
>>> lst[3]
3

lst[start:stop] 这样可以访问这个list的一段，从start开始，到stop结束，不包含stop
>>> lst[1:3]  从索引 1 开始，到索引 3 结束，返回新的list，不会对原有的list做任何操作
[1, 2]

lst[:stop]   当start为0的时候可以省略
>>> lst[:4]
[0, 1, 2, 3]

lst[start:]   当stop为 -0 的时候，可以省略
>>> lst[4:]
[4, 5, 6, 7, 8, 9]

lst[:]  等效于copy方法
>>> lst[:]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

既然stop不写默认为 -1 那么就说，切片是可以支持负数的
>>> lst[-5:-3]
[5, 6]

>>> lst[:100]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> lst[-100:]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> lst[-100:100]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
通过上面三个小例子，我们可以总结以下几点
* start 超出索引范围： start = 0
* stop 超出索引范围： stop = -0   -0 是不可用的，只是在这里表示"包含最后一位索引"的意思

>>>lst[3:1]   当 start 大于等于 stop的时候，返回空列表

总结以下

• 负数索引，实际上可以转化为len(str) + index
• 当start为0时可以省略，当stop为-0时可以省略
• 当stop <= start时，返回空列表
• 当start超出索引范围，start = 0， 当stop超出索引范围 stop为 -0

用代码来描述下切片的过程

def slice(lst, start=0, stop=0):
    if start < 0:
        start = len(lst) + start
    if stop <= 0:
        stop = len(lst) + stop
    if stop <= start:
        return []
    if stop > len(lst):
        stop = len(lst)
    if start < 0:
        start = 0
    ret = []
    for i,v in enumerate(lst):
        if i >= start and i < stop:
            ret.append(v)
    return ret

>>>slice(lst,1,3)
[1,2]

其实可迭代对象还有一个不常用的参数

lst[start:stop:step] step参数是一次增加多少

>>> lst
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> lst[3:8:2]
[3, 5, 7]

>>> lst[8:3:-2]
[8, 6, 4]

>>> lst[::-1]   实现了反转
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]