文章目录

• 1. 序列(Sequence)常见通用操作
• • (1) in, not in
  • (2) +
  • (3) *
  • (4) s[i]、s[i:j]、s[i:j:k]
  • (5) len
  • (6) min(s), max(s)
  • (7) index
  • (8) count
• 2. 列表常见操作
• • 2.1 增操作
  • • append
    • insert
    • extend
    • 通过切片s[i:i] = iterable object 在任意index i 插入元素、拼接可迭代对象。
  • 2.2 删操作
  • • del s[i:j]
    • s.clear()
    • s.pop() or s. pop(i)
    • s.remove(x)
  • 2.3 查操作
  • 2.4 改操作
  • • 单点赋值、切片赋值
    • 反转列表 s.reverse()
    • 排序 s.sort(*, key=None, reverse=False)

1. 序列(Sequence)常见通用操作

因为列表也是序列的一种，所以序列的通用操作也适合列表。以下操作对任何内置序列类型都适用，包括列表、元祖、字符串、range objects等，下面以列表为例介绍序列通用操作，换做任何一种内置序列类型也都可以。

(1) in, not in

判断元素是否存在序列中

s = [1,2,3,4,5]
1 in s  # True
6 in s  # False
1 not in s # False
6 not in s # True

(2) +

s1+s2 , 不是和数组那样对应元素相加。序列相加是拼接操作。

s1 = [1,2,3]
s2 = [4,5,6]
s1+s2 # 输出 [1, 2, 3, 4, 5, 6]

(3) *

s * n，相当于n个s序列拼接。

s = [1,2]
s * 3 # 输出 [1, 2, 1, 2, 1, 2]

(4) s[i]、s[i:j]、s[i:j:k]

序列之所以叫序列，是因为其元素是有序的，这个序就是index。可以通过特定index取出序列的一部分。

s = [1,2,3,4,5]
s[1] # 输出2，i为对应的index
s[1:3] # 输出 [2,3],含前不含后
s[1:5:2] # 输出2,4,k是步长

(5) len

计算序列的长度，也就是序列包含的元素个数。

(6) min(s), max(s)

用这两个函数得保证s里元素是可比的。若全是字符串类型则按照字母顺序排。

s1 = [4,10,0,2]
max(s1), min(s1) # 输出 10, 0 

s2 = ['b','a','d','c'] # 输出'd', 'a' 
max(s2), min(s2)

s3 = [1,'a',2] 
max(s3) # 报错，无法比较字符串和整数

(7) index

s.index(x)。返回元素x在序列s中第一次出现的index，若s有多个x元素也只返回x第一次出现的index。另外，当x不存在于s时会报错。

s = [10,4,0,4,2]

s.index(4)  # 1，4第一次出现的index
s.index(5) # 报错ValueError: 5 is not in list

(8) count

s.count(x)。统计元素x在序列s中有多少个。没出现就是0个。

2. 列表常见操作

上面介绍了所有内置序列类型的通用操作。无论是可变序列(列表)还是不可变序列（元祖、字符串）都适用于上面的操作。下面介绍专属于可变序列（列表）的操作。
因为列表是可变序列，容器内的元素可以改变，所以可以在不改变列表的id情况下进行增、删、改的操作，而像元祖、字符串只能进行查操作。

2.1 增操作

append

s.append(object)。在列表的末尾插入任意对象。注意的是要和下面extend区分开。无论object是什么类型，都只占据一个index。

a = [1,2,3]
b = 4
a.append(b)
print(a) # 输出[1,2,3,4]

c = [5,6]
a.append(c)
pirnt(a) # 输出 [1, 2, 3, 4, [5, 6]]，c这个列表作为一个元素存在于s中。

insert

s.insert(index, object)。是对于append的扩展。因为append只能在末尾插入一个对象，而insert可以在任意位置插入一个对象，占据index这个位置。

a = [1,2,3]
a.insert(2, [4,5])
print(a) # [1, 2, [4, 5], 3]

