794 lines
86 KiB
HTML
794 lines
86 KiB
HTML
|
||
<!DOCTYPE html>
|
||
|
||
<html xmlns="http://www.w3.org/1999/xhtml" lang="zh_CN">
|
||
<head>
|
||
<meta charset="utf-8" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
|
||
|
||
<title>5. 数据结构 — Python 3.8.20 文档</title><meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||
|
||
<link rel="stylesheet" href="../_static/pydoctheme.css" type="text/css" />
|
||
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
|
||
|
||
<script id="documentation_options" data-url_root="../" src="../_static/documentation_options.js"></script>
|
||
<script src="../_static/jquery.js"></script>
|
||
<script src="../_static/underscore.js"></script>
|
||
<script src="../_static/doctools.js"></script>
|
||
<script src="../_static/language_data.js"></script>
|
||
<script src="../_static/translations.js"></script>
|
||
|
||
<script src="../_static/sidebar.js"></script>
|
||
|
||
<link rel="search" type="application/opensearchdescription+xml"
|
||
title="在 Python 3.8.20 文档 中搜索"
|
||
href="../_static/opensearch.xml"/>
|
||
<link rel="author" title="关于这些文档" href="../about.html" />
|
||
<link rel="index" title="索引" href="../genindex.html" />
|
||
<link rel="search" title="搜索" href="../search.html" />
|
||
<link rel="copyright" title="版权所有" href="../copyright.html" />
|
||
<link rel="next" title="6. 模块" href="modules.html" />
|
||
<link rel="prev" title="4. 更多控制流工具" href="controlflow.html" />
|
||
<link rel="canonical" href="https://docs.python.org/3/tutorial/datastructures.html" />
|
||
|
||
|
||
|
||
|
||
|
||
<style>
|
||
@media only screen {
|
||
table.full-width-table {
|
||
width: 100%;
|
||
}
|
||
}
|
||
</style>
|
||
<link rel="shortcut icon" type="image/png" href="../_static/py.svg" />
|
||
<script type="text/javascript" src="../_static/copybutton.js"></script>
|
||
<script type="text/javascript" src="../_static/menu.js"></script>
|
||
|
||
</head>
|
||
<body>
|
||
<div class="mobile-nav">
|
||
<input type="checkbox" id="menuToggler" class="toggler__input" aria-controls="navigation"
|
||
aria-pressed="false" aria-expanded="false" role="button" aria-label="Menu" />
|
||
<label for="menuToggler" class="toggler__label">
|
||
<span></span>
|
||
</label>
|
||
<nav class="nav-content" role="navigation">
|
||
<a href="https://www.python.org/" class="nav-logo">
|
||
<img src="../_static/py.svg" alt="Logo"/>
|
||
</a>
|
||
<div class="version_switcher_placeholder"></div>
|
||
<form role="search" class="search" action="../search.html" method="get">
|
||
<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" class="search-icon">
|
||
<path fill-rule="nonzero"
|
||
d="M15.5 14h-.79l-.28-.27a6.5 6.5 0 001.48-5.34c-.47-2.78-2.79-5-5.59-5.34a6.505 6.505 0 00-7.27 7.27c.34 2.8 2.56 5.12 5.34 5.59a6.5 6.5 0 005.34-1.48l.27.28v.79l4.25 4.25c.41.41 1.08.41 1.49 0 .41-.41.41-1.08 0-1.49L15.5 14zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z" fill="#444"></path>
|
||
</svg>
|
||
<input type="text" name="q" aria-label="快速搜索"/>
|
||
<input type="submit" value="转向"/>
|
||
</form>
|
||
</nav>
|
||
<div class="menu-wrapper">
|
||
<nav class="menu" role="navigation" aria-label="main navigation">
|
||
<div class="language_switcher_placeholder"></div>
|
||
<h3><a href="../contents.html">目录</a></h3>
|
||
<ul>
|
||
<li><a class="reference internal" href="#">5. 数据结构</a><ul>
|
||
<li><a class="reference internal" href="#more-on-lists">5.1. 列表详解</a><ul>
|
||
<li><a class="reference internal" href="#using-lists-as-stacks">5.1.1. 用列表实现堆栈</a></li>
|
||
<li><a class="reference internal" href="#using-lists-as-queues">5.1.2. 用列表实现队列</a></li>
|
||
<li><a class="reference internal" href="#list-comprehensions">5.1.3. 列表推导式</a></li>
|
||
<li><a class="reference internal" href="#nested-list-comprehensions">5.1.4. 嵌套的列表推导式</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a class="reference internal" href="#the-del-statement">5.2. <code class="xref std std-keyword docutils literal notranslate"><span class="pre">del</span></code> 语句</a></li>
|
||
<li><a class="reference internal" href="#tuples-and-sequences">5.3. 元组和序列</a></li>
|
||
<li><a class="reference internal" href="#sets">5.4. 集合</a></li>
|
||
<li><a class="reference internal" href="#dictionaries">5.5. 字典</a></li>
|
||
<li><a class="reference internal" href="#looping-techniques">5.6. 循环的技巧</a></li>
|
||
<li><a class="reference internal" href="#more-on-conditions">5.7. 深入条件控制</a></li>
|
||
<li><a class="reference internal" href="#comparing-sequences-and-other-types">5.8. 序列和其他类型的比较</a></li>
|
||
</ul>
|
||
</li>
|
||
</ul>
|
||
|
||
<h4>上一个主题</h4>
|
||
<p class="topless"><a href="controlflow.html"
|
||
title="上一章"><span class="section-number">4. </span>更多控制流工具</a></p>
|
||
<h4>下一个主题</h4>
|
||
<p class="topless"><a href="modules.html"
|
||
title="下一章"><span class="section-number">6. </span>模块</a></p>
|
||
<div role="note" aria-label="source link">
|
||
<h3>本页</h3>
|
||
<ul class="this-page-menu">
|
||
<li><a href="../bugs.html">报告 Bug</a></li>
|
||
<li>
|
||
<a href="https://github.com/python/cpython/blob/3.8/Doc/tutorial/datastructures.rst"
|
||
rel="nofollow">显示源代码
|
||
</a>
|
||
</li>
|
||
</ul>
|
||
</div>
|
||
</nav>
|
||
</div>
|
||
</div>
|
||
|
||
<div id="outdated-warning" style="padding: .5em; text-align: center; background-color: #FFBABA; color: #6A0E0E;">
|
||
这个文档所针对的是一个已不再受支持的 Python 旧版本。
|
||
你应当升级版本，并阅读
|
||
<a href="/3/tutorial/datastructures.html"> Python 当前稳定版本的文档</a>.
|
||
</div>
|
||
|
||
<div class="related" role="navigation" aria-label="related navigation">
|
||
<h3>导航</h3>
|
||
<ul>
|
||
<li class="right" style="margin-right: 10px">
|
||
<a href="../genindex.html" title="总目录"
|
||
accesskey="I">索引</a></li>
|
||
<li class="right" >
|
||
<a href="../py-modindex.html" title="Python 模块索引"
|
||
>模块</a> |</li>
|
||
<li class="right" >
|
||
<a href="modules.html" title="6. 模块"
|
||
accesskey="N">下一页</a> |</li>
|
||
<li class="right" >
|
||
<a href="controlflow.html" title="4. 更多控制流工具"
|
||
accesskey="P">上一页</a> |</li>
|
||
|
||
<li><img src="../_static/py.svg" alt="python logo" style="vertical-align: middle; margin-top: -1px"/></li>
|
||
<li><a href="https://www.python.org/">Python</a> »</li>
|
||
<li class="switchers">
|
||
<div class="language_switcher_placeholder"></div>
|
||
<div class="version_switcher_placeholder"></div>
|
||
</li>
|
||
<li>
|
||
|
||
</li>
|
||
<li id="cpython-language-and-version">
|
||
<a href="../index.html">3.8.20 Documentation</a> »
|
||
</li>
|
||
|
||
<li class="nav-item nav-item-1"><a href="index.html" accesskey="U">Python 教程</a> »</li>
|
||
<li class="right">
|
||
|
||
|
||
<div class="inline-search" role="search">
|
||
<form class="inline-search" action="../search.html" method="get">
|
||
<input placeholder="快速搜索" aria-label="快速搜索" type="text" name="q" />
|
||
<input type="submit" value="转向" />
|
||
<input type="hidden" name="check_keywords" value="yes" />
|
||
<input type="hidden" name="area" value="default" />
|
||
</form>
|
||
</div>
|
||
|
|
||
</li>
|
||
|
||
</ul>
|
||
</div>
|
||
|
||
<div class="document">
|
||
<div class="documentwrapper">
|
||
<div class="bodywrapper">
|
||
<div class="body" role="main">
|
||
|
||
<section id="data-structures">
|
||
<span id="tut-structures"></span><h1><span class="section-number">5. </span>数据结构<a class="headerlink" href="#data-structures" title="永久链接至标题">¶</a></h1>
|
||
<p>本章深入讲解之前学过的一些内容，同时，还增加了新的知识点。</p>
|
||
<section id="more-on-lists">
|
||
<span id="tut-morelists"></span><h2><span class="section-number">5.1. </span>列表详解<a class="headerlink" href="#more-on-lists" title="永久链接至标题">¶</a></h2>
|
||
<p>列表数据类型支持很多方法，列表对象的所有方法所示如下：</p>
|
||
<dl class="method">
|
||
<dt>
|
||
<code class="sig-prename descclassname">list.</code><code class="sig-name descname">append</code><span class="sig-paren">(</span><em class="sig-param">x</em><span class="sig-paren">)</span></dt>
|
||
<dd><p>在列表末尾添加一个元素，相当于 <code class="docutils literal notranslate"><span class="pre">a[len(a):]</span> <span class="pre">=</span> <span class="pre">[x]</span></code> 。</p>
|
||
</dd></dl>
|
||
|
||
<dl class="method">
|
||
<dt>
|
||
<code class="sig-prename descclassname">list.</code><code class="sig-name descname">extend</code><span class="sig-paren">(</span><em class="sig-param">iterable</em><span class="sig-paren">)</span></dt>
|
||
<dd><p>用可迭代对象的元素扩展列表。相当于 <code class="docutils literal notranslate"><span class="pre">a[len(a):]</span> <span class="pre">=</span> <span class="pre">iterable</span></code> 。</p>
|
||
</dd></dl>
|
||
|
||
<dl class="method">
|
||
<dt>
|
||
<code class="sig-prename descclassname">list.</code><code class="sig-name descname">insert</code><span class="sig-paren">(</span><em class="sig-param">i</em>, <em class="sig-param">x</em><span class="sig-paren">)</span></dt>
|
||
<dd><p>在指定位置插入元素。第一个参数是插入元素的索引，因此，<code class="docutils literal notranslate"><span class="pre">a.insert(0,</span> <span class="pre">x)</span></code> 在列表开头插入元素， <code class="docutils literal notranslate"><span class="pre">a.insert(len(a),</span> <span class="pre">x)</span></code> 等同于 <code class="docutils literal notranslate"><span class="pre">a.append(x)</span></code> 。</p>
|
||
</dd></dl>
|
||
|
||
<dl class="method">
|
||
<dt>
|
||
<code class="sig-prename descclassname">list.</code><code class="sig-name descname">remove</code><span class="sig-paren">(</span><em class="sig-param">x</em><span class="sig-paren">)</span></dt>
|
||
<dd><p>从列表中删除第一个值为 <em>x</em> 的元素。未找到指定元素时，触发 <a class="reference internal" href="../library/exceptions.html#ValueError" title="ValueError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">ValueError</span></code></a> 异常。</p>
|
||
</dd></dl>
|
||
|
||
<dl class="method">
|
||
<dt>
|
||
<code class="sig-prename descclassname">list.</code><code class="sig-name descname">pop</code><span class="sig-paren">(</span><span class="optional">[</span><em class="sig-param">i</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
|
||
<dd><p>删除列表中指定位置的元素，并返回被删除的元素。未指定位置时，<code class="docutils literal notranslate"><span class="pre">a.pop()</span></code> 删除并返回列表的最后一个元素。（方法签名中 <em>i</em> 两边的方括号表示该参数是可选的，不是要求输入方括号。这种表示法常见于 Python 参考库）。</p>
|
||
</dd></dl>
|
||
|
||
<dl class="method">
|
||
<dt>
|
||
<code class="sig-prename descclassname">list.</code><code class="sig-name descname">clear</code><span class="sig-paren">(</span><span class="sig-paren">)</span></dt>
|
||
<dd><p>删除列表里的所有元素，相当于 <code class="docutils literal notranslate"><span class="pre">del</span> <span class="pre">a[:]</span></code> 。</p>
|
||
</dd></dl>
|
||
|
||
<dl class="method">
|
||
<dt>
|
||
<code class="sig-prename descclassname">list.</code><code class="sig-name descname">index</code><span class="sig-paren">(</span><em class="sig-param">x</em><span class="optional">[</span>, <em class="sig-param">start</em><span class="optional">[</span>, <em class="sig-param">end</em><span class="optional">]</span><span class="optional">]</span><span class="sig-paren">)</span></dt>
|
||
<dd><p>返回列表中第一个值为 <em>x</em> 的元素的零基索引。未找到指定元素时，触发 <a class="reference internal" href="../library/exceptions.html#ValueError" title="ValueError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">ValueError</span></code></a> 异常。</p>
|
||
<p>可选参数 <em>start</em> 和 <em>end</em> 是切片符号，用于将搜索限制为列表的特定子序列。返回的索引是相对于整个序列的开始计算的，而不是 <em>start</em> 参数。</p>
|
||
</dd></dl>
|
||
|
||
<dl class="method">
|
||
<dt>
|
||
<code class="sig-prename descclassname">list.</code><code class="sig-name descname">count</code><span class="sig-paren">(</span><em class="sig-param">x</em><span class="sig-paren">)</span></dt>
|
||
<dd><p>返回列表中元素 <em>x</em> 出现的次数。</p>
|
||
</dd></dl>
|
||
|
||
<dl class="method">
|
||
<dt>
|
||
<code class="sig-prename descclassname">list.</code><code class="sig-name descname">sort</code><span class="sig-paren">(</span><em class="sig-param">*</em>, <em class="sig-param">key=None</em>, <em class="sig-param">reverse=False</em><span class="sig-paren">)</span></dt>
|
||
<dd><p>就地排序列表中的元素（要了解自定义排序参数，详见 <a class="reference internal" href="../library/functions.html#sorted" title="sorted"><code class="xref py py-func docutils literal notranslate"><span class="pre">sorted()</span></code></a>）。</p>
|
||
</dd></dl>
|
||
|
||
<dl class="method">
|
||
<dt>
|
||
<code class="sig-prename descclassname">list.</code><code class="sig-name descname">reverse</code><span class="sig-paren">(</span><span class="sig-paren">)</span></dt>
|
||
<dd><p>翻转列表中的元素。</p>
|
||
</dd></dl>
|
||
|
||
<dl class="method">
|
||
<dt>
|
||
<code class="sig-prename descclassname">list.</code><code class="sig-name descname">copy</code><span class="sig-paren">(</span><span class="sig-paren">)</span></dt>
|
||
<dd><p>返回列表的浅拷贝。相当于 <code class="docutils literal notranslate"><span class="pre">a[:]</span></code> 。</p>
|
||
</dd></dl>
|
||
|
||
<p>多数列表方法示例：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">fruits</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'orange'</span><span class="p">,</span> <span class="s1">'apple'</span><span class="p">,</span> <span class="s1">'pear'</span><span class="p">,</span> <span class="s1">'banana'</span><span class="p">,</span> <span class="s1">'kiwi'</span><span class="p">,</span> <span class="s1">'apple'</span><span class="p">,</span> <span class="s1">'banana'</span><span class="p">]</span>
|
||
<span class="gp">>>> </span><span class="n">fruits</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="s1">'apple'</span><span class="p">)</span>
|
||
<span class="go">2</span>
|
||
<span class="gp">>>> </span><span class="n">fruits</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="s1">'tangerine'</span><span class="p">)</span>
|
||
<span class="go">0</span>
|
||
<span class="gp">>>> </span><span class="n">fruits</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="s1">'banana'</span><span class="p">)</span>
|
||
<span class="go">3</span>
|
||
<span class="gp">>>> </span><span class="n">fruits</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="s1">'banana'</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span> <span class="c1"># Find next banana starting a position 4</span>
|
||
<span class="go">6</span>
|
||
<span class="gp">>>> </span><span class="n">fruits</span><span class="o">.</span><span class="n">reverse</span><span class="p">()</span>
|
||
<span class="gp">>>> </span><span class="n">fruits</span>
|
||
<span class="go">['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']</span>
|
||
<span class="gp">>>> </span><span class="n">fruits</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="s1">'grape'</span><span class="p">)</span>
|
||
<span class="gp">>>> </span><span class="n">fruits</span>
|
||
<span class="go">['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']</span>
|
||
<span class="gp">>>> </span><span class="n">fruits</span><span class="o">.</span><span class="n">sort</span><span class="p">()</span>
|
||
<span class="gp">>>> </span><span class="n">fruits</span>
|
||
<span class="go">['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']</span>
|
||
<span class="gp">>>> </span><span class="n">fruits</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>
|
||
<span class="go">'pear'</span>
|
||
</pre></div>
|
||
</div>
|
||
<p><code class="docutils literal notranslate"><span class="pre">insert</span></code>、<code class="docutils literal notranslate"><span class="pre">remove</span></code>、<code class="docutils literal notranslate"><span class="pre">sort</span></code> 等方法只修改列表，不输出返回值——返回的默认值为 <code class="docutils literal notranslate"><span class="pre">None</span></code> 。<a class="footnote-reference brackets" href="#id2" id="id1">1</a> 这是所有 Python 可变数据结构的设计原则。</p>
|
||
<p>还有，不是所有数据都可以排序或比较。例如，<code class="docutils literal notranslate"><span class="pre">[None,</span> <span class="pre">'hello',</span> <span class="pre">10]</span></code> 就不可排序，因为整数不能与字符串对比，而 <em>None</em> 不能与其他类型对比。有些类型根本就没有定义顺序关系，例如，<code class="docutils literal notranslate"><span class="pre">3+4j</span> <span class="pre"><</span> <span class="pre">5+7j</span></code> 这种对比操作就是无效的。</p>
|
||
<section id="using-lists-as-stacks">
|
||
<span id="tut-lists-as-stacks"></span><h3><span class="section-number">5.1.1. </span>用列表实现堆栈<a class="headerlink" href="#using-lists-as-stacks" title="永久链接至标题">¶</a></h3>
|
||
<p>使用列表方法实现堆栈非常容易，最后插入的最先取出（“后进先出”）。把元素添加到堆栈的顶端，使用 <code class="xref py py-meth docutils literal notranslate"><span class="pre">append()</span></code> 。从堆栈顶部取出元素，使用 <code class="xref py py-meth docutils literal notranslate"><span class="pre">pop()</span></code> ，不用指定索引。例如：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">stack</span> <span class="o">=</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">]</span>
|
||
<span class="gp">>>> </span><span class="n">stack</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="mi">6</span><span class="p">)</span>
|
||
<span class="gp">>>> </span><span class="n">stack</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="mi">7</span><span class="p">)</span>
|
||
<span class="gp">>>> </span><span class="n">stack</span>
|
||
<span class="go">[3, 4, 5, 6, 7]</span>
|
||
<span class="gp">>>> </span><span class="n">stack</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>
|
||
<span class="go">7</span>
|
||
<span class="gp">>>> </span><span class="n">stack</span>
|
||
<span class="go">[3, 4, 5, 6]</span>
|
||
<span class="gp">>>> </span><span class="n">stack</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>
|
||
<span class="go">6</span>
|
||
<span class="gp">>>> </span><span class="n">stack</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>
|
||
<span class="go">5</span>
|
||
<span class="gp">>>> </span><span class="n">stack</span>
|
||
<span class="go">[3, 4]</span>
|
||
</pre></div>
|
||
</div>
|
||
</section>
|
||
<section id="using-lists-as-queues">
|
||
<span id="tut-lists-as-queues"></span><h3><span class="section-number">5.1.2. </span>用列表实现队列<a class="headerlink" href="#using-lists-as-queues" title="永久链接至标题">¶</a></h3>
|
||
<p>列表也可以用作队列，最先加入的元素，最先取出（“先进先出”）；然而，列表作为队列的效率很低。因为，在列表末尾添加和删除元素非常快，但在列表开头插入或移除元素却很慢（因为所有其他元素都必须移动一位）。</p>
|
||
<p>实现队列最好用 <a class="reference internal" href="../library/collections.html#collections.deque" title="collections.deque"><code class="xref py py-class docutils literal notranslate"><span class="pre">collections.deque</span></code></a>，可以快速从两端添加或删除元素。例如：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">collections</span> <span class="kn">import</span> <span class="n">deque</span>
|
||
<span class="gp">>>> </span><span class="n">queue</span> <span class="o">=</span> <span class="n">deque</span><span class="p">([</span><span class="s2">"Eric"</span><span class="p">,</span> <span class="s2">"John"</span><span class="p">,</span> <span class="s2">"Michael"</span><span class="p">])</span>
|
||
<span class="gp">>>> </span><span class="n">queue</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="s2">"Terry"</span><span class="p">)</span> <span class="c1"># Terry arrives</span>
|
||
<span class="gp">>>> </span><span class="n">queue</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="s2">"Graham"</span><span class="p">)</span> <span class="c1"># Graham arrives</span>
|
||
<span class="gp">>>> </span><span class="n">queue</span><span class="o">.</span><span class="n">popleft</span><span class="p">()</span> <span class="c1"># The first to arrive now leaves</span>
|
||
<span class="go">'Eric'</span>
|
||
<span class="gp">>>> </span><span class="n">queue</span><span class="o">.</span><span class="n">popleft</span><span class="p">()</span> <span class="c1"># The second to arrive now leaves</span>
|
||
<span class="go">'John'</span>
|
||
<span class="gp">>>> </span><span class="n">queue</span> <span class="c1"># Remaining queue in order of arrival</span>
|
||
<span class="go">deque(['Michael', 'Terry', 'Graham'])</span>
|
||
</pre></div>
|
||
</div>
|
||
</section>
|
||
<section id="list-comprehensions">
|
||
<span id="tut-listcomps"></span><h3><span class="section-number">5.1.3. </span>列表推导式<a class="headerlink" href="#list-comprehensions" title="永久链接至标题">¶</a></h3>
|
||
<p>列表推导式创建列表的方式更简洁。常见的用法为，对序列或可迭代对象中的每个元素应用某种操作，用生成的结果创建新的列表；或用满足特定条件的元素创建子序列。</p>
|
||
<p>例如，创建平方值的列表：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">squares</span> <span class="o">=</span> <span class="p">[]</span>
|
||
<span class="gp">>>> </span><span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">):</span>
|
||
<span class="gp">... </span> <span class="n">squares</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">x</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span>
|
||
<span class="gp">...</span>
|
||
<span class="gp">>>> </span><span class="n">squares</span>
|
||
<span class="go">[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>注意，这段代码创建（或覆盖）变量 <code class="docutils literal notranslate"><span class="pre">x</span></code>，该变量在循环结束后仍然存在。下述方法可以无副作用地计算平方列表：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">squares</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">**</span><span class="mi">2</span><span class="p">,</span> <span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">)))</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>或等价于：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">squares</span> <span class="o">=</span> <span class="p">[</span><span class="n">x</span><span class="o">**</span><span class="mi">2</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">)]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>上面这种写法更简洁、易读。</p>
|
||
<p>列表推导式的方括号内包含以下内容：一个表达式，后面为一个 <code class="xref std std-keyword docutils literal notranslate"><span class="pre">for</span></code> 子句，然后，是零个或多个 <code class="xref std std-keyword docutils literal notranslate"><span class="pre">for</span></code> 或 <code class="xref std std-keyword docutils literal notranslate"><span class="pre">if</span></code> 子句。结果是由表达式依据 <code class="xref std std-keyword docutils literal notranslate"><span class="pre">for</span></code> 和 <code class="xref std std-keyword docutils literal notranslate"><span class="pre">if</span></code> 子句求值计算而得出一个新列表。 举例来说，以下列表推导式将两个列表中不相等的元素组合起来：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="p">[(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">]</span> <span class="k">for</span> <span class="n">y</span> <span class="ow">in</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">4</span><span class="p">]</span> <span class="k">if</span> <span class="n">x</span> <span class="o">!=</span> <span class="n">y</span><span class="p">]</span>
|
||
<span class="go">[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>等价于：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">combs</span> <span class="o">=</span> <span class="p">[]</span>
|
||
<span class="gp">>>> </span><span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">]:</span>
|
||
<span class="gp">... </span> <span class="k">for</span> <span class="n">y</span> <span class="ow">in</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">4</span><span class="p">]:</span>
|
||
<span class="gp">... </span> <span class="k">if</span> <span class="n">x</span> <span class="o">!=</span> <span class="n">y</span><span class="p">:</span>
|
||
<span class="gp">... </span> <span class="n">combs</span><span class="o">.</span><span class="n">append</span><span class="p">((</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">))</span>
|
||
<span class="gp">...</span>
|
||
<span class="gp">>>> </span><span class="n">combs</span>
|
||
<span class="go">[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>注意，上面两段代码中，<a class="reference internal" href="../reference/compound_stmts.html#for"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">for</span></code></a> 和 <a class="reference internal" href="../reference/compound_stmts.html#if"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">if</span></code></a> 的顺序相同。</p>
|
||
<p>表达式是元组（例如上例的 <code class="docutils literal notranslate"><span class="pre">(x,</span> <span class="pre">y)</span></code>）时，必须加上括号：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">vec</span> <span class="o">=</span> <span class="p">[</span><span class="o">-</span><span class="mi">4</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">4</span><span class="p">]</span>
|
||
<span class="gp">>>> </span><span class="c1"># create a new list with the values doubled</span>
|
||
<span class="gp">>>> </span><span class="p">[</span><span class="n">x</span><span class="o">*</span><span class="mi">2</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">vec</span><span class="p">]</span>
|
||
<span class="go">[-8, -4, 0, 4, 8]</span>
|
||
<span class="gp">>>> </span><span class="c1"># filter the list to exclude negative numbers</span>
|
||
<span class="gp">>>> </span><span class="p">[</span><span class="n">x</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">vec</span> <span class="k">if</span> <span class="n">x</span> <span class="o">>=</span> <span class="mi">0</span><span class="p">]</span>
|
||
<span class="go">[0, 2, 4]</span>
|
||
<span class="gp">>>> </span><span class="c1"># apply a function to all the elements</span>
|
||
<span class="gp">>>> </span><span class="p">[</span><span class="nb">abs</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">vec</span><span class="p">]</span>
|
||
<span class="go">[4, 2, 0, 2, 4]</span>
|
||
<span class="gp">>>> </span><span class="c1"># call a method on each element</span>
|
||
<span class="gp">>>> </span><span class="n">freshfruit</span> <span class="o">=</span> <span class="p">[</span><span class="s1">' banana'</span><span class="p">,</span> <span class="s1">' loganberry '</span><span class="p">,</span> <span class="s1">'passion fruit '</span><span class="p">]</span>
|
||
<span class="gp">>>> </span><span class="p">[</span><span class="n">weapon</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span> <span class="k">for</span> <span class="n">weapon</span> <span class="ow">in</span> <span class="n">freshfruit</span><span class="p">]</span>
|
||
<span class="go">['banana', 'loganberry', 'passion fruit']</span>
|
||
<span class="gp">>>> </span><span class="c1"># create a list of 2-tuples like (number, square)</span>
|
||
<span class="gp">>>> </span><span class="p">[(</span><span class="n">x</span><span class="p">,</span> <span class="n">x</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">6</span><span class="p">)]</span>
|
||
<span class="go">[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]</span>
|
||
<span class="gp">>>> </span><span class="c1"># the tuple must be parenthesized, otherwise an error is raised</span>
|
||
<span class="gp">>>> </span><span class="p">[</span><span class="n">x</span><span class="p">,</span> <span class="n">x</span><span class="o">**</span><span class="mi">2</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">6</span><span class="p">)]</span>
|
||
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>, in <span class="n"><module></span>
|
||
<span class="w"> </span><span class="p">[</span><span class="n">x</span><span class="p">,</span> <span class="n">x</span><span class="o">**</span><span class="mi">2</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">6</span><span class="p">)]</span>
|
||
<span class="w"> </span><span class="pm">^</span>
|
||
<span class="gr">SyntaxError</span>: <span class="n">invalid syntax</span>
|
||
<span class="gp">>>> </span><span class="c1"># flatten a list using a listcomp with two 'for'</span>
|
||
<span class="gp">>>> </span><span class="n">vec</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">],</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">],</span> <span class="p">[</span><span class="mi">7</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">9</span><span class="p">]]</span>
|
||
<span class="gp">>>> </span><span class="p">[</span><span class="n">num</span> <span class="k">for</span> <span class="n">elem</span> <span class="ow">in</span> <span class="n">vec</span> <span class="k">for</span> <span class="n">num</span> <span class="ow">in</span> <span class="n">elem</span><span class="p">]</span>
|
||
<span class="go">[1, 2, 3, 4, 5, 6, 7, 8, 9]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>列表推导式可以使用复杂的表达式和嵌套函数：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">math</span> <span class="kn">import</span> <span class="n">pi</span>
|
||
<span class="gp">>>> </span><span class="p">[</span><span class="nb">str</span><span class="p">(</span><span class="nb">round</span><span class="p">(</span><span class="n">pi</span><span class="p">,</span> <span class="n">i</span><span class="p">))</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">6</span><span class="p">)]</span>
|
||
<span class="go">['3.1', '3.14', '3.142', '3.1416', '3.14159']</span>
|
||
</pre></div>
|
||
</div>
|
||
</section>
|
||
<section id="nested-list-comprehensions">
|
||
<h3><span class="section-number">5.1.4. </span>嵌套的列表推导式<a class="headerlink" href="#nested-list-comprehensions" title="永久链接至标题">¶</a></h3>
|
||
<p>列表推导式中的初始表达式可以是任何表达式，甚至可以是另一个列表推导式。</p>
|
||
<p>下面这个 3x4 矩阵，由 3 个长度为 4 的列表组成：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">matrix</span> <span class="o">=</span> <span class="p">[</span>
|
||
<span class="gp">... </span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">],</span>
|
||
<span class="gp">... </span> <span class="p">[</span><span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="p">],</span>
|
||
<span class="gp">... </span> <span class="p">[</span><span class="mi">9</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">11</span><span class="p">,</span> <span class="mi">12</span><span class="p">],</span>
|
||
<span class="gp">... </span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>下面的列表推导式可以转置行列：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="p">[[</span><span class="n">row</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="k">for</span> <span class="n">row</span> <span class="ow">in</span> <span class="n">matrix</span><span class="p">]</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">4</span><span class="p">)]</span>
|
||
<span class="go">[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>如上节所示，嵌套的列表推导式基于其后的 <a class="reference internal" href="../reference/compound_stmts.html#for"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">for</span></code></a> 求值，所以这个例子等价于：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">transposed</span> <span class="o">=</span> <span class="p">[]</span>
|
||
<span class="gp">>>> </span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">4</span><span class="p">):</span>
|
||
<span class="gp">... </span> <span class="n">transposed</span><span class="o">.</span><span class="n">append</span><span class="p">([</span><span class="n">row</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="k">for</span> <span class="n">row</span> <span class="ow">in</span> <span class="n">matrix</span><span class="p">])</span>
|
||
<span class="gp">...</span>
|
||
<span class="gp">>>> </span><span class="n">transposed</span>
|
||
<span class="go">[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>反过来说，也等价于：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">transposed</span> <span class="o">=</span> <span class="p">[]</span>
|
||
<span class="gp">>>> </span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">4</span><span class="p">):</span>
|
||
<span class="gp">... </span> <span class="c1"># the following 3 lines implement the nested listcomp</span>
|
||
<span class="gp">... </span> <span class="n">transposed_row</span> <span class="o">=</span> <span class="p">[]</span>
|
||
<span class="gp">... </span> <span class="k">for</span> <span class="n">row</span> <span class="ow">in</span> <span class="n">matrix</span><span class="p">:</span>
|
||
<span class="gp">... </span> <span class="n">transposed_row</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">row</span><span class="p">[</span><span class="n">i</span><span class="p">])</span>
|
||
<span class="gp">... </span> <span class="n">transposed</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">transposed_row</span><span class="p">)</span>
|
||
<span class="gp">...</span>
|
||
<span class="gp">>>> </span><span class="n">transposed</span>
|
||
<span class="go">[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>实际应用中，最好用内置函数替代复杂的流程语句。此时，<a class="reference internal" href="../library/functions.html#zip" title="zip"><code class="xref py py-func docutils literal notranslate"><span class="pre">zip()</span></code></a> 函数更好用：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="nb">zip</span><span class="p">(</span><span class="o">*</span><span class="n">matrix</span><span class="p">))</span>
|
||
<span class="go">[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>关于本行中星号的详细说明，参见 <a class="reference internal" href="controlflow.html#tut-unpacking-arguments"><span class="std std-ref">解包实参列表</span></a>。</p>
|
||
</section>
|
||
</section>
|
||
<section id="the-del-statement">
|
||
<span id="tut-del"></span><h2><span class="section-number">5.2. </span><code class="xref std std-keyword docutils literal notranslate"><span class="pre">del</span></code> 语句<a class="headerlink" href="#the-del-statement" title="永久链接至标题">¶</a></h2>
|
||
<p><a class="reference internal" href="../reference/simple_stmts.html#del"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">del</span></code></a> 语句按索引，而不是值从列表中移除元素。与返回值的 <code class="xref py py-meth docutils literal notranslate"><span class="pre">pop()</span></code> 方法不同， <code class="xref std std-keyword docutils literal notranslate"><span class="pre">del</span></code> 语句也可以从列表中移除切片，或清空整个列表（之前是将空列表赋值给切片）。 例如：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">a</span> <span class="o">=</span> <span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mf">66.25</span><span class="p">,</span> <span class="mi">333</span><span class="p">,</span> <span class="mi">333</span><span class="p">,</span> <span class="mf">1234.5</span><span class="p">]</span>
|
||
<span class="gp">>>> </span><span class="k">del</span> <span class="n">a</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
|
||
<span class="gp">>>> </span><span class="n">a</span>
|
||
<span class="go">[1, 66.25, 333, 333, 1234.5]</span>
|
||
<span class="gp">>>> </span><span class="k">del</span> <span class="n">a</span><span class="p">[</span><span class="mi">2</span><span class="p">:</span><span class="mi">4</span><span class="p">]</span>
|
||
<span class="gp">>>> </span><span class="n">a</span>
|
||
<span class="go">[1, 66.25, 1234.5]</span>
|
||
<span class="gp">>>> </span><span class="k">del</span> <span class="n">a</span><span class="p">[:]</span>
|
||
<span class="gp">>>> </span><span class="n">a</span>
|
||
<span class="go">[]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p><a class="reference internal" href="../reference/simple_stmts.html#del"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">del</span></code></a> 也可以用来删除整个变量：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">del</span> <span class="n">a</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>此后，再引用 <code class="docutils literal notranslate"><span class="pre">a</span></code> 就会报错（直到为它赋与另一个值）。后文会介绍 <a class="reference internal" href="../reference/simple_stmts.html#del"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">del</span></code></a> 的其他用法。</p>
|
||
</section>
|
||
<section id="tuples-and-sequences">
|
||
<span id="tut-tuples"></span><h2><span class="section-number">5.3. </span>元组和序列<a class="headerlink" href="#tuples-and-sequences" title="永久链接至标题">¶</a></h2>
|
||
<p>列表和字符串有很多共性，例如，索引和切片操作。这两种数据类型是 <em>序列</em> （参见 <a class="reference internal" href="../library/stdtypes.html#typesseq"><span class="std std-ref">序列类型 --- list, tuple, range</span></a>）。随着 Python 语言的发展，其他的序列类型也被加入其中。本节介绍另一种标准序列类型：<em>元组</em>。</p>
|
||
<p>元组由多个用逗号隔开的值组成，例如：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">t</span> <span class="o">=</span> <span class="mi">12345</span><span class="p">,</span> <span class="mi">54321</span><span class="p">,</span> <span class="s1">'hello!'</span>
|
||
<span class="gp">>>> </span><span class="n">t</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
|
||
<span class="go">12345</span>
|
||
<span class="gp">>>> </span><span class="n">t</span>
|
||
<span class="go">(12345, 54321, 'hello!')</span>
|
||
<span class="gp">>>> </span><span class="c1"># Tuples may be nested:</span>
|
||
<span class="gp">... </span><span class="n">u</span> <span class="o">=</span> <span class="n">t</span><span class="p">,</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
|
||
<span class="gp">>>> </span><span class="n">u</span>
|
||
<span class="go">((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))</span>
|
||
<span class="gp">>>> </span><span class="c1"># Tuples are immutable:</span>
|
||
<span class="gp">... </span><span class="n">t</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="mi">88888</span>
|
||
<span class="gt">Traceback (most recent call last):</span>
|
||
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>, in <span class="n"><module></span>
|
||
<span class="gr">TypeError</span>: <span class="n">'tuple' object does not support item assignment</span>
|
||
<span class="gp">>>> </span><span class="c1"># but they can contain mutable objects:</span>
|
||
<span class="gp">... </span><span class="n">v</span> <span class="o">=</span> <span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">],</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">])</span>
|
||
<span class="gp">>>> </span><span class="n">v</span>
|
||
<span class="go">([1, 2, 3], [3, 2, 1])</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>输出时，元组都要由圆括号标注，这样才能正确地解释嵌套元组。输入时，圆括号可有可无，不过经常是必须的（如果元组是更大的表达式的一部分）。不允许为元组中的单个元素赋值，当然，可以创建含列表等可变对象的元组。</p>
|
||
<p>虽然，元组与列表很像，但使用场景不同，用途也不同。元组是 <a class="reference internal" href="../glossary.html#term-immutable"><span class="xref std std-term">immutable</span></a> （不可变的），一般可包含异质元素序列，通过解包（见本节下文）或索引访问（如果是 <a class="reference internal" href="../library/collections.html#collections.namedtuple" title="collections.namedtuple"><code class="xref py py-func docutils literal notranslate"><span class="pre">namedtuples</span></code></a>，可以属性访问）。列表是 <a class="reference internal" href="../glossary.html#term-mutable"><span class="xref std std-term">mutable</span></a> （可变的），列表元素一般为同质类型，可迭代访问。</p>
|
||
<p>构造 0 个或 1 个元素的元组比较特殊：为了适应这种情况，对句法有一些额外的改变。用一对空圆括号就可以创建空元组；只有一个元素的元组可以通过在这个元素后添加逗号来构建（圆括号里只有一个值的话不够明确）。丑陋，但是有效。例如：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">empty</span> <span class="o">=</span> <span class="p">()</span>
|
||
<span class="gp">>>> </span><span class="n">singleton</span> <span class="o">=</span> <span class="s1">'hello'</span><span class="p">,</span> <span class="c1"># <-- note trailing comma</span>
|
||
<span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="n">empty</span><span class="p">)</span>
|
||
<span class="go">0</span>
|
||
<span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="n">singleton</span><span class="p">)</span>
|
||
<span class="go">1</span>
|
||
<span class="gp">>>> </span><span class="n">singleton</span>
|
||
<span class="go">('hello',)</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>语句 <code class="docutils literal notranslate"><span class="pre">t</span> <span class="pre">=</span> <span class="pre">12345,</span> <span class="pre">54321,</span> <span class="pre">'hello!'</span></code> 是 <em>元组打包</em> 的例子：值 <code class="docutils literal notranslate"><span class="pre">12345</span></code>, <code class="docutils literal notranslate"><span class="pre">54321</span></code> 和 <code class="docutils literal notranslate"><span class="pre">'hello!'</span></code> 一起被打包进元组。逆操作也可以：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">z</span> <span class="o">=</span> <span class="n">t</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>称之为 <em>序列解包</em> 也是妥妥的，适用于右侧的任何序列。序列解包时，左侧变量与右侧序列元素的数量应相等。注意，多重赋值其实只是元组打包和序列解包的组合。</p>
|
||
</section>
|
||
<section id="sets">
|
||
<span id="tut-sets"></span><h2><span class="section-number">5.4. </span>集合<a class="headerlink" href="#sets" title="永久链接至标题">¶</a></h2>
|
||
<p>Python 还支持 <em>集合</em> 这种数据类型。集合是由不重复元素组成的无序容器。基本用法包括成员检测、消除重复元素。集合对象支持合集、交集、差集、对称差分等数学运算。</p>
|
||
<p>创建集合用花括号或 <a class="reference internal" href="../library/stdtypes.html#set" title="set"><code class="xref py py-func docutils literal notranslate"><span class="pre">set()</span></code></a> 函数。注意，创建空集合只能用 <code class="docutils literal notranslate"><span class="pre">set()</span></code>，不能用 <code class="docutils literal notranslate"><span class="pre">{}</span></code>，<code class="docutils literal notranslate"><span class="pre">{}</span></code> 创建的是空字典，下一小节介绍数据结构：字典。</p>
|
||
<p>以下是一些简单的示例</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">basket</span> <span class="o">=</span> <span class="p">{</span><span class="s1">'apple'</span><span class="p">,</span> <span class="s1">'orange'</span><span class="p">,</span> <span class="s1">'apple'</span><span class="p">,</span> <span class="s1">'pear'</span><span class="p">,</span> <span class="s1">'orange'</span><span class="p">,</span> <span class="s1">'banana'</span><span class="p">}</span>
|
||
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">basket</span><span class="p">)</span> <span class="c1"># show that duplicates have been removed</span>
|
||
<span class="go">{'orange', 'banana', 'pear', 'apple'}</span>
|
||
<span class="gp">>>> </span><span class="s1">'orange'</span> <span class="ow">in</span> <span class="n">basket</span> <span class="c1"># fast membership testing</span>
|
||
<span class="go">True</span>
|
||
<span class="gp">>>> </span><span class="s1">'crabgrass'</span> <span class="ow">in</span> <span class="n">basket</span>
|
||
<span class="go">False</span>
|
||
|
||
<span class="gp">>>> </span><span class="c1"># Demonstrate set operations on unique letters from two words</span>
|
||
<span class="gp">...</span>
|
||
<span class="gp">>>> </span><span class="n">a</span> <span class="o">=</span> <span class="nb">set</span><span class="p">(</span><span class="s1">'abracadabra'</span><span class="p">)</span>
|
||
<span class="gp">>>> </span><span class="n">b</span> <span class="o">=</span> <span class="nb">set</span><span class="p">(</span><span class="s1">'alacazam'</span><span class="p">)</span>
|
||
<span class="gp">>>> </span><span class="n">a</span> <span class="c1"># unique letters in a</span>
|
||
<span class="go">{'a', 'r', 'b', 'c', 'd'}</span>
|
||
<span class="gp">>>> </span><span class="n">a</span> <span class="o">-</span> <span class="n">b</span> <span class="c1"># letters in a but not in b</span>
|
||
<span class="go">{'r', 'd', 'b'}</span>
|
||
<span class="gp">>>> </span><span class="n">a</span> <span class="o">|</span> <span class="n">b</span> <span class="c1"># letters in a or b or both</span>
|
||
<span class="go">{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}</span>
|
||
<span class="gp">>>> </span><span class="n">a</span> <span class="o">&</span> <span class="n">b</span> <span class="c1"># letters in both a and b</span>
|
||
<span class="go">{'a', 'c'}</span>
|
||
<span class="gp">>>> </span><span class="n">a</span> <span class="o">^</span> <span class="n">b</span> <span class="c1"># letters in a or b but not both</span>
|
||
<span class="go">{'r', 'd', 'b', 'm', 'z', 'l'}</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>与 <a class="reference internal" href="#tut-listcomps"><span class="std std-ref">列表推导式</span></a> 类似，集合也支持推导式：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">a</span> <span class="o">=</span> <span class="p">{</span><span class="n">x</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="s1">'abracadabra'</span> <span class="k">if</span> <span class="n">x</span> <span class="ow">not</span> <span class="ow">in</span> <span class="s1">'abc'</span><span class="p">}</span>
|
||
<span class="gp">>>> </span><span class="n">a</span>
|
||
<span class="go">{'r', 'd'}</span>
|
||
</pre></div>
|
||
</div>
|
||
</section>
|
||
<section id="dictionaries">
|
||
<span id="tut-dictionaries"></span><h2><span class="section-number">5.5. </span>字典<a class="headerlink" href="#dictionaries" title="永久链接至标题">¶</a></h2>
|
||
<p><em>字典</em> （参见 <a class="reference internal" href="../library/stdtypes.html#typesmapping"><span class="std std-ref">映射类型 --- dict</span></a>） 也是一种常用的 Python 內置数据类型。其他语言可能把字典称为 <em>联合内存</em> 或 <em>联合数组</em>。与以连续整数为索引的序列不同，字典以 <em>关键字</em> 为索引，关键字通常是字符串或数字，也可以是其他任意不可变类型。只包含字符串、数字、元组的元组，也可以用作关键字。但如果元组直接或间接地包含了可变对象，就不能用作关键字。列表不能当关键字，因为列表可以用索引、切片、<code class="xref py py-meth docutils literal notranslate"><span class="pre">append()</span></code> 、<code class="xref py py-meth docutils literal notranslate"><span class="pre">extend()</span></code> 等方法修改。</p>
|
||
<p>可以把字典理解为 <em>键值对</em> 的集合，但字典的键必须是唯一的。花括号 <code class="docutils literal notranslate"><span class="pre">{}</span></code> 用于创建空字典。另一种初始化字典的方式是，在花括号里输入逗号分隔的键值对，这也是字典的输出方式。</p>
|
||
<p>字典的主要用途是通过关键字存储、提取值。用 <code class="docutils literal notranslate"><span class="pre">del</span></code> 可以删除键值对。用已存在的关键字存储值，与该关键字关联的旧值会被取代。通过不存在的键提取值，则会报错。</p>
|
||
<p>对字典执行 <code class="docutils literal notranslate"><span class="pre">list(d)</span></code> 操作，返回该字典中所有键的列表，按插入次序排列（如需排序，请使用 <code class="docutils literal notranslate"><span class="pre">sorted(d)</span></code>）。检查字典里是否存在某个键，使用关键字 <a class="reference internal" href="../reference/expressions.html#in"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">in</span></code></a>。</p>
|
||
<p>以下是一些字典的简单示例：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">tel</span> <span class="o">=</span> <span class="p">{</span><span class="s1">'jack'</span><span class="p">:</span> <span class="mi">4098</span><span class="p">,</span> <span class="s1">'sape'</span><span class="p">:</span> <span class="mi">4139</span><span class="p">}</span>
|
||
<span class="gp">>>> </span><span class="n">tel</span><span class="p">[</span><span class="s1">'guido'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">4127</span>
|
||
<span class="gp">>>> </span><span class="n">tel</span>
|
||
<span class="go">{'jack': 4098, 'sape': 4139, 'guido': 4127}</span>
|
||
<span class="gp">>>> </span><span class="n">tel</span><span class="p">[</span><span class="s1">'jack'</span><span class="p">]</span>
|
||
<span class="go">4098</span>
|
||
<span class="gp">>>> </span><span class="k">del</span> <span class="n">tel</span><span class="p">[</span><span class="s1">'sape'</span><span class="p">]</span>
|
||
<span class="gp">>>> </span><span class="n">tel</span><span class="p">[</span><span class="s1">'irv'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">4127</span>
|
||
<span class="gp">>>> </span><span class="n">tel</span>
|
||
<span class="go">{'jack': 4098, 'guido': 4127, 'irv': 4127}</span>
|
||
<span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="n">tel</span><span class="p">)</span>
|
||
<span class="go">['jack', 'guido', 'irv']</span>
|
||
<span class="gp">>>> </span><span class="nb">sorted</span><span class="p">(</span><span class="n">tel</span><span class="p">)</span>
|
||
<span class="go">['guido', 'irv', 'jack']</span>
|
||
<span class="gp">>>> </span><span class="s1">'guido'</span> <span class="ow">in</span> <span class="n">tel</span>
|
||
<span class="go">True</span>
|
||
<span class="gp">>>> </span><span class="s1">'jack'</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">tel</span>
|
||
<span class="go">False</span>
|
||
</pre></div>
|
||
</div>
|
||
<p><a class="reference internal" href="../library/stdtypes.html#dict" title="dict"><code class="xref py py-func docutils literal notranslate"><span class="pre">dict()</span></code></a> 构造函数可以直接用键值对序列创建字典：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">dict</span><span class="p">([(</span><span class="s1">'sape'</span><span class="p">,</span> <span class="mi">4139</span><span class="p">),</span> <span class="p">(</span><span class="s1">'guido'</span><span class="p">,</span> <span class="mi">4127</span><span class="p">),</span> <span class="p">(</span><span class="s1">'jack'</span><span class="p">,</span> <span class="mi">4098</span><span class="p">)])</span>
|
||
<span class="go">{'sape': 4139, 'guido': 4127, 'jack': 4098}</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>字典推导式可以用任意键值表达式创建字典：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="p">{</span><span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="o">**</span><span class="mi">2</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">6</span><span class="p">)}</span>
|
||
<span class="go">{2: 4, 4: 16, 6: 36}</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>关键字是比较简单的字符串时，直接用关键字参数指定键值对更便捷：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">dict</span><span class="p">(</span><span class="n">sape</span><span class="o">=</span><span class="mi">4139</span><span class="p">,</span> <span class="n">guido</span><span class="o">=</span><span class="mi">4127</span><span class="p">,</span> <span class="n">jack</span><span class="o">=</span><span class="mi">4098</span><span class="p">)</span>
|
||
<span class="go">{'sape': 4139, 'guido': 4127, 'jack': 4098}</span>
|
||
</pre></div>
|
||
</div>
|
||
</section>
|
||
<section id="looping-techniques">
|
||
<span id="tut-loopidioms"></span><h2><span class="section-number">5.6. </span>循环的技巧<a class="headerlink" href="#looping-techniques" title="永久链接至标题">¶</a></h2>
|
||
<p>在字典中循环时，用 <code class="xref py py-meth docutils literal notranslate"><span class="pre">items()</span></code> 方法可同时取出键和对应的值：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">knights</span> <span class="o">=</span> <span class="p">{</span><span class="s1">'gallahad'</span><span class="p">:</span> <span class="s1">'the pure'</span><span class="p">,</span> <span class="s1">'robin'</span><span class="p">:</span> <span class="s1">'the brave'</span><span class="p">}</span>
|
||
<span class="gp">>>> </span><span class="k">for</span> <span class="n">k</span><span class="p">,</span> <span class="n">v</span> <span class="ow">in</span> <span class="n">knights</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
|
||
<span class="gp">... </span> <span class="nb">print</span><span class="p">(</span><span class="n">k</span><span class="p">,</span> <span class="n">v</span><span class="p">)</span>
|
||
<span class="gp">...</span>
|
||
<span class="go">gallahad the pure</span>
|
||
<span class="go">robin the brave</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>在序列中循环时，用 <a class="reference internal" href="../library/functions.html#enumerate" title="enumerate"><code class="xref py py-func docutils literal notranslate"><span class="pre">enumerate()</span></code></a> 函数可以同时取出位置索引和对应的值：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">for</span> <span class="n">i</span><span class="p">,</span> <span class="n">v</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">([</span><span class="s1">'tic'</span><span class="p">,</span> <span class="s1">'tac'</span><span class="p">,</span> <span class="s1">'toe'</span><span class="p">]):</span>
|
||
<span class="gp">... </span> <span class="nb">print</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">v</span><span class="p">)</span>
|
||
<span class="gp">...</span>
|
||
<span class="go">0 tic</span>
|
||
<span class="go">1 tac</span>
|
||
<span class="go">2 toe</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>同时循环两个或多个序列时，用 <a class="reference internal" href="../library/functions.html#zip" title="zip"><code class="xref py py-func docutils literal notranslate"><span class="pre">zip()</span></code></a> 函数可以将其内的元素一一匹配：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">questions</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'name'</span><span class="p">,</span> <span class="s1">'quest'</span><span class="p">,</span> <span class="s1">'favorite color'</span><span class="p">]</span>
|
||
<span class="gp">>>> </span><span class="n">answers</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'lancelot'</span><span class="p">,</span> <span class="s1">'the holy grail'</span><span class="p">,</span> <span class="s1">'blue'</span><span class="p">]</span>
|
||
<span class="gp">>>> </span><span class="k">for</span> <span class="n">q</span><span class="p">,</span> <span class="n">a</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">questions</span><span class="p">,</span> <span class="n">answers</span><span class="p">):</span>
|
||
<span class="gp">... </span> <span class="nb">print</span><span class="p">(</span><span class="s1">'What is your </span><span class="si">{0}</span><span class="s1">? It is </span><span class="si">{1}</span><span class="s1">.'</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">q</span><span class="p">,</span> <span class="n">a</span><span class="p">))</span>
|
||
<span class="gp">...</span>
|
||
<span class="go">What is your name? It is lancelot.</span>
|
||
<span class="go">What is your quest? It is the holy grail.</span>
|
||
<span class="go">What is your favorite color? It is blue.</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>为了逆向对序列进行循环，可以求出欲循环的正向序列，然后调用 <a class="reference internal" href="../library/functions.html#reversed" title="reversed"><code class="xref py py-func docutils literal notranslate"><span class="pre">reversed()</span></code></a> 函数：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">reversed</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">2</span><span class="p">)):</span>
|
||
<span class="gp">... </span> <span class="nb">print</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
|
||
<span class="gp">...</span>
|
||
<span class="go">9</span>
|
||
<span class="go">7</span>
|
||
<span class="go">5</span>
|
||
<span class="go">3</span>
|
||
<span class="go">1</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>按指定顺序循环序列，可以用 <a class="reference internal" href="../library/functions.html#sorted" title="sorted"><code class="xref py py-func docutils literal notranslate"><span class="pre">sorted()</span></code></a> 函数，在不改动原序列的基础上，返回一个重新的序列：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">basket</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'apple'</span><span class="p">,</span> <span class="s1">'orange'</span><span class="p">,</span> <span class="s1">'apple'</span><span class="p">,</span> <span class="s1">'pear'</span><span class="p">,</span> <span class="s1">'orange'</span><span class="p">,</span> <span class="s1">'banana'</span><span class="p">]</span>
|
||
<span class="gp">>>> </span><span class="k">for</span> <span class="n">f</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="nb">set</span><span class="p">(</span><span class="n">basket</span><span class="p">)):</span>
|
||
<span class="gp">... </span> <span class="nb">print</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
|
||
<span class="gp">...</span>
|
||
<span class="go">apple</span>
|
||
<span class="go">banana</span>
|
||
<span class="go">orange</span>
|
||
<span class="go">pear</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>一般来说，在循环中修改列表的内容时，创建新列表比较简单，且安全：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">import</span> <span class="nn">math</span>
|
||
<span class="gp">>>> </span><span class="n">raw_data</span> <span class="o">=</span> <span class="p">[</span><span class="mf">56.2</span><span class="p">,</span> <span class="nb">float</span><span class="p">(</span><span class="s1">'NaN'</span><span class="p">),</span> <span class="mf">51.7</span><span class="p">,</span> <span class="mf">55.3</span><span class="p">,</span> <span class="mf">52.5</span><span class="p">,</span> <span class="nb">float</span><span class="p">(</span><span class="s1">'NaN'</span><span class="p">),</span> <span class="mf">47.8</span><span class="p">]</span>
|
||
<span class="gp">>>> </span><span class="n">filtered_data</span> <span class="o">=</span> <span class="p">[]</span>
|
||
<span class="gp">>>> </span><span class="k">for</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">raw_data</span><span class="p">:</span>
|
||
<span class="gp">... </span> <span class="k">if</span> <span class="ow">not</span> <span class="n">math</span><span class="o">.</span><span class="n">isnan</span><span class="p">(</span><span class="n">value</span><span class="p">):</span>
|
||
<span class="gp">... </span> <span class="n">filtered_data</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
|
||
<span class="gp">...</span>
|
||
<span class="gp">>>> </span><span class="n">filtered_data</span>
|
||
<span class="go">[56.2, 51.7, 55.3, 52.5, 47.8]</span>
|
||
</pre></div>
|
||
</div>
|
||
</section>
|
||
<section id="more-on-conditions">
|
||
<span id="tut-conditions"></span><h2><span class="section-number">5.7. </span>深入条件控制<a class="headerlink" href="#more-on-conditions" title="永久链接至标题">¶</a></h2>
|
||
<p><code class="docutils literal notranslate"><span class="pre">while</span></code> 和 <code class="docutils literal notranslate"><span class="pre">if</span></code> 条件句不只可以进行比较，还可以使用任意运算符。</p>
|
||
<p>比较操作符 <code class="docutils literal notranslate"><span class="pre">in</span></code> 和 <code class="docutils literal notranslate"><span class="pre">not</span> <span class="pre">in</span></code> 校验一个值是否在（或不在）一个序列里。操作符 <code class="docutils literal notranslate"><span class="pre">is</span></code> 和 <code class="docutils literal notranslate"><span class="pre">is</span> <span class="pre">not</span></code> 比较两个对象是不是同一个对象，这只对像列表这样的可变对象比较重要。所有的比较操作符都有相同的优先级，且这个优先级比数值运算符低。</p>
|
||
<p>比较操作支持链式操作。例如，<code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre"><</span> <span class="pre">b</span> <span class="pre">==</span> <span class="pre">c</span></code> 校验 <code class="docutils literal notranslate"><span class="pre">a</span></code> 是否小于 <code class="docutils literal notranslate"><span class="pre">b</span></code>，且 <code class="docutils literal notranslate"><span class="pre">b</span></code> 是否等于 <code class="docutils literal notranslate"><span class="pre">c</span></code>。</p>
|
||
<p>比较操作可以用布尔运算符 <code class="docutils literal notranslate"><span class="pre">and</span></code> 和 <code class="docutils literal notranslate"><span class="pre">or</span></code> 组合，并且，比较操作（或其他布尔运算）的结果都可以用 <code class="docutils literal notranslate"><span class="pre">not</span></code> 取反。这些操作符的优先级低于比较操作符；<code class="docutils literal notranslate"><span class="pre">not</span></code> 的优先级最高， <code class="docutils literal notranslate"><span class="pre">or</span></code> 的优先级最低，因此，<code class="docutils literal notranslate"><span class="pre">A</span> <span class="pre">and</span> <span class="pre">not</span> <span class="pre">B</span> <span class="pre">or</span> <span class="pre">C</span></code> 等价于 <code class="docutils literal notranslate"><span class="pre">(A</span> <span class="pre">and</span> <span class="pre">(not</span> <span class="pre">B))</span> <span class="pre">or</span> <span class="pre">C</span></code>。与其他运算符操作一样，此处也可以用圆括号表示想要的组合。</p>
|
||
<p>布尔运算符 <code class="docutils literal notranslate"><span class="pre">and</span></code> 和 <code class="docutils literal notranslate"><span class="pre">or</span></code> 是所谓的 <em>短路</em> 运算符：其参数从左至右求值，一旦可以确定结果，求值就会停止。例如，如果 <code class="docutils literal notranslate"><span class="pre">A</span></code> 和 <code class="docutils literal notranslate"><span class="pre">C</span></code> 为真，<code class="docutils literal notranslate"><span class="pre">B</span></code> 为假，那么 <code class="docutils literal notranslate"><span class="pre">A</span> <span class="pre">and</span> <span class="pre">B</span> <span class="pre">and</span> <span class="pre">C</span></code> 不会对 <code class="docutils literal notranslate"><span class="pre">C</span></code> 求值。用作普通值而不是布尔值时，短路运算符的返回值通常是最后一个求了值的参数。</p>
|
||
<p>还可以把比较运算或其它布尔表达式的结果赋值给变量，例如：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">string1</span><span class="p">,</span> <span class="n">string2</span><span class="p">,</span> <span class="n">string3</span> <span class="o">=</span> <span class="s1">''</span><span class="p">,</span> <span class="s1">'Trondheim'</span><span class="p">,</span> <span class="s1">'Hammer Dance'</span>
|
||
<span class="gp">>>> </span><span class="n">non_null</span> <span class="o">=</span> <span class="n">string1</span> <span class="ow">or</span> <span class="n">string2</span> <span class="ow">or</span> <span class="n">string3</span>
|
||
<span class="gp">>>> </span><span class="n">non_null</span>
|
||
<span class="go">'Trondheim'</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>注意，Python 与 C 不同，在表达式内部赋值必须显式使用 <a class="reference internal" href="../faq/design.html#why-can-t-i-use-an-assignment-in-an-expression"><span class="std std-ref">海象运算符</span></a> <code class="docutils literal notranslate"><span class="pre">:=</span></code>。 这避免了 C 程序中常见的问题：要在表达式中写 <code class="docutils literal notranslate"><span class="pre">==</span></code> 时，却写成了 <code class="docutils literal notranslate"><span class="pre">=</span></code>。</p>
|
||
</section>
|
||
<section id="comparing-sequences-and-other-types">
|
||
<span id="tut-comparing"></span><h2><span class="section-number">5.8. </span>序列和其他类型的比较<a class="headerlink" href="#comparing-sequences-and-other-types" title="永久链接至标题">¶</a></h2>
|
||
<p>序列对象可以与相同序列类型的其他对象比较。这种比较使用 <em>字典式</em> 顺序：首先，比较前两个对应元素，如果不相等，则可确定比较结果；如果相等，则比较之后的两个元素，以此类推，直到其中一个序列结束。如果要比较的两个元素本身是相同类型的序列，则递归地执行字典式顺序比较。如果两个序列中所有的对应元素都相等，则两个序列相等。如果一个序列是另一个的初始子序列，则较短的序列可被视为较小（较少）的序列。 对于字符串来说，字典式顺序使用 Unicode 码位序号排序单个字符。下面列出了一些比较相同类型序列的例子：</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span> <span class="o"><</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
|
||
<span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span> <span class="o"><</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">4</span><span class="p">]</span>
|
||
<span class="s1">'ABC'</span> <span class="o"><</span> <span class="s1">'C'</span> <span class="o"><</span> <span class="s1">'Pascal'</span> <span class="o"><</span> <span class="s1">'Python'</span>
|
||
<span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span> <span class="o"><</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span> <span class="o"><</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span> <span class="o">==</span> <span class="p">(</span><span class="mf">1.0</span><span class="p">,</span> <span class="mf">2.0</span><span class="p">,</span> <span class="mf">3.0</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="p">(</span><span class="s1">'aa'</span><span class="p">,</span> <span class="s1">'ab'</span><span class="p">))</span> <span class="o"><</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="p">(</span><span class="s1">'abc'</span><span class="p">,</span> <span class="s1">'a'</span><span class="p">),</span> <span class="mi">4</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>注意，当比较不同类型的对象时，只要待比较的对象提供了合适的比较方法，就可以使用 <code class="docutils literal notranslate"><span class="pre"><</span></code> 和 <code class="docutils literal notranslate"><span class="pre">></span></code> 进行比较。例如，混合的数字类型通过数字值进行比较，所以，0 等于 0.0，等等。如果没有提供合适的比较方法，解释器不会随便给出一个比较结果，而是引发 <a class="reference internal" href="../library/exceptions.html#TypeError" title="TypeError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">TypeError</span></code></a> 异常。</p>
|
||
<p class="rubric">备注</p>
|
||
<dl class="footnote brackets">
|
||
<dt class="label" id="id2"><span class="brackets"><a class="fn-backref" href="#id1">1</a></span></dt>
|
||
<dd><p>别的语言可能会将可变对象返回，允许方法连续执行，例如 <code class="docutils literal notranslate"><span class="pre">d->insert("a")->remove("b")->sort();</span></code>。</p>
|
||
</dd>
|
||
</dl>
|
||
</section>
|
||
</section>
|
||
|
||
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
|
||
<div class="sphinxsidebarwrapper">
|
||
<h3><a href="../contents.html">目录</a></h3>
|
||
<ul>
|
||
<li><a class="reference internal" href="#">5. 数据结构</a><ul>
|
||
<li><a class="reference internal" href="#more-on-lists">5.1. 列表详解</a><ul>
|
||
<li><a class="reference internal" href="#using-lists-as-stacks">5.1.1. 用列表实现堆栈</a></li>
|
||
<li><a class="reference internal" href="#using-lists-as-queues">5.1.2. 用列表实现队列</a></li>
|
||
<li><a class="reference internal" href="#list-comprehensions">5.1.3. 列表推导式</a></li>
|
||
<li><a class="reference internal" href="#nested-list-comprehensions">5.1.4. 嵌套的列表推导式</a></li>
|
||
</ul>
|
||
</li>
|
||
<li><a class="reference internal" href="#the-del-statement">5.2. <code class="xref std std-keyword docutils literal notranslate"><span class="pre">del</span></code> 语句</a></li>
|
||
<li><a class="reference internal" href="#tuples-and-sequences">5.3. 元组和序列</a></li>
|
||
<li><a class="reference internal" href="#sets">5.4. 集合</a></li>
|
||
<li><a class="reference internal" href="#dictionaries">5.5. 字典</a></li>
|
||
<li><a class="reference internal" href="#looping-techniques">5.6. 循环的技巧</a></li>
|
||
<li><a class="reference internal" href="#more-on-conditions">5.7. 深入条件控制</a></li>
|
||
<li><a class="reference internal" href="#comparing-sequences-and-other-types">5.8. 序列和其他类型的比较</a></li>
|
||
</ul>
|
||
</li>
|
||
</ul>
|
||
|
||
<h4>上一个主题</h4>
|
||
<p class="topless"><a href="controlflow.html"
|
||
title="上一章"><span class="section-number">4. </span>更多控制流工具</a></p>
|
||
<h4>下一个主题</h4>
|
||
<p class="topless"><a href="modules.html"
|
||
title="下一章"><span class="section-number">6. </span>模块</a></p>
|
||
<div role="note" aria-label="source link">
|
||
<h3>本页</h3>
|
||
<ul class="this-page-menu">
|
||
<li><a href="../bugs.html">报告 Bug</a></li>
|
||
<li>
|
||
<a href="https://github.com/python/cpython/blob/3.8/Doc/tutorial/datastructures.rst"
|
||
rel="nofollow">显示源代码
|
||
</a>
|
||
</li>
|
||
</ul>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div class="clearer"></div>
|
||
</div>
|
||
<div class="related" role="navigation" aria-label="related navigation">
|
||
<h3>导航</h3>
|
||
<ul>
|
||
<li class="right" style="margin-right: 10px">
|
||
<a href="../genindex.html" title="总目录"
|
||
>索引</a></li>
|
||
<li class="right" >
|
||
<a href="../py-modindex.html" title="Python 模块索引"
|
||
>模块</a> |</li>
|
||
<li class="right" >
|
||
<a href="modules.html" title="6. 模块"
|
||
>下一页</a> |</li>
|
||
<li class="right" >
|
||
<a href="controlflow.html" title="4. 更多控制流工具"
|
||
>上一页</a> |</li>
|
||
|
||
<li><img src="../_static/py.svg" alt="python logo" style="vertical-align: middle; margin-top: -1px"/></li>
|
||
<li><a href="https://www.python.org/">Python</a> »</li>
|
||
<li class="switchers">
|
||
<div class="language_switcher_placeholder"></div>
|
||
<div class="version_switcher_placeholder"></div>
|
||
</li>
|
||
<li>
|
||
|
||
</li>
|
||
<li id="cpython-language-and-version">
|
||
<a href="../index.html">3.8.20 Documentation</a> »
|
||
</li>
|
||
|
||
<li class="nav-item nav-item-1"><a href="index.html" >Python 教程</a> »</li>
|
||
<li class="right">
|
||
|
||
|
||
<div class="inline-search" role="search">
|
||
<form class="inline-search" action="../search.html" method="get">
|
||
<input placeholder="快速搜索" aria-label="快速搜索" type="text" name="q" />
|
||
<input type="submit" value="转向" />
|
||
<input type="hidden" name="check_keywords" value="yes" />
|
||
<input type="hidden" name="area" value="default" />
|
||
</form>
|
||
</div>
|
||
|
|
||
</li>
|
||
|
||
</ul>
|
||
</div>
|
||
<div class="footer">
|
||
© <a href="../copyright.html">版权所有</a> 2001-2024, Python Software Foundation.
|
||
<br />
|
||
This page is licensed under the Python Software Foundation License Version 2.
|
||
<br />
|
||
Examples, recipes, and other code in the documentation are additionally licensed under the Zero Clause BSD License.
|
||
<br />
|
||
|
||
<br />
|
||
|
||
The Python Software Foundation is a non-profit corporation.
|
||
<a href="https://www.python.org/psf/donations/">Please donate.</a>
|
||
<br />
|
||
<br />
|
||
|
||
最后更新于 12月 09, 2024.
|
||
<a href="https://docs.python.org/3/bugs.html">Found a bug</a>?
|
||
<br />
|
||
|
||
Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 2.4.4.
|
||
</div>
|
||
|
||
</body>
|
||
</html> |