1.  
  2. 主页
  3.  / 
  4. Python基础到高级
  5.  / 
  6. 线性结构
  7.  / 
  8. 介绍与切片

介绍与切片

列表,元组,字符串,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]
这篇文章对您有用吗? 1

我们要如何帮助您?

发表评论

您的电子邮箱地址不会被公开。