extend

s.extend( iterable object)。和上面不一样，append参数可以是任何对象，而extend必须要是可迭代对象。因为extend相当于拼接操作，将一个序列拼接到当前序列的末尾，这个iterable object有几个元素，拼接在s后就要占几个index。

a = [1,2,3]
b = 4
a.extend(b) # 报错，因为b不是可迭代对象

c = [5,6]
a.extend(c) 
print(a) # [1,2,3,5,6]

通过切片s[i:i] = iterable object 在任意index i 插入元素、拼接可迭代对象。

相当于extend只能在末尾拼接，而切片可以在列表任意位置进行拼接。

a = [1,2,3]
a[0:0]=[9] # 在index=0 插入9
print(a) # [9,1,2,3]

a[len(a):len(a)] = [98,99] # 在末尾拼接列表
print(a)  # [9, 1, 2, 3, 98, 99]

2.2 删操作

del s[i:j]

删除列表中连续的一块，从index=i到index=j-1。

s = [1,2,3,4]
del s[1:3]
print(s) # [1, 4]

删除列表里所有元素和删除列表对象是不一样的。

s = [1,2,3,4]
del s[:]
s # 删除了所有元素，s为空列表

s = [1,2,3,4]
del s # 这时s已经不存在了

s.clear()

相当于del s[:]。清空列表元素，但是列表对象还在。

s.pop() or s. pop(i)

若不指定要删除的index，则默认删除列表最后一个元素，并且返回删除的元素
若指定index，则删除该元素并返回其值。

s.remove(x)

x为列表中某个元素的值，s.remove(x)会把x从s中删除，没有返回值。若x不存在于s里的话会报错ValueError 。若s里有多个x则s.remove(x)会删除第一个x。

a = [1,2,3,2,4,2]
a.remove(2)
print(a) # [1, 3, 2, 4, 2]

2.3 查操作

列表的查询很简单，因为列表主要是由index来决定顺序的，那么查询就是通过传入特定的index来获得列表里对应的元素。

s = [1,2,3,4,5]
s[1]  # 2
s[1:4] # [2,3, 4]
s[1:4:2] #  [2, 4]

2.4 改操作

因为列表是可变对象，每一个index对应的元素是可以修改、删除的。一般指定对应的index然后对其赋值就能对列表进行修改。

单点赋值、切片赋值

s = [1,2,3,4,5]
# 修改某个index的元素的值，可以赋值任何对象。
s[1] = (99,98) 
print(s) #  [1, [99, 98], 3, 4, 5]

# 切片修改某个部分的值，要赋值一个可迭代对象，并将这个可迭代对象的所有元素一个一个放入列表，而不是作为整体占一个index。
s = [1,2,3,4,5]
s[1:2] = [99,98]
print(s) # [1, 99, 98, 3, 4, 5]  注意切片和单点的区别

反转列表 s.reverse()

通过s.reverse()反转列表。

s = [1,4,2,5,3]
s.reverse()
print(s) # [3, 5, 2, 4, 1

排序 s.sort(*, key=None, reverse=False)

• 作用：依据key的规则对列表s进行生序排序。
• 返回值：无返回值，直接修改列表s
• key可以是自定义的规则函数，也可以是内置函数如len等，若不穿入key则默认按照元素的大小顺序排。相当于对每个元素调用key，得到返回值后再排序。
• reverse=False表示升序排序，不反转。
• sort 与 sorted 区别： sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作的函数。sort 方法返回的是对已经存在的列表进行操作而 sorted 方法返回的是一个新的列表。

# 指定key的排序
s = [1,4,2,5,3]
def distance_of_e(x):
    # x到自然对数e的距离
    return abs(x-math.e)
# 利用元素到自然对数的距离大小来对列表进行排序
s.sort(key=distance_of_e) # 就相当于对每个元素调用一次distance_of_e，再由返回值得到顺序。
print(s) # [3, 2, 4, 1, 5]