06-03线性结构与切片

Posted 2020-12-06 cishi

线性结构与切片

线性结构

• 列表、元组、字符串、bytes, bytearray
• 共同点：都是顺序存储, 顺序访问的, 都是可迭代对象, 都可以通过索引访问

线性结构特征

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

例如：可迭代的表现形式
In [1]: for i in [1, 2, 3]:
   ...:     print(i)
   ...:
1
2
3

In [2]: for i in (1, 2, 3):
   ...:     print(i)
   ...:
1
2
3

In [4]: for c in ‘i lve python‘:
   ...:     print(c)
   ...:
i
 
l
v
e
 
p
y
t
h
o
n

函数enumerate

作用：接收一个可迭代对象,返回一个enumerate对象
作用（菜鸟教程）：enumerate(sequence, [start=0]) 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

实例：
In [5]: enumerate([1, 2, 3])   # 接收一个可迭代对象,返回一个enumerate对象（这种语句都不知道讲什么鬼）
Out[5]: <enumerate at 0x7fc5a6fa2750>

In [6]: list(enumerate([1, 2, 3]))   # 会得到一个列表
Out[6]: [(0, 1), (1, 2), (2, 3)]

>>>seasons = [‘Spring‘, ‘Summer‘, ‘Fall‘, ‘Winter‘]
>>> list(enumerate(seasons))
[(0, ‘Spring‘), (1, ‘Summer‘), (2, ‘Fall‘), (3, ‘Winter‘)]
>>> list(enumerate(seasons, start=1))       # 下标从 1 开始
[(1, ‘Spring‘), (2, ‘Summer‘), (3, ‘Fall‘), (4, ‘Winter‘)]


enumerate的实现
In [8]: def enumerate(iterator):   # 方式1
   ...:     i = ()
   ...:     for v in iterator:
   ...:         yield i, v
   ...:         i += 1
   ...:

In [9]: def enumerate(interator):    # 方式2
   ...:     ret = []
   ...:     i = ()
   ...:     for v in iterator:
   ...:         ret.append((i, v))
   ...:         i += 1
   ...:     return ret
   ...:

方式1与方式2并不等效, 但是返回的效果是一样的。

iter函数

作用：将一个可迭代对象转换为一个迭代器
两种使用方式：

• iter(iterable) -> iterator
• iter(callable, sentinel) -> iterator # sentinel必须是一个可调用对象，当每次调用这个__next__()方法时，都会调用该对象。

In [10]: len(range(5))   # 可迭代对象都可以用len获取长度
Out[10]: 5

iter函数可以将一个可迭代对象转换为一个迭代器
next函数可以读取迭代器的下一个值

In [11]: next(iter(range(5)))   # 一起使用的方式
Out[11]: 0

可迭代对象可以通过 iter 函数转换为迭代器

切片操作

• 操作对象：都可以通过索引访问的数据类型
• 操作方式：都是返回一个新的对象，不会对原有数据做更改
  • lst[start:stop] 可以访问这个list一段, 从start开始, 到stop结束, 不包含stop，例如lst[3:7]
    • 当start为0时可以省略
    • 当stop为-0的时候可以省略
    • lst[:]都省略的时候等效于copy
    • 支持负数索引，负数索引实际上可以转换为len(lst) + index
    • 超出范围不报错
      • start超出索引范围：start = 0
      • stop超出索引范围：stop = -0
    • 当start >= stop时,返回空列表
  • lst[start: stop: step] step参数表示一次增加多少
    • lst[8:3:-2] # step为负数的时候,反过来，此时start应该 >= stop
    • lst[::-1] # 只有step, 全面反转

In [15]: lst = list(range(10))

In [16]: lst
Out[16]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [17]: lst[3]   # 可以通过索引访问
Out[17]: 3

lst[start:stop] 可以访问这个list一段, 从start开始, 到stop结束, 不包含stop

In [18]: lst[3:7]    # 从索引3开始, 到索引7结束, 不包含7, 返回新的list, 不会对原有的list做任何修改
Out[18]: [3, 4, 5, 6]

In [19]: lst[:4]       # 当start为0时可以省略
Out[19]: [0, 1, 2, 3]

In [20]: lst[3:]   #  当stop为-0的时候可以省略
Out[20]: [3, 4, 5, 6, 7, 8, 9]

In [21]: lst[:]   # 都省略的时候等效于copy
Out[21]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [22]: lst[-5:-3]   # 可以支持负数索引
Out[22]: [5, 6]

In [23]: lst[:100]   # stop超出索引范围
Out[23]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [24]: lst[-100:]   # stop超出索引范围
Out[24]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [25]: lst[-100:100]   # 同时超出索引范围
Out[25]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

start超出索引范围：start = 0
stop超出索引范围：stop = -0

In [27]: lst[100:]   # 和上两个结论冲突, lst[100:-1]
Out[27]: []

In [28]: lst[:-100]  # 和上两个结论冲突, lst[0:-100]
Out[28]: []

In [29]: lst[100:-100]   # 正向反向都超出的时候
Out[29]: []

In [30]: lst[3:1]   # 当start > stop时,返回空列表
Out[30]: []

In [31]: lst[3:3]   # 当start = stop时,也返回空列表
Out[31]: []

In [32]: lst[3:-1]   # 负数索引, 实际上等于len(lst) + index, 10 + (-1) = 9
Out[32]: [3, 4, 5, 6, 7, 8]

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

In [4]: 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
   ...: 

In [5]: slice(lst, -100, 100)
Out[5]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

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

In [3]: lst[3:8:2]
Out[3]: [3, 5, 7]

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

In [5]: lst[8:3:-2]   # step为负数的时候,反过来
Out[5]: [8, 6, 4]

In [2]: lst[::-1]     # 只有step, 全面反转
Out[2]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

In [4]: def slice(lst, start=0, stop=0, step=1):
   ...:     current = start
   ...:     ret = []
   ...:     while current < stop:
   ...:         try:
   ...:             ret.append(lst[current])
   ...:         except IndexError:
   ...:             pass
   ...:         current += step
   ...:     return ret
   ...: 

In [5]: slice(lst, 0, 10, 1)
Out[5]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

当step为负数的时候
In [16]: def slice(lst, start=0, stop=0, step=1):
    ...:     ret = []
    ...:     current = start
    ...:     if step > 0:
    ...:         while current < stop:
    ...:             try:
    ...:                 ret.append(lst[current])
    ...:             except IndexError:
    ...:                 pass
    ...:             current += step
    ...:     if step < 0:
    ...:         while current > stop:
    ...:             try:
    ...:                 ret.append(lst[current])
    ...:             except IndexError:
    ...:                 pass
    ...:             current += step
    ...:     return ret
    ...: