《Python基础教程》读书笔记02-列表和元组

最基本的数据结构：序列（sequence），序列中每个元素被分配一个序列号（即元素的位置），也称为索引。

Python 包含六种内建的序列，列表、元组、字符串、Unicode 字符串、buffer 对象和 xrange 对象。

列表和元组的主要区别在于，列表可以修改，元组不能。内建函数一般会返回元组。

在 dict 中可以使用元组作为键，而不能使用列表，因为键是不能修改的（不可变对象）。

通用序列操作

索引

>>> x = 'hello'
>>> x[0]
'h'
>>> x[-1] # 可以使用负数索引
'o'
>>> 'hello'[0]
'h'

分片（切片）

>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[3:6]
[4, 5, 6]
>>> numbers[0:1] # 不包含第二个索引
[1]
>>> numbers[-3:] # 可以使用负数索引
[8, 9, 10]
>>> numbers[-3:-1] # 开始点必须小于结束点
[8, 9]
>>> numbers[7:] # 如果分片所得的部分要包含序列结尾的元素
[8, 9, 10]
>>> numbers[:3] # 也可以空置第一个索引
[1, 2, 3]
>>> numbers[:] # 复制整个序列
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

步长，在上面的例子中步长默认为 1

>>> numbers[0:10:1] # 默认不写，步长为1
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[0:10:2]
[1, 3, 5, 7, 9]
>>> numbers[::4]
[1, 5, 9]

# 当使用负数作为步长时，必须开始点大于结束点
>>> numbers[8:3:-1] # 步长可以为负数，此时分片从右到左提取元素，同样开始点包含，结束点不包含
[9, 8, 7, 6, 5]
>>> numbers[5::-2]
[6, 4, 2]
>>> numbers[:5:-2]
[10, 8]
>>> numbers[-1:-5:-2]
[10, 8]

序列相加

相同类型的序列才可以相加，列表与字符串无法连接在一起

>>> [1,2,3] + [4,5]
[1, 2, 3, 4, 5]
>>> [1,2] + 'hello'

Traceback (most recent call last):
  File "<pyshell#37>", line 1, in <module>
    [1,2] + 'hello'
TypeError: can only concatenate list (not "str") to list
>>> 'hello, ' + 'world'
'hello, world'
>>> [1, 1] + ['a', 'b']
[1, 1, 'a', 'b']

乘法

>>> 'python' * 5
'pythonpythonpythonpythonpython'
>>> [42] * 10
[42, 42, 42, 42, 42, 42, 42, 42, 42, 42]
>>> sequence = [None] * 10 # 可以用于创建一个占用10个元素空间，却不包含任何有用内容的列表
>>> sequence
[None, None, None, None, None, None, None, None, None, None]

成员资格（是否包含）

包含返回 True，不包含返回 False

>>> permissions = 'rw'
>>> 'w' in permissions
True
>>> 'x' in permissions
False
>>> users = ['zhang', 'wang', 'li']
>>> 'li' in users
True
>>> 'zhao' in users
False
>>> 'rw' in permissions
True
>>> users = [['zhang', 1], ['wang', 2], ['li', 3]]
>>> ['li', 3] in users
True

长度、最小值和最大值

>>> numbers = [100, 34, 678]
>>> len(numbers) # len函数返回序列中所包含元素的数量
3
>>> max(numbers) # 返回最大元素
678
>>> min(numbers) # 返回最小元素
34
>>> max(2, 3)  # 这里的参数不是序列，而是以多个数字直接作为参数，可变参数
3
>>> min(5, 3, 6)
3

列表

list

>>> x = list('hello') # list 是一种类型，不是函数
>>> x
['h', 'e', 'l', 'l', 'o']
>>> ''.join(x) # 将一个由字符串组成的列表转换为字符串
'hello'

元素赋值

>>> x
['h', 'e', 'l', 'o']
>>> x[1] = '2' # 不能越界
>>> x
['h', '2', 'l', 'o']

分片赋值

>>> name = list('Perl')
>>> name
['P', 'e', 'r', 'l']
>>> name[2:] = list('ar') # 可以一次为多个元素赋值
>>> name
['P', 'e', 'a', 'r']
>>> name[1:] = list('ython') # 可以更改列表的长度，并添加替换
>>> name
['P', 'y', 't', 'h', 'o', 'n']

