探索Python4: 使用列表  

Python 提供了一系列有用的功能，其中 list 类是最重要的功能之一。本文介绍 list 类，并演示了众多方法中的一些方法，了解如何使用这些方法简化困难的编程任务。

Python list

在介绍 Python tuple 时，我使用了类比的方法，将其比做一个袋子，您可以在袋子中存放不同的东西。Python list 与此非常类似，因此，它的功能与袋子的功能也非常类似。但有一点是不同的，即您可以使用方括号创建 list，如清单 1 所示。

清单 1. 在 Python 中创建一个 list

  1. >>> l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  2. >>> l
  3. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  4. >>> type(l)
  5. <type ‘list’>
  6. >>> el = []    # Create an empty list
  7. >>> len(el)
  8. 0
  9. >>> sl = [1]    # Create a single item list
  10. >>> len(sl)
  11. 1
  12. >>> sl = [1,]    # Create
  13. a single item list, as with a tuple
  14. >>> len(sl)
  15. 1

复制代码

本例展示如何创建包含从 0 到 9（包括 0 和 9）的简单 list，以及如何创建一个空列表和一个包含单个条目的列表。如果您还记得的话，创建单个条目的 tuple 还需要在单个条目后面跟一个逗号。这是区分单个条目 tuple 与方法调用的必要条件，这一点将在以后的文章中详细讨论。而对于 list，则是不必要的，尽管也允许使用单个逗号。

与往常一样，要获取有关 Python 主题的更多信息，您可以使用内置的帮助解释器，例如，清单 2 展示了如何开始 list 类的帮助描述。

清单 2. 获取有关 list 的帮助

  1. >>> help(list)
  2. Help on class list in module __builtin__:
  3. class list(object)
  4. |  list() -> new list
  5. |  list(sequence) -> new list initialized from sequence’s items
  6. |
  7. |  Methods defined here:
  8. |
  9. |  __add__(…)
  10. |      x.__add__(y) <==> x+y
  11. |
  12. |  __contains__(…)
  13. |      x.__contains__(y) <==> y in x
  14. |
  15. …

复制代码

如果仔细观察清单 2 中对 list 类的描述，您会看到其中提供了两个不同的构造函数：一个没有参数，另一个接受一个序列类作为参数。因此，使用构造函数及方括号简化符号，可以创建 list。这就提供了很大的灵活性，原因是您可以方便地将现有的序列，如 tuple 或 string 转换为 list，如清单 3 所示。不过，请注意，传递的参数必须是序列 —— 并且不只是对象序列 —— 否则将会出现错误。对于任何序列类型，您都可以使用 len 方法容易地查找序列中条目的数量。

清单 3. 直接创建 list 对象

  1. >>> l = list()
  2. >>> type(l)
  3. <type ‘list’>
  4. >>> len(l)
  5. 0
  6. >>> l
  7. []
  8. >>> l = list((0, 1, 2, 3, 4, 5, 6, 7,
  9. 8, 9))    # Create a list from a tuple
  10. >>> l
  11. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  12. >>> len(l)
  13. 10
  14. >>> l = list([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])    # Create a list from a list
  15. >>> l
  16. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  17. >>> len(l)
  18. 10
  19. >>> l = list(0, 1, 2, 3, 4, 5, 6, 7,
  20. 8, 9)      # Error: Must pass in a sequence
  21. Traceback (most recent call last):
  22. File “<stdin>”, line 1, in ?
  23. TypeError: list() takes at most 1 argument (10 given)
  24. >>> l = list(“0123456789”) # Create a list from a string
  25. >>> l
  26. [‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’]
  27. >>> type(l)
  28. <type ‘list’>
  29. >>> len(l)
  30. 10

复制代码

正如您看到的，创建 list 是很容易的，如果还没有尝试过，现在可以试一试。您不仅能够将序列直接传递给构造函数，还可以将拥有元组或字符串的变量传递给 list 构造函数。

