8: 连接和合并列表

1.连接 list1 和 list2 的最简单方法：

merged = list1 + list2

2. zip 返回一个元组列表，其中第 i 个元组包含每个参数中的第 i 个元素。 序列或可迭代元素中的第 i 个元素：

alist = ['a1', 'a2', 'a3']
blist = ['b1', 'b2', 'b3']

for a, b in zip(alist, blist):
  print(a, b)

# Output:
# a1 b1
# a2 b2
# a3 b3

如果列表的长度不同，那么结果将只包括最短的一个元素：

alist = ['a1', 'a2', 'a3']
blist = ['b1', 'b2', 'b3', 'b4']

for a, b in zip(alist, blist):
  print(a, b)

# Output:
# a1 b1
# a2 b2
# a3 b3

alist = []
len(list(zip(alist, blist)))

# Output:
# 0

使用 itertools.zip_longest 填充长度不等的列表到最长的那个。 (Python 2 中的 itertools.izip_longest)

alist = ['a1', 'a2', 'a3']
blist = ['b1']
clist = ['c1', 'c2', 'c3', 'c4']

for a,b,c in itertools.zip_longest(alist, blist, clist):
  print(a, b, c)

# Output:
# a1 b1 c1
# a2 None c2
# a3 None c3
# None None c4

3. 插入到特定索引的值：

alist = [123, 'xyz', 'zara', 'abc']
alist.insert(3, [2009])
print("Final List :", alist)

输出：

Final List : [123, 'xyz', 'zara', 2009, 'abc']

9: 列表的长度

使用 len() 获取一个列表的一维长度。

len(['one', 'two']) # 返回 2

len(['one', [2, 3], 'four']) # 返回 3, 而不是 4

len() 也适用于字符串、字典和其他类似于 list 的数据结构。

请注意，len() 是一个内置函数，而不是列表对象的方法。

还要注意的是，len() 的代价是 0(1)，这意味着无论列表的长度是多少，获取列表长度所需的时间都是相同的。

10: 删除列表中的重复值

要删除列表中的重复值，可以将 list 转换为 set（即不同对象的无序集合）。如果需要使用列表数据结构，则可以使用函数 list() 将 set 转换回 list ：

>>> names = ["aixk", "duke", "edik", "tofp", "duke"]
>>> list(set(names))
# Out: ['duke', 'tofp', 'aixk', 'edik']

请注意，将列表转换为集合时，会丢失原来的排序。

要保留列表的顺序，可以使用 OrderedDict

>>> import collections
>>> collections.OrderedDict.fromkeys(names).keys()
# Out: ['aixk', 'duke', 'edik', 'tofp']

11: 列表比较

使用比较运算符可以按词典顺序比较列表和其他序列。两个操作数必须是同一类型。

[1, 10, 100] < [2, 10, 100]
# True, because 1 < 2
[1, 10, 100] < [1, 10, 100]
# False, because the lists are equal
[1, 10, 100] <= [1, 10, 100]
# True, because the lists are equal
[1, 10, 100] < [1, 10, 101]
# True, because 100 < 101
[1, 10, 100] < [0, 10, 100]
# False, because 0 < 1

如果其中一个列表包含在另一个列表的开头，则最短列表获胜。

[1, 10] < [1, 10, 100]
# True

12: 访问嵌套列表中的值

从三维列表开始

alist = [[[1,2],[3,4]], [[5,6,7],[8,9,10], [12, 13, 14]]]

访问列表中的项目

print(alist[0][0][1])
# 2
# 访问第一个列表中的第二个元素
print(alist[1][1][2])
# 10
# 访问第二个列表中第二个列表的第三个元素

执行辅助操作：

alist[0][0].append(11)
print(alist[0][0][2])
# 11
# 将 11 添加到第一个列表中第一个列表的末尾

使用嵌套 for 循环打印列表：

for row in alist: # 嵌套列表循环的一种方法
    for col in row:
      print(col)
# [1, 2, 11]
# [3, 4]
# [5, 6, 7]
# [8, 9, 10]
# [12, 13, 14]

请注意，这种操作可以在列表推导式中使用，甚至可以作为生成器来产生效率，例如：

[col for row in alist for col in row]
# [[1, 2, 11], [3, 4], [5, 6, 7], [8, 9, 10], [12, 13, 14]]

并非外部列表中的所有项目本身都必须是列表：

alist[1].insert(2, 15)
# 将 15 插入第二个列表的第三个位置

嵌套 for 循环的另一种使用方法。另一种方法更好，但我偶尔也需要用到这种方法：

for row in range(len(alist)): # 一种不那么 Pythonic 的列表循环方式
  for col in range(len(alist[row])):
    print(alist[row][col])
# [1, 2, 11]
# [3, 4]
# [5, 6, 7]
# [8, 9, 10]
# 15
# [12, 13, 14]

在嵌套列表中使用切片

print(alist[1][1:])
# [[8, 9, 10], 15, [12, 13, 14]]
# 切片仍然有效

最终的列表：

print(alist)
# [[[1, 2, 11], [3, 4]], [[5, 6, 7], [8, 9, 10], 15, [12, 13, 14]]]

13: 将列表初始化为固定元素数

对于 “不可变 ”元素 (如 None, string literals 等)：

my_list = [None] * 10
my_list = ['test'] * 10

对于可变元素，相同的构造会导致列表中的所有元素都引用同一个对象，例如，对于集合：

>>> my_list=[{1}] * 10
>>> print(my_list)
[{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}]
>>> my_list[0].add(2)
>>> print(my_list)
[{1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}]

要使用固定数量的 “不同可变 ”对象初始化列表，请使用

my_list=[{1} for _ in range(10)]