Baoding-FenShuaJiang
/
Green_GoodERP18_FSJ_Standard
Volgen 1
Ster 0
Wiki 捐赠
gooderp18绿色标准版
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 0f75e31513
Branches Labels
${ item.name }
Maak branch ${ searchTerm }
van '0f75e31513'
${ noResults }
Green_GoodERP18_FSJ_Standard/python/Doc/html/library/collections.html

1723 lines
192KB
Ruw Blame Geschiedenis 

  1. <!DOCTYPE html>

  2. 

  3. <html lang="en" data-content_root="../">

  4.   <head>

  5.     <meta charset="utf-8" />

  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />

  7. <meta property="og:title" content="collections — Container datatypes" />

  8. <meta property="og:type" content="website" />

  9. <meta property="og:url" content="https://docs.python.org/3/library/collections.html" />

  10. <meta property="og:site_name" content="Python documentation" />

  11. <meta property="og:description" content="Source code: Lib/collections/__init__.py This module implements specialized container datatypes providing alternatives to Python’s general purpose built-in containers, dict, list, set, and tuple.,,..." />

  12. <meta property="og:image" content="https://docs.python.org/3/_static/og-image.png" />

  13. <meta property="og:image:alt" content="Python documentation" />

  14. <meta name="description" content="Source code: Lib/collections/__init__.py This module implements specialized container datatypes providing alternatives to Python’s general purpose built-in containers, dict, list, set, and tuple.,,..." />

  15. <meta property="og:image:width" content="200" />

  16. <meta property="og:image:height" content="200" />

  17. <meta name="theme-color" content="#3776ab" />

  18. 

  19.     <title>collections — Container datatypes &#8212; Python 3.12.3 documentation</title><meta name="viewport" content="width=device-width, initial-scale=1.0">

  20.     

  21.     <link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=80d5e7a1" />

  22.     <link rel="stylesheet" type="text/css" href="../_static/pydoctheme.css?v=bb723527" />

  23.     <link id="pygments_dark_css" media="(prefers-color-scheme: dark)" rel="stylesheet" type="text/css" href="../_static/pygments_dark.css?v=b20cc3f5" />

  24.     

  25.     <script src="../_static/documentation_options.js?v=2c828074"></script>

  26.     <script src="../_static/doctools.js?v=888ff710"></script>

  27.     <script src="../_static/sphinx_highlight.js?v=dc90522c"></script>

  28.     

  29.     <script src="../_static/sidebar.js"></script>

  30.     

  31.     <link rel="search" type="application/opensearchdescription+xml"

  32.           title="Search within Python 3.12.3 documentation"

  33.           href="../_static/opensearch.xml"/>

  34.     <link rel="author" title="About these documents" href="../about.html" />

  35.     <link rel="index" title="Index" href="../genindex.html" />

  36.     <link rel="search" title="Search" href="../search.html" />

  37.     <link rel="copyright" title="Copyright" href="../copyright.html" />

  38.     <link rel="next" title="collections.abc — Abstract Base Classes for Containers" href="collections.abc.html" />

  39.     <link rel="prev" title="calendar — General calendar-related functions" href="calendar.html" />

  40.     <link rel="canonical" href="https://docs.python.org/3/library/collections.html" />

  41.     

  42.       

  43.     

  44. 

  45.     

  46.     <style>

  47.       @media only screen {

  48.         table.full-width-table {

  49.             width: 100%;

  50.         }

  51.       }

  52.     </style>

  53. <link rel="stylesheet" href="../_static/pydoctheme_dark.css" media="(prefers-color-scheme: dark)" id="pydoctheme_dark_css">

  54.     <link rel="shortcut icon" type="image/png" href="../_static/py.svg" />

  55.             <script type="text/javascript" src="../_static/copybutton.js"></script>

  56.             <script type="text/javascript" src="../_static/menu.js"></script>

  57.             <script type="text/javascript" src="../_static/search-focus.js"></script>

  58.             <script type="text/javascript" src="../_static/themetoggle.js"></script> 

  59. 

  60.   </head>

  61. <body>

  62. <div class="mobile-nav">

  63.     <input type="checkbox" id="menuToggler" class="toggler__input" aria-controls="navigation"

  64.            aria-pressed="false" aria-expanded="false" role="button" aria-label="Menu" />

  65.     <nav class="nav-content" role="navigation">

  66.         <label for="menuToggler" class="toggler__label">

  67.             <span></span>

  68.         </label>

  69.         <span class="nav-items-wrapper">

  70.             <a href="https://www.python.org/" class="nav-logo">

  71.                 <img src="../_static/py.svg" alt="Python logo"/>

  72.             </a>

  73.             <span class="version_switcher_placeholder"></span>

  74.             <form role="search" class="search" action="../search.html" method="get">

  75.                 <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" class="search-icon">

  76.                     <path fill-rule="nonzero" fill="currentColor" 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"></path>

  77.                 </svg>

  78.                 <input placeholder="Quick search" aria-label="Quick search" type="search" name="q" />

  79.                 <input type="submit" value="Go"/>

  80.             </form>

  81.         </span>

  82.     </nav>

  83.     <div class="menu-wrapper">

  84.         <nav class="menu" role="navigation" aria-label="main navigation">

  85.             <div class="language_switcher_placeholder"></div>

  86.             

  87. <label class="theme-selector-label">

  88.     Theme

  89.     <select class="theme-selector" oninput="activateTheme(this.value)">

  90.         <option value="auto" selected>Auto</option>

  91.         <option value="light">Light</option>

  92.         <option value="dark">Dark</option>

  93.     </select>

  94. </label>

  95.   <div>

  96.     <h3><a href="../contents.html">Table of Contents</a></h3>

  97.     <ul>

  98. <li><a class="reference internal" href="#"><code class="xref py py-mod docutils literal notranslate"><span class="pre">collections</span></code> — Container datatypes</a><ul>

  99. <li><a class="reference internal" href="#chainmap-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">ChainMap</span></code> objects</a><ul>

  100. <li><a class="reference internal" href="#chainmap-examples-and-recipes"><code class="xref py py-class docutils literal notranslate"><span class="pre">ChainMap</span></code> Examples and Recipes</a></li>

  101. </ul>

  102. </li>

  103. <li><a class="reference internal" href="#counter-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">Counter</span></code> objects</a></li>

  104. <li><a class="reference internal" href="#deque-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">deque</span></code> objects</a><ul>

  105. <li><a class="reference internal" href="#deque-recipes"><code class="xref py py-class docutils literal notranslate"><span class="pre">deque</span></code> Recipes</a></li>

  106. </ul>

  107. </li>

  108. <li><a class="reference internal" href="#defaultdict-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">defaultdict</span></code> objects</a><ul>

  109. <li><a class="reference internal" href="#defaultdict-examples"><code class="xref py py-class docutils literal notranslate"><span class="pre">defaultdict</span></code> Examples</a></li>

  110. </ul>

  111. </li>

  112. <li><a class="reference internal" href="#namedtuple-factory-function-for-tuples-with-named-fields"><code class="xref py py-func docutils literal notranslate"><span class="pre">namedtuple()</span></code> Factory Function for Tuples with Named Fields</a></li>

  113. <li><a class="reference internal" href="#ordereddict-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code> objects</a><ul>

  114. <li><a class="reference internal" href="#ordereddict-examples-and-recipes"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code> Examples and Recipes</a></li>

  115. </ul>

  116. </li>

  117. <li><a class="reference internal" href="#userdict-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserDict</span></code> objects</a></li>

  118. <li><a class="reference internal" href="#userlist-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserList</span></code> objects</a></li>

  119. <li><a class="reference internal" href="#userstring-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserString</span></code> objects</a></li>

  120. </ul>

  121. </li>

  122. </ul>

  123. 

  124.   </div>

  125.   <div>

  126.     <h4>Previous topic</h4>

  127.     <p class="topless"><a href="calendar.html"

  128.                           title="previous chapter"><code class="xref py py-mod docutils literal notranslate"><span class="pre">calendar</span></code> — General calendar-related functions</a></p>

  129.   </div>

  130.   <div>

  131.     <h4>Next topic</h4>

  132.     <p class="topless"><a href="collections.abc.html"

  133.                           title="next chapter"><code class="xref py py-mod docutils literal notranslate"><span class="pre">collections.abc</span></code> — Abstract Base Classes for Containers</a></p>

  134.   </div>

  135.   <div role="note" aria-label="source link">

  136.     <h3>This Page</h3>

  137.     <ul class="this-page-menu">

  138.       <li><a href="../bugs.html">Report a Bug</a></li>

  139.       <li>

  140.         <a href="https://github.com/python/cpython/blob/main/Doc/library/collections.rst"

  141.             rel="nofollow">Show Source

  142.         </a>

  143.       </li>

  144.     </ul>

  145.   </div>

  146.         </nav>

  147.     </div>

  148. </div>

  149. 

  150.   

  151.     <div class="related" role="navigation" aria-label="related navigation">

  152.       <h3>Navigation</h3>

  153.       <ul>

  154.         <li class="right" style="margin-right: 10px">

  155.           <a href="../genindex.html" title="General Index"

  156.              accesskey="I">index</a></li>

  157.         <li class="right" >

  158.           <a href="../py-modindex.html" title="Python Module Index"

  159.              >modules</a> |</li>

  160.         <li class="right" >

  161.           <a href="collections.abc.html" title="collections.abc — Abstract Base Classes for Containers"

  162.              accesskey="N">next</a> |</li>

  163.         <li class="right" >

  164.           <a href="calendar.html" title="calendar — General calendar-related functions"

  165.              accesskey="P">previous</a> |</li>

  166. 

  167.           <li><img src="../_static/py.svg" alt="Python logo" style="vertical-align: middle; margin-top: -1px"/></li>

  168.           <li><a href="https://www.python.org/">Python</a> &#187;</li>

  169.           <li class="switchers">

  170.             <div class="language_switcher_placeholder"></div>

  171.             <div class="version_switcher_placeholder"></div>

  172.           </li>

  173.           <li>

  174.               

  175.           </li>

  176.     <li id="cpython-language-and-version">

  177.       <a href="../index.html">3.12.3 Documentation</a> &#187;

  178.     </li>

  179. 

  180.           <li class="nav-item nav-item-1"><a href="index.html" >The Python Standard Library</a> &#187;</li>

  181.           <li class="nav-item nav-item-2"><a href="datatypes.html" accesskey="U">Data Types</a> &#187;</li>

  182.         <li class="nav-item nav-item-this"><a href=""><code class="xref py py-mod docutils literal notranslate"><span class="pre">collections</span></code> — Container datatypes</a></li>

  183.                 <li class="right">

  184.                     

  185. 

  186.     <div class="inline-search" role="search">

  187.         <form class="inline-search" action="../search.html" method="get">

  188.           <input placeholder="Quick search" aria-label="Quick search" type="search" name="q" id="search-box" />

  189.           <input type="submit" value="Go" />

  190.         </form>

  191.     </div>

  192.                      |

  193.                 </li>

  194.             <li class="right">

  195. <label class="theme-selector-label">

  196.     Theme

  197.     <select class="theme-selector" oninput="activateTheme(this.value)">

  198.         <option value="auto" selected>Auto</option>

  199.         <option value="light">Light</option>

  200.         <option value="dark">Dark</option>

  201.     </select>

  202. </label> |</li>

  203.             

  204.       </ul>

  205.     </div>    

  206. 

  207.     <div class="document">

  208.       <div class="documentwrapper">

  209.         <div class="bodywrapper">

  210.           <div class="body" role="main">

  211.             

  212.   <section id="module-collections">

  213. <span id="collections-container-datatypes"></span><h1><a class="reference internal" href="#module-collections" title="collections: Container datatypes"><code class="xref py py-mod docutils literal notranslate"><span class="pre">collections</span></code></a> — Container datatypes<a class="headerlink" href="#module-collections" title="Link to this heading">¶</a></h1>

  214. <p><strong>Source code:</strong> <a class="reference external" href="https://github.com/python/cpython/tree/3.12/Lib/collections/__init__.py">Lib/collections/__init__.py</a></p>

  215. <hr class="docutils" />

  216. <p>This module implements specialized container datatypes providing alternatives to

  217. Python’s general purpose built-in containers, <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a>, <a class="reference internal" href="stdtypes.html#list" title="list"><code class="xref py py-class docutils literal notranslate"><span class="pre">list</span></code></a>,

  218. <a class="reference internal" href="stdtypes.html#set" title="set"><code class="xref py py-class docutils literal notranslate"><span class="pre">set</span></code></a>, and <a class="reference internal" href="stdtypes.html#tuple" title="tuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">tuple</span></code></a>.</p>

  219. <table class="docutils align-default">

  220. <tbody>

  221. <tr class="row-odd"><td><p><a class="reference internal" href="#collections.namedtuple" title="collections.namedtuple"><code class="xref py py-func docutils literal notranslate"><span class="pre">namedtuple()</span></code></a></p></td>

  222. <td><p>factory function for creating tuple subclasses with named fields</p></td>

  223. </tr>

  224. <tr class="row-even"><td><p><a class="reference internal" href="#collections.deque" title="collections.deque"><code class="xref py py-class docutils literal notranslate"><span class="pre">deque</span></code></a></p></td>

  225. <td><p>list-like container with fast appends and pops on either end</p></td>

  226. </tr>

  227. <tr class="row-odd"><td><p><a class="reference internal" href="#collections.ChainMap" title="collections.ChainMap"><code class="xref py py-class docutils literal notranslate"><span class="pre">ChainMap</span></code></a></p></td>

  228. <td><p>dict-like class for creating a single view of multiple mappings</p></td>

  229. </tr>

  230. <tr class="row-even"><td><p><a class="reference internal" href="#collections.Counter" title="collections.Counter"><code class="xref py py-class docutils literal notranslate"><span class="pre">Counter</span></code></a></p></td>

  231. <td><p>dict subclass for counting <a class="reference internal" href="../glossary.html#term-hashable"><span class="xref std std-term">hashable</span></a> objects</p></td>

  232. </tr>

  233. <tr class="row-odd"><td><p><a class="reference internal" href="#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code></a></p></td>

  234. <td><p>dict subclass that remembers the order entries were added</p></td>

  235. </tr>

  236. <tr class="row-even"><td><p><a class="reference internal" href="#collections.defaultdict" title="collections.defaultdict"><code class="xref py py-class docutils literal notranslate"><span class="pre">defaultdict</span></code></a></p></td>

  237. <td><p>dict subclass that calls a factory function to supply missing values</p></td>

  238. </tr>

  239. <tr class="row-odd"><td><p><a class="reference internal" href="#collections.UserDict" title="collections.UserDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserDict</span></code></a></p></td>

  240. <td><p>wrapper around dictionary objects for easier dict subclassing</p></td>

  241. </tr>

  242. <tr class="row-even"><td><p><a class="reference internal" href="#collections.UserList" title="collections.UserList"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserList</span></code></a></p></td>

  243. <td><p>wrapper around list objects for easier list subclassing</p></td>

  244. </tr>

  245. <tr class="row-odd"><td><p><a class="reference internal" href="#collections.UserString" title="collections.UserString"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserString</span></code></a></p></td>

  246. <td><p>wrapper around string objects for easier string subclassing</p></td>

  247. </tr>

  248. </tbody>

  249. </table>

  250. <section id="chainmap-objects">

  251. <h2><a class="reference internal" href="#collections.ChainMap" title="collections.ChainMap"><code class="xref py py-class docutils literal notranslate"><span class="pre">ChainMap</span></code></a> objects<a class="headerlink" href="#chainmap-objects" title="Link to this heading">¶</a></h2>

  252. <div class="versionadded">

  253. <p><span class="versionmodified added">New in version 3.3.</span></p>

  254. </div>

  255. <p>A <a class="reference internal" href="#collections.ChainMap" title="collections.ChainMap"><code class="xref py py-class docutils literal notranslate"><span class="pre">ChainMap</span></code></a> class is provided for quickly linking a number of mappings

  256. so they can be treated as a single unit.  It is often much faster than creating

  257. a new dictionary and running multiple <a class="reference internal" href="stdtypes.html#dict.update" title="dict.update"><code class="xref py py-meth docutils literal notranslate"><span class="pre">update()</span></code></a> calls.</p>

  258. <p>The class can be used to simulate nested scopes and is useful in templating.</p>

  259. <dl class="py class">

  260. <dt class="sig sig-object py" id="collections.ChainMap">

  261. <em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">collections.</span></span><span class="sig-name descname"><span class="pre">ChainMap</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">maps</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.ChainMap" title="Link to this definition">¶</a></dt>

  262. <dd><p>A <a class="reference internal" href="#collections.ChainMap" title="collections.ChainMap"><code class="xref py py-class docutils literal notranslate"><span class="pre">ChainMap</span></code></a> groups multiple dicts or other mappings together to

  263. create a single, updateable view.  If no <em>maps</em> are specified, a single empty

  264. dictionary is provided so that a new chain always has at least one mapping.</p>

  265. <p>The underlying mappings are stored in a list.  That list is public and can

  266. be accessed or updated using the <em>maps</em> attribute.  There is no other state.</p>

  267. <p>Lookups search the underlying mappings successively until a key is found.  In

  268. contrast, writes, updates, and deletions only operate on the first mapping.</p>

  269. <p>A <a class="reference internal" href="#collections.ChainMap" title="collections.ChainMap"><code class="xref py py-class docutils literal notranslate"><span class="pre">ChainMap</span></code></a> incorporates the underlying mappings by reference.  So, if

  270. one of the underlying mappings gets updated, those changes will be reflected

  271. in <a class="reference internal" href="#collections.ChainMap" title="collections.ChainMap"><code class="xref py py-class docutils literal notranslate"><span class="pre">ChainMap</span></code></a>.</p>

  272. <p>All of the usual dictionary methods are supported.  In addition, there is a

  273. <em>maps</em> attribute, a method for creating new subcontexts, and a property for

  274. accessing all but the first mapping:</p>

  275. <dl class="py attribute">

  276. <dt class="sig sig-object py" id="collections.ChainMap.maps">

  277. <span class="sig-name descname"><span class="pre">maps</span></span><a class="headerlink" href="#collections.ChainMap.maps" title="Link to this definition">¶</a></dt>

  278. <dd><p>A user updateable list of mappings.  The list is ordered from

  279. first-searched to last-searched.  It is the only stored state and can

  280. be modified to change which mappings are searched.  The list should

  281. always contain at least one mapping.</p>

  282. </dd></dl>

  283. 

  284. <dl class="py method">

  285. <dt class="sig sig-object py" id="collections.ChainMap.new_child">

  286. <span class="sig-name descname"><span class="pre">new_child</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">m</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">kwargs</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.ChainMap.new_child" title="Link to this definition">¶</a></dt>

  287. <dd><p>Returns a new <a class="reference internal" href="#collections.ChainMap" title="collections.ChainMap"><code class="xref py py-class docutils literal notranslate"><span class="pre">ChainMap</span></code></a> containing a new map followed by

  288. all of the maps in the current instance.  If <code class="docutils literal notranslate"><span class="pre">m</span></code> is specified,

  289. it becomes the new map at the front of the list of mappings; if not

  290. specified, an empty dict is used, so that a call to <code class="docutils literal notranslate"><span class="pre">d.new_child()</span></code>

  291. is equivalent to: <code class="docutils literal notranslate"><span class="pre">ChainMap({},</span> <span class="pre">*d.maps)</span></code>. If any keyword arguments

  292. are specified, they update passed map or new empty dict. This method

  293. is used for creating subcontexts that can be updated without altering

  294. values in any of the parent mappings.</p>

  295. <div class="versionchanged">

  296. <p><span class="versionmodified changed">Changed in version 3.4: </span>The optional <code class="docutils literal notranslate"><span class="pre">m</span></code> parameter was added.</p>

  297. </div>

  298. <div class="versionchanged">

  299. <p><span class="versionmodified changed">Changed in version 3.10: </span>Keyword arguments support was added.</p>

  300. </div>

  301. </dd></dl>

  302. 

  303. <dl class="py attribute">

  304. <dt class="sig sig-object py" id="collections.ChainMap.parents">

  305. <span class="sig-name descname"><span class="pre">parents</span></span><a class="headerlink" href="#collections.ChainMap.parents" title="Link to this definition">¶</a></dt>

  306. <dd><p>Property returning a new <a class="reference internal" href="#collections.ChainMap" title="collections.ChainMap"><code class="xref py py-class docutils literal notranslate"><span class="pre">ChainMap</span></code></a> containing all of the maps in

  307. the current instance except the first one.  This is useful for skipping

  308. the first map in the search.  Use cases are similar to those for the

  309. <a class="reference internal" href="../reference/simple_stmts.html#nonlocal"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">nonlocal</span></code></a> keyword used in <a class="reference internal" href="../glossary.html#term-nested-scope"><span class="xref std std-term">nested scopes</span></a>.  The use cases also parallel those for the built-in

  310. <a class="reference internal" href="functions.html#super" title="super"><code class="xref py py-func docutils literal notranslate"><span class="pre">super()</span></code></a> function.  A reference to <code class="docutils literal notranslate"><span class="pre">d.parents</span></code> is equivalent to:

  311. <code class="docutils literal notranslate"><span class="pre">ChainMap(*d.maps[1:])</span></code>.</p>

  312. </dd></dl>

  313. 

  314. <p>Note, the iteration order of a <a class="reference internal" href="#collections.ChainMap" title="collections.ChainMap"><code class="xref py py-class docutils literal notranslate"><span class="pre">ChainMap()</span></code></a> is determined by

  315. scanning the mappings last to first:</p>

  316. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">baseline</span> <span class="o">=</span> <span class="p">{</span><span class="s1">&#39;music&#39;</span><span class="p">:</span> <span class="s1">&#39;bach&#39;</span><span class="p">,</span> <span class="s1">&#39;art&#39;</span><span class="p">:</span> <span class="s1">&#39;rembrandt&#39;</span><span class="p">}</span>

  317. <span class="gp">&gt;&gt;&gt; </span><span class="n">adjustments</span> <span class="o">=</span> <span class="p">{</span><span class="s1">&#39;art&#39;</span><span class="p">:</span> <span class="s1">&#39;van gogh&#39;</span><span class="p">,</span> <span class="s1">&#39;opera&#39;</span><span class="p">:</span> <span class="s1">&#39;carmen&#39;</span><span class="p">}</span>

  318. <span class="gp">&gt;&gt;&gt; </span><span class="nb">list</span><span class="p">(</span><span class="n">ChainMap</span><span class="p">(</span><span class="n">adjustments</span><span class="p">,</span> <span class="n">baseline</span><span class="p">))</span>

  319. <span class="go">[&#39;music&#39;, &#39;art&#39;, &#39;opera&#39;]</span>

  320. </pre></div>

  321. </div>

  322. <p>This gives the same ordering as a series of <a class="reference internal" href="stdtypes.html#dict.update" title="dict.update"><code class="xref py py-meth docutils literal notranslate"><span class="pre">dict.update()</span></code></a> calls

  323. starting with the last mapping:</p>

  324. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">combined</span> <span class="o">=</span> <span class="n">baseline</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>

  325. <span class="gp">&gt;&gt;&gt; </span><span class="n">combined</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="n">adjustments</span><span class="p">)</span>

  326. <span class="gp">&gt;&gt;&gt; </span><span class="nb">list</span><span class="p">(</span><span class="n">combined</span><span class="p">)</span>

  327. <span class="go">[&#39;music&#39;, &#39;art&#39;, &#39;opera&#39;]</span>

  328. </pre></div>

  329. </div>

  330. <div class="versionchanged">

  331. <p><span class="versionmodified changed">Changed in version 3.9: </span>Added support for <code class="docutils literal notranslate"><span class="pre">|</span></code> and <code class="docutils literal notranslate"><span class="pre">|=</span></code> operators, specified in <span class="target" id="index-0"></span><a class="pep reference external" href="https://peps.python.org/pep-0584/"><strong>PEP 584</strong></a>.</p>

  332. </div>

  333. </dd></dl>

  334. 

  335. <div class="admonition seealso">

  336. <p class="admonition-title">See also</p>

  337. <ul class="simple">

  338. <li><p>The <a class="reference external" href="https://github.com/enthought/codetools/blob/4.0.0/codetools/contexts/multi_context.py">MultiContext class</a>

  339. in the Enthought <a class="reference external" href="https://github.com/enthought/codetools">CodeTools package</a> has options to support

  340. writing to any mapping in the chain.</p></li>

  341. <li><p>Django’s <a class="reference external" href="https://github.com/django/django/blob/main/django/template/context.py">Context class</a>

  342. for templating is a read-only chain of mappings.  It also features

  343. pushing and popping of contexts similar to the

  344. <a class="reference internal" href="#collections.ChainMap.new_child" title="collections.ChainMap.new_child"><code class="xref py py-meth docutils literal notranslate"><span class="pre">new_child()</span></code></a> method and the

  345. <a class="reference internal" href="#collections.ChainMap.parents" title="collections.ChainMap.parents"><code class="xref py py-attr docutils literal notranslate"><span class="pre">parents</span></code></a> property.</p></li>

  346. <li><p>The <a class="reference external" href="https://code.activestate.com/recipes/577434/">Nested Contexts recipe</a> has options to control

  347. whether writes and other mutations apply only to the first mapping or to

  348. any mapping in the chain.</p></li>

  349. <li><p>A <a class="reference external" href="https://code.activestate.com/recipes/305268/">greatly simplified read-only version of Chainmap</a>.</p></li>

  350. </ul>

  351. </div>

  352. <section id="chainmap-examples-and-recipes">

  353. <h3><a class="reference internal" href="#collections.ChainMap" title="collections.ChainMap"><code class="xref py py-class docutils literal notranslate"><span class="pre">ChainMap</span></code></a> Examples and Recipes<a class="headerlink" href="#chainmap-examples-and-recipes" title="Link to this heading">¶</a></h3>

  354. <p>This section shows various approaches to working with chained maps.</p>

  355. <p>Example of simulating Python’s internal lookup chain:</p>

  356. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">builtins</span>

  357. <span class="n">pylookup</span> <span class="o">=</span> <span class="n">ChainMap</span><span class="p">(</span><span class="nb">locals</span><span class="p">(),</span> <span class="nb">globals</span><span class="p">(),</span> <span class="nb">vars</span><span class="p">(</span><span class="n">builtins</span><span class="p">))</span>

  358. </pre></div>

  359. </div>

  360. <p>Example of letting user specified command-line arguments take precedence over

  361. environment variables which in turn take precedence over default values:</p>

  362. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">os</span><span class="o">,</span> <span class="nn">argparse</span>

  363. 

  364. <span class="n">defaults</span> <span class="o">=</span> <span class="p">{</span><span class="s1">&#39;color&#39;</span><span class="p">:</span> <span class="s1">&#39;red&#39;</span><span class="p">,</span> <span class="s1">&#39;user&#39;</span><span class="p">:</span> <span class="s1">&#39;guest&#39;</span><span class="p">}</span>

  365. 

  366. <span class="n">parser</span> <span class="o">=</span> <span class="n">argparse</span><span class="o">.</span><span class="n">ArgumentParser</span><span class="p">()</span>

  367. <span class="n">parser</span><span class="o">.</span><span class="n">add_argument</span><span class="p">(</span><span class="s1">&#39;-u&#39;</span><span class="p">,</span> <span class="s1">&#39;--user&#39;</span><span class="p">)</span>

  368. <span class="n">parser</span><span class="o">.</span><span class="n">add_argument</span><span class="p">(</span><span class="s1">&#39;-c&#39;</span><span class="p">,</span> <span class="s1">&#39;--color&#39;</span><span class="p">)</span>

  369. <span class="n">namespace</span> <span class="o">=</span> <span class="n">parser</span><span class="o">.</span><span class="n">parse_args</span><span class="p">()</span>

  370. <span class="n">command_line_args</span> <span class="o">=</span> <span class="p">{</span><span class="n">k</span><span class="p">:</span> <span class="n">v</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="nb">vars</span><span class="p">(</span><span class="n">namespace</span><span class="p">)</span><span class="o">.</span><span class="n">items</span><span class="p">()</span> <span class="k">if</span> <span class="n">v</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">}</span>

  371. 

  372. <span class="n">combined</span> <span class="o">=</span> <span class="n">ChainMap</span><span class="p">(</span><span class="n">command_line_args</span><span class="p">,</span> <span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">,</span> <span class="n">defaults</span><span class="p">)</span>

  373. <span class="nb">print</span><span class="p">(</span><span class="n">combined</span><span class="p">[</span><span class="s1">&#39;color&#39;</span><span class="p">])</span>

  374. <span class="nb">print</span><span class="p">(</span><span class="n">combined</span><span class="p">[</span><span class="s1">&#39;user&#39;</span><span class="p">])</span>

  375. </pre></div>

  376. </div>

  377. <p>Example patterns for using the <a class="reference internal" href="#collections.ChainMap" title="collections.ChainMap"><code class="xref py py-class docutils literal notranslate"><span class="pre">ChainMap</span></code></a> class to simulate nested

  378. contexts:</p>

  379. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">c</span> <span class="o">=</span> <span class="n">ChainMap</span><span class="p">()</span>        <span class="c1"># Create root context</span>

  380. <span class="n">d</span> <span class="o">=</span> <span class="n">c</span><span class="o">.</span><span class="n">new_child</span><span class="p">()</span>     <span class="c1"># Create nested child context</span>

  381. <span class="n">e</span> <span class="o">=</span> <span class="n">c</span><span class="o">.</span><span class="n">new_child</span><span class="p">()</span>     <span class="c1"># Child of c, independent from d</span>

  382. <span class="n">e</span><span class="o">.</span><span class="n">maps</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>             <span class="c1"># Current context dictionary -- like Python&#39;s locals()</span>

  383. <span class="n">e</span><span class="o">.</span><span class="n">maps</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>            <span class="c1"># Root context -- like Python&#39;s globals()</span>

  384. <span class="n">e</span><span class="o">.</span><span class="n">parents</span>             <span class="c1"># Enclosing context chain -- like Python&#39;s nonlocals</span>

  385. 

  386. <span class="n">d</span><span class="p">[</span><span class="s1">&#39;x&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="mi">1</span>            <span class="c1"># Set value in current context</span>

  387. <span class="n">d</span><span class="p">[</span><span class="s1">&#39;x&#39;</span><span class="p">]</span>                <span class="c1"># Get first key in the chain of contexts</span>

  388. <span class="k">del</span> <span class="n">d</span><span class="p">[</span><span class="s1">&#39;x&#39;</span><span class="p">]</span>            <span class="c1"># Delete from current context</span>

  389. <span class="nb">list</span><span class="p">(</span><span class="n">d</span><span class="p">)</span>               <span class="c1"># All nested values</span>

  390. <span class="n">k</span> <span class="ow">in</span> <span class="n">d</span>                <span class="c1"># Check all nested values</span>

  391. <span class="nb">len</span><span class="p">(</span><span class="n">d</span><span class="p">)</span>                <span class="c1"># Number of nested values</span>

  392. <span class="n">d</span><span class="o">.</span><span class="n">items</span><span class="p">()</span>             <span class="c1"># All nested items</span>

  393. <span class="nb">dict</span><span class="p">(</span><span class="n">d</span><span class="p">)</span>               <span class="c1"># Flatten into a regular dictionary</span>

  394. </pre></div>

  395. </div>

  396. <p>The <a class="reference internal" href="#collections.ChainMap" title="collections.ChainMap"><code class="xref py py-class docutils literal notranslate"><span class="pre">ChainMap</span></code></a> class only makes updates (writes and deletions) to the

  397. first mapping in the chain while lookups will search the full chain.  However,

  398. if deep writes and deletions are desired, it is easy to make a subclass that

  399. updates keys found deeper in the chain:</p>

  400. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">DeepChainMap</span><span class="p">(</span><span class="n">ChainMap</span><span class="p">):</span>

  401.     <span class="s1">&#39;Variant of ChainMap that allows direct updates to inner scopes&#39;</span>

  402. 

  403.     <span class="k">def</span> <span class="fm">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>

  404.         <span class="k">for</span> <span class="n">mapping</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">:</span>

  405.             <span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">mapping</span><span class="p">:</span>

  406.                 <span class="n">mapping</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span>

  407.                 <span class="k">return</span>

  408.         <span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span>

  409. 

  410.     <span class="k">def</span> <span class="fm">__delitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>

  411.         <span class="k">for</span> <span class="n">mapping</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">:</span>

  412.             <span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">mapping</span><span class="p">:</span>

  413.                 <span class="k">del</span> <span class="n">mapping</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>

  414.                 <span class="k">return</span>

  415.         <span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>

  416. 

  417. <span class="o">&gt;&gt;&gt;</span> <span class="n">d</span> <span class="o">=</span> <span class="n">DeepChainMap</span><span class="p">({</span><span class="s1">&#39;zebra&#39;</span><span class="p">:</span> <span class="s1">&#39;black&#39;</span><span class="p">},</span> <span class="p">{</span><span class="s1">&#39;elephant&#39;</span><span class="p">:</span> <span class="s1">&#39;blue&#39;</span><span class="p">},</span> <span class="p">{</span><span class="s1">&#39;lion&#39;</span><span class="p">:</span> <span class="s1">&#39;yellow&#39;</span><span class="p">})</span>

  418. <span class="o">&gt;&gt;&gt;</span> <span class="n">d</span><span class="p">[</span><span class="s1">&#39;lion&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;orange&#39;</span>         <span class="c1"># update an existing key two levels down</span>

  419. <span class="o">&gt;&gt;&gt;</span> <span class="n">d</span><span class="p">[</span><span class="s1">&#39;snake&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;red&#39;</span>           <span class="c1"># new keys get added to the topmost dict</span>

  420. <span class="o">&gt;&gt;&gt;</span> <span class="k">del</span> <span class="n">d</span><span class="p">[</span><span class="s1">&#39;elephant&#39;</span><span class="p">]</span>            <span class="c1"># remove an existing key one level down</span>

  421. <span class="o">&gt;&gt;&gt;</span> <span class="n">d</span>                            <span class="c1"># display result</span>

  422. <span class="n">DeepChainMap</span><span class="p">({</span><span class="s1">&#39;zebra&#39;</span><span class="p">:</span> <span class="s1">&#39;black&#39;</span><span class="p">,</span> <span class="s1">&#39;snake&#39;</span><span class="p">:</span> <span class="s1">&#39;red&#39;</span><span class="p">},</span> <span class="p">{},</span> <span class="p">{</span><span class="s1">&#39;lion&#39;</span><span class="p">:</span> <span class="s1">&#39;orange&#39;</span><span class="p">})</span>

  423. </pre></div>

  424. </div>

  425. </section>

  426. </section>

  427. <section id="counter-objects">

  428. <h2><a class="reference internal" href="#collections.Counter" title="collections.Counter"><code class="xref py py-class docutils literal notranslate"><span class="pre">Counter</span></code></a> objects<a class="headerlink" href="#counter-objects" title="Link to this heading">¶</a></h2>

  429. <p>A counter tool is provided to support convenient and rapid tallies.

  430. For example:</p>

  431. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="c1"># Tally occurrences of words in a list</span>

  432. <span class="gp">&gt;&gt;&gt; </span><span class="n">cnt</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">()</span>

  433. <span class="gp">&gt;&gt;&gt; </span><span class="k">for</span> <span class="n">word</span> <span class="ow">in</span> <span class="p">[</span><span class="s1">&#39;red&#39;</span><span class="p">,</span> <span class="s1">&#39;blue&#39;</span><span class="p">,</span> <span class="s1">&#39;red&#39;</span><span class="p">,</span> <span class="s1">&#39;green&#39;</span><span class="p">,</span> <span class="s1">&#39;blue&#39;</span><span class="p">,</span> <span class="s1">&#39;blue&#39;</span><span class="p">]:</span>

  434. <span class="gp">... </span>    <span class="n">cnt</span><span class="p">[</span><span class="n">word</span><span class="p">]</span> <span class="o">+=</span> <span class="mi">1</span>

  435. <span class="gp">...</span>

  436. <span class="gp">&gt;&gt;&gt; </span><span class="n">cnt</span>

  437. <span class="go">Counter({&#39;blue&#39;: 3, &#39;red&#39;: 2, &#39;green&#39;: 1})</span>

  438. 

  439. <span class="gp">&gt;&gt;&gt; </span><span class="c1"># Find the ten most common words in Hamlet</span>

  440. <span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span> <span class="nn">re</span>

  441. <span class="gp">&gt;&gt;&gt; </span><span class="n">words</span> <span class="o">=</span> <span class="n">re</span><span class="o">.</span><span class="n">findall</span><span class="p">(</span><span class="sa">r</span><span class="s1">&#39;\w+&#39;</span><span class="p">,</span> <span class="nb">open</span><span class="p">(</span><span class="s1">&#39;hamlet.txt&#39;</span><span class="p">)</span><span class="o">.</span><span class="n">read</span><span class="p">()</span><span class="o">.</span><span class="n">lower</span><span class="p">())</span>

  442. <span class="gp">&gt;&gt;&gt; </span><span class="n">Counter</span><span class="p">(</span><span class="n">words</span><span class="p">)</span><span class="o">.</span><span class="n">most_common</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span>

  443. <span class="go">[(&#39;the&#39;, 1143), (&#39;and&#39;, 966), (&#39;to&#39;, 762), (&#39;of&#39;, 669), (&#39;i&#39;, 631),</span>

  444. <span class="go"> (&#39;you&#39;, 554),  (&#39;a&#39;, 546), (&#39;my&#39;, 514), (&#39;hamlet&#39;, 471), (&#39;in&#39;, 451)]</span>

  445. </pre></div>

  446. </div>

  447. <dl class="py class">

  448. <dt class="sig sig-object py" id="collections.Counter">

  449. <em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">collections.</span></span><span class="sig-name descname"><span class="pre">Counter</span></span><span class="sig-paren">(</span><span class="optional">[</span><em class="sig-param"><span class="n"><span class="pre">iterable-or-mapping</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.Counter" title="Link to this definition">¶</a></dt>

  450. <dd><p>A <a class="reference internal" href="#collections.Counter" title="collections.Counter"><code class="xref py py-class docutils literal notranslate"><span class="pre">Counter</span></code></a> is a <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> subclass for counting <a class="reference internal" href="../glossary.html#term-hashable"><span class="xref std std-term">hashable</span></a> objects.

  451. It is a collection where elements are stored as dictionary keys

  452. and their counts are stored as dictionary values.  Counts are allowed to be

  453. any integer value including zero or negative counts.  The <a class="reference internal" href="#collections.Counter" title="collections.Counter"><code class="xref py py-class docutils literal notranslate"><span class="pre">Counter</span></code></a>

  454. class is similar to bags or multisets in other languages.</p>

  455. <p>Elements are counted from an <em>iterable</em> or initialized from another

  456. <em>mapping</em> (or counter):</p>

  457. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">()</span>                           <span class="c1"># a new, empty counter</span>

  458. <span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">(</span><span class="s1">&#39;gallahad&#39;</span><span class="p">)</span>                 <span class="c1"># a new counter from an iterable</span>

  459. <span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">({</span><span class="s1">&#39;red&#39;</span><span class="p">:</span> <span class="mi">4</span><span class="p">,</span> <span class="s1">&#39;blue&#39;</span><span class="p">:</span> <span class="mi">2</span><span class="p">})</span>      <span class="c1"># a new counter from a mapping</span>

  460. <span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">(</span><span class="n">cats</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span> <span class="n">dogs</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span>             <span class="c1"># a new counter from keyword args</span>

  461. </pre></div>

  462. </div>

  463. <p>Counter objects have a dictionary interface except that they return a zero

  464. count for missing items instead of raising a <a class="reference internal" href="exceptions.html#KeyError" title="KeyError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">KeyError</span></code></a>:</p>

  465. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">([</span><span class="s1">&#39;eggs&#39;</span><span class="p">,</span> <span class="s1">&#39;ham&#39;</span><span class="p">])</span>

  466. <span class="gp">&gt;&gt;&gt; </span><span class="n">c</span><span class="p">[</span><span class="s1">&#39;bacon&#39;</span><span class="p">]</span>                              <span class="c1"># count of a missing element is zero</span>

  467. <span class="go">0</span>

  468. </pre></div>

  469. </div>

  470. <p>Setting a count to zero does not remove an element from a counter.

  471. Use <code class="docutils literal notranslate"><span class="pre">del</span></code> to remove it entirely:</p>

  472. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">c</span><span class="p">[</span><span class="s1">&#39;sausage&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="mi">0</span>                        <span class="c1"># counter entry with a zero count</span>

  473. <span class="gp">&gt;&gt;&gt; </span><span class="k">del</span> <span class="n">c</span><span class="p">[</span><span class="s1">&#39;sausage&#39;</span><span class="p">]</span>                        <span class="c1"># del actually removes the entry</span>

  474. </pre></div>

  475. </div>

  476. <div class="versionadded">

  477. <p><span class="versionmodified added">New in version 3.1.</span></p>

  478. </div>

  479. <div class="versionchanged">

  480. <p><span class="versionmodified changed">Changed in version 3.7: </span>As a <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> subclass, <a class="reference internal" href="#collections.Counter" title="collections.Counter"><code class="xref py py-class docutils literal notranslate"><span class="pre">Counter</span></code></a>

  481. inherited the capability to remember insertion order.  Math operations

  482. on <em>Counter</em> objects also preserve order.  Results are ordered

  483. according to when an element is first encountered in the left operand

  484. and then by the order encountered in the right operand.</p>

  485. </div>

  486. <p>Counter objects support additional methods beyond those available for all

  487. dictionaries:</p>

  488. <dl class="py method">

  489. <dt class="sig sig-object py" id="collections.Counter.elements">

  490. <span class="sig-name descname"><span class="pre">elements</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.Counter.elements" title="Link to this definition">¶</a></dt>

  491. <dd><p>Return an iterator over elements repeating each as many times as its

  492. count.  Elements are returned in the order first encountered. If an

  493. element’s count is less than one, <a class="reference internal" href="#collections.Counter.elements" title="collections.Counter.elements"><code class="xref py py-meth docutils literal notranslate"><span class="pre">elements()</span></code></a> will ignore it.</p>

  494. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">(</span><span class="n">a</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span> <span class="n">b</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span> <span class="n">c</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">d</span><span class="o">=-</span><span class="mi">2</span><span class="p">)</span>

  495. <span class="gp">&gt;&gt;&gt; </span><span class="nb">sorted</span><span class="p">(</span><span class="n">c</span><span class="o">.</span><span class="n">elements</span><span class="p">())</span>

  496. <span class="go">[&#39;a&#39;, &#39;a&#39;, &#39;a&#39;, &#39;a&#39;, &#39;b&#39;, &#39;b&#39;]</span>

  497. </pre></div>

  498. </div>

  499. </dd></dl>

  500. 

  501. <dl class="py method">

  502. <dt class="sig sig-object py" id="collections.Counter.most_common">

  503. <span class="sig-name descname"><span class="pre">most_common</span></span><span class="sig-paren">(</span><span class="optional">[</span><em class="sig-param"><span class="n"><span class="pre">n</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.Counter.most_common" title="Link to this definition">¶</a></dt>

  504. <dd><p>Return a list of the <em>n</em> most common elements and their counts from the

  505. most common to the least.  If <em>n</em> is omitted or <code class="docutils literal notranslate"><span class="pre">None</span></code>,

  506. <a class="reference internal" href="#collections.Counter.most_common" title="collections.Counter.most_common"><code class="xref py py-meth docutils literal notranslate"><span class="pre">most_common()</span></code></a> returns <em>all</em> elements in the counter.

  507. Elements with equal counts are ordered in the order first encountered:</p>

  508. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">Counter</span><span class="p">(</span><span class="s1">&#39;abracadabra&#39;</span><span class="p">)</span><span class="o">.</span><span class="n">most_common</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>

  509. <span class="go">[(&#39;a&#39;, 5), (&#39;b&#39;, 2), (&#39;r&#39;, 2)]</span>

  510. </pre></div>

  511. </div>

  512. </dd></dl>

  513. 

  514. <dl class="py method">

  515. <dt class="sig sig-object py" id="collections.Counter.subtract">

  516. <span class="sig-name descname"><span class="pre">subtract</span></span><span class="sig-paren">(</span><span class="optional">[</span><em class="sig-param"><span class="n"><span class="pre">iterable-or-mapping</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.Counter.subtract" title="Link to this definition">¶</a></dt>

  517. <dd><p>Elements are subtracted from an <em>iterable</em> or from another <em>mapping</em>

  518. (or counter).  Like <a class="reference internal" href="stdtypes.html#dict.update" title="dict.update"><code class="xref py py-meth docutils literal notranslate"><span class="pre">dict.update()</span></code></a> but subtracts counts instead

  519. of replacing them.  Both inputs and outputs may be zero or negative.</p>

  520. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">(</span><span class="n">a</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span> <span class="n">b</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span> <span class="n">c</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">d</span><span class="o">=-</span><span class="mi">2</span><span class="p">)</span>

  521. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">(</span><span class="n">a</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">b</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span> <span class="n">c</span><span class="o">=</span><span class="mi">3</span><span class="p">,</span> <span class="n">d</span><span class="o">=</span><span class="mi">4</span><span class="p">)</span>

  522. <span class="gp">&gt;&gt;&gt; </span><span class="n">c</span><span class="o">.</span><span class="n">subtract</span><span class="p">(</span><span class="n">d</span><span class="p">)</span>

  523. <span class="gp">&gt;&gt;&gt; </span><span class="n">c</span>

  524. <span class="go">Counter({&#39;a&#39;: 3, &#39;b&#39;: 0, &#39;c&#39;: -3, &#39;d&#39;: -6})</span>

  525. </pre></div>

  526. </div>

  527. <div class="versionadded">

  528. <p><span class="versionmodified added">New in version 3.2.</span></p>

  529. </div>

  530. </dd></dl>

  531. 

  532. <dl class="py method">

  533. <dt class="sig sig-object py" id="collections.Counter.total">

  534. <span class="sig-name descname"><span class="pre">total</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.Counter.total" title="Link to this definition">¶</a></dt>

  535. <dd><p>Compute the sum of the counts.</p>

  536. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">(</span><span class="n">a</span><span class="o">=</span><span class="mi">10</span><span class="p">,</span> <span class="n">b</span><span class="o">=</span><span class="mi">5</span><span class="p">,</span> <span class="n">c</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span>

  537. <span class="gp">&gt;&gt;&gt; </span><span class="n">c</span><span class="o">.</span><span class="n">total</span><span class="p">()</span>

  538. <span class="go">15</span>

  539. </pre></div>

  540. </div>

  541. <div class="versionadded">

  542. <p><span class="versionmodified added">New in version 3.10.</span></p>

  543. </div>

  544. </dd></dl>

  545. 

  546. <p>The usual dictionary methods are available for <a class="reference internal" href="#collections.Counter" title="collections.Counter"><code class="xref py py-class docutils literal notranslate"><span class="pre">Counter</span></code></a> objects

  547. except for two which work differently for counters.</p>

  548. <dl class="py method">

  549. <dt class="sig sig-object py" id="collections.Counter.fromkeys">

  550. <span class="sig-name descname"><span class="pre">fromkeys</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">iterable</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.Counter.fromkeys" title="Link to this definition">¶</a></dt>

  551. <dd><p>This class method is not implemented for <a class="reference internal" href="#collections.Counter" title="collections.Counter"><code class="xref py py-class docutils literal notranslate"><span class="pre">Counter</span></code></a> objects.</p>

  552. </dd></dl>

  553. 

  554. <dl class="py method">

  555. <dt class="sig sig-object py" id="collections.Counter.update">

  556. <span class="sig-name descname"><span class="pre">update</span></span><span class="sig-paren">(</span><span class="optional">[</span><em class="sig-param"><span class="n"><span class="pre">iterable-or-mapping</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.Counter.update" title="Link to this definition">¶</a></dt>

  557. <dd><p>Elements are counted from an <em>iterable</em> or added-in from another

  558. <em>mapping</em> (or counter).  Like <a class="reference internal" href="stdtypes.html#dict.update" title="dict.update"><code class="xref py py-meth docutils literal notranslate"><span class="pre">dict.update()</span></code></a> but adds counts

  559. instead of replacing them.  Also, the <em>iterable</em> is expected to be a

  560. sequence of elements, not a sequence of <code class="docutils literal notranslate"><span class="pre">(key,</span> <span class="pre">value)</span></code> pairs.</p>

  561. </dd></dl>

  562. 

  563. </dd></dl>

  564. 

  565. <p>Counters support rich comparison operators for equality, subset, and

  566. superset relationships: <code class="docutils literal notranslate"><span class="pre">==</span></code>, <code class="docutils literal notranslate"><span class="pre">!=</span></code>, <code class="docutils literal notranslate"><span class="pre">&lt;</span></code>, <code class="docutils literal notranslate"><span class="pre">&lt;=</span></code>, <code class="docutils literal notranslate"><span class="pre">&gt;</span></code>, <code class="docutils literal notranslate"><span class="pre">&gt;=</span></code>.

  567. All of those tests treat missing elements as having zero counts so that

  568. <code class="docutils literal notranslate"><span class="pre">Counter(a=1)</span> <span class="pre">==</span> <span class="pre">Counter(a=1,</span> <span class="pre">b=0)</span></code> returns true.</p>

  569. <div class="versionchanged">

  570. <p><span class="versionmodified changed">Changed in version 3.10: </span>Rich comparison operations were added.</p>

  571. </div>

  572. <div class="versionchanged">

  573. <p><span class="versionmodified changed">Changed in version 3.10: </span>In equality tests, missing elements are treated as having zero counts.

  574. Formerly, <code class="docutils literal notranslate"><span class="pre">Counter(a=3)</span></code> and <code class="docutils literal notranslate"><span class="pre">Counter(a=3,</span> <span class="pre">b=0)</span></code> were considered

  575. distinct.</p>

  576. </div>

  577. <p>Common patterns for working with <a class="reference internal" href="#collections.Counter" title="collections.Counter"><code class="xref py py-class docutils literal notranslate"><span class="pre">Counter</span></code></a> objects:</p>

  578. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">c</span><span class="o">.</span><span class="n">total</span><span class="p">()</span>                       <span class="c1"># total of all counts</span>

  579. <span class="n">c</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>                       <span class="c1"># reset all counts</span>

  580. <span class="nb">list</span><span class="p">(</span><span class="n">c</span><span class="p">)</span>                         <span class="c1"># list unique elements</span>

  581. <span class="nb">set</span><span class="p">(</span><span class="n">c</span><span class="p">)</span>                          <span class="c1"># convert to a set</span>

  582. <span class="nb">dict</span><span class="p">(</span><span class="n">c</span><span class="p">)</span>                         <span class="c1"># convert to a regular dictionary</span>

  583. <span class="n">c</span><span class="o">.</span><span class="n">items</span><span class="p">()</span>                       <span class="c1"># convert to a list of (elem, cnt) pairs</span>

  584. <span class="n">Counter</span><span class="p">(</span><span class="nb">dict</span><span class="p">(</span><span class="n">list_of_pairs</span><span class="p">))</span>    <span class="c1"># convert from a list of (elem, cnt) pairs</span>

  585. <span class="n">c</span><span class="o">.</span><span class="n">most_common</span><span class="p">()[:</span><span class="o">-</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">:</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>       <span class="c1"># n least common elements</span>

  586. <span class="o">+</span><span class="n">c</span>                              <span class="c1"># remove zero and negative counts</span>

  587. </pre></div>

  588. </div>

  589. <p>Several mathematical operations are provided for combining <a class="reference internal" href="#collections.Counter" title="collections.Counter"><code class="xref py py-class docutils literal notranslate"><span class="pre">Counter</span></code></a>

  590. objects to produce multisets (counters that have counts greater than zero).

  591. Addition and subtraction combine counters by adding or subtracting the counts

  592. of corresponding elements.  Intersection and union return the minimum and

  593. maximum of corresponding counts.  Equality and inclusion compare

  594. corresponding counts.  Each operation can accept inputs with signed

  595. counts, but the output will exclude results with counts of zero or less.</p>

  596. <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">(</span><span class="n">a</span><span class="o">=</span><span class="mi">3</span><span class="p">,</span> <span class="n">b</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>

  597. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">(</span><span class="n">a</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">b</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>

  598. <span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">+</span> <span class="n">d</span>                       <span class="c1"># add two counters together:  c[x] + d[x]</span>

  599. <span class="go">Counter({&#39;a&#39;: 4, &#39;b&#39;: 3})</span>

  600. <span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">-</span> <span class="n">d</span>                       <span class="c1"># subtract (keeping only positive counts)</span>

  601. <span class="go">Counter({&#39;a&#39;: 2})</span>

  602. <span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">&amp;</span> <span class="n">d</span>                       <span class="c1"># intersection:  min(c[x], d[x])</span>

  603. <span class="go">Counter({&#39;a&#39;: 1, &#39;b&#39;: 1})</span>

  604. <span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">|</span> <span class="n">d</span>                       <span class="c1"># union:  max(c[x], d[x])</span>

  605. <span class="go">Counter({&#39;a&#39;: 3, &#39;b&#39;: 2})</span>

  606. <span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">==</span> <span class="n">d</span>                      <span class="c1"># equality:  c[x] == d[x]</span>

  607. <span class="go">False</span>

  608. <span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">&lt;=</span> <span class="n">d</span>                      <span class="c1"># inclusion:  c[x] &lt;= d[x]</span>

  609. <span class="go">False</span>

  610. </pre></div>

  611. </div>

  612. <p>Unary addition and subtraction are shortcuts for adding an empty counter

  613. or subtracting from an empty counter.</p>

  614. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">(</span><span class="n">a</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span> <span class="n">b</span><span class="o">=-</span><span class="mi">4</span><span class="p">)</span>

  615. <span class="gp">&gt;&gt;&gt; </span><span class="o">+</span><span class="n">c</span>

  616. <span class="go">Counter({&#39;a&#39;: 2})</span>

  617. <span class="gp">&gt;&gt;&gt; </span><span class="o">-</span><span class="n">c</span>

  618. <span class="go">Counter({&#39;b&#39;: 4})</span>

  619. </pre></div>

  620. </div>

  621. <div class="versionadded">

  622. <p><span class="versionmodified added">New in version 3.3: </span>Added support for unary plus, unary minus, and in-place multiset operations.</p>

  623. </div>

  624. <div class="admonition note">

  625. <p class="admonition-title">Note</p>

  626. <p>Counters were primarily designed to work with positive integers to represent

  627. running counts; however, care was taken to not unnecessarily preclude use

  628. cases needing other types or negative values.  To help with those use cases,

  629. this section documents the minimum range and type restrictions.</p>

  630. <ul class="simple">

  631. <li><p>The <a class="reference internal" href="#collections.Counter" title="collections.Counter"><code class="xref py py-class docutils literal notranslate"><span class="pre">Counter</span></code></a> class itself is a dictionary subclass with no

  632. restrictions on its keys and values.  The values are intended to be numbers

  633. representing counts, but you <em>could</em> store anything in the value field.</p></li>

  634. <li><p>The <a class="reference internal" href="#collections.Counter.most_common" title="collections.Counter.most_common"><code class="xref py py-meth docutils literal notranslate"><span class="pre">most_common()</span></code></a> method requires only that the values be orderable.</p></li>

  635. <li><p>For in-place operations such as <code class="docutils literal notranslate"><span class="pre">c[key]</span> <span class="pre">+=</span> <span class="pre">1</span></code>, the value type need only

  636. support addition and subtraction.  So fractions, floats, and decimals would

  637. work and negative values are supported.  The same is also true for

  638. <a class="reference internal" href="#collections.Counter.update" title="collections.Counter.update"><code class="xref py py-meth docutils literal notranslate"><span class="pre">update()</span></code></a> and <a class="reference internal" href="#collections.Counter.subtract" title="collections.Counter.subtract"><code class="xref py py-meth docutils literal notranslate"><span class="pre">subtract()</span></code></a> which allow negative and zero values

  639. for both inputs and outputs.</p></li>

  640. <li><p>The multiset methods are designed only for use cases with positive values.

  641. The inputs may be negative or zero, but only outputs with positive values

  642. are created.  There are no type restrictions, but the value type needs to

  643. support addition, subtraction, and comparison.</p></li>

  644. <li><p>The <a class="reference internal" href="#collections.Counter.elements" title="collections.Counter.elements"><code class="xref py py-meth docutils literal notranslate"><span class="pre">elements()</span></code></a> method requires integer counts.  It ignores zero and

  645. negative counts.</p></li>

  646. </ul>

  647. </div>

  648. <div class="admonition seealso">

  649. <p class="admonition-title">See also</p>

  650. <ul>

  651. <li><p><a class="reference external" href="https://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html">Bag class</a>

  652. in Smalltalk.</p></li>

  653. <li><p>Wikipedia entry for <a class="reference external" href="https://en.wikipedia.org/wiki/Multiset">Multisets</a>.</p></li>

  654. <li><p><a class="reference external" href="http://www.java2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm">C++ multisets</a>

  655. tutorial with examples.</p></li>

  656. <li><p>For mathematical operations on multisets and their use cases, see

  657. <em>Knuth, Donald. The Art of Computer Programming Volume II,

  658. Section 4.6.3, Exercise 19</em>.</p></li>

  659. <li><p>To enumerate all distinct multisets of a given size over a given set of

  660. elements, see <a class="reference internal" href="itertools.html#itertools.combinations_with_replacement" title="itertools.combinations_with_replacement"><code class="xref py py-func docutils literal notranslate"><span class="pre">itertools.combinations_with_replacement()</span></code></a>:</p>

  661. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="nb">map</span><span class="p">(</span><span class="n">Counter</span><span class="p">,</span> <span class="n">combinations_with_replacement</span><span class="p">(</span><span class="s1">&#39;ABC&#39;</span><span class="p">,</span> <span class="mi">2</span><span class="p">))</span> <span class="c1"># --&gt; AA AB AC BB BC CC</span>

  662. </pre></div>

  663. </div>

  664. </li>

  665. </ul>

  666. </div>

  667. </section>

  668. <section id="deque-objects">

  669. <h2><a class="reference internal" href="#collections.deque" title="collections.deque"><code class="xref py py-class docutils literal notranslate"><span class="pre">deque</span></code></a> objects<a class="headerlink" href="#deque-objects" title="Link to this heading">¶</a></h2>

  670. <dl class="py class">

  671. <dt class="sig sig-object py" id="collections.deque">

  672. <em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">collections.</span></span><span class="sig-name descname"><span class="pre">deque</span></span><span class="sig-paren">(</span><span class="optional">[</span><em class="sig-param"><span class="n"><span class="pre">iterable</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">maxlen</span></span></em><span class="optional">]</span><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.deque" title="Link to this definition">¶</a></dt>

  673. <dd><p>Returns a new deque object initialized left-to-right (using <a class="reference internal" href="#collections.deque.append" title="collections.deque.append"><code class="xref py py-meth docutils literal notranslate"><span class="pre">append()</span></code></a>) with

  674. data from <em>iterable</em>.  If <em>iterable</em> is not specified, the new deque is empty.</p>

  675. <p>Deques are a generalization of stacks and queues (the name is pronounced “deck”

  676. and is short for “double-ended queue”).  Deques support thread-safe, memory

  677. efficient appends and pops from either side of the deque with approximately the

  678. same <em>O</em>(1) performance in either direction.</p>

  679. <p>Though <a class="reference internal" href="stdtypes.html#list" title="list"><code class="xref py py-class docutils literal notranslate"><span class="pre">list</span></code></a> objects support similar operations, they are optimized for

  680. fast fixed-length operations and incur <em>O</em>(<em>n</em>) memory movement costs for

  681. <code class="docutils literal notranslate"><span class="pre">pop(0)</span></code> and <code class="docutils literal notranslate"><span class="pre">insert(0,</span> <span class="pre">v)</span></code> operations which change both the size and

  682. position of the underlying data representation.</p>

  683. <p>If <em>maxlen</em> is not specified or is <code class="docutils literal notranslate"><span class="pre">None</span></code>, deques may grow to an

  684. arbitrary length.  Otherwise, the deque is bounded to the specified maximum

  685. length.  Once a bounded length deque is full, when new items are added, a

  686. corresponding number of items are discarded from the opposite end.  Bounded

  687. length deques provide functionality similar to the <code class="docutils literal notranslate"><span class="pre">tail</span></code> filter in

  688. Unix. They are also useful for tracking transactions and other pools of data

  689. where only the most recent activity is of interest.</p>

  690. <p>Deque objects support the following methods:</p>

  691. <dl class="py method">

  692. <dt class="sig sig-object py" id="collections.deque.append">

  693. <span class="sig-name descname"><span class="pre">append</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.deque.append" title="Link to this definition">¶</a></dt>

  694. <dd><p>Add <em>x</em> to the right side of the deque.</p>

  695. </dd></dl>

  696. 

  697. <dl class="py method">

  698. <dt class="sig sig-object py" id="collections.deque.appendleft">

  699. <span class="sig-name descname"><span class="pre">appendleft</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.deque.appendleft" title="Link to this definition">¶</a></dt>

  700. <dd><p>Add <em>x</em> to the left side of the deque.</p>

  701. </dd></dl>

  702. 

  703. <dl class="py method">

  704. <dt class="sig sig-object py" id="collections.deque.clear">

  705. <span class="sig-name descname"><span class="pre">clear</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.deque.clear" title="Link to this definition">¶</a></dt>

  706. <dd><p>Remove all elements from the deque leaving it with length 0.</p>

  707. </dd></dl>

  708. 

  709. <dl class="py method">

  710. <dt class="sig sig-object py" id="collections.deque.copy">

  711. <span class="sig-name descname"><span class="pre">copy</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.deque.copy" title="Link to this definition">¶</a></dt>

  712. <dd><p>Create a shallow copy of the deque.</p>

  713. <div class="versionadded">

  714. <p><span class="versionmodified added">New in version 3.5.</span></p>

  715. </div>

  716. </dd></dl>

  717. 

  718. <dl class="py method">

  719. <dt class="sig sig-object py" id="collections.deque.count">

  720. <span class="sig-name descname"><span class="pre">count</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.deque.count" title="Link to this definition">¶</a></dt>

  721. <dd><p>Count the number of deque elements equal to <em>x</em>.</p>

  722. <div class="versionadded">

  723. <p><span class="versionmodified added">New in version 3.2.</span></p>

  724. </div>

  725. </dd></dl>

  726. 

  727. <dl class="py method">

  728. <dt class="sig sig-object py" id="collections.deque.extend">

  729. <span class="sig-name descname"><span class="pre">extend</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">iterable</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.deque.extend" title="Link to this definition">¶</a></dt>

  730. <dd><p>Extend the right side of the deque by appending elements from the iterable

  731. argument.</p>

  732. </dd></dl>

  733. 

  734. <dl class="py method">

  735. <dt class="sig sig-object py" id="collections.deque.extendleft">

  736. <span class="sig-name descname"><span class="pre">extendleft</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">iterable</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.deque.extendleft" title="Link to this definition">¶</a></dt>

  737. <dd><p>Extend the left side of the deque by appending elements from <em>iterable</em>.

  738. Note, the series of left appends results in reversing the order of

  739. elements in the iterable argument.</p>

  740. </dd></dl>

  741. 

  742. <dl class="py method">

  743. <dt class="sig sig-object py" id="collections.deque.index">

  744. <span class="sig-name descname"><span class="pre">index</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">start</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">stop</span></span></em><span class="optional">]</span><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.deque.index" title="Link to this definition">¶</a></dt>

  745. <dd><p>Return the position of <em>x</em> in the deque (at or after index <em>start</em>

  746. and before index <em>stop</em>).  Returns the first match or raises

  747. <a class="reference internal" href="exceptions.html#ValueError" title="ValueError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">ValueError</span></code></a> if not found.</p>

  748. <div class="versionadded">

  749. <p><span class="versionmodified added">New in version 3.5.</span></p>

  750. </div>

  751. </dd></dl>

  752. 

  753. <dl class="py method">

  754. <dt class="sig sig-object py" id="collections.deque.insert">

  755. <span class="sig-name descname"><span class="pre">insert</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">i</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">x</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.deque.insert" title="Link to this definition">¶</a></dt>

  756. <dd><p>Insert <em>x</em> into the deque at position <em>i</em>.</p>

  757. <p>If the insertion would cause a bounded deque to grow beyond <em>maxlen</em>,

  758. an <a class="reference internal" href="exceptions.html#IndexError" title="IndexError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">IndexError</span></code></a> is raised.</p>

  759. <div class="versionadded">

  760. <p><span class="versionmodified added">New in version 3.5.</span></p>

  761. </div>

  762. </dd></dl>

  763. 

  764. <dl class="py method">

  765. <dt class="sig sig-object py" id="collections.deque.pop">

  766. <span class="sig-name descname"><span class="pre">pop</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.deque.pop" title="Link to this definition">¶</a></dt>

  767. <dd><p>Remove and return an element from the right side of the deque. If no

  768. elements are present, raises an <a class="reference internal" href="exceptions.html#IndexError" title="IndexError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">IndexError</span></code></a>.</p>

  769. </dd></dl>

  770. 

  771. <dl class="py method">

  772. <dt class="sig sig-object py" id="collections.deque.popleft">

  773. <span class="sig-name descname"><span class="pre">popleft</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.deque.popleft" title="Link to this definition">¶</a></dt>

  774. <dd><p>Remove and return an element from the left side of the deque. If no

  775. elements are present, raises an <a class="reference internal" href="exceptions.html#IndexError" title="IndexError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">IndexError</span></code></a>.</p>

  776. </dd></dl>

  777. 

  778. <dl class="py method">

  779. <dt class="sig sig-object py" id="collections.deque.remove">

  780. <span class="sig-name descname"><span class="pre">remove</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">value</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.deque.remove" title="Link to this definition">¶</a></dt>

  781. <dd><p>Remove the first occurrence of <em>value</em>.  If not found, raises a

  782. <a class="reference internal" href="exceptions.html#ValueError" title="ValueError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">ValueError</span></code></a>.</p>

  783. </dd></dl>

  784. 

  785. <dl class="py method">

  786. <dt class="sig sig-object py" id="collections.deque.reverse">

  787. <span class="sig-name descname"><span class="pre">reverse</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.deque.reverse" title="Link to this definition">¶</a></dt>

  788. <dd><p>Reverse the elements of the deque in-place and then return <code class="docutils literal notranslate"><span class="pre">None</span></code>.</p>

  789. <div class="versionadded">

  790. <p><span class="versionmodified added">New in version 3.2.</span></p>

  791. </div>

  792. </dd></dl>

  793. 

  794. <dl class="py method">

  795. <dt class="sig sig-object py" id="collections.deque.rotate">

  796. <span class="sig-name descname"><span class="pre">rotate</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">n</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">1</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.deque.rotate" title="Link to this definition">¶</a></dt>

  797. <dd><p>Rotate the deque <em>n</em> steps to the right.  If <em>n</em> is negative, rotate

  798. to the left.</p>

  799. <p>When the deque is not empty, rotating one step to the right is equivalent

  800. to <code class="docutils literal notranslate"><span class="pre">d.appendleft(d.pop())</span></code>, and rotating one step to the left is

  801. equivalent to <code class="docutils literal notranslate"><span class="pre">d.append(d.popleft())</span></code>.</p>

  802. </dd></dl>

  803. 

  804. <p>Deque objects also provide one read-only attribute:</p>

  805. <dl class="py attribute">

  806. <dt class="sig sig-object py" id="collections.deque.maxlen">

  807. <span class="sig-name descname"><span class="pre">maxlen</span></span><a class="headerlink" href="#collections.deque.maxlen" title="Link to this definition">¶</a></dt>

  808. <dd><p>Maximum size of a deque or <code class="docutils literal notranslate"><span class="pre">None</span></code> if unbounded.</p>

  809. <div class="versionadded">

  810. <p><span class="versionmodified added">New in version 3.1.</span></p>

  811. </div>

  812. </dd></dl>

  813. 

  814. </dd></dl>

  815. 

  816. <p>In addition to the above, deques support iteration, pickling, <code class="docutils literal notranslate"><span class="pre">len(d)</span></code>,

  817. <code class="docutils literal notranslate"><span class="pre">reversed(d)</span></code>, <code class="docutils literal notranslate"><span class="pre">copy.copy(d)</span></code>, <code class="docutils literal notranslate"><span class="pre">copy.deepcopy(d)</span></code>, membership testing with

  818. the <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> operator, and subscript references such as <code class="docutils literal notranslate"><span class="pre">d[0]</span></code> to access

  819. the first element.  Indexed access is <em>O</em>(1) at both ends but slows to <em>O</em>(<em>n</em>) in

  820. the middle.  For fast random access, use lists instead.</p>

  821. <p>Starting in version 3.5, deques support <code class="docutils literal notranslate"><span class="pre">__add__()</span></code>, <code class="docutils literal notranslate"><span class="pre">__mul__()</span></code>,

  822. and <code class="docutils literal notranslate"><span class="pre">__imul__()</span></code>.</p>

  823. <p>Example:</p>

  824. <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">collections</span> <span class="kn">import</span> <span class="n">deque</span>

  825. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span> <span class="o">=</span> <span class="n">deque</span><span class="p">(</span><span class="s1">&#39;ghi&#39;</span><span class="p">)</span>                 <span class="c1"># make a new deque with three items</span>

  826. <span class="gp">&gt;&gt;&gt; </span><span class="k">for</span> <span class="n">elem</span> <span class="ow">in</span> <span class="n">d</span><span class="p">:</span>                   <span class="c1"># iterate over the deque&#39;s elements</span>

  827. <span class="gp">... </span>    <span class="nb">print</span><span class="p">(</span><span class="n">elem</span><span class="o">.</span><span class="n">upper</span><span class="p">())</span>

  828. <span class="go">G</span>

  829. <span class="go">H</span>

  830. <span class="go">I</span>

  831. 

  832. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="s1">&#39;j&#39;</span><span class="p">)</span>                    <span class="c1"># add a new entry to the right side</span>

  833. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span><span class="o">.</span><span class="n">appendleft</span><span class="p">(</span><span class="s1">&#39;f&#39;</span><span class="p">)</span>                <span class="c1"># add a new entry to the left side</span>

  834. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span>                                <span class="c1"># show the representation of the deque</span>

  835. <span class="go">deque([&#39;f&#39;, &#39;g&#39;, &#39;h&#39;, &#39;i&#39;, &#39;j&#39;])</span>

  836. 

  837. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>                          <span class="c1"># return and remove the rightmost item</span>

  838. <span class="go">&#39;j&#39;</span>

  839. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span><span class="o">.</span><span class="n">popleft</span><span class="p">()</span>                      <span class="c1"># return and remove the leftmost item</span>

  840. <span class="go">&#39;f&#39;</span>

  841. <span class="gp">&gt;&gt;&gt; </span><span class="nb">list</span><span class="p">(</span><span class="n">d</span><span class="p">)</span>                          <span class="c1"># list the contents of the deque</span>

  842. <span class="go">[&#39;g&#39;, &#39;h&#39;, &#39;i&#39;]</span>

  843. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>                             <span class="c1"># peek at leftmost item</span>

  844. <span class="go">&#39;g&#39;</span>

  845. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>                            <span class="c1"># peek at rightmost item</span>

  846. <span class="go">&#39;i&#39;</span>

  847. 

  848. <span class="gp">&gt;&gt;&gt; </span><span class="nb">list</span><span class="p">(</span><span class="nb">reversed</span><span class="p">(</span><span class="n">d</span><span class="p">))</span>                <span class="c1"># list the contents of a deque in reverse</span>

  849. <span class="go">[&#39;i&#39;, &#39;h&#39;, &#39;g&#39;]</span>

  850. <span class="gp">&gt;&gt;&gt; </span><span class="s1">&#39;h&#39;</span> <span class="ow">in</span> <span class="n">d</span>                         <span class="c1"># search the deque</span>

  851. <span class="go">True</span>

  852. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="s1">&#39;jkl&#39;</span><span class="p">)</span>                  <span class="c1"># add multiple elements at once</span>

  853. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span>

  854. <span class="go">deque([&#39;g&#39;, &#39;h&#39;, &#39;i&#39;, &#39;j&#39;, &#39;k&#39;, &#39;l&#39;])</span>

  855. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span><span class="o">.</span><span class="n">rotate</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>                      <span class="c1"># right rotation</span>

  856. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span>

  857. <span class="go">deque([&#39;l&#39;, &#39;g&#39;, &#39;h&#39;, &#39;i&#39;, &#39;j&#39;, &#39;k&#39;])</span>

  858. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span><span class="o">.</span><span class="n">rotate</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>                     <span class="c1"># left rotation</span>

  859. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span>

  860. <span class="go">deque([&#39;g&#39;, &#39;h&#39;, &#39;i&#39;, &#39;j&#39;, &#39;k&#39;, &#39;l&#39;])</span>

  861. 

  862. <span class="gp">&gt;&gt;&gt; </span><span class="n">deque</span><span class="p">(</span><span class="nb">reversed</span><span class="p">(</span><span class="n">d</span><span class="p">))</span>               <span class="c1"># make a new deque in reverse order</span>

  863. <span class="go">deque([&#39;l&#39;, &#39;k&#39;, &#39;j&#39;, &#39;i&#39;, &#39;h&#39;, &#39;g&#39;])</span>

  864. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>                        <span class="c1"># empty the deque</span>

  865. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>                          <span class="c1"># cannot pop from an empty deque</span>

  866. <span class="gt">Traceback (most recent call last):</span>

  867. <span class="w">    </span><span class="n">File</span> <span class="s2">&quot;&lt;pyshell#6&gt;&quot;</span><span class="p">,</span> <span class="n">line</span> <span class="mi">1</span><span class="p">,</span> <span class="ow">in</span> <span class="o">-</span><span class="n">toplevel</span><span class="o">-</span>

  868. <span class="w">    </span>    <span class="n">d</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>

  869. <span class="gr">IndexError</span>: <span class="n">pop from an empty deque</span>

  870. 

  871. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span><span class="o">.</span><span class="n">extendleft</span><span class="p">(</span><span class="s1">&#39;abc&#39;</span><span class="p">)</span>              <span class="c1"># extendleft() reverses the input order</span>

  872. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span>

  873. <span class="go">deque([&#39;c&#39;, &#39;b&#39;, &#39;a&#39;])</span>

  874. </pre></div>

  875. </div>

  876. <section id="deque-recipes">

  877. <h3><a class="reference internal" href="#collections.deque" title="collections.deque"><code class="xref py py-class docutils literal notranslate"><span class="pre">deque</span></code></a> Recipes<a class="headerlink" href="#deque-recipes" title="Link to this heading">¶</a></h3>

  878. <p>This section shows various approaches to working with deques.</p>

  879. <p>Bounded length deques provide functionality similar to the <code class="docutils literal notranslate"><span class="pre">tail</span></code> filter

  880. in Unix:</p>

  881. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">tail</span><span class="p">(</span><span class="n">filename</span><span class="p">,</span> <span class="n">n</span><span class="o">=</span><span class="mi">10</span><span class="p">):</span>

  882.     <span class="s1">&#39;Return the last n lines of a file&#39;</span>

  883.     <span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">filename</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>

  884.         <span class="k">return</span> <span class="n">deque</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">n</span><span class="p">)</span>

  885. </pre></div>

  886. </div>

  887. <p>Another approach to using deques is to maintain a sequence of recently

  888. added elements by appending to the right and popping to the left:</p>

  889. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">moving_average</span><span class="p">(</span><span class="n">iterable</span><span class="p">,</span> <span class="n">n</span><span class="o">=</span><span class="mi">3</span><span class="p">):</span>

  890.     <span class="c1"># moving_average([40, 30, 50, 46, 39, 44]) --&gt; 40.0 42.0 45.0 43.0</span>

  891.     <span class="c1"># https://en.wikipedia.org/wiki/Moving_average</span>

  892.     <span class="n">it</span> <span class="o">=</span> <span class="nb">iter</span><span class="p">(</span><span class="n">iterable</span><span class="p">)</span>

  893.     <span class="n">d</span> <span class="o">=</span> <span class="n">deque</span><span class="p">(</span><span class="n">itertools</span><span class="o">.</span><span class="n">islice</span><span class="p">(</span><span class="n">it</span><span class="p">,</span> <span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">))</span>

  894.     <span class="n">d</span><span class="o">.</span><span class="n">appendleft</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>

  895.     <span class="n">s</span> <span class="o">=</span> <span class="nb">sum</span><span class="p">(</span><span class="n">d</span><span class="p">)</span>

  896.     <span class="k">for</span> <span class="n">elem</span> <span class="ow">in</span> <span class="n">it</span><span class="p">:</span>

  897.         <span class="n">s</span> <span class="o">+=</span> <span class="n">elem</span> <span class="o">-</span> <span class="n">d</span><span class="o">.</span><span class="n">popleft</span><span class="p">()</span>

  898.         <span class="n">d</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">elem</span><span class="p">)</span>

  899.         <span class="k">yield</span> <span class="n">s</span> <span class="o">/</span> <span class="n">n</span>

  900. </pre></div>

  901. </div>

  902. <p>A <a class="reference external" href="https://en.wikipedia.org/wiki/Round-robin_scheduling">round-robin scheduler</a> can be implemented with

  903. input iterators stored in a <a class="reference internal" href="#collections.deque" title="collections.deque"><code class="xref py py-class docutils literal notranslate"><span class="pre">deque</span></code></a>.  Values are yielded from the active

  904. iterator in position zero.  If that iterator is exhausted, it can be removed

  905. with <a class="reference internal" href="#collections.deque.popleft" title="collections.deque.popleft"><code class="xref py py-meth docutils literal notranslate"><span class="pre">popleft()</span></code></a>; otherwise, it can be cycled back to the end with

  906. the <a class="reference internal" href="#collections.deque.rotate" title="collections.deque.rotate"><code class="xref py py-meth docutils literal notranslate"><span class="pre">rotate()</span></code></a> method:</p>

  907. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">roundrobin</span><span class="p">(</span><span class="o">*</span><span class="n">iterables</span><span class="p">):</span>

  908.     <span class="s2">&quot;roundrobin(&#39;ABC&#39;, &#39;D&#39;, &#39;EF&#39;) --&gt; A D E B F C&quot;</span>

  909.     <span class="n">iterators</span> <span class="o">=</span> <span class="n">deque</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="nb">iter</span><span class="p">,</span> <span class="n">iterables</span><span class="p">))</span>

  910.     <span class="k">while</span> <span class="n">iterators</span><span class="p">:</span>

  911.         <span class="k">try</span><span class="p">:</span>

  912.             <span class="k">while</span> <span class="kc">True</span><span class="p">:</span>

  913.                 <span class="k">yield</span> <span class="nb">next</span><span class="p">(</span><span class="n">iterators</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>

  914.                 <span class="n">iterators</span><span class="o">.</span><span class="n">rotate</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>

  915.         <span class="k">except</span> <span class="ne">StopIteration</span><span class="p">:</span>

  916.             <span class="c1"># Remove an exhausted iterator.</span>

  917.             <span class="n">iterators</span><span class="o">.</span><span class="n">popleft</span><span class="p">()</span>

  918. </pre></div>

  919. </div>

  920. <p>The <a class="reference internal" href="#collections.deque.rotate" title="collections.deque.rotate"><code class="xref py py-meth docutils literal notranslate"><span class="pre">rotate()</span></code></a> method provides a way to implement <a class="reference internal" href="#collections.deque" title="collections.deque"><code class="xref py py-class docutils literal notranslate"><span class="pre">deque</span></code></a> slicing and

  921. deletion.  For example, a pure Python implementation of <code class="docutils literal notranslate"><span class="pre">del</span> <span class="pre">d[n]</span></code> relies on

  922. the <code class="docutils literal notranslate"><span class="pre">rotate()</span></code> method to position elements to be popped:</p>

  923. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">delete_nth</span><span class="p">(</span><span class="n">d</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span>

  924.     <span class="n">d</span><span class="o">.</span><span class="n">rotate</span><span class="p">(</span><span class="o">-</span><span class="n">n</span><span class="p">)</span>

  925.     <span class="n">d</span><span class="o">.</span><span class="n">popleft</span><span class="p">()</span>

  926.     <span class="n">d</span><span class="o">.</span><span class="n">rotate</span><span class="p">(</span><span class="n">n</span><span class="p">)</span>

  927. </pre></div>

  928. </div>

  929. <p>To implement <a class="reference internal" href="#collections.deque" title="collections.deque"><code class="xref py py-class docutils literal notranslate"><span class="pre">deque</span></code></a> slicing, use a similar approach applying

  930. <a class="reference internal" href="#collections.deque.rotate" title="collections.deque.rotate"><code class="xref py py-meth docutils literal notranslate"><span class="pre">rotate()</span></code></a> to bring a target element to the left side of the deque. Remove

  931. old entries with <a class="reference internal" href="#collections.deque.popleft" title="collections.deque.popleft"><code class="xref py py-meth docutils literal notranslate"><span class="pre">popleft()</span></code></a>, add new entries with <a class="reference internal" href="#collections.deque.extend" title="collections.deque.extend"><code class="xref py py-meth docutils literal notranslate"><span class="pre">extend()</span></code></a>, and then

  932. reverse the rotation.

  933. With minor variations on that approach, it is easy to implement Forth style

  934. stack manipulations such as <code class="docutils literal notranslate"><span class="pre">dup</span></code>, <code class="docutils literal notranslate"><span class="pre">drop</span></code>, <code class="docutils literal notranslate"><span class="pre">swap</span></code>, <code class="docutils literal notranslate"><span class="pre">over</span></code>, <code class="docutils literal notranslate"><span class="pre">pick</span></code>,

  935. <code class="docutils literal notranslate"><span class="pre">rot</span></code>, and <code class="docutils literal notranslate"><span class="pre">roll</span></code>.</p>

  936. </section>

  937. </section>

  938. <section id="defaultdict-objects">

  939. <h2><a class="reference internal" href="#collections.defaultdict" title="collections.defaultdict"><code class="xref py py-class docutils literal notranslate"><span class="pre">defaultdict</span></code></a> objects<a class="headerlink" href="#defaultdict-objects" title="Link to this heading">¶</a></h2>

  940. <dl class="py class">

  941. <dt class="sig sig-object py" id="collections.defaultdict">

  942. <em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">collections.</span></span><span class="sig-name descname"><span class="pre">defaultdict</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">default_factory=None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">/</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">...</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.defaultdict" title="Link to this definition">¶</a></dt>

  943. <dd><p>Return a new dictionary-like object.  <a class="reference internal" href="#collections.defaultdict" title="collections.defaultdict"><code class="xref py py-class docutils literal notranslate"><span class="pre">defaultdict</span></code></a> is a subclass of the

  944. built-in <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> class.  It overrides one method and adds one writable

  945. instance variable.  The remaining functionality is the same as for the

  946. <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> class and is not documented here.</p>

  947. <p>The first argument provides the initial value for the <a class="reference internal" href="#collections.defaultdict.default_factory" title="collections.defaultdict.default_factory"><code class="xref py py-attr docutils literal notranslate"><span class="pre">default_factory</span></code></a>

  948. attribute; it defaults to <code class="docutils literal notranslate"><span class="pre">None</span></code>. All remaining arguments are treated the same

  949. as if they were passed to the <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> constructor, including keyword

  950. arguments.</p>

  951. <p><a class="reference internal" href="#collections.defaultdict" title="collections.defaultdict"><code class="xref py py-class docutils literal notranslate"><span class="pre">defaultdict</span></code></a> objects support the following method in addition to the

  952. standard <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> operations:</p>

  953. <dl class="py method">

  954. <dt class="sig sig-object py" id="collections.defaultdict.__missing__">

  955. <span class="sig-name descname"><span class="pre">__missing__</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">key</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.defaultdict.__missing__" title="Link to this definition">¶</a></dt>

  956. <dd><p>If the <a class="reference internal" href="#collections.defaultdict.default_factory" title="collections.defaultdict.default_factory"><code class="xref py py-attr docutils literal notranslate"><span class="pre">default_factory</span></code></a> attribute is <code class="docutils literal notranslate"><span class="pre">None</span></code>, this raises a

  957. <a class="reference internal" href="exceptions.html#KeyError" title="KeyError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">KeyError</span></code></a> exception with the <em>key</em> as argument.</p>

  958. <p>If <a class="reference internal" href="#collections.defaultdict.default_factory" title="collections.defaultdict.default_factory"><code class="xref py py-attr docutils literal notranslate"><span class="pre">default_factory</span></code></a> is not <code class="docutils literal notranslate"><span class="pre">None</span></code>, it is called without arguments

  959. to provide a default value for the given <em>key</em>, this value is inserted in

  960. the dictionary for the <em>key</em>, and returned.</p>

  961. <p>If calling <a class="reference internal" href="#collections.defaultdict.default_factory" title="collections.defaultdict.default_factory"><code class="xref py py-attr docutils literal notranslate"><span class="pre">default_factory</span></code></a> raises an exception this exception is

  962. propagated unchanged.</p>

  963. <p>This method is called by the <a class="reference internal" href="../reference/datamodel.html#object.__getitem__" title="object.__getitem__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__getitem__()</span></code></a> method of the

  964. <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> class when the requested key is not found; whatever it

  965. returns or raises is then returned or raised by <a class="reference internal" href="../reference/datamodel.html#object.__getitem__" title="object.__getitem__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__getitem__()</span></code></a>.</p>

  966. <p>Note that <a class="reference internal" href="#collections.defaultdict.__missing__" title="collections.defaultdict.__missing__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__missing__()</span></code></a> is <em>not</em> called for any operations besides

  967. <a class="reference internal" href="../reference/datamodel.html#object.__getitem__" title="object.__getitem__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__getitem__()</span></code></a>. This means that <code class="xref py py-meth docutils literal notranslate"><span class="pre">get()</span></code> will, like normal

  968. dictionaries, return <code class="docutils literal notranslate"><span class="pre">None</span></code> as a default rather than using

  969. <a class="reference internal" href="#collections.defaultdict.default_factory" title="collections.defaultdict.default_factory"><code class="xref py py-attr docutils literal notranslate"><span class="pre">default_factory</span></code></a>.</p>

  970. </dd></dl>

  971. 

  972. <p><a class="reference internal" href="#collections.defaultdict" title="collections.defaultdict"><code class="xref py py-class docutils literal notranslate"><span class="pre">defaultdict</span></code></a> objects support the following instance variable:</p>

  973. <dl class="py attribute">

  974. <dt class="sig sig-object py" id="collections.defaultdict.default_factory">

  975. <span class="sig-name descname"><span class="pre">default_factory</span></span><a class="headerlink" href="#collections.defaultdict.default_factory" title="Link to this definition">¶</a></dt>

  976. <dd><p>This attribute is used by the <a class="reference internal" href="#collections.defaultdict.__missing__" title="collections.defaultdict.__missing__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__missing__()</span></code></a> method; it is

  977. initialized from the first argument to the constructor, if present, or to

  978. <code class="docutils literal notranslate"><span class="pre">None</span></code>, if absent.</p>

  979. </dd></dl>

  980. 

  981. <div class="versionchanged">

  982. <p><span class="versionmodified changed">Changed in version 3.9: </span>Added merge (<code class="docutils literal notranslate"><span class="pre">|</span></code>) and update (<code class="docutils literal notranslate"><span class="pre">|=</span></code>) operators, specified in

  983. <span class="target" id="index-1"></span><a class="pep reference external" href="https://peps.python.org/pep-0584/"><strong>PEP 584</strong></a>.</p>

  984. </div>

  985. </dd></dl>

  986. 

  987. <section id="defaultdict-examples">

  988. <h3><a class="reference internal" href="#collections.defaultdict" title="collections.defaultdict"><code class="xref py py-class docutils literal notranslate"><span class="pre">defaultdict</span></code></a> Examples<a class="headerlink" href="#defaultdict-examples" title="Link to this heading">¶</a></h3>

  989. <p>Using <a class="reference internal" href="stdtypes.html#list" title="list"><code class="xref py py-class docutils literal notranslate"><span class="pre">list</span></code></a> as the <a class="reference internal" href="#collections.defaultdict.default_factory" title="collections.defaultdict.default_factory"><code class="xref py py-attr docutils literal notranslate"><span class="pre">default_factory</span></code></a>, it is easy to group a

  990. sequence of key-value pairs into a dictionary of lists:</p>

  991. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">s</span> <span class="o">=</span> <span class="p">[(</span><span class="s1">&#39;yellow&#39;</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="p">(</span><span class="s1">&#39;blue&#39;</span><span class="p">,</span> <span class="mi">2</span><span class="p">),</span> <span class="p">(</span><span class="s1">&#39;yellow&#39;</span><span class="p">,</span> <span class="mi">3</span><span class="p">),</span> <span class="p">(</span><span class="s1">&#39;blue&#39;</span><span class="p">,</span> <span class="mi">4</span><span class="p">),</span> <span class="p">(</span><span class="s1">&#39;red&#39;</span><span class="p">,</span> <span class="mi">1</span><span class="p">)]</span>

  992. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span> <span class="o">=</span> <span class="n">defaultdict</span><span class="p">(</span><span class="nb">list</span><span class="p">)</span>

  993. <span class="gp">&gt;&gt;&gt; </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">s</span><span class="p">:</span>

  994. <span class="gp">... </span>    <span class="n">d</span><span class="p">[</span><span class="n">k</span><span class="p">]</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>

  995. <span class="gp">...</span>

  996. <span class="gp">&gt;&gt;&gt; </span><span class="nb">sorted</span><span class="p">(</span><span class="n">d</span><span class="o">.</span><span class="n">items</span><span class="p">())</span>

  997. <span class="go">[(&#39;blue&#39;, [2, 4]), (&#39;red&#39;, [1]), (&#39;yellow&#39;, [1, 3])]</span>

  998. </pre></div>

  999. </div>

  1000. <p>When each key is encountered for the first time, it is not already in the

  1001. mapping; so an entry is automatically created using the <a class="reference internal" href="#collections.defaultdict.default_factory" title="collections.defaultdict.default_factory"><code class="xref py py-attr docutils literal notranslate"><span class="pre">default_factory</span></code></a>

  1002. function which returns an empty <a class="reference internal" href="stdtypes.html#list" title="list"><code class="xref py py-class docutils literal notranslate"><span class="pre">list</span></code></a>.  The <code class="xref py py-meth docutils literal notranslate"><span class="pre">list.append()</span></code>

  1003. operation then attaches the value to the new list.  When keys are encountered

  1004. again, the look-up proceeds normally (returning the list for that key) and the

  1005. <code class="xref py py-meth docutils literal notranslate"><span class="pre">list.append()</span></code> operation adds another value to the list. This technique is

  1006. simpler and faster than an equivalent technique using <a class="reference internal" href="stdtypes.html#dict.setdefault" title="dict.setdefault"><code class="xref py py-meth docutils literal notranslate"><span class="pre">dict.setdefault()</span></code></a>:</p>

  1007. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">d</span> <span class="o">=</span> <span class="p">{}</span>

  1008. <span class="gp">&gt;&gt;&gt; </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">s</span><span class="p">:</span>

  1009. <span class="gp">... </span>    <span class="n">d</span><span class="o">.</span><span class="n">setdefault</span><span class="p">(</span><span class="n">k</span><span class="p">,</span> <span class="p">[])</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>

  1010. <span class="gp">...</span>

  1011. <span class="gp">&gt;&gt;&gt; </span><span class="nb">sorted</span><span class="p">(</span><span class="n">d</span><span class="o">.</span><span class="n">items</span><span class="p">())</span>

  1012. <span class="go">[(&#39;blue&#39;, [2, 4]), (&#39;red&#39;, [1]), (&#39;yellow&#39;, [1, 3])]</span>

  1013. </pre></div>

  1014. </div>

  1015. <p>Setting the <a class="reference internal" href="#collections.defaultdict.default_factory" title="collections.defaultdict.default_factory"><code class="xref py py-attr docutils literal notranslate"><span class="pre">default_factory</span></code></a> to <a class="reference internal" href="functions.html#int" title="int"><code class="xref py py-class docutils literal notranslate"><span class="pre">int</span></code></a> makes the

  1016. <a class="reference internal" href="#collections.defaultdict" title="collections.defaultdict"><code class="xref py py-class docutils literal notranslate"><span class="pre">defaultdict</span></code></a> useful for counting (like a bag or multiset in other

  1017. languages):</p>

  1018. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">s</span> <span class="o">=</span> <span class="s1">&#39;mississippi&#39;</span>

  1019. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span> <span class="o">=</span> <span class="n">defaultdict</span><span class="p">(</span><span class="nb">int</span><span class="p">)</span>

  1020. <span class="gp">&gt;&gt;&gt; </span><span class="k">for</span> <span class="n">k</span> <span class="ow">in</span> <span class="n">s</span><span class="p">:</span>

  1021. <span class="gp">... </span>    <span class="n">d</span><span class="p">[</span><span class="n">k</span><span class="p">]</span> <span class="o">+=</span> <span class="mi">1</span>

  1022. <span class="gp">...</span>

  1023. <span class="gp">&gt;&gt;&gt; </span><span class="nb">sorted</span><span class="p">(</span><span class="n">d</span><span class="o">.</span><span class="n">items</span><span class="p">())</span>

  1024. <span class="go">[(&#39;i&#39;, 4), (&#39;m&#39;, 1), (&#39;p&#39;, 2), (&#39;s&#39;, 4)]</span>

  1025. </pre></div>

  1026. </div>

  1027. <p>When a letter is first encountered, it is missing from the mapping, so the

  1028. <a class="reference internal" href="#collections.defaultdict.default_factory" title="collections.defaultdict.default_factory"><code class="xref py py-attr docutils literal notranslate"><span class="pre">default_factory</span></code></a> function calls <a class="reference internal" href="functions.html#int" title="int"><code class="xref py py-func docutils literal notranslate"><span class="pre">int()</span></code></a> to supply a default count of

  1029. zero.  The increment operation then builds up the count for each letter.</p>

  1030. <p>The function <a class="reference internal" href="functions.html#int" title="int"><code class="xref py py-func docutils literal notranslate"><span class="pre">int()</span></code></a> which always returns zero is just a special case of

  1031. constant functions.  A faster and more flexible way to create constant functions

  1032. is to use a lambda function which can supply any constant value (not just

  1033. zero):</p>

  1034. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="k">def</span> <span class="nf">constant_factory</span><span class="p">(</span><span class="n">value</span><span class="p">):</span>

  1035. <span class="gp">... </span>    <span class="k">return</span> <span class="k">lambda</span><span class="p">:</span> <span class="n">value</span>

  1036. <span class="gp">...</span>

  1037. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span> <span class="o">=</span> <span class="n">defaultdict</span><span class="p">(</span><span class="n">constant_factory</span><span class="p">(</span><span class="s1">&#39;&lt;missing&gt;&#39;</span><span class="p">))</span>

  1038. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s1">&#39;John&#39;</span><span class="p">,</span> <span class="n">action</span><span class="o">=</span><span class="s1">&#39;ran&#39;</span><span class="p">)</span>

  1039. <span class="gp">&gt;&gt;&gt; </span><span class="s1">&#39;</span><span class="si">%(name)s</span><span class="s1"> </span><span class="si">%(action)s</span><span class="s1"> to </span><span class="si">%(object)s</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="n">d</span>

  1040. <span class="go">&#39;John ran to &lt;missing&gt;&#39;</span>

  1041. </pre></div>

  1042. </div>

  1043. <p>Setting the <a class="reference internal" href="#collections.defaultdict.default_factory" title="collections.defaultdict.default_factory"><code class="xref py py-attr docutils literal notranslate"><span class="pre">default_factory</span></code></a> to <a class="reference internal" href="stdtypes.html#set" title="set"><code class="xref py py-class docutils literal notranslate"><span class="pre">set</span></code></a> makes the

  1044. <a class="reference internal" href="#collections.defaultdict" title="collections.defaultdict"><code class="xref py py-class docutils literal notranslate"><span class="pre">defaultdict</span></code></a> useful for building a dictionary of sets:</p>

  1045. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">s</span> <span class="o">=</span> <span class="p">[(</span><span class="s1">&#39;red&#39;</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="p">(</span><span class="s1">&#39;blue&#39;</span><span class="p">,</span> <span class="mi">2</span><span class="p">),</span> <span class="p">(</span><span class="s1">&#39;red&#39;</span><span class="p">,</span> <span class="mi">3</span><span class="p">),</span> <span class="p">(</span><span class="s1">&#39;blue&#39;</span><span class="p">,</span> <span class="mi">4</span><span class="p">),</span> <span class="p">(</span><span class="s1">&#39;red&#39;</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="p">(</span><span class="s1">&#39;blue&#39;</span><span class="p">,</span> <span class="mi">4</span><span class="p">)]</span>

  1046. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span> <span class="o">=</span> <span class="n">defaultdict</span><span class="p">(</span><span class="nb">set</span><span class="p">)</span>

  1047. <span class="gp">&gt;&gt;&gt; </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">s</span><span class="p">:</span>

  1048. <span class="gp">... </span>    <span class="n">d</span><span class="p">[</span><span class="n">k</span><span class="p">]</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>

  1049. <span class="gp">...</span>

  1050. <span class="gp">&gt;&gt;&gt; </span><span class="nb">sorted</span><span class="p">(</span><span class="n">d</span><span class="o">.</span><span class="n">items</span><span class="p">())</span>

  1051. <span class="go">[(&#39;blue&#39;, {2, 4}), (&#39;red&#39;, {1, 3})]</span>

  1052. </pre></div>

  1053. </div>

  1054. </section>

  1055. </section>

  1056. <section id="namedtuple-factory-function-for-tuples-with-named-fields">

  1057. <h2><a class="reference internal" href="#collections.namedtuple" title="collections.namedtuple"><code class="xref py py-func docutils literal notranslate"><span class="pre">namedtuple()</span></code></a> Factory Function for Tuples with Named Fields<a class="headerlink" href="#namedtuple-factory-function-for-tuples-with-named-fields" title="Link to this heading">¶</a></h2>

  1058. <p>Named tuples assign meaning to each position in a tuple and allow for more readable,

  1059. self-documenting code.  They can be used wherever regular tuples are used, and

  1060. they add the ability to access fields by name instead of position index.</p>

  1061. <dl class="py function">

  1062. <dt class="sig sig-object py" id="collections.namedtuple">

  1063. <span class="sig-prename descclassname"><span class="pre">collections.</span></span><span class="sig-name descname"><span class="pre">namedtuple</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">typename</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">field_names</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">rename</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">defaults</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">module</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.namedtuple" title="Link to this definition">¶</a></dt>

  1064. <dd><p>Returns a new tuple subclass named <em>typename</em>.  The new subclass is used to

  1065. create tuple-like objects that have fields accessible by attribute lookup as

  1066. well as being indexable and iterable.  Instances of the subclass also have a

  1067. helpful docstring (with typename and field_names) and a helpful <code class="xref py py-meth docutils literal notranslate"><span class="pre">__repr__()</span></code>

  1068. method which lists the tuple contents in a <code class="docutils literal notranslate"><span class="pre">name=value</span></code> format.</p>

  1069. <p>The <em>field_names</em> are a sequence of strings such as <code class="docutils literal notranslate"><span class="pre">['x',</span> <span class="pre">'y']</span></code>.

  1070. Alternatively, <em>field_names</em> can be a single string with each fieldname

  1071. separated by whitespace and/or commas, for example <code class="docutils literal notranslate"><span class="pre">'x</span> <span class="pre">y'</span></code> or <code class="docutils literal notranslate"><span class="pre">'x,</span> <span class="pre">y'</span></code>.</p>

  1072. <p>Any valid Python identifier may be used for a fieldname except for names

  1073. starting with an underscore.  Valid identifiers consist of letters, digits,

  1074. and underscores but do not start with a digit or underscore and cannot be

  1075. a <a class="reference internal" href="keyword.html#module-keyword" title="keyword: Test whether a string is a keyword in Python."><code class="xref py py-mod docutils literal notranslate"><span class="pre">keyword</span></code></a> such as <em>class</em>, <em>for</em>, <em>return</em>, <em>global</em>, <em>pass</em>,

  1076. or <em>raise</em>.</p>

  1077. <p>If <em>rename</em> is true, invalid fieldnames are automatically replaced

  1078. with positional names.  For example, <code class="docutils literal notranslate"><span class="pre">['abc',</span> <span class="pre">'def',</span> <span class="pre">'ghi',</span> <span class="pre">'abc']</span></code> is

  1079. converted to <code class="docutils literal notranslate"><span class="pre">['abc',</span> <span class="pre">'_1',</span> <span class="pre">'ghi',</span> <span class="pre">'_3']</span></code>, eliminating the keyword

  1080. <code class="docutils literal notranslate"><span class="pre">def</span></code> and the duplicate fieldname <code class="docutils literal notranslate"><span class="pre">abc</span></code>.</p>

  1081. <p><em>defaults</em> can be <code class="docutils literal notranslate"><span class="pre">None</span></code> or an <a class="reference internal" href="../glossary.html#term-iterable"><span class="xref std std-term">iterable</span></a> of default values.

  1082. Since fields with a default value must come after any fields without a

  1083. default, the <em>defaults</em> are applied to the rightmost parameters.  For

  1084. example, if the fieldnames are <code class="docutils literal notranslate"><span class="pre">['x',</span> <span class="pre">'y',</span> <span class="pre">'z']</span></code> and the defaults are

  1085. <code class="docutils literal notranslate"><span class="pre">(1,</span> <span class="pre">2)</span></code>, then <code class="docutils literal notranslate"><span class="pre">x</span></code> will be a required argument, <code class="docutils literal notranslate"><span class="pre">y</span></code> will default to

  1086. <code class="docutils literal notranslate"><span class="pre">1</span></code>, and <code class="docutils literal notranslate"><span class="pre">z</span></code> will default to <code class="docutils literal notranslate"><span class="pre">2</span></code>.</p>

  1087. <p>If <em>module</em> is defined, the <code class="docutils literal notranslate"><span class="pre">__module__</span></code> attribute of the named tuple is

  1088. set to that value.</p>

  1089. <p>Named tuple instances do not have per-instance dictionaries, so they are

  1090. lightweight and require no more memory than regular tuples.</p>

  1091. <p>To support pickling, the named tuple class should be assigned to a variable

  1092. that matches <em>typename</em>.</p>

  1093. <div class="versionchanged">

  1094. <p><span class="versionmodified changed">Changed in version 3.1: </span>Added support for <em>rename</em>.</p>

  1095. </div>

  1096. <div class="versionchanged">

  1097. <p><span class="versionmodified changed">Changed in version 3.6: </span>The <em>verbose</em> and <em>rename</em> parameters became

  1098. <a class="reference internal" href="../glossary.html#keyword-only-parameter"><span class="std std-ref">keyword-only arguments</span></a>.</p>

  1099. </div>

  1100. <div class="versionchanged">

  1101. <p><span class="versionmodified changed">Changed in version 3.6: </span>Added the <em>module</em> parameter.</p>

  1102. </div>

  1103. <div class="versionchanged">

  1104. <p><span class="versionmodified changed">Changed in version 3.7: </span>Removed the <em>verbose</em> parameter and the <code class="xref py py-attr docutils literal notranslate"><span class="pre">_source</span></code> attribute.</p>

  1105. </div>

  1106. <div class="versionchanged">

  1107. <p><span class="versionmodified changed">Changed in version 3.7: </span>Added the <em>defaults</em> parameter and the <code class="xref py py-attr docutils literal notranslate"><span class="pre">_field_defaults</span></code>

  1108. attribute.</p>

  1109. </div>

  1110. </dd></dl>

  1111. 

  1112. <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="c1"># Basic example</span>

  1113. <span class="gp">&gt;&gt;&gt; </span><span class="n">Point</span> <span class="o">=</span> <span class="n">namedtuple</span><span class="p">(</span><span class="s1">&#39;Point&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;x&#39;</span><span class="p">,</span> <span class="s1">&#39;y&#39;</span><span class="p">])</span>

  1114. <span class="gp">&gt;&gt;&gt; </span><span class="n">p</span> <span class="o">=</span> <span class="n">Point</span><span class="p">(</span><span class="mi">11</span><span class="p">,</span> <span class="n">y</span><span class="o">=</span><span class="mi">22</span><span class="p">)</span>     <span class="c1"># instantiate with positional or keyword arguments</span>

  1115. <span class="gp">&gt;&gt;&gt; </span><span class="n">p</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">+</span> <span class="n">p</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>             <span class="c1"># indexable like the plain tuple (11, 22)</span>

  1116. <span class="go">33</span>

  1117. <span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">p</span>                <span class="c1"># unpack like a regular tuple</span>

  1118. <span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="p">,</span> <span class="n">y</span>

  1119. <span class="go">(11, 22)</span>

  1120. <span class="gp">&gt;&gt;&gt; </span><span class="n">p</span><span class="o">.</span><span class="n">x</span> <span class="o">+</span> <span class="n">p</span><span class="o">.</span><span class="n">y</span>               <span class="c1"># fields also accessible by name</span>

  1121. <span class="go">33</span>

  1122. <span class="gp">&gt;&gt;&gt; </span><span class="n">p</span>                       <span class="c1"># readable __repr__ with a name=value style</span>

  1123. <span class="go">Point(x=11, y=22)</span>

  1124. </pre></div>

  1125. </div>

  1126. <p>Named tuples are especially useful for assigning field names to result tuples returned

  1127. by the <a class="reference internal" href="csv.html#module-csv" title="csv: Write and read tabular data to and from delimited files."><code class="xref py py-mod docutils literal notranslate"><span class="pre">csv</span></code></a> or <a class="reference internal" href="sqlite3.html#module-sqlite3" title="sqlite3: A DB-API 2.0 implementation using SQLite 3.x."><code class="xref py py-mod docutils literal notranslate"><span class="pre">sqlite3</span></code></a> modules:</p>

  1128. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">EmployeeRecord</span> <span class="o">=</span> <span class="n">namedtuple</span><span class="p">(</span><span class="s1">&#39;EmployeeRecord&#39;</span><span class="p">,</span> <span class="s1">&#39;name, age, title, department, paygrade&#39;</span><span class="p">)</span>

  1129. 

  1130. <span class="kn">import</span> <span class="nn">csv</span>

  1131. <span class="k">for</span> <span class="n">emp</span> <span class="ow">in</span> <span class="nb">map</span><span class="p">(</span><span class="n">EmployeeRecord</span><span class="o">.</span><span class="n">_make</span><span class="p">,</span> <span class="n">csv</span><span class="o">.</span><span class="n">reader</span><span class="p">(</span><span class="nb">open</span><span class="p">(</span><span class="s2">&quot;employees.csv&quot;</span><span class="p">,</span> <span class="s2">&quot;rb&quot;</span><span class="p">))):</span>

  1132.     <span class="nb">print</span><span class="p">(</span><span class="n">emp</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="n">emp</span><span class="o">.</span><span class="n">title</span><span class="p">)</span>

  1133. 

  1134. <span class="kn">import</span> <span class="nn">sqlite3</span>

  1135. <span class="n">conn</span> <span class="o">=</span> <span class="n">sqlite3</span><span class="o">.</span><span class="n">connect</span><span class="p">(</span><span class="s1">&#39;/companydata&#39;</span><span class="p">)</span>

  1136. <span class="n">cursor</span> <span class="o">=</span> <span class="n">conn</span><span class="o">.</span><span class="n">cursor</span><span class="p">()</span>

  1137. <span class="n">cursor</span><span class="o">.</span><span class="n">execute</span><span class="p">(</span><span class="s1">&#39;SELECT name, age, title, department, paygrade FROM employees&#39;</span><span class="p">)</span>

  1138. <span class="k">for</span> <span class="n">emp</span> <span class="ow">in</span> <span class="nb">map</span><span class="p">(</span><span class="n">EmployeeRecord</span><span class="o">.</span><span class="n">_make</span><span class="p">,</span> <span class="n">cursor</span><span class="o">.</span><span class="n">fetchall</span><span class="p">()):</span>

  1139.     <span class="nb">print</span><span class="p">(</span><span class="n">emp</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="n">emp</span><span class="o">.</span><span class="n">title</span><span class="p">)</span>

  1140. </pre></div>

  1141. </div>

  1142. <p>In addition to the methods inherited from tuples, named tuples support

  1143. three additional methods and two attributes.  To prevent conflicts with

  1144. field names, the method and attribute names start with an underscore.</p>

  1145. <dl class="py method">

  1146. <dt class="sig sig-object py" id="collections.somenamedtuple._make">

  1147. <em class="property"><span class="pre">classmethod</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">somenamedtuple.</span></span><span class="sig-name descname"><span class="pre">_make</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">iterable</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.somenamedtuple._make" title="Link to this definition">¶</a></dt>

  1148. <dd><p>Class method that makes a new instance from an existing sequence or iterable.</p>

  1149. <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">t</span> <span class="o">=</span> <span class="p">[</span><span class="mi">11</span><span class="p">,</span> <span class="mi">22</span><span class="p">]</span>

  1150. <span class="gp">&gt;&gt;&gt; </span><span class="n">Point</span><span class="o">.</span><span class="n">_make</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>

  1151. <span class="go">Point(x=11, y=22)</span>

  1152. </pre></div>

  1153. </div>

  1154. </dd></dl>

  1155. 

  1156. <dl class="py method">

  1157. <dt class="sig sig-object py" id="collections.somenamedtuple._asdict">

  1158. <span class="sig-prename descclassname"><span class="pre">somenamedtuple.</span></span><span class="sig-name descname"><span class="pre">_asdict</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.somenamedtuple._asdict" title="Link to this definition">¶</a></dt>

  1159. <dd><p>Return a new <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> which maps field names to their corresponding

  1160. values:</p>

  1161. <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">p</span> <span class="o">=</span> <span class="n">Point</span><span class="p">(</span><span class="n">x</span><span class="o">=</span><span class="mi">11</span><span class="p">,</span> <span class="n">y</span><span class="o">=</span><span class="mi">22</span><span class="p">)</span>

  1162. <span class="gp">&gt;&gt;&gt; </span><span class="n">p</span><span class="o">.</span><span class="n">_asdict</span><span class="p">()</span>

  1163. <span class="go">{&#39;x&#39;: 11, &#39;y&#39;: 22}</span>

  1164. </pre></div>

  1165. </div>

  1166. <div class="versionchanged">

  1167. <p><span class="versionmodified changed">Changed in version 3.1: </span>Returns an <a class="reference internal" href="#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code></a> instead of a regular <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a>.</p>

  1168. </div>

  1169. <div class="versionchanged">

  1170. <p><span class="versionmodified changed">Changed in version 3.8: </span>Returns a regular <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> instead of an <a class="reference internal" href="#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code></a>.

  1171. As of Python 3.7, regular dicts are guaranteed to be ordered.  If the

  1172. extra features of <a class="reference internal" href="#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code></a> are required, the suggested

  1173. remediation is to cast the result to the desired type:

  1174. <code class="docutils literal notranslate"><span class="pre">OrderedDict(nt._asdict())</span></code>.</p>

  1175. </div>

  1176. </dd></dl>

  1177. 

  1178. <dl class="py method">

  1179. <dt class="sig sig-object py" id="collections.somenamedtuple._replace">

  1180. <span class="sig-prename descclassname"><span class="pre">somenamedtuple.</span></span><span class="sig-name descname"><span class="pre">_replace</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">kwargs</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.somenamedtuple._replace" title="Link to this definition">¶</a></dt>

  1181. <dd><p>Return a new instance of the named tuple replacing specified fields with new

  1182. values:</p>

  1183. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">p</span> <span class="o">=</span> <span class="n">Point</span><span class="p">(</span><span class="n">x</span><span class="o">=</span><span class="mi">11</span><span class="p">,</span> <span class="n">y</span><span class="o">=</span><span class="mi">22</span><span class="p">)</span>

  1184. <span class="gp">&gt;&gt;&gt; </span><span class="n">p</span><span class="o">.</span><span class="n">_replace</span><span class="p">(</span><span class="n">x</span><span class="o">=</span><span class="mi">33</span><span class="p">)</span>

  1185. <span class="go">Point(x=33, y=22)</span>

  1186. 

  1187. <span class="gp">&gt;&gt;&gt; </span><span class="k">for</span> <span class="n">partnum</span><span class="p">,</span> <span class="n">record</span> <span class="ow">in</span> <span class="n">inventory</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>

  1188. <span class="gp">... </span>    <span class="n">inventory</span><span class="p">[</span><span class="n">partnum</span><span class="p">]</span> <span class="o">=</span> <span class="n">record</span><span class="o">.</span><span class="n">_replace</span><span class="p">(</span><span class="n">price</span><span class="o">=</span><span class="n">newprices</span><span class="p">[</span><span class="n">partnum</span><span class="p">],</span> <span class="n">timestamp</span><span class="o">=</span><span class="n">time</span><span class="o">.</span><span class="n">now</span><span class="p">())</span>

  1189. </pre></div>

  1190. </div>

  1191. </dd></dl>

  1192. 

  1193. <dl class="py attribute">

  1194. <dt class="sig sig-object py" id="collections.somenamedtuple._fields">

  1195. <span class="sig-prename descclassname"><span class="pre">somenamedtuple.</span></span><span class="sig-name descname"><span class="pre">_fields</span></span><a class="headerlink" href="#collections.somenamedtuple._fields" title="Link to this definition">¶</a></dt>

  1196. <dd><p>Tuple of strings listing the field names.  Useful for introspection

  1197. and for creating new named tuple types from existing named tuples.</p>

  1198. <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">p</span><span class="o">.</span><span class="n">_fields</span>            <span class="c1"># view the field names</span>

  1199. <span class="go">(&#39;x&#39;, &#39;y&#39;)</span>

  1200. 

  1201. <span class="gp">&gt;&gt;&gt; </span><span class="n">Color</span> <span class="o">=</span> <span class="n">namedtuple</span><span class="p">(</span><span class="s1">&#39;Color&#39;</span><span class="p">,</span> <span class="s1">&#39;red green blue&#39;</span><span class="p">)</span>

  1202. <span class="gp">&gt;&gt;&gt; </span><span class="n">Pixel</span> <span class="o">=</span> <span class="n">namedtuple</span><span class="p">(</span><span class="s1">&#39;Pixel&#39;</span><span class="p">,</span> <span class="n">Point</span><span class="o">.</span><span class="n">_fields</span> <span class="o">+</span> <span class="n">Color</span><span class="o">.</span><span class="n">_fields</span><span class="p">)</span>

  1203. <span class="gp">&gt;&gt;&gt; </span><span class="n">Pixel</span><span class="p">(</span><span class="mi">11</span><span class="p">,</span> <span class="mi">22</span><span class="p">,</span> <span class="mi">128</span><span class="p">,</span> <span class="mi">255</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>

  1204. <span class="go">Pixel(x=11, y=22, red=128, green=255, blue=0)</span>

  1205. </pre></div>

  1206. </div>

  1207. </dd></dl>

  1208. 

  1209. <dl class="py attribute">

  1210. <dt class="sig sig-object py" id="collections.somenamedtuple._field_defaults">

  1211. <span class="sig-prename descclassname"><span class="pre">somenamedtuple.</span></span><span class="sig-name descname"><span class="pre">_field_defaults</span></span><a class="headerlink" href="#collections.somenamedtuple._field_defaults" title="Link to this definition">¶</a></dt>

  1212. <dd><p>Dictionary mapping field names to default values.</p>

  1213. <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">Account</span> <span class="o">=</span> <span class="n">namedtuple</span><span class="p">(</span><span class="s1">&#39;Account&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;type&#39;</span><span class="p">,</span> <span class="s1">&#39;balance&#39;</span><span class="p">],</span> <span class="n">defaults</span><span class="o">=</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>

  1214. <span class="gp">&gt;&gt;&gt; </span><span class="n">Account</span><span class="o">.</span><span class="n">_field_defaults</span>

  1215. <span class="go">{&#39;balance&#39;: 0}</span>

  1216. <span class="gp">&gt;&gt;&gt; </span><span class="n">Account</span><span class="p">(</span><span class="s1">&#39;premium&#39;</span><span class="p">)</span>

  1217. <span class="go">Account(type=&#39;premium&#39;, balance=0)</span>

  1218. </pre></div>

  1219. </div>

  1220. </dd></dl>

  1221. 

  1222. <p>To retrieve a field whose name is stored in a string, use the <a class="reference internal" href="functions.html#getattr" title="getattr"><code class="xref py py-func docutils literal notranslate"><span class="pre">getattr()</span></code></a>

  1223. function:</p>

  1224. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="nb">getattr</span><span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="s1">&#39;x&#39;</span><span class="p">)</span>

  1225. <span class="go">11</span>

  1226. </pre></div>

  1227. </div>

  1228. <p>To convert a dictionary to a named tuple, use the double-star-operator

  1229. (as described in <a class="reference internal" href="../tutorial/controlflow.html#tut-unpacking-arguments"><span class="std std-ref">Unpacking Argument Lists</span></a>):</p>

  1230. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">d</span> <span class="o">=</span> <span class="p">{</span><span class="s1">&#39;x&#39;</span><span class="p">:</span> <span class="mi">11</span><span class="p">,</span> <span class="s1">&#39;y&#39;</span><span class="p">:</span> <span class="mi">22</span><span class="p">}</span>

  1231. <span class="gp">&gt;&gt;&gt; </span><span class="n">Point</span><span class="p">(</span><span class="o">**</span><span class="n">d</span><span class="p">)</span>

  1232. <span class="go">Point(x=11, y=22)</span>

  1233. </pre></div>

  1234. </div>

  1235. <p>Since a named tuple is a regular Python class, it is easy to add or change

  1236. functionality with a subclass.  Here is how to add a calculated field and

  1237. a fixed-width print format:</p>

  1238. <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="k">class</span> <span class="nc">Point</span><span class="p">(</span><span class="n">namedtuple</span><span class="p">(</span><span class="s1">&#39;Point&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;x&#39;</span><span class="p">,</span> <span class="s1">&#39;y&#39;</span><span class="p">])):</span>

  1239. <span class="gp">... </span>    <span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>

  1240. <span class="gp">... </span>    <span class="nd">@property</span>

  1241. <span class="gp">... </span>    <span class="k">def</span> <span class="nf">hypot</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>

  1242. <span class="gp">... </span>        <span class="k">return</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">x</span> <span class="o">**</span> <span class="mi">2</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">y</span> <span class="o">**</span> <span class="mi">2</span><span class="p">)</span> <span class="o">**</span> <span class="mf">0.5</span>

  1243. <span class="gp">... </span>    <span class="k">def</span> <span class="fm">__str__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>

  1244. <span class="gp">... </span>        <span class="k">return</span> <span class="s1">&#39;Point: x=</span><span class="si">%6.3f</span><span class="s1">  y=</span><span class="si">%6.3f</span><span class="s1">  hypot=</span><span class="si">%6.3f</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">x</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">y</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">hypot</span><span class="p">)</span>

  1245. 

  1246. <span class="gp">&gt;&gt;&gt; </span><span class="k">for</span> <span class="n">p</span> <span class="ow">in</span> <span class="n">Point</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="n">Point</span><span class="p">(</span><span class="mi">14</span><span class="p">,</span> <span class="mi">5</span><span class="o">/</span><span class="mi">7</span><span class="p">):</span>

  1247. <span class="gp">... </span>    <span class="nb">print</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>

  1248. <span class="go">Point: x= 3.000  y= 4.000  hypot= 5.000</span>

  1249. <span class="go">Point: x=14.000  y= 0.714  hypot=14.018</span>

  1250. </pre></div>

  1251. </div>

  1252. <p>The subclass shown above sets <code class="docutils literal notranslate"><span class="pre">__slots__</span></code> to an empty tuple.  This helps

  1253. keep memory requirements low by preventing the creation of instance dictionaries.</p>

  1254. <p>Subclassing is not useful for adding new, stored fields.  Instead, simply

  1255. create a new named tuple type from the <a class="reference internal" href="#collections.somenamedtuple._fields" title="collections.somenamedtuple._fields"><code class="xref py py-attr docutils literal notranslate"><span class="pre">_fields</span></code></a> attribute:</p>

  1256. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">Point3D</span> <span class="o">=</span> <span class="n">namedtuple</span><span class="p">(</span><span class="s1">&#39;Point3D&#39;</span><span class="p">,</span> <span class="n">Point</span><span class="o">.</span><span class="n">_fields</span> <span class="o">+</span> <span class="p">(</span><span class="s1">&#39;z&#39;</span><span class="p">,))</span>

  1257. </pre></div>

  1258. </div>

  1259. <p>Docstrings can be customized by making direct assignments to the <code class="docutils literal notranslate"><span class="pre">__doc__</span></code>

  1260. fields:</p>

  1261. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">Book</span> <span class="o">=</span> <span class="n">namedtuple</span><span class="p">(</span><span class="s1">&#39;Book&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;id&#39;</span><span class="p">,</span> <span class="s1">&#39;title&#39;</span><span class="p">,</span> <span class="s1">&#39;authors&#39;</span><span class="p">])</span>

  1262. <span class="gp">&gt;&gt;&gt; </span><span class="n">Book</span><span class="o">.</span><span class="vm">__doc__</span> <span class="o">+=</span> <span class="s1">&#39;: Hardcover book in active collection&#39;</span>

  1263. <span class="gp">&gt;&gt;&gt; </span><span class="n">Book</span><span class="o">.</span><span class="n">id</span><span class="o">.</span><span class="vm">__doc__</span> <span class="o">=</span> <span class="s1">&#39;13-digit ISBN&#39;</span>

  1264. <span class="gp">&gt;&gt;&gt; </span><span class="n">Book</span><span class="o">.</span><span class="n">title</span><span class="o">.</span><span class="vm">__doc__</span> <span class="o">=</span> <span class="s1">&#39;Title of first printing&#39;</span>

  1265. <span class="gp">&gt;&gt;&gt; </span><span class="n">Book</span><span class="o">.</span><span class="n">authors</span><span class="o">.</span><span class="vm">__doc__</span> <span class="o">=</span> <span class="s1">&#39;List of authors sorted by last name&#39;</span>

  1266. </pre></div>

  1267. </div>

  1268. <div class="versionchanged">

  1269. <p><span class="versionmodified changed">Changed in version 3.5: </span>Property docstrings became writeable.</p>

  1270. </div>

  1271. <div class="admonition seealso">

  1272. <p class="admonition-title">See also</p>

  1273. <ul>

  1274. <li><p>See <a class="reference internal" href="typing.html#typing.NamedTuple" title="typing.NamedTuple"><code class="xref py py-class docutils literal notranslate"><span class="pre">typing.NamedTuple</span></code></a> for a way to add type hints for named

  1275. tuples.  It also provides an elegant notation using the <a class="reference internal" href="../reference/compound_stmts.html#class"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">class</span></code></a>

  1276. keyword:</p>

  1277. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Component</span><span class="p">(</span><span class="n">NamedTuple</span><span class="p">):</span>

  1278.     <span class="n">part_number</span><span class="p">:</span> <span class="nb">int</span>

  1279.     <span class="n">weight</span><span class="p">:</span> <span class="nb">float</span>

  1280.     <span class="n">description</span><span class="p">:</span> <span class="n">Optional</span><span class="p">[</span><span class="nb">str</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span>

  1281. </pre></div>

  1282. </div>

  1283. </li>

  1284. <li><p>See <a class="reference internal" href="types.html#types.SimpleNamespace" title="types.SimpleNamespace"><code class="xref py py-meth docutils literal notranslate"><span class="pre">types.SimpleNamespace()</span></code></a> for a mutable namespace based on an

  1285. underlying dictionary instead of a tuple.</p></li>

  1286. <li><p>The <a class="reference internal" href="dataclasses.html#module-dataclasses" title="dataclasses: Generate special methods on user-defined classes."><code class="xref py py-mod docutils literal notranslate"><span class="pre">dataclasses</span></code></a> module provides a decorator and functions for

  1287. automatically adding generated special methods to user-defined classes.</p></li>

  1288. </ul>

  1289. </div>

  1290. </section>

  1291. <section id="ordereddict-objects">

  1292. <h2><a class="reference internal" href="#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code></a> objects<a class="headerlink" href="#ordereddict-objects" title="Link to this heading">¶</a></h2>

  1293. <p>Ordered dictionaries are just like regular dictionaries but have some extra

  1294. capabilities relating to ordering operations.  They have become less

  1295. important now that the built-in <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> class gained the ability

  1296. to remember insertion order (this new behavior became guaranteed in

  1297. Python 3.7).</p>

  1298. <p>Some differences from <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> still remain:</p>

  1299. <ul>

  1300. <li><p>The regular <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> was designed to be very good at mapping

  1301. operations.  Tracking insertion order was secondary.</p></li>

  1302. <li><p>The <a class="reference internal" href="#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code></a> was designed to be good at reordering operations.

  1303. Space efficiency, iteration speed, and the performance of update

  1304. operations were secondary.</p></li>

  1305. <li><p>The <a class="reference internal" href="#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code></a> algorithm can handle frequent reordering operations

  1306. better than <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a>.  As shown in the recipes below, this makes it

  1307. suitable for implementing various kinds of LRU caches.</p></li>

  1308. <li><p>The equality operation for <a class="reference internal" href="#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code></a> checks for matching order.</p>

  1309. <p>A regular <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> can emulate the order sensitive equality test with

  1310. <code class="docutils literal notranslate"><span class="pre">p</span> <span class="pre">==</span> <span class="pre">q</span> <span class="pre">and</span> <span class="pre">all(k1</span> <span class="pre">==</span> <span class="pre">k2</span> <span class="pre">for</span> <span class="pre">k1,</span> <span class="pre">k2</span> <span class="pre">in</span> <span class="pre">zip(p,</span> <span class="pre">q))</span></code>.</p>

  1311. </li>

  1312. <li><p>The <code class="xref py py-meth docutils literal notranslate"><span class="pre">popitem()</span></code> method of <a class="reference internal" href="#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code></a> has a different

  1313. signature.  It accepts an optional argument to specify which item is popped.</p>

  1314. <p>A regular <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> can emulate OrderedDict’s <code class="docutils literal notranslate"><span class="pre">od.popitem(last=True)</span></code>

  1315. with <code class="docutils literal notranslate"><span class="pre">d.popitem()</span></code> which is guaranteed to pop the rightmost (last) item.</p>

  1316. <p>A regular <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> can emulate OrderedDict’s <code class="docutils literal notranslate"><span class="pre">od.popitem(last=False)</span></code>

  1317. with <code class="docutils literal notranslate"><span class="pre">(k</span> <span class="pre">:=</span> <span class="pre">next(iter(d)),</span> <span class="pre">d.pop(k))</span></code> which will return and remove the

  1318. leftmost (first) item if it exists.</p>

  1319. </li>

  1320. <li><p><a class="reference internal" href="#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code></a> has a <code class="xref py py-meth docutils literal notranslate"><span class="pre">move_to_end()</span></code> method to efficiently

  1321. reposition an element to an endpoint.</p>

  1322. <p>A regular <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> can emulate OrderedDict’s <code class="docutils literal notranslate"><span class="pre">od.move_to_end(k,</span>

  1323. <span class="pre">last=True)</span></code> with <code class="docutils literal notranslate"><span class="pre">d[k]</span> <span class="pre">=</span> <span class="pre">d.pop(k)</span></code> which will move the key and its

  1324. associated value to the rightmost (last) position.</p>

  1325. <p>A regular <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> does not have an efficient equivalent for

  1326. OrderedDict’s <code class="docutils literal notranslate"><span class="pre">od.move_to_end(k,</span> <span class="pre">last=False)</span></code> which moves the key

  1327. and its associated value to the leftmost (first) position.</p>

  1328. </li>

  1329. <li><p>Until Python 3.8, <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> lacked a <code class="xref py py-meth docutils literal notranslate"><span class="pre">__reversed__()</span></code> method.</p></li>

  1330. </ul>

  1331. <dl class="py class">

  1332. <dt class="sig sig-object py" id="collections.OrderedDict">

  1333. <em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">collections.</span></span><span class="sig-name descname"><span class="pre">OrderedDict</span></span><span class="sig-paren">(</span><span class="optional">[</span><em class="sig-param"><span class="n"><span class="pre">items</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.OrderedDict" title="Link to this definition">¶</a></dt>

  1334. <dd><p>Return an instance of a <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> subclass that has methods

  1335. specialized for rearranging dictionary order.</p>

  1336. <div class="versionadded">

  1337. <p><span class="versionmodified added">New in version 3.1.</span></p>

  1338. </div>

  1339. <dl class="py method">

  1340. <dt class="sig sig-object py" id="collections.OrderedDict.popitem">

  1341. <span class="sig-name descname"><span class="pre">popitem</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">last</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.OrderedDict.popitem" title="Link to this definition">¶</a></dt>

  1342. <dd><p>The <a class="reference internal" href="#collections.OrderedDict.popitem" title="collections.OrderedDict.popitem"><code class="xref py py-meth docutils literal notranslate"><span class="pre">popitem()</span></code></a> method for ordered dictionaries returns and removes a

  1343. (key, value) pair.  The pairs are returned in

  1344. <abbr title="last-in, first-out">LIFO</abbr> order if <em>last</em> is true

  1345. or <abbr title="first-in, first-out">FIFO</abbr> order if false.</p>

  1346. </dd></dl>

  1347. 

  1348. <dl class="py method">

  1349. <dt class="sig sig-object py" id="collections.OrderedDict.move_to_end">

  1350. <span class="sig-name descname"><span class="pre">move_to_end</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">key</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">last</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.OrderedDict.move_to_end" title="Link to this definition">¶</a></dt>

  1351. <dd><p>Move an existing <em>key</em> to either end of an ordered dictionary.  The item

  1352. is moved to the right end if <em>last</em> is true (the default) or to the

  1353. beginning if <em>last</em> is false.  Raises <a class="reference internal" href="exceptions.html#KeyError" title="KeyError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">KeyError</span></code></a> if the <em>key</em> does

  1354. not exist:</p>

  1355. <div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">d</span> <span class="o">=</span> <span class="n">OrderedDict</span><span class="o">.</span><span class="n">fromkeys</span><span class="p">(</span><span class="s1">&#39;abcde&#39;</span><span class="p">)</span>

  1356. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span><span class="o">.</span><span class="n">move_to_end</span><span class="p">(</span><span class="s1">&#39;b&#39;</span><span class="p">)</span>

  1357. <span class="gp">&gt;&gt;&gt; </span><span class="s1">&#39;&#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">d</span><span class="p">)</span>

  1358. <span class="go">&#39;acdeb&#39;</span>

  1359. <span class="gp">&gt;&gt;&gt; </span><span class="n">d</span><span class="o">.</span><span class="n">move_to_end</span><span class="p">(</span><span class="s1">&#39;b&#39;</span><span class="p">,</span> <span class="n">last</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>

  1360. <span class="gp">&gt;&gt;&gt; </span><span class="s1">&#39;&#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">d</span><span class="p">)</span>

  1361. <span class="go">&#39;bacde&#39;</span>

  1362. </pre></div>

  1363. </div>

  1364. <div class="versionadded">

  1365. <p><span class="versionmodified added">New in version 3.2.</span></p>

  1366. </div>

  1367. </dd></dl>

  1368. 

  1369. </dd></dl>

  1370. 

  1371. <p>In addition to the usual mapping methods, ordered dictionaries also support

  1372. reverse iteration using <a class="reference internal" href="functions.html#reversed" title="reversed"><code class="xref py py-func docutils literal notranslate"><span class="pre">reversed()</span></code></a>.</p>

  1373. <p>Equality tests between <a class="reference internal" href="#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code></a> objects are order-sensitive

  1374. and are implemented as <code class="docutils literal notranslate"><span class="pre">list(od1.items())==list(od2.items())</span></code>.

  1375. Equality tests between <a class="reference internal" href="#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code></a> objects and other

  1376. <a class="reference internal" href="collections.abc.html#collections.abc.Mapping" title="collections.abc.Mapping"><code class="xref py py-class docutils literal notranslate"><span class="pre">Mapping</span></code></a> objects are order-insensitive like regular

  1377. dictionaries.  This allows <a class="reference internal" href="#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code></a> objects to be substituted

  1378. anywhere a regular dictionary is used.</p>

  1379. <div class="versionchanged">

  1380. <p><span class="versionmodified changed">Changed in version 3.5: </span>The items, keys, and values <a class="reference internal" href="../glossary.html#term-dictionary-view"><span class="xref std std-term">views</span></a>

  1381. of <a class="reference internal" href="#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code></a> now support reverse iteration using <a class="reference internal" href="functions.html#reversed" title="reversed"><code class="xref py py-func docutils literal notranslate"><span class="pre">reversed()</span></code></a>.</p>

  1382. </div>

  1383. <div class="versionchanged">

  1384. <p><span class="versionmodified changed">Changed in version 3.6: </span>With the acceptance of <span class="target" id="index-2"></span><a class="pep reference external" href="https://peps.python.org/pep-0468/"><strong>PEP 468</strong></a>, order is retained for keyword arguments

  1385. passed to the <a class="reference internal" href="#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code></a> constructor and its <code class="xref py py-meth docutils literal notranslate"><span class="pre">update()</span></code>

  1386. method.</p>

  1387. </div>

  1388. <div class="versionchanged">

  1389. <p><span class="versionmodified changed">Changed in version 3.9: </span>Added merge (<code class="docutils literal notranslate"><span class="pre">|</span></code>) and update (<code class="docutils literal notranslate"><span class="pre">|=</span></code>) operators, specified in <span class="target" id="index-3"></span><a class="pep reference external" href="https://peps.python.org/pep-0584/"><strong>PEP 584</strong></a>.</p>

  1390. </div>

  1391. <section id="ordereddict-examples-and-recipes">

  1392. <h3><a class="reference internal" href="#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code></a> Examples and Recipes<a class="headerlink" href="#ordereddict-examples-and-recipes" title="Link to this heading">¶</a></h3>

  1393. <p>It is straightforward to create an ordered dictionary variant

  1394. that remembers the order the keys were <em>last</em> inserted.

  1395. If a new entry overwrites an existing entry, the

  1396. original insertion position is changed and moved to the end:</p>

  1397. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">LastUpdatedOrderedDict</span><span class="p">(</span><span class="n">OrderedDict</span><span class="p">):</span>

  1398.     <span class="s1">&#39;Store items in the order the keys were last added&#39;</span>

  1399. 

  1400.     <span class="k">def</span> <span class="fm">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>

  1401.         <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__setitem__</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>

  1402.         <span class="bp">self</span><span class="o">.</span><span class="n">move_to_end</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>

  1403. </pre></div>

  1404. </div>

  1405. <p>An <a class="reference internal" href="#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code></a> would also be useful for implementing

  1406. variants of <a class="reference internal" href="functools.html#functools.lru_cache" title="functools.lru_cache"><code class="xref py py-func docutils literal notranslate"><span class="pre">functools.lru_cache()</span></code></a>:</p>

  1407. <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">collections</span> <span class="kn">import</span> <span class="n">OrderedDict</span>

  1408. <span class="kn">from</span> <span class="nn">time</span> <span class="kn">import</span> <span class="n">time</span>

  1409. 

  1410. <span class="k">class</span> <span class="nc">TimeBoundedLRU</span><span class="p">:</span>

  1411.     <span class="s2">&quot;LRU Cache that invalidates and refreshes old entries.&quot;</span>

  1412. 

  1413.     <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">func</span><span class="p">,</span> <span class="n">maxsize</span><span class="o">=</span><span class="mi">128</span><span class="p">,</span> <span class="n">maxage</span><span class="o">=</span><span class="mi">30</span><span class="p">):</span>

  1414.         <span class="bp">self</span><span class="o">.</span><span class="n">cache</span> <span class="o">=</span> <span class="n">OrderedDict</span><span class="p">()</span>      <span class="c1"># { args : (timestamp, result)}</span>

  1415.         <span class="bp">self</span><span class="o">.</span><span class="n">func</span> <span class="o">=</span> <span class="n">func</span>

  1416.         <span class="bp">self</span><span class="o">.</span><span class="n">maxsize</span> <span class="o">=</span> <span class="n">maxsize</span>

  1417.         <span class="bp">self</span><span class="o">.</span><span class="n">maxage</span> <span class="o">=</span> <span class="n">maxage</span>

  1418. 

  1419.     <span class="k">def</span> <span class="fm">__call__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">):</span>

  1420.         <span class="k">if</span> <span class="n">args</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">cache</span><span class="p">:</span>

  1421.             <span class="bp">self</span><span class="o">.</span><span class="n">cache</span><span class="o">.</span><span class="n">move_to_end</span><span class="p">(</span><span class="n">args</span><span class="p">)</span>

  1422.             <span class="n">timestamp</span><span class="p">,</span> <span class="n">result</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">cache</span><span class="p">[</span><span class="n">args</span><span class="p">]</span>

  1423.             <span class="k">if</span> <span class="n">time</span><span class="p">()</span> <span class="o">-</span> <span class="n">timestamp</span> <span class="o">&lt;=</span> <span class="bp">self</span><span class="o">.</span><span class="n">maxage</span><span class="p">:</span>

  1424.                 <span class="k">return</span> <span class="n">result</span>

  1425.         <span class="n">result</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">func</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">)</span>

  1426.         <span class="bp">self</span><span class="o">.</span><span class="n">cache</span><span class="p">[</span><span class="n">args</span><span class="p">]</span> <span class="o">=</span> <span class="n">time</span><span class="p">(),</span> <span class="n">result</span>

  1427.         <span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">cache</span><span class="p">)</span> <span class="o">&gt;</span> <span class="bp">self</span><span class="o">.</span><span class="n">maxsize</span><span class="p">:</span>

  1428.             <span class="bp">self</span><span class="o">.</span><span class="n">cache</span><span class="o">.</span><span class="n">popitem</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>

  1429.         <span class="k">return</span> <span class="n">result</span>

  1430. </pre></div>

  1431. </div>

  1432. <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">MultiHitLRUCache</span><span class="p">:</span>

  1433. <span class="w">    </span><span class="sd">&quot;&quot;&quot; LRU cache that defers caching a result until</span>

  1434. <span class="sd">        it has been requested multiple times.</span>

  1435. 

  1436. <span class="sd">        To avoid flushing the LRU cache with one-time requests,</span>

  1437. <span class="sd">        we don&#39;t cache until a request has been made more than once.</span>

  1438. 

  1439. <span class="sd">    &quot;&quot;&quot;</span>

  1440. 

  1441.     <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">func</span><span class="p">,</span> <span class="n">maxsize</span><span class="o">=</span><span class="mi">128</span><span class="p">,</span> <span class="n">maxrequests</span><span class="o">=</span><span class="mi">4096</span><span class="p">,</span> <span class="n">cache_after</span><span class="o">=</span><span class="mi">1</span><span class="p">):</span>

  1442.         <span class="bp">self</span><span class="o">.</span><span class="n">requests</span> <span class="o">=</span> <span class="n">OrderedDict</span><span class="p">()</span>   <span class="c1"># { uncached_key : request_count }</span>

  1443.         <span class="bp">self</span><span class="o">.</span><span class="n">cache</span> <span class="o">=</span> <span class="n">OrderedDict</span><span class="p">()</span>      <span class="c1"># { cached_key : function_result }</span>

  1444.         <span class="bp">self</span><span class="o">.</span><span class="n">func</span> <span class="o">=</span> <span class="n">func</span>

  1445.         <span class="bp">self</span><span class="o">.</span><span class="n">maxrequests</span> <span class="o">=</span> <span class="n">maxrequests</span>  <span class="c1"># max number of uncached requests</span>

  1446.         <span class="bp">self</span><span class="o">.</span><span class="n">maxsize</span> <span class="o">=</span> <span class="n">maxsize</span>          <span class="c1"># max number of stored return values</span>

  1447.         <span class="bp">self</span><span class="o">.</span><span class="n">cache_after</span> <span class="o">=</span> <span class="n">cache_after</span>

  1448. 

  1449.     <span class="k">def</span> <span class="fm">__call__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">):</span>

  1450.         <span class="k">if</span> <span class="n">args</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">cache</span><span class="p">:</span>

  1451.             <span class="bp">self</span><span class="o">.</span><span class="n">cache</span><span class="o">.</span><span class="n">move_to_end</span><span class="p">(</span><span class="n">args</span><span class="p">)</span>

  1452.             <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">cache</span><span class="p">[</span><span class="n">args</span><span class="p">]</span>

  1453.         <span class="n">result</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">func</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">)</span>

  1454.         <span class="bp">self</span><span class="o">.</span><span class="n">requests</span><span class="p">[</span><span class="n">args</span><span class="p">]</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">requests</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span>

  1455.         <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">requests</span><span class="p">[</span><span class="n">args</span><span class="p">]</span> <span class="o">&lt;=</span> <span class="bp">self</span><span class="o">.</span><span class="n">cache_after</span><span class="p">:</span>

  1456.             <span class="bp">self</span><span class="o">.</span><span class="n">requests</span><span class="o">.</span><span class="n">move_to_end</span><span class="p">(</span><span class="n">args</span><span class="p">)</span>

  1457.             <span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">requests</span><span class="p">)</span> <span class="o">&gt;</span> <span class="bp">self</span><span class="o">.</span><span class="n">maxrequests</span><span class="p">:</span>

  1458.                 <span class="bp">self</span><span class="o">.</span><span class="n">requests</span><span class="o">.</span><span class="n">popitem</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>

  1459.         <span class="k">else</span><span class="p">:</span>

  1460.             <span class="bp">self</span><span class="o">.</span><span class="n">requests</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>

  1461.             <span class="bp">self</span><span class="o">.</span><span class="n">cache</span><span class="p">[</span><span class="n">args</span><span class="p">]</span> <span class="o">=</span> <span class="n">result</span>

  1462.             <span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">cache</span><span class="p">)</span> <span class="o">&gt;</span> <span class="bp">self</span><span class="o">.</span><span class="n">maxsize</span><span class="p">:</span>

  1463.                 <span class="bp">self</span><span class="o">.</span><span class="n">cache</span><span class="o">.</span><span class="n">popitem</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>

  1464.         <span class="k">return</span> <span class="n">result</span>

  1465. </pre></div>

  1466. </div>

  1467. </section>

  1468. </section>

  1469. <section id="userdict-objects">

  1470. <h2><a class="reference internal" href="#collections.UserDict" title="collections.UserDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserDict</span></code></a> objects<a class="headerlink" href="#userdict-objects" title="Link to this heading">¶</a></h2>

  1471. <p>The class, <a class="reference internal" href="#collections.UserDict" title="collections.UserDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserDict</span></code></a> acts as a wrapper around dictionary objects.

  1472. The need for this class has been partially supplanted by the ability to

  1473. subclass directly from <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a>; however, this class can be easier

  1474. to work with because the underlying dictionary is accessible as an

  1475. attribute.</p>

  1476. <dl class="py class">

  1477. <dt class="sig sig-object py" id="collections.UserDict">

  1478. <em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">collections.</span></span><span class="sig-name descname"><span class="pre">UserDict</span></span><span class="sig-paren">(</span><span class="optional">[</span><em class="sig-param"><span class="n"><span class="pre">initialdata</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.UserDict" title="Link to this definition">¶</a></dt>

  1479. <dd><p>Class that simulates a dictionary.  The instance’s contents are kept in a

  1480. regular dictionary, which is accessible via the <a class="reference internal" href="#collections.UserDict.data" title="collections.UserDict.data"><code class="xref py py-attr docutils literal notranslate"><span class="pre">data</span></code></a> attribute of

  1481. <a class="reference internal" href="#collections.UserDict" title="collections.UserDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserDict</span></code></a> instances.  If <em>initialdata</em> is provided, <a class="reference internal" href="#collections.UserDict.data" title="collections.UserDict.data"><code class="xref py py-attr docutils literal notranslate"><span class="pre">data</span></code></a> is

  1482. initialized with its contents; note that a reference to <em>initialdata</em> will not

  1483. be kept, allowing it to be used for other purposes.</p>

  1484. <p>In addition to supporting the methods and operations of mappings,

  1485. <a class="reference internal" href="#collections.UserDict" title="collections.UserDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserDict</span></code></a> instances provide the following attribute:</p>

  1486. <dl class="py attribute">

  1487. <dt class="sig sig-object py" id="collections.UserDict.data">

  1488. <span class="sig-name descname"><span class="pre">data</span></span><a class="headerlink" href="#collections.UserDict.data" title="Link to this definition">¶</a></dt>

  1489. <dd><p>A real dictionary used to store the contents of the <a class="reference internal" href="#collections.UserDict" title="collections.UserDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserDict</span></code></a>

  1490. class.</p>

  1491. </dd></dl>

  1492. 

  1493. </dd></dl>

  1494. 

  1495. </section>

  1496. <section id="userlist-objects">

  1497. <h2><a class="reference internal" href="#collections.UserList" title="collections.UserList"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserList</span></code></a> objects<a class="headerlink" href="#userlist-objects" title="Link to this heading">¶</a></h2>

  1498. <p>This class acts as a wrapper around list objects.  It is a useful base class

  1499. for your own list-like classes which can inherit from them and override

  1500. existing methods or add new ones.  In this way, one can add new behaviors to

  1501. lists.</p>

  1502. <p>The need for this class has been partially supplanted by the ability to

  1503. subclass directly from <a class="reference internal" href="stdtypes.html#list" title="list"><code class="xref py py-class docutils literal notranslate"><span class="pre">list</span></code></a>; however, this class can be easier

  1504. to work with because the underlying list is accessible as an attribute.</p>

  1505. <dl class="py class">

  1506. <dt class="sig sig-object py" id="collections.UserList">

  1507. <em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">collections.</span></span><span class="sig-name descname"><span class="pre">UserList</span></span><span class="sig-paren">(</span><span class="optional">[</span><em class="sig-param"><span class="n"><span class="pre">list</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#collections.UserList" title="Link to this definition">¶</a></dt>

  1508. <dd><p>Class that simulates a list.  The instance’s contents are kept in a regular

  1509. list, which is accessible via the <a class="reference internal" href="#collections.UserList.data" title="collections.UserList.data"><code class="xref py py-attr docutils literal notranslate"><span class="pre">data</span></code></a> attribute of <a class="reference internal" href="#collections.UserList" title="collections.UserList"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserList</span></code></a>

  1510. instances.  The instance’s contents are initially set to a copy of <em>list</em>,

  1511. defaulting to the empty list <code class="docutils literal notranslate"><span class="pre">[]</span></code>.  <em>list</em> can be any iterable, for

  1512. example a real Python list or a <a class="reference internal" href="#collections.UserList" title="collections.UserList"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserList</span></code></a> object.</p>

  1513. <p>In addition to supporting the methods and operations of mutable sequences,

  1514. <a class="reference internal" href="#collections.UserList" title="collections.UserList"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserList</span></code></a> instances provide the following attribute:</p>

  1515. <dl class="py attribute">

  1516. <dt class="sig sig-object py" id="collections.UserList.data">

  1517. <span class="sig-name descname"><span class="pre">data</span></span><a class="headerlink" href="#collections.UserList.data" title="Link to this definition">¶</a></dt>

  1518. <dd><p>A real <a class="reference internal" href="stdtypes.html#list" title="list"><code class="xref py py-class docutils literal notranslate"><span class="pre">list</span></code></a> object used to store the contents of the

  1519. <a class="reference internal" href="#collections.UserList" title="collections.UserList"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserList</span></code></a> class.</p>

  1520. </dd></dl>

  1521. 

  1522. </dd></dl>

  1523. 

  1524. <p><strong>Subclassing requirements:</strong> Subclasses of <a class="reference internal" href="#collections.UserList" title="collections.UserList"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserList</span></code></a> are expected to

  1525. offer a constructor which can be called with either no arguments or one

  1526. argument.  List operations which return a new sequence attempt to create an

  1527. instance of the actual implementation class.  To do so, it assumes that the

  1528. constructor can be called with a single parameter, which is a sequence object

  1529. used as a data source.</p>

  1530. <p>If a derived class does not wish to comply with this requirement, all of the

  1531. special methods supported by this class will need to be overridden; please

  1532. consult the sources for information about the methods which need to be provided

  1533. in that case.</p>

  1534. </section>

  1535. <section id="userstring-objects">

  1536. <h2><a class="reference internal" href="#collections.UserString" title="collections.UserString"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserString</span></code></a> objects<a class="headerlink" href="#userstring-objects" title="Link to this heading">¶</a></h2>

  1537. <p>The class, <a class="reference internal" href="#collections.UserString" title="collections.UserString"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserString</span></code></a> acts as a wrapper around string objects.

  1538. The need for this class has been partially supplanted by the ability to

  1539. subclass directly from <a class="reference internal" href="stdtypes.html#str" title="str"><code class="xref py py-class docutils literal notranslate"><span class="pre">str</span></code></a>; however, this class can be easier

  1540. to work with because the underlying string is accessible as an

  1541. attribute.</p>

  1542. <dl class="py class">

  1543. <dt class="sig sig-object py" id="collections.UserString">

  1544. <em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">collections.</span></span><span class="sig-name descname"><span class="pre">UserString</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">seq</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#collections.UserString" title="Link to this definition">¶</a></dt>

  1545. <dd><p>Class that simulates a string object.  The instance’s

  1546. content is kept in a regular string object, which is accessible via the

  1547. <a class="reference internal" href="#collections.UserString.data" title="collections.UserString.data"><code class="xref py py-attr docutils literal notranslate"><span class="pre">data</span></code></a> attribute of <a class="reference internal" href="#collections.UserString" title="collections.UserString"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserString</span></code></a> instances.  The instance’s

  1548. contents are initially set to a copy of <em>seq</em>.  The <em>seq</em> argument can

  1549. be any object which can be converted into a string using the built-in

  1550. <a class="reference internal" href="stdtypes.html#str" title="str"><code class="xref py py-func docutils literal notranslate"><span class="pre">str()</span></code></a> function.</p>

  1551. <p>In addition to supporting the methods and operations of strings,

  1552. <a class="reference internal" href="#collections.UserString" title="collections.UserString"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserString</span></code></a> instances provide the following attribute:</p>

  1553. <dl class="py attribute">

  1554. <dt class="sig sig-object py" id="collections.UserString.data">

  1555. <span class="sig-name descname"><span class="pre">data</span></span><a class="headerlink" href="#collections.UserString.data" title="Link to this definition">¶</a></dt>

  1556. <dd><p>A real <a class="reference internal" href="stdtypes.html#str" title="str"><code class="xref py py-class docutils literal notranslate"><span class="pre">str</span></code></a> object used to store the contents of the

  1557. <a class="reference internal" href="#collections.UserString" title="collections.UserString"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserString</span></code></a> class.</p>

  1558. </dd></dl>

  1559. 

  1560. <div class="versionchanged">

  1561. <p><span class="versionmodified changed">Changed in version 3.5: </span>New methods <code class="docutils literal notranslate"><span class="pre">__getnewargs__</span></code>, <code class="docutils literal notranslate"><span class="pre">__rmod__</span></code>, <code class="docutils literal notranslate"><span class="pre">casefold</span></code>,

  1562. <code class="docutils literal notranslate"><span class="pre">format_map</span></code>, <code class="docutils literal notranslate"><span class="pre">isprintable</span></code>, and <code class="docutils literal notranslate"><span class="pre">maketrans</span></code>.</p>

  1563. </div>

  1564. </dd></dl>

  1565. 

  1566. </section>

  1567. </section>

  1568. 

  1569. 

  1570.             <div class="clearer"></div>

  1571.           </div>

  1572.         </div>

  1573.       </div>

  1574.       <div class="sphinxsidebar" role="navigation" aria-label="main navigation">

  1575.         <div class="sphinxsidebarwrapper">

  1576.   <div>

  1577.     <h3><a href="../contents.html">Table of Contents</a></h3>

  1578.     <ul>

  1579. <li><a class="reference internal" href="#"><code class="xref py py-mod docutils literal notranslate"><span class="pre">collections</span></code> — Container datatypes</a><ul>

  1580. <li><a class="reference internal" href="#chainmap-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">ChainMap</span></code> objects</a><ul>

  1581. <li><a class="reference internal" href="#chainmap-examples-and-recipes"><code class="xref py py-class docutils literal notranslate"><span class="pre">ChainMap</span></code> Examples and Recipes</a></li>

  1582. </ul>

  1583. </li>

  1584. <li><a class="reference internal" href="#counter-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">Counter</span></code> objects</a></li>

  1585. <li><a class="reference internal" href="#deque-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">deque</span></code> objects</a><ul>

  1586. <li><a class="reference internal" href="#deque-recipes"><code class="xref py py-class docutils literal notranslate"><span class="pre">deque</span></code> Recipes</a></li>

  1587. </ul>

  1588. </li>

  1589. <li><a class="reference internal" href="#defaultdict-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">defaultdict</span></code> objects</a><ul>

  1590. <li><a class="reference internal" href="#defaultdict-examples"><code class="xref py py-class docutils literal notranslate"><span class="pre">defaultdict</span></code> Examples</a></li>

  1591. </ul>

  1592. </li>

  1593. <li><a class="reference internal" href="#namedtuple-factory-function-for-tuples-with-named-fields"><code class="xref py py-func docutils literal notranslate"><span class="pre">namedtuple()</span></code> Factory Function for Tuples with Named Fields</a></li>

  1594. <li><a class="reference internal" href="#ordereddict-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code> objects</a><ul>

  1595. <li><a class="reference internal" href="#ordereddict-examples-and-recipes"><code class="xref py py-class docutils literal notranslate"><span class="pre">OrderedDict</span></code> Examples and Recipes</a></li>

  1596. </ul>

  1597. </li>

  1598. <li><a class="reference internal" href="#userdict-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserDict</span></code> objects</a></li>

  1599. <li><a class="reference internal" href="#userlist-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserList</span></code> objects</a></li>

  1600. <li><a class="reference internal" href="#userstring-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">UserString</span></code> objects</a></li>

  1601. </ul>

  1602. </li>

  1603. </ul>

  1604. 

  1605.   </div>

  1606.   <div>

  1607.     <h4>Previous topic</h4>

  1608.     <p class="topless"><a href="calendar.html"

  1609.                           title="previous chapter"><code class="xref py py-mod docutils literal notranslate"><span class="pre">calendar</span></code> — General calendar-related functions</a></p>

  1610.   </div>

  1611.   <div>

  1612.     <h4>Next topic</h4>

  1613.     <p class="topless"><a href="collections.abc.html"

  1614.                           title="next chapter"><code class="xref py py-mod docutils literal notranslate"><span class="pre">collections.abc</span></code> — Abstract Base Classes for Containers</a></p>

  1615.   </div>

  1616.   <div role="note" aria-label="source link">

  1617.     <h3>This Page</h3>

  1618.     <ul class="this-page-menu">

  1619.       <li><a href="../bugs.html">Report a Bug</a></li>

  1620.       <li>

  1621.         <a href="https://github.com/python/cpython/blob/main/Doc/library/collections.rst"

  1622.             rel="nofollow">Show Source

  1623.         </a>

  1624.       </li>

  1625.     </ul>

  1626.   </div>

  1627.         </div>

  1628. <div id="sidebarbutton" title="Collapse sidebar">

  1629. <span>«</span>

  1630. </div>

  1631. 

  1632.       </div>

  1633.       <div class="clearer"></div>

  1634.     </div>  

  1635.     <div class="related" role="navigation" aria-label="related navigation">

  1636.       <h3>Navigation</h3>

  1637.       <ul>

  1638.         <li class="right" style="margin-right: 10px">

  1639.           <a href="../genindex.html" title="General Index"

  1640.              >index</a></li>

  1641.         <li class="right" >

  1642.           <a href="../py-modindex.html" title="Python Module Index"

  1643.              >modules</a> |</li>

  1644.         <li class="right" >

  1645.           <a href="collections.abc.html" title="collections.abc — Abstract Base Classes for Containers"

  1646.              >next</a> |</li>

  1647.         <li class="right" >

  1648.           <a href="calendar.html" title="calendar — General calendar-related functions"

  1649.              >previous</a> |</li>

  1650. 

  1651.           <li><img src="../_static/py.svg" alt="Python logo" style="vertical-align: middle; margin-top: -1px"/></li>

  1652.           <li><a href="https://www.python.org/">Python</a> &#187;</li>

  1653.           <li class="switchers">

  1654.             <div class="language_switcher_placeholder"></div>

  1655.             <div class="version_switcher_placeholder"></div>

  1656.           </li>

  1657.           <li>

  1658.               

  1659.           </li>

  1660.     <li id="cpython-language-and-version">

  1661.       <a href="../index.html">3.12.3 Documentation</a> &#187;

  1662.     </li>

  1663. 

  1664.           <li class="nav-item nav-item-1"><a href="index.html" >The Python Standard Library</a> &#187;</li>

  1665.           <li class="nav-item nav-item-2"><a href="datatypes.html" >Data Types</a> &#187;</li>

  1666.         <li class="nav-item nav-item-this"><a href=""><code class="xref py py-mod docutils literal notranslate"><span class="pre">collections</span></code> — Container datatypes</a></li>

  1667.                 <li class="right">

  1668.                     

  1669. 

  1670.     <div class="inline-search" role="search">

  1671.         <form class="inline-search" action="../search.html" method="get">

  1672.           <input placeholder="Quick search" aria-label="Quick search" type="search" name="q" id="search-box" />

  1673.           <input type="submit" value="Go" />

  1674.         </form>

  1675.     </div>

  1676.                      |

  1677.                 </li>

  1678.             <li class="right">

  1679. <label class="theme-selector-label">

  1680.     Theme

  1681.     <select class="theme-selector" oninput="activateTheme(this.value)">

  1682.         <option value="auto" selected>Auto</option>

  1683.         <option value="light">Light</option>

  1684.         <option value="dark">Dark</option>

  1685.     </select>

  1686. </label> |</li>

  1687.             

  1688.       </ul>

  1689.     </div>  

  1690.     <div class="footer">

  1691.     &copy; 

  1692.       <a href="../copyright.html">

  1693.     

  1694.     Copyright

  1695.     

  1696.       </a>

  1697.      2001-2024, Python Software Foundation.

  1698.     <br />

  1699.     This page is licensed under the Python Software Foundation License Version 2.

  1700.     <br />

  1701.     Examples, recipes, and other code in the documentation are additionally licensed under the Zero Clause BSD License.

  1702.     <br />

  1703.     

  1704.       See <a href="/license.html">History and License</a> for more information.<br />

  1705.     

  1706.     

  1707.     <br />

  1708. 

  1709.     The Python Software Foundation is a non-profit corporation.

  1710. <a href="https://www.python.org/psf/donations/">Please donate.</a>

  1711. <br />

  1712.     <br />

  1713.       Last updated on Apr 09, 2024 (13:47 UTC).

  1714.     

  1715.       <a href="/bugs.html">Found a bug</a>?

  1716.     

  1717.     <br />

  1718. 

  1719.     Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 7.2.6.

  1720.     </div>

  1721. 

  1722.   </body>

  1723. </html>
上海开阖软件有限公司 沪ICP备12045867号-1