>>> numbers = [1, 5]
>>> numbers[1:1] = [2, 3, 4] # 可以不替换任何元素的情况下，插入新的元素
>>> numbers
[1, 2, 3, 4, 5]
>>> numbers[1:4] = [] # 删除元素
>>> numbers
[1, 5]
>>> numbers[2:2] = [2] # 向最后的位置添加元素
>>> numbers
[1, 5, 2]

>>> numbers = [1, 2, 3, 4, 5]
>>> numbers[4:1:-2] = [6] # 加入步长，所赋值的元素前后数量要一致

Traceback (most recent call last):
  File "<pyshell#100>", line 1, in <module>
    numbers[4:1:-2] = [6]
ValueError: attempt to assign sequence of size 1 to extended slice of size 2
>>> numbers[4:1:-2] = [6,7]
>>> numbers
[1, 2, 7, 4, 6]
>>> numbers[4:1:-3] = [8]
>>> numbers
[1, 2, 7, 4, 8]

删除

del

删除指定位置的元素 del 语句：

>>> x
['h', 'e', 'l', 'l', 'o']
>>> del x[2]
>>> x
['h', 'e', 'l', 'o']

pop

要删除 list 末尾的元素，用 pop() 方法：

>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']

要删除指定位置的元素，用 pop(i) 方法，其中 i 是索引位置：

>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']

remove

remove 方法用于移除列表中某个值的第一个匹配项：

>>> x = [1, 2, 3, 4, 2]
>>> x.remove(2)
>>> x
[1, 3, 4, 2]
>>> x.remove(5) # 如果列表不存在该元素则报错

Traceback (most recent call last):
  File "<pyshell#122>", line 1, in <module>
    x.remove(5)
ValueError: list.remove(x): x not in list

循环中删除

# 删除 num_list 中为空的元素
num_list = [1, 2, 3, 4, None, 6, 7, 8, None, 10, 11, None, 13, 14, None]

# 方法一：使用逆序遍历
for i in range(len(num_list) - 1, -1, -1):
    if not num_list[i]:
        num_list.pop(i)
print(num_list)  # [1, 2, 3, 4, 6, 7, 8, 10, 11, 13, 14]

# 方法二：使用逆序遍历，与一类似
num_list = [1, 2, 3, 4, None, 6, 7, 8, None, 10, 11, None, 13, 14, None]
for i in num_list[::-1]:
    if not i:
        num_list.remove(i)

print(num_list)  # [1, 2, 3, 4, 6, 7, 8, 10, 11, 13, 14]

# 方法三：写入新列表中
num_list = [1, 2, 3, 4, None, 6, 7, 8, None, 10, 11, None, 13, 14, None]
new_list = []
for i in num_list:
    if i:
        new_list.append(i)

print(new_list)  # [1, 2, 3, 4, 6, 7, 8, 10, 11, 13, 14]

# 方法四：列表推导式
new_list = [i for i in num_list if i]  # [1, 2, 3, 4, 6, 7, 8, 10, 11, 13, 14]

# 方法五：使用 filter 和 lambda
new_list = list(filter(lambda x: x, num_list))  # [1, 2, 3, 4, 6, 7, 8, 10, 11, 13, 14]

http://www.chenxm.cc/article/67.html

添加

append，insert，extend 方法会直接修改原来的列表，+ 连接不会修改原来的列表

append

可以往 list 中追加元素到末尾

>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']

insert

也可以把元素插入到指定的位置，比如索引号为 1 的位置：

>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

extend

extend 方法可以在列表的末尾一次性追加另一个序列的多个值：

>>> a = [1]
>>> b = [2]
>>> a.extend(b)
>>> a
[1, 2]

>>> x = [1]
>>> y = [2]
>>> z = x + y
>>> z
[1, 2]
>>> x
[1]

>>> a = a + b # 效率要比extend低

也可以使用分片，但可读性低

>>> a = [1]
>>> b = [2]
>>> a[len(a):] = b
>>> a
[1, 2]

查找

index 方法用于从列表中找出某个值第一个匹配项的索引位置

>>> x = [1, 2, 3, 4]
>>> x.index(2)
1
>>> x.index(6) # 未找到引发异常