很明显，序列较为有用的主要原因是它可以非常方便地访问序列中的条目。如果还记得对 tuple 的讨论，便知道可以在序列中一次访问一个条目或者通过将条目切片来访问条目。Python list 也可以使用相同的技术，如清单 4 所示。

清单 4. 从 list 访问条目

  1. >>> l = list([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
  2. >>> l[0]         # Get the first item in the list
  3. 0
  4. >>> type(l[0])
  5. <type ‘int’>
  6. >>> l[5]         # Get the sixth item in the list
  7. 5
  8. >>> l[1:5]       # Get the second through fifth items
  9. [1, 2, 3, 4]
  10. >>> type(l[1:5])
  11. <type ‘list’>
  12. >>> l[0::2]      # Get every second item
  13. [0, 2, 4, 6, 8]
  14. >>> l[0], l[1], l[2]
  15. (0, 1, 2)

复制代码

在以前的文章中已经了解到，切片 是一个非常有用的概念，其一般形式为 l[start:end:step]，其中 start 和 end 分别是开始和结束索引，step 是在切片时要跨过的条目数量。此外，还可以对结束索引使用负值，即从序列的结尾往回计数。另一个有用的功能是以一种很合适的方式处理错误（如超过序列的长度）。如前一个例子所示，您还可以选择忽略切片中使用的三个值中的一个或多个值。例如，我在切片 l[0::2] 中没有使用结束索引。

可变的序列

在本文的开头，我提到过 list 和 tuple 之间的主要区别在于 list 是一个可变的序列，这就意味着您不但可以方便地访问 list 中的条目，而且可以方便地修改它们。但这会引起一个并发症状：您只能修改序列中的条目。若要向序列中添加条目（而不仅仅是修改条目），可使用 append 方法，如清单 5 所示。

清单 5. 修改 list

  1. >>> l = []
  2. >>> l[0] = 0      # The list is empty
  3. Traceback (most recent call last):
  4. File “<stdin>”, line 1, in ?
  5. IndexError: list assignment index out of range
  6. >>> l.append(0)
  7. >>> l
  8. [0]
  9. >>> l[0] = 1
  10. >>> l
  11. [1]

复制代码

正如前一个例子所演示的，尝试修改不存在的 list 条目会导致出现错误。这一点意义重大，并演示了 Python 方法生成错误的情况。当问题较为严重时，将会产生一个错误，如果问题较小并且可以很容易地处理，则忽略它。

异构的可变序列

您可能想了解更为复杂的修改。通过综合切片知识以及如何修改 list 的知识，您应该已经获得了非常重要的见识：可以通过多种方式修改列表。就像 tuple 一样，list 也可以持有不同类型的数据（或不同类型的对象），这就是我所说的异构的可变序列。这两种功能在清单 6 中进行了更完整的描述。

清单 6. 异构的可变 list

  1. >>> l=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  2. >>> l
  3. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  4. >>> l[2] = 2
  5. >>> type(l[2])
  6. <type ‘int’>
  7. >>> l[2] = “two”      # Change the type of an element
  8. >>> ,ype(l[2])
  9. <type ‘str’>
  10. >>> l
  11. [0, 1, ‘two’, 3, 4, 5, 6, 7, 8, 9]
  12. >>> l[2] = l[2:5] * 2
  13. >>> l
  14. [0, 1, [‘two’, 3, 4, ‘two’, 3, 4], 3, 4, 5, 6, 7, 8, 9]
  15. >>> del(l[2])         # Remove single element
  16. >>> l
  17. [0, 1, 3, 4, 5, 6, 7, 8, 9]
  18. >>> l[1:3] = []       # Remove a slice
  19. >>> l
  20. [0, 4, 5, 6, 7, 8, 9]

复制代码

修改 list 中的条目相当容易：您可以适当地设置条目的值，甚至设置成另一种不同的类型，如 string 或另一 list。您还可以使用重复运算符，可以将该运算符识别为乘法运算符，以便从小片段中构建更大的列表。

前面的例子向您展示了如何向 list 中添加元素，以及如何修改 list 中的条目。前一个例子还演示了如何从 list 中删除对象。删除条目的第一个方法是使用 del 方法。使用此方法可以删除一个条目或一个条目范围。您还可以使用灵活而强大的切片方法从 list 中删除切片。

数组

在前一个例子中您可以看到，list 可以包含另一个 list 作为条目。如果扩展此例子，您可能想知道每个条目由一个 list 替换将会发生什么样的事情。结果是一个数组，或者从更加数学方面来讲是一个矩阵。清单 7 展示了如何使用 list 保持二维 (2-D) 或三维 (3-D) 数组。

清单 7. list 作为一个数组

  1. >>> al = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
  2. >>> al
  3. [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
  4. >>> al[0][0]          # First element in 2D array
  5. 0
  6. >>> al[2][2]          # Last element in 2D array
  7. 8
  8. >>> al[1][2]
  9. 5
  10. >>> al = [[[0, 1], [2, 3]], [[4, 5], [6, 7]]]
  11. >>> al
  12. [[[0, 1], [2, 3]], [[4, 5], [6, 7]]]
  13. >>> al[0][0][1]
  14. 1
  15. >>> len(al)           # Length of outer dimension
  16. 2
  17. >>> len(al[0])        # Length of middle dimension
  18. 2
  19. >>> len(al[0][0])     # Length of inner dimension
  20. 2

复制代码

其他列表操作

list 对象具有许多可以应用于现有列表的有用方法。例如，您可以反转 list 中的所有条目或排序 list。不过，要记住这些操作的一个重点在于，它们是就地 操作，这意味着它们会修改调用它们所针对的 list。因此，如果您尝试创建新列表，并将其设置为对这些方法之一调用所产生的结果，则会得到一个空列表。

list 除可以用于模拟数组外，还可以用于模拟其他数据结构。例如，append 和 pop 方法对 list 函数的操作要么是先进先出 (FIFO) 数据结构（也称为队列），要么是后进先出 (LIFO) 数据结构（也称为堆栈）。通过允许您将条目设置为从 list 中弹出（删除并返回），pop 方法支持这些功能。如果弹出 list 的第一项，则是一个队列；反之，如果弹出 list 的最后一项，则是一个堆栈，如清单 8 所示。

清单 8. 操纵 list

  1. >>> l=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  2. >>> id(l) # This is the object id for our current list
  3. 4525432
  4. >>> l.reverse()       # Reverse the list
  5. >>> l
  6. [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
  7. >>> id(l) # The id is the same, modified list in place.
  8. 4525432
  9. >>> l.sort()          # Sort the list in numerical order
  10. >>> l
  11. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  12. >>> id(l) # Modified the existing list
  13. 4525432
  14. >>> l.index(5)        # Same as l[5]
  15. 5
  16. >>> l.count(0)        # How
  17. many times does ‘0’ occur in the list
  18. 1
  19. >>> l.pop()           # Take off the last item (Stack)
  20. 9
  21. >>> l
  22. [0, 1, 2, 3, 4, 5, 6, 7, 8]
  23. >>> l.pop(5)          # Take out the fifth element
  24. 5
  25. >>> l
  26. [0, 1, 2, 3, 4, 6, 7, 8]
  27. >>> l.pop(0)          # Take the first item off the list (Queue)
  28. 0
  29. >>> l
  30. [1, 2, 3, 4, 6, 7, 8]

复制代码

 

欢迎大佬支持本博客的发展 -- Donate --

本文链接：探索Python4: 使用列表

转载声明：本站文章若无特别说明，皆为原创，转载请注明来源：三十岁，谢谢！^^


分享到：          

  1. 没有评论

  1. 没有通告