当前位置：Gxlcms > Python > [译]ThePythonTutorial#DataStructures

[译]ThePythonTutorial#DataStructures

时间：2021-07-01 10:21:17 帮助过：24人阅读

[译]The Python Tutorial#Data Structures

5.1 Data Structures

本章节详细介绍之前介绍过的一些内容，并且也会介绍一些新的内容。

5.1 More on Lists

列表数据类型拥有更多方法，以下是列表对象的所有方法：

  • list.append(x)
    在列表末尾添加新项，等同于a[len(a):] = [x]

  • list.extend(iterable)
    添加可迭代对象中所有的项来扩展列表，等同于a[len(a):] = iterable

  • list.insert(i, x)
    在指定位置插入项。第一个参数为元素索引，新的项会在这个索引之前插入，因此a.insert(0, x)会在列表最前面插入，a.insert(len(a), x)等同于a.append(x)。

  • list.remove(x)
    从列表中移除值为x的第一个项，若x不存在，方法抛出异常(ValueError异常)

  • list.pop([i])
    从列表中移除指定位置的项并返回。如果没有指定索引，a.pop()移除并返回列表中最后一个项。（方法签名中包裹i的方括号表示参数是可选的，而不是在这个位置写一个方括号。这种记号法在Python Library Reference中经常用到）

  • list.clear()
    移除列表中的所有项，等同于del a[:]

  • list.index(x[, start[, end]])
    返回第一个值为x的项的基于0的索引，如果x不存在抛出ValueError异常。
    可选参数start和end被解释为切片记号法，用来将搜索限制在列表特定的子列表内。返回的索引是相对于完整列表索引，而不是相对于start参数的。

  • list.count(x)
    返回列表中x出现的次数

  • list.sort(key=None, reverse=False)
    对列表的所有项进行排序（参数用来自定义排序，参见sorted()获取更多信息）

  • list.reverse()
    反转列表元素

  • list.copy()
    返回列表的浅拷贝，等同于a[:]

以下是演示列表方法的例子：

  1. <code class="sourceCode python"><span class="op">>>></span> fruits <span class="op">=</span> [<span class="st">'orange'</span>, <span class="st">'apple'</span>, <span class="st">'pear'</span>, <span class="st">'banana'</span>, <span class="st">'kiwi'</span>, <span class="st">'apple'</span>, <span class="st">'banana'</span>]
  2. <span class="op">>>></span> fruits.count(<span class="st">'apple'</span>)
  3. <span class="dv">2</span>
  4. <span class="op">>>></span> fruits.count(<span class="st">'tangerine'</span>)
  5. <span class="dv">0</span>
  6. <span class="op">>>></span> fruits.index(<span class="st">'banana'</span>)
  7. <span class="dv">3</span>
  8. <span class="op">>>></span> fruits.index(<span class="st">'banana'</span>, <span class="dv">4</span>)  <span class="co"># Find next banana starting a position 4</span>
  9. <span class="dv">6</span>
  10. <span class="op">>>></span> fruits.reverse()
  11. <span class="op">>>></span> fruits
  12. [<span class="st">'banana'</span>, <span class="st">'apple'</span>, <span class="st">'kiwi'</span>, <span class="st">'banana'</span>, <span class="st">'pear'</span>, <span class="st">'apple'</span>, <span class="st">'orange'</span>]
  13. <span class="op">>>></span> fruits.append(<span class="st">'grape'</span>)
  14. <span class="op">>>></span> fruits
  15. [<span class="st">'banana'</span>, <span class="st">'apple'</span>, <span class="st">'kiwi'</span>, <span class="st">'banana'</span>, <span class="st">'pear'</span>, <span class="st">'apple'</span>, <span class="st">'orange'</span>, <span class="st">'grape'</span>]
  16. <span class="op">>>></span> fruits.sort()
  17. <span class="op">>>></span> fruits
  18. [<span class="st">'apple'</span>, <span class="st">'apple'</span>, <span class="st">'banana'</span>, <span class="st">'banana'</span>, <span class="st">'grape'</span>, <span class="st">'kiwi'</span>, <span class="st">'orange'</span>, <span class="st">'pear'</span>]
  19. <span class="op">>>></span> fruits.pop()
  20. <span class="co">'pear'</span></code>

诸如insert, reverse或者sort的这样，只改变了列表但是没有返回值打印，它们返回默认的None[1]。这是Python可变数据结构适用的设计原则。

5.1.1 Using Lists as Stacks

列表方法使得将其用作栈非常容易，栈中最后一个加入的元素第一个被释放（后进先出）。使用append()方法添加元素到栈顶，使用不带参数的pop()将栈顶元素出栈。示例：

  1. <code class="sourceCode python"><span class="op">>>></span> stack <span class="op">=</span> [<span class="dv">3</span>, <span class="dv">4</span>, <span class="dv">5</span>]
  2. <span class="op">>>></span> stack.append(<span class="dv">6</span>)
  3. <span class="op">>>></span> stack.append(<span class="dv">7</span>)
  4. <span class="op">>>></span> stack
  5. [<span class="dv">3</span>, <span class="dv">4</span>, <span class="dv">5</span>, <span class="dv">6</span>, <span class="dv">7</span>]
  6. <span class="op">>>></span> stack.pop()
  7. <span class="dv">7</span>
  8. <span class="op">>>></span> stack
  9. [<span class="dv">3</span>, <span class="dv">4</span>, <span class="dv">5</span>, <span class="dv">6</span>]
  10. <span class="op">>>></span> stack.pop()
  11. <span class="dv">6</span>
  12. <span class="op">>>></span> stack.pop()
  13. <span class="dv">5</span>
  14. <span class="op">>>></span> stack
  15. [<span class="dv">3</span>, <span class="dv">4</span>]</code>