Traceback (most recent call last):
  File "<pyshell#126>", line 1, in <module>
    x.index(6)
ValueError: 6 is not in list

元素出现次数

count 方法统计某个元素在列表中出现的次数。

>>> x = [1, 2, 3, 4, 5, 2, 2]
>>> x.count(2)
3
>>> x.count(6)
0

反转

reverse 方法将列表中的元素反向存放，不返回值，直接修改列表

>>> x = [1, 2, 3, 4]
>>> x.reverse()
>>> x
[4, 3, 2, 1]

如果需要对一个序列进行反向迭代，可以使用 reversed 函数，返回一个迭代器对象，可以使用 list 转换成列表

>>> x
[4, 3, 2, 1]
>>> y = list(reversed(x)) # 不改变原本序列
>>> y
[1, 2, 3, 4]
>>> x
[4, 3, 2, 1]

>>> x[::-1]  # 也可以使用分片
[4, 3, 2, 1]

排序

sort

sort 方法修改原列表，不返回值

>>> x = [23, 523, 25, 3]
>>> x.sort()
>>> x
[3, 23, 25, 523]

如果要不改变原列表，则需要复制整个列表：

>>> x = [23, 523, 25, 3]
>>> y = x[:]
>>> y
[23, 523, 25, 3]
>>> y.sort()
>>> y
[3, 23, 25, 523]
>>> x
[23, 523, 25, 3]

sorted

另一种不改变原列表，获得已排序列表的方法。sorted 可以用于任何可迭代的对象。

>>> y = sorted(x)
>>> y
[3, 23, 25, 523]
>>> x
[23, 523, 25, 3]

Python2 自定义排序

可以通过 compare(x, y) 的形式自定义比较函数。在 x<y 时返回负数，在 x>y 时返回正数，在 x=y 时返回 0。定义好之后可以提供给 sort 方法作为参数了。内建函数 cmp 提供了比较函数的默认实现。

>>> cmp(43, 34)
1
>>> cmp(23, 34)
-1
>>> cmp(20, 20)
0
>>> x
[23, 523, 25, 3]
>>> x.sort(cmp)
>>> x
[3, 23, 25, 523]

def pmc(x, y): # 自定义比较函数，从大到小
    if x > y:
        return -1
    if x < y:
        return 1
    if x == y:
        return 0

>>> x.sort(pmc)
>>> x
[523, 25, 23, 3]

sort 的两个可选参数

key 和 reverse，如果要使用他们需要通过名字指定(关键字参数)。cmp, key, reverse 参数都可以用于 sorted 函数。

参数 key 和参数 cmp 类似，也是需要提供一个函数，然而，该函数不是直接用来确定对象的大小，而是为每个元素创建一个键，然后所有元素根据键来排序。

如果需要根据元素长度进行排序，可以使用 len 函数作为键函数

x = ['12345', '123', '1234']
x.sort(key=len)
x
# ['123', '1234', '12345']

def acounts(x): # 自定义比较函数，根据'a'的数量排序
    return x.count('a')

>>> x = ['aa', 'a', 'aaa']
>>> x.sort(key=acounts)
>>> x
['a', 'aa', 'aaa']

# Python3 没有 cmp 函数，所以需要使用 key 参数
>>> random = [(2, 2), (3, 4), (4, 1), (1, 3)]
>>> random.sort(key=lambda x: x[1])
>>> random
[(4, 1), (2, 2), (1, 3), (3, 4)]

关键字参数 reverse，是简单的布尔值，用来指明列表是否要进行反向排序。

>>> x = [23,234,26,41]
>>> x.sort(reverse=True)
>>> x
[234, 41, 26, 23]

元组

元组不能修改，用圆括号()括起来，

>>> (1, 2, 3)
(1, 2, 3)
>>> ()
()
>>> (1) # 这个不是元组
1
>>> (1,) # 单个元组，必须要加逗号
(1,)
>>> 3 * (40 + 3)
129
>>> 3 * (40 + 3,)
(43, 43, 43)

tuple

可以将序列转换为元组

>>> tuple([1, 2, 3])
(1, 2, 3)
>>> tuple('asd')
('a', 's', 'd')

---

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 bin07280@qq.com