5.1.2 Using Lists as Queues

将列表用作队列也是可能的，队列中先添加的元素先释放（先进先出）；然而，这样用列表效率非常不高。因为在列表末尾添加和取出元素很快，但是在列表开头插入或者删除元素很慢（因为不得不将其他所有元素位移一位）。

经过特殊设计的collections.deque在首尾两端添加和删除元素都很快，可以使用它来实现队列。示例：

  1. <code class="sourceCode python"><span class="op">>>></span> <span class="im">from</span> collections <span class="im">import</span> deque
  2. <span class="op">>>></span> queue <span class="op">=</span> deque([<span class="st">"Eric"</span>, <span class="st">"John"</span>, <span class="st">"Michael"</span>])
  3. <span class="op">>>></span> queue.append(<span class="st">"Terry"</span>)           <span class="co"># Terry arrives</span>
  4. <span class="op">>>></span> queue.append(<span class="st">"Graham"</span>)          <span class="co"># Graham arrives</span>
  5. <span class="op">>>></span> queue.popleft()                 <span class="co"># The first to arrive now leaves</span>
  6. <span class="co">'Eric'</span>
  7. <span class="op">>>></span> queue.popleft()                 <span class="co"># The second to arrive now leaves</span>
  8. <span class="co">'John'</span>
  9. <span class="op">>>></span> queue                           <span class="co"># Remaining queue in order of arrival</span>
  10. deque([<span class="st">'Michael'</span>, <span class="st">'Terry'</span>, <span class="st">'Graham'</span>])</code>

5.1.3 List Comprehensions

列表推导式为创建列表提供了简洁方式。一般的应用方式是：创建新列表，列表元素是对其他序列或者可迭代对象操作的结果；或者创建元素满足特定条件的子序列。

假如希望创建一个平方列表：

  1. <code class="sourceCode python"><span class="op">>>></span> squares <span class="op">=</span> []
  2. <span class="op">>>></span> <span class="cf">for</span> x <span class="op">in</span> <span class="bu">range</span>(<span class="dv">10</span>):
  3. ...     squares.append(x<span class="op">**</span><span class="dv">2</span>)
  4. ...
  5. <span class="op">>>></span> squares
  6. [<span class="dv">0</span>, <span class="dv">1</span>, <span class="dv">4</span>, <span class="dv">9</span>, <span class="dv">16</span>, <span class="dv">25</span>, <span class="dv">36</span>, <span class="dv">49</span>, <span class="dv">64</span>, <span class="dv">81</span>]</code>

注意以上创建（或者重写）了名为x的变量，该变量在循环结束之后仍然存在。使用以下方法可创建没有任何副作用的平方列表：

  1. <code class="sourceCode python">squares <span class="op">=</span> <span class="bu">list</span>(<span class="bu">map</span>(<span class="kw">lambda</span> x: x<span class="op">**</span><span class="dv">2</span>, <span class="bu">range</span>(<span class="dv">10</span>)))</code>

或者，等用于：

  1. <code class="sourceCode python">squares <span class="op">=</span> [x<span class="op">**</span><span class="dv">2</span> <span class="cf">for</span> x <span class="op">in</span> <span class="bu">range</span>(<span class="dv">10</span>)]</code>

这种方式更加简洁和易读。

跟随着for子句，紧接零个或者多个for子句或者if子句的表达式再加上中括号，构成了列表推导式。其返回结果是一个新的列表，列表的元素是表达式中for和if子句的计算结果。例如，以下列表推导式组合两个列表中不相等的元素：

  1. <code class="sourceCode python"><span class="op">>>></span> [(x, y) <span class="cf">for</span> x <span class="op">in</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>] <span class="cf">for</span> y <span class="op">in</span> [<span class="dv">3</span>,<span class="dv">1</span>,<span class="dv">4</span>] <span class="cf">if</span> x <span class="op">!=</span> y]
  2. [(<span class="dv">1</span>, <span class="dv">3</span>), (<span class="dv">1</span>, <span class="dv">4</span>), (<span class="dv">2</span>, <span class="dv">3</span>), (<span class="dv">2</span>, <span class="dv">1</span>), (<span class="dv">2</span>, <span class="dv">4</span>), (<span class="dv">3</span>, <span class="dv">1</span>), (<span class="dv">3</span>, <span class="dv">4</span>)]</code>

等价于：

  1. <code class="sourceCode python"><span class="op">>>></span> combs <span class="op">=</span> []
  2. <span class="op">>>></span> <span class="cf">for</span> x <span class="op">in</span> [<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>]:
  3. ...     <span class="cf">for</span> y <span class="op">in</span> [<span class="dv">3</span>,<span class="dv">1</span>,<span class="dv">4</span>]:
  4. ...         <span class="cf">if</span> x <span class="op">!=</span> y:
  5. ...             combs.append((x, y))
  6. ...
  7. <span class="op">>>></span> combs
  8. [(<span class="dv">1</span>, <span class="dv">3</span>), (<span class="dv">1</span>, <span class="dv">4</span>), (<span class="dv">2</span>, <span class="dv">3</span>), (<span class="dv">2</span>, <span class="dv">1</span>), (<span class="dv">2</span>, <span class="dv">4</span>), (<span class="dv">3</span>, <span class="dv">1</span>), (<span class="dv">3</span>, <span class="dv">4</span>)]</code>

注意上面两个代码段中for和if语句的顺序是相同的。

如果表达式是一个元组（如上所示的(x, y)），必须将其加上括号。

  1. <code class="sourceCode python"><span class="op">>>></span> vec <span class="op">=</span> [<span class="op">-</span><span class="dv">4</span>, <span class="op">-</span><span class="dv">2</span>, <span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">4</span>]
  2. <span class="op">>>></span> <span class="co"># create a new list with the values doubled</span>
  3. <span class="op">>>></span> [x<span class="op">*</span><span class="dv">2</span> <span class="cf">for</span> x <span class="op">in</span> vec]
  4. [<span class="op">-</span><span class="dv">8</span>, <span class="op">-</span><span class="dv">4</span>, <span class="dv">0</span>, <span class="dv">4</span>, <span class="dv">8</span>]
  5. <span class="op">>>></span> <span class="co"># filter the list to exclude negative numbers</span>
  6. <span class="op">>>></span> [x <span class="cf">for</span> x <span class="op">in</span> vec <span class="cf">if</span> x <span class="op">>=</span> <span class="dv">0</span>]
  7. [<span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">4</span>]
  8. <span class="op">>>></span> <span class="co"># apply a function to all the elements</span>
  9. <span class="op">>>></span> [<span class="bu">abs</span>(x) <span class="cf">for</span> x <span class="op">in</span> vec]
  10. [<span class="dv">4</span>, <span class="dv">2</span>, <span class="dv">0</span>, <span class="dv">2</span>, <span class="dv">4</span>]
  11. <span class="op">>>></span> <span class="co"># call a method on each element</span>
  12. <span class="op">>>></span> freshfruit <span class="op">=</span> [<span class="st">'  banana'</span>, <span class="st">'  loganberry '</span>, <span class="st">'passion fruit  '</span>]
  13. <span class="op">>>></span> [weapon.strip() <span class="cf">for</span> weapon <span class="op">in</span> freshfruit]
  14. [<span class="st">'banana'</span>, <span class="st">'loganberry'</span>, <span class="st">'passion fruit'</span>]
  15. <span class="op">>>></span> <span class="co"># create a list of 2-tuples like (number, square)</span>
  16. <span class="op">>>></span> [(x, x<span class="op">**</span><span class="dv">2</span>) <span class="cf">for</span> x <span class="op">in</span> <span class="bu">range</span>(<span class="dv">6</span>)]
  17. [(<span class="dv">0</span>, <span class="dv">0</span>), (<span class="dv">1</span>, <span class="dv">1</span>), (<span class="dv">2</span>, <span class="dv">4</span>), (<span class="dv">3</span>, <span class="dv">9</span>), (<span class="dv">4</span>, <span class="dv">16</span>), (<span class="dv">5</span>, <span class="dv">25</span>)]
  18. <span class="op">>>></span> <span class="co"># the tuple must be parenthesized, otherwise an error is raised</span>
  19. <span class="op">>>></span> [x, x<span class="op">**</span><span class="dv">2</span> <span class="cf">for</span> x <span class="op">in</span> <span class="bu">range</span>(<span class="dv">6</span>)]
  20.   File <span class="st">"<stdin>"</span>, line <span class="dv">1</span>, <span class="op">in</span> <span class="op"><</span>module<span class="op">></span>
  21.     [x, x<span class="op">**</span><span class="dv">2</span> <span class="cf">for</span> x <span class="op">in</span> <span class="bu">range</span>(<span class="dv">6</span>)]
  22.                <span class="op">^</span>
  23. <span class="pp">SyntaxError</span>: invalid syntax
  24. <span class="op">>>></span> <span class="co"># flatten a list using a listcomp with two 'for'</span>
  25. <span class="op">>>></span> vec <span class="op">=</span> [[<span class="dv">1</span>,<span class="dv">2</span>,<span class="dv">3</span>], [<span class="dv">4</span>,<span class="dv">5</span>,<span class="dv">6</span>], [<span class="dv">7</span>,<span class="dv">8</span>,<span class="dv">9</span>]]
  26. <span class="op">>>></span> [num <span class="cf">for</span> elem <span class="op">in</span> vec <span class="cf">for</span> num <span class="op">in</span> elem]
  27. [<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">4</span>, <span class="dv">5</span>, <span class="dv">6</span>, <span class="dv">7</span>, <span class="dv">8</span>, <span class="dv">9</span>]</code>

列表推导式可以包含复杂的表达式甚至嵌套函数：

  1. <code class="sourceCode python"><span class="op">>>></span> <span class="im">from</span> math <span class="im">import</span> pi
  2. <span class="op">>>></span> [<span class="bu">str</span>(<span class="bu">round</span>(pi, i)) <span class="cf">for</span> i <span class="op">in</span> <span class="bu">range</span>(<span class="dv">1</span>, <span class="dv">6</span>)]
  3. [<span class="st">'3.1'</span>, <span class="st">'3.14'</span>, <span class="st">'3.142'</span>, <span class="st">'3.1416'</span>, <span class="st">'3.14159'</span>]</code>

5.1.4 Nested List Comprehensions

列表推导式开头的表达式可以是任意表达式，包括另一个列表推导式。

考虑以下示例，一个包含3个长度为4的列表的列表实现了3x4的矩阵：

  1. <code class="sourceCode python">matrix <span class="op">=</span> [
  2.     [<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">4</span>],
  3.     [<span class="dv">5</span>, <span class="dv">6</span>, <span class="dv">7</span>, <span class="dv">8</span>],
  4.     [<span class="dv">9</span>, <span class="dv">10</span>, <span class="dv">11</span>, <span class="dv">12</span>],
  5. ]</code>

以下列表推导式反转行列：

  1. <code class="sourceCode python"><span class="op">>>></span> [[row[i] <span class="cf">for</span> row <span class="op">in</span> matrix] <span class="cf">for</span> i <span class="op">in</span> <span class="bu">range</span>(<span class="dv">4</span>)]
  2. [[<span class="dv">1</span>, <span class="dv">5</span>, <span class="dv">9</span>], [<span class="dv">2</span>, <span class="dv">6</span>, <span class="dv">10</span>], [<span class="dv">3</span>, <span class="dv">7</span>, <span class="dv">11</span>], [<span class="dv">4</span>, <span class="dv">8</span>, <span class="dv">12</span>]]</code>

前面的章节提到，嵌套的列表推导式是在其后跟随的for的上下文中求值的，因此这个示例等同于：

  1. <code class="sourceCode python"><span class="op">>>></span> transposed <span class="op">=</span> []
  2. <span class="op">>>></span> <span class="cf">for</span> i <span class="op">in</span> <span class="bu">range</span>(<span class="dv">4</span>):
  3. ...     transposed.append([row[i] <span class="cf">for</span> row <span class="op">in</span> matrix])
  4. ...
  5. <span class="op">>>></span> transposed
  6. [[<span class="dv">1</span>, <span class="dv">5</span>, <span class="dv">9</span>], [<span class="dv">2</span>, <span class="dv">6</span>, <span class="dv">10</span>], [<span class="dv">3</span>, <span class="dv">7</span>, <span class="dv">11</span>], [<span class="dv">4</span>, <span class="dv">8</span>, <span class="dv">12</span>]]</code>

依次等同于：

  1. <code class="sourceCode python"><span class="op">>>></span> transposed <span class="op">=</span> []
  2. <span class="op">>>></span> <span class="cf">for</span> i <span class="op">in</span> <span class="bu">range</span>(<span class="dv">4</span>):
  3. ...     <span class="co"># the following 3 lines implement the nested listcomp</span>
  4. ...     transposed_row <span class="op">=</span> []
  5. ...     <span class="cf">for</span> row <span class="op">in</span> matrix:
  6. ...         transposed_row.append(row[i])
  7. ...     transposed.append(transposed_row)
  8. <span class="op">>>></span> transposed
  9. [[<span class="dv">1</span>, <span class="dv">5</span>, <span class="dv">9</span>], [<span class="dv">2</span>, <span class="dv">6</span>, <span class="dv">10</span>], [<span class="dv">3</span>, <span class="dv">7</span>, <span class="dv">11</span>], [<span class="dv">4</span>, <span class="dv">8</span>, <span class="dv">12</span>]]</code>

在实践中，应该选择built-in函数来复合流程语句。在以上的用例中zip()函数更有用：

  1. <code class="sourceCode python"><span class="op">>>></span> <span class="bu">list</span>(<span class="bu">zip</span>(<span class="op">*</span>matrix))
  2. [(<span class="dv">1</span>, <span class="dv">5</span>, <span class="dv">9</span>), (<span class="dv">2</span>, <span class="dv">6</span>, <span class="dv">10</span>), (<span class="dv">3</span>, <span class="dv">7</span>, <span class="dv">11</span>), (<span class="dv">4</span>, <span class="dv">8</span>, <span class="dv">12</span>)]</code>

参见 Unpacking Argument Lists了解关于上面*使用的更多详细信息。

5.2 The del statement

在提供列表索引而不是值的情况下，有一种方法可以移除列表中的元素：del语句。这种方式与返回值的pop()方法不同。del语句也可以用来移除部分列表或者清除整个列表（之前使用将空的列表赋值给列表片段的方式实现）。示例：

  1. <code class="sourceCode python"><span class="op">>>></span> a <span class="op">=</span> [<span class="op">-</span><span class="dv">1</span>, <span class="dv">1</span>, <span class="fl">66.25</span>, <span class="dv">333</span>, <span class="dv">333</span>, <span class="fl">1234.5</span>]
  2. <span class="op">>>></span> <span class="kw">del</span> a[<span class="dv">0</span>]
  3. <span class="op">>>></span> a
  4. [<span class="dv">1</span>, <span class="fl">66.25</span>, <span class="dv">333</span>, <span class="dv">333</span>, <span class="fl">1234.5</span>]
  5. <span class="op">>>></span> <span class="kw">del</span> a[<span class="dv">2</span>:<span class="dv">4</span>]
  6. <span class="op">>>></span> a
  7. [<span class="dv">1</span>, <span class="fl">66.25</span>, <span class="fl">1234.5</span>]
  8. <span class="op">>>></span> <span class="kw">del</span> a[:]
  9. <span class="op">>>></span> a
  10. []</code>

del也可以用来删除整个变量：

  1. <code class="sourceCode python"><span class="op">>>></span> <span class="kw">del</span> a</code>

此后引用名字a会抛出异常（至少在其他值赋值给名字a之前）。接下来会有更多del的使用

5.3 Tuples and Sequences

列表和字符串有很多常用属性，比如索引和切片操作。它们是序列数据类型（参见 Sequence Types - list, tuple, range）的两种。Python是一种不断进化的语言，其他的序列类型也可以加入。元组是另一种标准的序列数据类型。

元组包含若干由逗号分隔的值，示例：

  1. <code class="sourceCode python"><span class="op">>>></span> t <span class="op">=</span> <span class="dv">12345</span>, <span class="dv">54321</span>, <span class="st">'hello!'</span>
  2. <span class="op">>>></span> t[<span class="dv">0</span>]
  3. <span class="dv">12345</span>
  4. <span class="op">>>></span> t
  5. (<span class="dv">12345</span>, <span class="dv">54321</span>, <span class="st">'hello!'</span>)
  6. <span class="op">>>></span> <span class="co"># Tuples may be nested:</span>
  7. ... u <span class="op">=</span> t, (<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">4</span>, <span class="dv">5</span>)
  8. <span class="op">>>></span> u
  9. ((<span class="dv">12345</span>, <span class="dv">54321</span>, <span class="st">'hello!'</span>), (<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">4</span>, <span class="dv">5</span>))
  10. <span class="op">>>></span> <span class="co"># Tuples are immutable:</span>
  11. ... t[<span class="dv">0</span>] <span class="op">=</span> <span class="dv">88888</span>
  12. Traceback (most recent call last):
  13.   File <span class="st">"<stdin>"</span>, line <span class="dv">1</span>, <span class="op">in</span> <span class="op"><</span>module<span class="op">></span>
  14. <span class="pp">TypeError</span>: <span class="st">'tuple'</span> <span class="bu">object</span> does <span class="op">not</span> support item assignment
  15. <span class="op">>>></span> <span class="co"># but they can contain mutable objects:</span>
  16. ... v <span class="op">=</span> ([<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>], [<span class="dv">3</span>, <span class="dv">2</span>, <span class="dv">1</span>])
  17. <span class="op">>>></span> v
  18. ([<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>], [<span class="dv">3</span>, <span class="dv">2</span>, <span class="dv">1</span>])</code>

可见，输出的元组总是放在圆括号中，以便于嵌套的元组可以被正确解析；虽然圆括号总是必须的（如果元组是其他更大表达式的一部分），但是在输入元组的时候可以选择使用圆括号。不能对元组的单个项赋值，但是可以创建包含如列表的可变对象的元组。

虽然元组和列表有些相似，但是他们通常以不同的目的，用于不同的场景。元组是不可变的，通常包含不同类型的元素，可以通过拆包操作（参见后续章节）或者索引（或者当元组是命名元组时，甚至可以通过属性来访问）来访问。列表是可变的，通常其元素也是不同类型的，可以通过对列表的迭代访问元素。

构建包含零个或者1个项的元组比较特殊：一种额外的奇怪语法可以适用于这种情况。空元组由一对空的圆括号创建；一个元素的元组由一个跟着逗号的值创建（在圆括号中放入单个值是不够的。译注：这种情况：(1)表示整数而不是元组，使用(1, )表示元组也是可行的）。丑陋但是有效。示例：

  1. <code class="sourceCode python"><span class="op">>>></span> empty <span class="op">=</span> ()
  2. <span class="op">>>></span> singleton <span class="op">=</span> <span class="st">'hello'</span>,    <span class="co"># <-- note trailing comma</span>
  3. <span class="op">>>></span> <span class="bu">len</span>(empty)
  4. <span class="dv">0</span>
  5. <span class="op">>>></span> <span class="bu">len</span>(singleton)
  6. <span class="dv">1</span>
  7. <span class="op">>>></span> singleton
  8. (<span class="st">'hello'</span>,)</code>

语句t = 12345, 54321, 'hello!'是封装元组的一个示例：值12345, 54321和hello!被封装到了一个元组中。逆向操作也是可行的：

  1. <code class="sourceCode python"><span class="op">>>></span> x, y, z <span class="op">=</span> t</code>

非常恰当地称之为序列解包，适用于任何在等号右边的序列（译注：等号右操作数）。序列解包要求等号左边待赋值的变量数量与序列包含元素数目相同。注意多重赋值只是封装元组和序列解包的结合（译注：多重赋值：i, j = 1, 2）

5.4 Set

Python也包含实现了集合的数据类型。集合是无序不重复的元素集。基本功能包括成员关系测试和重复实体消除。集合对象也支持并集，交集，差集以及对称差集等数学操作。

可以使用花括号和set()函数创建集合。谨记：创建空集合必须使用set函数，不能使用{}，后者用于创建空字典。

以下是简单示范：

  1. <code class="sourceCode python"><span class="op">>>></span> basket <span class="op">=</span> {<span class="st">'apple'</span>, <span class="st">'orange'</span>, <span class="st">'apple'</span>, <span class="st">'pear'</span>, <span class="st">'orange'</span>, <span class="st">'banana'</span>}
  2. <span class="op">>>></span> <span class="bu">print</span>(basket)                      <span class="co"># show that duplicates have been removed</span>
  3. {<span class="st">'orange'</span>, <span class="st">'banana'</span>, <span class="st">'pear'</span>, <span class="st">'apple'</span>}
  4. <span class="op">>>></span> <span class="st">'orange'</span> <span class="op">in</span> basket                 <span class="co"># fast membership testing</span>
  5. <span class="va">True</span>
  6. <span class="op">>>></span> <span class="st">'crabgrass'</span> <span class="op">in</span> basket
  7. <span class="va">False</span>
  8. <span class="op">>>></span> <span class="co"># Demonstrate set operations on unique letters from two words</span>
  9. ...
  10. <span class="op">>>></span> a <span class="op">=</span> <span class="bu">set</span>(<span class="st">'abracadabra'</span>)
  11. <span class="op">>>></span> b <span class="op">=</span> <span class="bu">set</span>(<span class="st">'alacazam'</span>)
  12. <span class="op">>>></span> a                                  <span class="co"># unique letters in a</span>
  13. {<span class="st">'a'</span>, <span class="st">'r'</span>, <span class="st">'b'</span>, <span class="st">'c'</span>, <span class="st">'d'</span>}
  14. <span class="op">>>></span> a <span class="op">-</span> b                              <span class="co"># letters in a but not in b</span>
  15. {<span class="st">'r'</span>, <span class="st">'d'</span>, <span class="st">'b'</span>}
  16. <span class="op">>>></span> a <span class="op">|</span> b                              <span class="co"># letters in a or b or both</span>
  17. {<span class="st">'a'</span>, <span class="st">'c'</span>, <span class="st">'r'</span>, <span class="st">'d'</span>, <span class="st">'b'</span>, <span class="st">'m'</span>, <span class="st">'z'</span>, <span class="st">'l'</span>}
  18. <span class="op">>>></span> a <span class="op">&</span> b                              <span class="co"># letters in both a and b</span>
  19. {<span class="st">'a'</span>, <span class="st">'c'</span>}
  20. <span class="op">>>></span> a <span class="op">^</span> b                              <span class="co"># letters in a or b but not both</span>
  21. {<span class="st">'r'</span>, <span class="st">'d'</span>, <span class="st">'b'</span>, <span class="st">'m'</span>, <span class="st">'z'</span>, <span class="st">'l'</span>}</code>

与列表推导式相同，Python也支持集合推导式：

  1. <code class="sourceCode python"><span class="op">>>></span> a <span class="op">=</span> {x <span class="cf">for</span> x <span class="op">in</span> <span class="st">'abracadabra'</span> <span class="cf">if</span> x <span class="op">not</span> <span class="op">in</span> <span class="st">'abc'</span>}
  2. <span class="op">>>></span> a
  3. {<span class="st">'r'</span>, <span class="st">'d'</span>}</code>

5.5 Dictionaries

另一个内嵌入Python中的数据结构是字典（参见 Mapping Types - dict）。字典在其他一些语言中被称为“联合存储”或者“联合数组”。与序列不同，序列以一系列数字作索引，字典以键作索引，键可以是任何不可变类型；通常使用字符串和数字作为键。只包含字符串，数字或者其他元组的元组也可以作为键；直接或者间接包含可变对象的元组不能作为键。因为列表可以使用索引赋值，切片赋值或者append()以及extend()等方法改变自身，所以列表不能作为键。

最好的理解字典的方式是将其认为是键值对的无序集合，同一集合中键唯一。一对花括号创建空字典：{}。在花括号中放置由逗号分隔键值对列表可以为字典添加初始键值对；这也是字典输出的格式。

字典提供的主要操作是：使用键存储值以及取值。可以使用del删除一个键值对。如果使用已经存在的键来存储值，那么与键关联的旧值会被重写。使用不存在的键来取值会抛出异常。

在字典上执行list(d.keys())返回字典所有键的无序列表（使用sorted(d.keys())使其有序）[2]。使用关键字in检查键在字典中是否存在。

以下是使用字典的示例：

  1. <code class="sourceCode python"><span class="op">>>></span> tel <span class="op">=</span> {<span class="st">'jack'</span>: <span class="dv">4098</span>, <span class="st">'sape'</span>: <span class="dv">4139</span>}
  2. <span class="op">>>></span> tel[<span class="st">'guido'</span>] <span class="op">=</span> <span class="dv">4127</span>
  3. <span class="op">>>></span> tel
  4. {<span class="st">'sape'</span>: <span class="dv">4139</span>, <span class="st">'guido'</span>: <span class="dv">4127</span>, <span class="st">'jack'</span>: <span class="dv">4098</span>}
  5. <span class="op">>>></span> tel[<span class="st">'jack'</span>]
  6. <span class="dv">4098</span>
  7. <span class="op">>>></span> <span class="kw">del</span> tel[<span class="st">'sape'</span>]
  8. <span class="op">>>></span> tel[<span class="st">'irv'</span>] <span class="op">=</span> <span class="dv">4127</span>
  9. <span class="op">>>></span> tel
  10. {<span class="st">'guido'</span>: <span class="dv">4127</span>, <span class="st">'irv'</span>: <span class="dv">4127</span>, <span class="st">'jack'</span>: <span class="dv">4098</span>}
  11. <span class="op">>>></span> <span class="bu">list</span>(tel.keys())
  12. [<span class="st">'irv'</span>, <span class="st">'guido'</span>, <span class="st">'jack'</span>]
  13. <span class="op">>>></span> <span class="bu">sorted</span>(tel.keys())
  14. [<span class="st">'guido'</span>, <span class="st">'irv'</span>, <span class="st">'jack'</span>]
  15. <span class="op">>>></span> <span class="st">'guido'</span> <span class="op">in</span> tel
  16. <span class="va">True</span>
  17. <span class="op">>>></span> <span class="st">'jack'</span> <span class="op">not</span> <span class="op">in</span> tel
  18. <span class="va">False</span></code>

dict()构造器直接使用键值对序列构造字典：

  1. <code class="sourceCode python"><span class="op">>>></span> <span class="bu">dict</span>([(<span class="st">'sape'</span>, <span class="dv">4139</span>), (<span class="st">'guido'</span>, <span class="dv">4127</span>), (<span class="st">'jack'</span>, <span class="dv">4098</span>)])
  2. {<span class="st">'sape'</span>: <span class="dv">4139</span>, <span class="st">'jack'</span>: <span class="dv">4098</span>, <span class="st">'guido'</span>: <span class="dv">4127</span>}</code>

此外，字典推导式可以从任意键值表达式中创建字典：

  1. <code class="sourceCode python"><span class="op">>>></span> {x: x<span class="op">**</span><span class="dv">2</span> <span class="cf">for</span> x <span class="op">in</span> (<span class="dv">2</span>, <span class="dv">4</span>, <span class="dv">6</span>)}
  2. {<span class="dv">2</span>: <span class="dv">4</span>, <span class="dv">4</span>: <span class="dv">16</span>, <span class="dv">6</span>: <span class="dv">36</span>}</code>

当键是简单的字符串时，可以使用关键字参数来指定键值对：

  1. <code class="sourceCode python"><span class="op">>>></span> <span class="bu">dict</span>(sape<span class="op">=</span><span class="dv">4139</span>, guido<span class="op">=</span><span class="dv">4127</span>, jack<span class="op">=</span><span class="dv">4098</span>)
  2. {<span class="st">'sape'</span>: <span class="dv">4139</span>, <span class="st">'jack'</span>: <span class="dv">4098</span>, <span class="st">'guido'</span>: <span class="dv">4127</span>}</code>

5.6 Looping Techniques

遍历字典时，使用items()方法可以同时检索键及其对应的值。

  1. <code class="sourceCode python"><span class="op">>>></span> knights <span class="op">=</span> {<span class="st">'gallahad'</span>: <span class="st">'the pure'</span>, <span class="st">'robin'</span>: <span class="st">'the brave'</span>}
  2. <span class="op">>>></span> <span class="cf">for</span> k, v <span class="op">in</span> knights.items():
  3. ...     <span class="bu">print</span>(k, v)
  4. ...
  5. gallahad the pure
  6. robin the brave</code>

遍历序列时，使用enumerate()函数可以同时检索位置索引及其对应的值：

  1. <code class="sourceCode python"><span class="op">>>></span> <span class="cf">for</span> i, v <span class="op">in</span> <span class="bu">enumerate</span>([<span class="st">'tic'</span>, <span class="st">'tac'</span>, <span class="st">'toe'</span>]):
  2. ...     <span class="bu">print</span>(i, v)
  3. ...
  4. <span class="dv">0</span> tic
  5. <span class="dv">1</span> tac
  6. <span class="dv">2</span> toe</code>

同时遍历两个或者更多序列时，使用zip()函数可以将元素组成对：

  1. <code class="sourceCode python"><span class="op">>>></span> questions <span class="op">=</span> [<span class="st">'name'</span>, <span class="st">'quest'</span>, <span class="st">'favorite color'</span>]
  2. <span class="op">>>></span> answers <span class="op">=</span> [<span class="st">'lancelot'</span>, <span class="st">'the holy grail'</span>, <span class="st">'blue'</span>]
  3. <span class="op">>>></span> <span class="cf">for</span> q, a <span class="op">in</span> <span class="bu">zip</span>(questions, answers):
  4. ...     <span class="bu">print</span>(<span class="st">'What is your </span><span class="sc">{0}</span><span class="st">?  It is </span><span class="sc">{1}</span><span class="st">.'</span>.<span class="bu">format</span>(q, a))
  5. ...
  6. What <span class="op">is</span> your name?  It <span class="op">is</span> lancelot.
  7. What <span class="op">is</span> your quest?  It <span class="op">is</span> the holy grail.
  8. What <span class="op">is</span> your favorite color?  It <span class="op">is</span> blue.</code>

需要逆序遍历序列时，首先指定一个正向的序列，然后调用reversed()函数：

  1. <code class="sourceCode python"><span class="op">>>></span> <span class="cf">for</span> i <span class="op">in</span> <span class="bu">reversed</span>(<span class="bu">range</span>(<span class="dv">1</span>, <span class="dv">10</span>, <span class="dv">2</span>)):
  2. ...     <span class="bu">print</span>(i)
  3. ...
  4. <span class="dv">9</span>
  5. <span class="dv">7</span>
  6. <span class="dv">5</span>
  7. <span class="dv">3</span>
  8. <span class="dv">1</span></code>

需要以特定顺序遍历序列时，使用sorted()函数返回新的有序序列，原序列不会改动：

  1. <code class="sourceCode python"><span class="op">>>></span> basket <span class="op">=</span> [<span class="st">'apple'</span>, <span class="st">'orange'</span>, <span class="st">'apple'</span>, <span class="st">'pear'</span>, <span class="st">'orange'</span>, <span class="st">'banana'</span>]
  2. <span class="op">>>></span> <span class="cf">for</span> f <span class="op">in</span> <span class="bu">sorted</span>(<span class="bu">set</span>(basket)):
  3. ...     <span class="bu">print</span>(f)
  4. ...
  5. apple
  6. banana
  7. orange
  8. pear</code>

有时需要在遍历序列的同时修改序列，创建新的替代序列更加简单并且安全：

  1. <code class="sourceCode python"><span class="op">>>></span> <span class="im">import</span> math
  2. <span class="op">>>></span> raw_data <span class="op">=</span> [<span class="fl">56.2</span>, <span class="bu">float</span>(<span class="st">'NaN'</span>), <span class="fl">51.7</span>, <span class="fl">55.3</span>, <span class="fl">52.5</span>, <span class="bu">float</span>(<span class="st">'NaN'</span>), <span class="fl">47.8</span>]
  3. <span class="op">>>></span> filtered_data <span class="op">=</span> []
  4. <span class="op">>>></span> <span class="cf">for</span> value <span class="op">in</span> raw_data:
  5. ...     <span class="cf">if</span> <span class="op">not</span> math.isnan(value):
  6. ...         filtered_data.append(value)
  7. ...
  8. <span class="op">>>></span> filtered_data
  9. [<span class="fl">56.2</span>, <span class="fl">51.7</span>, <span class="fl">55.3</span>, <span class="fl">52.5</span>, <span class="fl">47.8</span>]</code>

5.7 More on Conditions

while和if语句中使用的条件可以包含任意操作符，不仅仅是比较运算符。

比较运算符in和not in检查指定值在序列中是否存在（不存在）。操作符is和is not比较两个对象是否真正相同（内存地址比较）；这两个操作符只对像列表那样的可变对象重要。所有的比较运算符拥有相同的优先级，并且都低于数字运算符。

比较运算符可以链接起来。例如a < b == c测试b是否大于a同时b等于c（译注：同其他高级语言的：a < b and b == c）

比较运算符可以结合布尔运算符and和or使用，比较的结果（或者其他任何布尔表达式）可以使用not来作否定。and,or和not优先级比比较运算符低；其中not的优先级最高而or优先级最低，因此A and not B or C等同于(A and (not B)) or C。一如既往，可以使用圆括号表述想要的优先级顺序。

布尔运算符and和or号称短路运算符：它们的参数从左向右求值，一旦结果确定，求值过程就会停止。例如，如果A和C是真，B是假，A and B and C不会对表达式C求值（译注：A and B为假，已经确定了整个表达式A and B and C的值为假，表达式C的值对结果不会造成影响，因此不会对其求值）。当用作一般值而不是布尔值时，短路操作的返回值是最后一个求值的参数。

可以将比较运算或者布尔表达式赋值给变量：

  1. <code class="sourceCode python"><span class="op">>>></span> string1, string2, string3 <span class="op">=</span> <span class="st">''</span>, <span class="st">'Trondheim'</span>, <span class="st">'Hammer Dance'</span>
  2. <span class="op">>>></span> non_null <span class="op">=</span> string1 <span class="op">or</span> string2 <span class="op">or</span> string3
  3. <span class="op">>>></span> non_null
  4. <span class="co">'Trondheim'</span></code>

注意在Python中，赋值操作不能像C语言一样在表达式内发生。C程序员也许会抱怨，但是这避免了C程序中遇到的一个普遍问题：当想要表示==时候可能误用了=。

5.8 Comparing Sequences and Other Types

相同序列类型之间的序列对象可以相互比较。比较使用字典序：首先比较两个序列的第一项，如果它们不同，比较运算的结果就可确定了；如果它们不同，比较两个序列中的下一个项，以此类推，直到其中一个序列耗尽。如果被比较的两个项是同一类型的，那么使用字典序递归比较。如果两个序列的所有项都是相等的，那么他们相等。如果其中一个序列是另一个序列的子序列，那么短的一个序列较小。字符串的字典序使用Unicode代码点数字排序单个字符。

以下是相同类型的序列对象之间的比较示例：

  1. <code class="sourceCode python">(<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>)              <span class="op"><</span> (<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">4</span>)
  2. [<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>]              <span class="op"><</span> [<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">4</span>]
  3. <span class="co">'ABC'</span> <span class="op"><</span> <span class="st">'C'</span> <span class="op"><</span> <span class="st">'Pascal'</span> <span class="op"><</span> <span class="st">'Python'</span>
  4. (<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">4</span>)           <span class="op"><</span> (<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">4</span>)
  5. (<span class="dv">1</span>, <span class="dv">2</span>)                 <span class="op"><</span> (<span class="dv">1</span>, <span class="dv">2</span>, <span class="op">-</span><span class="dv">1</span>)
  6. (<span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span>)             <span class="op">==</span> (<span class="fl">1.0</span>, <span class="fl">2.0</span>, <span class="fl">3.0</span>)
  7. (<span class="dv">1</span>, <span class="dv">2</span>, (<span class="st">'aa'</span>, <span class="st">'ab'</span>))   <span class="op"><</span> (<span class="dv">1</span>, <span class="dv">2</span>, (<span class="st">'abc'</span>, <span class="st">'a'</span>), <span class="dv">4</span>)</code>

注意当不同类型对象之间有合适的比较方式时，使用<或者>比较不同类型的对象是合法的。例如，混合数字类型之间的比较是根据其数字上的值，0等于0.0。否则，解释器会抛出TypeException异常，而不是随意提供结果

Footnotes

[1] 其他语言可能返回改变后的对象，从而允许方法链接，如：d->insert("a")>remove("b")->sort();
[2] 调用d.keys()返回一个dictionary view对象。从而支持如成员关系测试和迭代之类的操作，但是其内容并不是独立于原始字典的，只是一个视图

以上就是[译]The Python Tutorial#Data Structures的详细内容，更多请关注Gxl网其它相关文章！

人气教程排行

本站所有资源全部来源于网络，若本站发布的内容侵害到您的隐私或者利益，请联系我们删除！