effectivepython/atom.xml at gh-pages · machineL1994/effectivepython

978 lines (751 loc) · 149 KB
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom"><title>Effective Python</title><link href="http://www.effectivepython.com/" rel="alternate"></link><link href="http://www.effectivepython.com/atom.xml" rel="self"></link><id>http://www.effectivepython.com/</id><updated>2016-08-06T18:45:00-07:00</updated><entry><title>Python Eficaz</title><link href="http://www.effectivepython.com/2016/08/06/python-eficaz-portugu%C3%AAs/" rel="alternate"></link><updated>2016-08-06T18:45:00-07:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2016-08-06:2016/08/06/python-eficaz-português/</id><summary type="html">&lt;p&gt;&lt;a href="http://novatec.com.br/livros/python-eficaz/"&gt;&lt;img class="learn-more-photo" alt="Python Eficaz" src="http://www.effectivepython.com/images/cover_pt_br.jpg"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;The publishing house Novatec Editora has translated and released a Portuguese version of &lt;em&gt;Effective Python&lt;/em&gt;. You can buy the book &lt;a href="http://novatec.com.br/livros/python-eficaz/"&gt;directly from the publisher&lt;/a&gt;.&lt;/p&gt;</summary></entry><entry><title>Effective Python 简体中文</title><link href="http://www.effectivepython.com/2016/05/07/effective-python-hans/" rel="alternate"></link><updated>2016-05-07T09:00:00-07:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2016-05-07:2016/05/07/effective-python-hans/</id><summary type="html">&lt;p&gt;&lt;a href="https://www.amazon.cn/Effective-Python-%E7%BC%96%E5%86%99%E9%AB%98%E8%B4%A8%E9%87%8FPython%E4%BB%A3%E7%A0%81%E7%9A%8459%E4%B8%AA%E6%9C%89%E6%95%88%E6%96%B9%E6%B3%95-%E5%B8%83%E9%9B%B7%E7%89%B9%C2%B7%E6%96%AF%E6%8B%89%E7%89%B9%E9%87%91/dp/B01ASI36QS"&gt;&lt;img class="learn-more-photo" alt="Effective Python 简体中文" src="http://www.effectivepython.com/images/cover_zh_hans.jpg"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;The publishing house 机械工业出版社 (China Machine Press) has translated and released a Chinese (Simplified) version of &lt;em&gt;Effective Python&lt;/em&gt;. You can buy the book &lt;a href="http://www.cmpbook.com/stackroom.php?id=41800"&gt;directly from the publisher&lt;/a&gt; or &lt;a href="https://www.amazon.cn/Effective-Python-%E7%BC%96%E5%86%99%E9%AB%98%E8%B4%A8%E9%87%8FPython%E4%BB%A3%E7%A0%81%E7%9A%8459%E4%B8%AA%E6%9C%89%E6%95%88%E6%96%B9%E6%B3%95-%E5%B8%83%E9%9B%B7%E7%89%B9%C2%B7%E6%96%AF%E6%8B%89%E7%89%B9%E9%87%91/dp/B01ASI36QS"&gt;get it on Amazon.cn&lt;/a&gt;.&lt;/p&gt;</summary></entry><entry><title>Effective Python 파이썬 코딩의 기술</title><link href="http://www.effectivepython.com/2016/04/03/effective-python-kr/" rel="alternate"></link><updated>2016-04-03T17:00:00-07:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2016-04-03:2016/04/03/effective-python-kr/</id><summary type="html">&lt;p&gt;&lt;a href="http://www.gilbut.co.kr/book/bookView.aspx?bookcode=BN001430"&gt;&lt;img class="learn-more-photo" alt="Effective Python 파이썬 코딩의 기술" src="http://www.effectivepython.com/images/cover_kr.jpg"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;The publishing house Gilbut Inc. has translated and released a Korean version of &lt;em&gt;Effective Python&lt;/em&gt;. &lt;a href="http://www.gilbut.co.kr/book/bookView.aspx?bookcode=BN001430"&gt;The publisher&amp;#8217;s website&lt;/a&gt; links to many different retailers online where you can buy the&amp;nbsp;book.&lt;/p&gt;</summary></entry><entry><title>Effective Python 日本語</title><link href="http://www.effectivepython.com/2016/01/23/effective-python-jp/" rel="alternate"></link><updated>2016-01-23T09:00:00-08:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2016-01-23:2016/01/23/effective-python-jp/</id><summary type="html">&lt;p&gt;&lt;a href="http://www.amazon.co.jp/exec/obidos/ASIN/4873117569"&gt;&lt;img class="learn-more-photo"  alt="Effective Python 日本語" src="http://www.effectivepython.com/images/cover_jp.jpg"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;The publishing house O&amp;#8217;Reilly Japan has translated and released a Japanese version of &lt;em&gt;Effective Python&lt;/em&gt;. You can buy the book &lt;a href="http://www.oreilly.co.jp/books/9784873117560/"&gt;directly from the publisher&lt;/a&gt; or &lt;a href="http://www.amazon.co.jp/exec/obidos/ASIN/4873117569"&gt;get it on Amazon.jp&lt;/a&gt;.&lt;/p&gt;</summary></entry><entry><title>Efektywny Python</title><link href="http://www.effectivepython.com/2015/11/20/efektywny-python-pl/" rel="alternate"></link><updated>2015-11-15T09:00:00-08:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2015-11-20:2015/11/20/efektywny-python-pl/</id><summary type="html">&lt;p&gt;&lt;a href="http://helion.pl/ksiazki/efektywny-python-59-sposobow-na-lepszy-kod-brett-slatkin,efepyt.htm"&gt;&lt;img class="learn-more-photo" alt="Efektywny Python" src="http://www.effectivepython.com/images/cover_pl.jpg"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;The publishing house Helion has translated and released a Polish version of &lt;em&gt;Effective Python&lt;/em&gt;. You can buy the book &lt;a href="http://helion.pl/ksiazki/efektywny-python-59-sposobow-na-lepszy-kod-brett-slatkin,efepyt.htm"&gt;directly from the publisher&lt;/a&gt;.&lt;/p&gt;</summary></entry><entry><title>Effektiv Python ​programmieren</title><link href="http://www.effectivepython.com/2015/11/15/effektiv-python-deutsch/" rel="alternate"></link><updated>2015-11-15T21:40:00-08:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2015-11-15:2015/11/15/effektiv-python-deutsch/</id><summary type="html">&lt;p&gt;&lt;a href="http://www.amazon.de/Effektiv-Python-programmieren-mitp-Professional/dp/3958451810"&gt;&lt;img class="learn-more-photo" alt="Effektiv Python programmieren" src="http://www.effectivepython.com/images/cover_de.jpg"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;The publishing house mitp-Verlag has translated and released a German version of &lt;em&gt;Effective Python&lt;/em&gt;. You can buy the book &lt;a href="http://www.mitp.de/IT-Web/Programmierung/Effektiv-Python-programmieren.html"&gt;directly from the publisher&lt;/a&gt; or &lt;a href="http://www.amazon.de/Effektiv-Python-programmieren-mitp-Professional/dp/3958451810"&gt;get it on Amazon.de&lt;/a&gt; (including Kindle&amp;nbsp;edition).&lt;/p&gt;</summary></entry><entry><title>Talk Python To Me Podcast</title><link href="http://www.effectivepython.com/2015/09/09/talk-python-to-me-podcast/" rel="alternate"></link><updated>2015-09-09T09:00:00-07:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2015-09-09:2015/09/09/talk-python-to-me-podcast/</id><summary type="html">&lt;p&gt;I was invited on to the &lt;a href="https://talkpython.fm/episodes/show/25/effective-python"&gt;Talk Python To Me Podcast&lt;/a&gt; to talk about &lt;em&gt;Effective Python&lt;/em&gt;. You can &lt;a href="https://talkpython.fm/episodes/transcript/25/effective-python"&gt;read the full transcript here&lt;/a&gt; or listen to the audio embedded below. Thanks to Michael Kennedy for being such a welcoming&amp;nbsp;host.&lt;/p&gt;
&lt;p&gt;&lt;audio controls&gt;
  &lt;source src="https://talkpython.fm/episodes/download/25/effective-python.mp3" type="audio/mpeg"&gt;
&lt;/audio&gt;&lt;/p&gt;</summary></entry><entry><title>Effective Python 中文版</title><link href="http://www.effectivepython.com/2015/08/27/effective-python-cn/" rel="alternate"></link><updated>2015-08-27T09:00:00-07:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2015-08-27:2015/08/27/effective-python-cn/</id><summary type="html">&lt;p&gt;&lt;a href="http://books.gotop.com.tw/v_ACL043700"&gt;&lt;img class="learn-more-photo" alt="Effective Python 中文版" src="http://www.effectivepython.com/images/cover_zh_hant.jpg"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;The publishing house 碁峰 (Acer Peak) has translated and released a Chinese (Traditional) version of &lt;em&gt;Effective Python&lt;/em&gt;. You can buy the book &lt;a href="http://books.gotop.com.tw/v_ACL043700"&gt;directly from the publisher&lt;/a&gt; or &lt;a href="https://play.google.com/store/books/details/Brett_Slatkin_Effective_Python_%E4%B8%AD%E6%96%87%E7%89%88_%E5%AF%AB%E5%87%BA%E8%89%AF%E5%A5%BD_Python_%E7%A8%8B%E5%BC%8F%E7%9A%84?id=V2m7CgAAQBAJ"&gt;get a digital edition on Google Play&lt;/a&gt;.&lt;/p&gt;</summary></entry><entry><title>Live Lessons Video</title><link href="http://www.effectivepython.com/2015/08/04/live-lessons-video/" rel="alternate"></link><updated>2015-08-04T09:00:00-07:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2015-08-04:2015/08/04/live-lessons-video/</id><summary type="html">&lt;p&gt;&lt;a href="http://www.informit.com/store/effective-python-livelessons-video-training-downloadable-9780134175164"&gt;&lt;img alt="Effective Python Live Lessons" class="learn-more-photo" src="http://www.effectivepython.com/images/live_lessons.png"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;I worked with Addison-Wesley to produce a video version of the book &lt;em&gt;Effective Python&lt;/em&gt;. You can view samples and buy the video &lt;a href="http://www.informit.com/store/effective-python-livelessons-video-training-downloadable-9780134175164"&gt;on the publisher&amp;#8217;s website&lt;/a&gt;. &lt;/p&gt;
&lt;p&gt;It includes 5 hours of video, covering 32 items from the book in six lessons. The content is primarily me using a source code editor to write Python programs that demonstrate the items from the&amp;nbsp;book.&lt;/p&gt;</summary></entry><entry><title>Talk at PyCon Montréal</title><link href="http://www.effectivepython.com/2015/04/10/pycon-montreal/" rel="alternate"></link><updated>2015-04-11T10:15:00-07:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2015-04-10:2015/04/10/pycon-montreal/</id><summary type="html">
&lt;p&gt;I gave a talk at PyCon Montréal entitled &amp;#8220;How to Be More Effective with Functions&amp;#8221;.&lt;/p&gt;
&lt;li&gt;The slides are embedded below (click the gear to download as a &lt;span class="caps"&gt;PDF&lt;/span&gt;).&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/bslatkin/pycon2015"&gt;The code from the examples is here on GitHub&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;The &lt;a href="https://www.youtube.com/watch?v=WjJUPxKB164"&gt;video is available here&lt;/a&gt; (also embedded&amp;nbsp;below).&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;br&gt;&lt;/p&gt;
&lt;iframe src="https://docs.google.com/presentation/d/14GbOzGgZacdw7zQN6yt-V0MVO6upL5Gd9VJ9Il6DsHQ/embed?start=false&amp;loop=false&amp;delayms=10000" frameborder="0" width="480" height="389" allowfullscreen="true" mozallowfullscreen="true" webkitallowfullscreen="true"&gt;&lt;/iframe&gt;
&lt;p&gt;&lt;br&gt;&lt;/p&gt;
&lt;iframe width="640" height="360" src="https://www.youtube.com/embed/WjJUPxKB164?rel=0" frameborder="0" allowfullscreen&gt;&lt;/iframe&gt;</summary></entry><entry><title>Item 40: Consider Coroutines to Run Many Functions Concurrently</title><link href="http://www.effectivepython.com/2015/03/10/consider-coroutines-to-run-many-functions-concurrently/" rel="alternate"></link><updated>2015-03-10T22:45:00-07:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2015-03-10:2015/03/10/consider-coroutines-to-run-many-functions-concurrently/</id><summary type="html">&lt;p&gt;&lt;em&gt;The following is a sample from the new book &lt;a href="/"&gt;Effective Python&lt;/a&gt;.&lt;/em&gt; &lt;br&gt;&lt;br&gt;&lt;/p&gt;
&lt;p&gt;Threads give Python programmers a way to run multiple functions seemingly at the same time. But there are three big problems with threads:&lt;/p&gt;
&lt;p&gt;They require special tools to coordinate with each other safely. This makes code that uses threads harder to reason about than procedural, single-threaded code. This complexity makes threaded code more difficult to extend and maintain over&amp;nbsp;time.&lt;/p&gt;
&lt;/li&gt;
&lt;p&gt;Threads require a lot of memory, about &lt;span class="caps"&gt;8MB&lt;/span&gt; per executing thread. On many computers, that amount of memory doesn&amp;#8217;t matter for a dozen threads or so. But what if you want your program to run tens of thousands of functions &amp;#8220;simultaneously&amp;#8221;? These functions may correspond to user requests to a server, pixels on a screen, particles in a simulation, etc. Running a thread per unique activity just won&amp;#8217;t&amp;nbsp;work.&lt;/p&gt;
&lt;/li&gt;
&lt;p&gt;Threads are costly to start. If you want to constantly be creating new concurrent functions and finishing them, the overhead of using threads becomes large and slows everything&amp;nbsp;down.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Python can work around all these issues with &lt;em&gt;coroutines&lt;/em&gt;. Coroutines let you have many seemingly simultaneous functions in your Python programs. They&amp;#8217;re implemented as an extension to generators. The cost of starting a generator coroutine is a function call. Once active, they each use less than &lt;span class="caps"&gt;1KB&lt;/span&gt; of memory until they&amp;#8217;re&amp;nbsp;exhausted.&lt;/p&gt;
&lt;p&gt;Coroutines work by enabling the code consuming a generator to &lt;code&gt;send&lt;/code&gt; a value back into the generator function after each &lt;code&gt;yield&lt;/code&gt; expression. The generator function receives the value passed to the &lt;code&gt;send&lt;/code&gt; function as the result of the corresponding &lt;code&gt;yield&lt;/code&gt; expression.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;my_coroutine&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
    &lt;span class="k"&gt;while&lt;/span&gt; &lt;span class="bp"&gt;True&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;received&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;yield&lt;/span&gt;
        &lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Received:&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;received&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;it&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;my_coroutine&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="nb"&gt;next&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;             &lt;span class="c"&gt;# Prime the coroutine&lt;/span&gt;
&lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;send&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;First&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;send&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Second&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
Received: First
Received: Second
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The initial call to &lt;code&gt;next&lt;/code&gt; is required to prepare the generator for receiving the first &lt;code&gt;send&lt;/code&gt; by advancing it to the first &lt;code&gt;yield&lt;/code&gt; expression. Together, &lt;code&gt;yield&lt;/code&gt; and &lt;code&gt;send&lt;/code&gt; provide generators with a standard way to vary their next yielded value in response to external&amp;nbsp;input.&lt;/p&gt;
&lt;p&gt;For example, say you want to implement a generator coroutine that yields the minimum value it&amp;#8217;s been sent so far. Here the bare &lt;code&gt;yield&lt;/code&gt; prepares the coroutine with the initial minimum value sent in from the outside. Then the generator repeatedly yields the new minimum in exchange for the next value to&amp;nbsp;consider.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;minimize&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
    &lt;span class="n"&gt;current&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;yield&lt;/span&gt;
    &lt;span class="k"&gt;while&lt;/span&gt; &lt;span class="bp"&gt;True&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;yield&lt;/span&gt; &lt;span class="n"&gt;current&lt;/span&gt;
        &lt;span class="n"&gt;current&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;min&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;current&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The code consuming the generator can run one step at a time and will output the minimum value seen after each&amp;nbsp;input.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;it&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;minimize&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="nb"&gt;next&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;            &lt;span class="c"&gt;# Prime the generator&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;send&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;10&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;send&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;send&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;22&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;send&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The generator function will seemingly run forever, making forward progress with each new call to &lt;code&gt;send&lt;/code&gt;. Like threads, coroutines are independent functions that can consume inputs from their environment and produce resulting outputs. The difference is that coroutines pause at each &lt;code&gt;yield&lt;/code&gt; expression in the generator function and resume after each call to &lt;code&gt;send&lt;/code&gt; from the outside. This is the magical mechanism of&amp;nbsp;coroutines.&lt;/p&gt;
&lt;p&gt;This behavior allows the code consuming the generator to take action after each &lt;code&gt;yield&lt;/code&gt; expression in the coroutine. The consuming code can use the generator&amp;#8217;s output values to call other functions and update data structures. Most importantly, it can advance other generator functions until their next &lt;code&gt;yield&lt;/code&gt; expressions. By advancing many separate generators in lockstep, they will all seem to be running simultaneously, mimicking the concurrent behavior of Python&amp;nbsp;threads.&lt;/p&gt;
&lt;h3&gt;The Game of&amp;nbsp;Life&lt;/h3&gt;
&lt;p&gt;Let me demonstrate the simultaneous behavior of coroutines with an example. Say you want to use coroutines to implement &lt;a href="http://en.wikipedia.org/wiki/Conway's_Game_of_Life"&gt;Conway&amp;#8217;s Game of Life&lt;/a&gt;. The rules of the game are simple. You have a two-dimensional grid of an arbitrary size. Each cell in the grid can either be alive or&amp;nbsp;empty.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;ALIVE&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;*&amp;#39;&lt;/span&gt;
&lt;span class="n"&gt;EMPTY&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;-&amp;#39;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The game progresses one tick of the clock at a time. At each tick, each cell counts how many of its neighboring eight cells are still alive. Based on its neighbor count, each cell decides if it will keep living, die, or regenerate. Here&amp;#8217;s an example of a 5x5 Game of Life grid after four generations with time going to the right. I&amp;#8217;ll explain the specific rules further&amp;nbsp;below.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;  0   |   1   |   2   |   3   |   4  
----- | ----- | ----- | ----- | -----
-*--- | --*-- | --**- | --*-- | -----
--**- | --**- | -*--- | -*--- | -**--
---*- | --**- | --**- | --*-- | -----
----- | ----- | ----- | ----- | -----
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;I can model this game by representing each cell as a generator coroutine running in lockstep with all the&amp;nbsp;others.&lt;/p&gt;
&lt;p&gt;To implement this, first I need a way to retrieve the status of neighboring cells. I can do this with a coroutine named &lt;code&gt;count_neighbors&lt;/code&gt; that works by yielding &lt;code&gt;Query&lt;/code&gt; objects. The &lt;code&gt;Query&lt;/code&gt; class I define myself. Its purpose is to provide the generator coroutine with a way to ask its surrounding environment for&amp;nbsp;information.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;Query&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;namedtuple&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Query&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;y&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;x&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The coroutine yields a &lt;code&gt;Query&lt;/code&gt; for each neighbor. The result of each &lt;code&gt;yield&lt;/code&gt; expression will be the value &lt;code&gt;ALIVE&lt;/code&gt; or &lt;code&gt;EMPTY&lt;/code&gt;. That&amp;#8217;s the interface contract I&amp;#8217;ve defined between the coroutine and its consuming code. The &lt;code&gt;count_neighbors&lt;/code&gt; generator sees the neighbors&amp;#8217; states and returns the count of living&amp;nbsp;neighbors.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;count_neighbors&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;n_&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;yield&lt;/span&gt; &lt;span class="n"&gt;Query&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;  &lt;span class="c"&gt;# North&lt;/span&gt;
    &lt;span class="n"&gt;ne&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;yield&lt;/span&gt; &lt;span class="n"&gt;Query&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;  &lt;span class="c"&gt;# Northeast&lt;/span&gt;
    &lt;span class="c"&gt;# Define e_, se, s_, sw, w_, nw ...&lt;/span&gt;
    &lt;span class="c"&gt;# ...&lt;/span&gt;
    &lt;span class="n"&gt;neighbor_states&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;n_&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;ne&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;e_&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;se&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;s_&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;sw&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;w_&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;nw&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="n"&gt;count&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;state&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;neighbor_states&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;state&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;ALIVE&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="n"&gt;count&lt;/span&gt; &lt;span class="o"&gt;+=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;count&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;I can drive the &lt;code&gt;count_neighbors&lt;/code&gt; coroutine with fake data to test it. Here I show how &lt;code&gt;Query&lt;/code&gt; objects will be yielded for each neighbor. &lt;code&gt;count_neighbors&lt;/code&gt; expects to receive cell states corresponding to each &lt;code&gt;Query&lt;/code&gt; through the coroutine&amp;#8217;s &lt;code&gt;send&lt;/code&gt; method. The final count is returned in the &lt;code&gt;StopIteration&lt;/code&gt; exception that is raised when the generator is exhausted by the &lt;code&gt;return&lt;/code&gt; statement.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;it&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;count_neighbors&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;10&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;q1&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;next&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;                  &lt;span class="c"&gt;# Get the first query&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;First yield: &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;q1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;q2&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;send&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ALIVE&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;            &lt;span class="c"&gt;# Send q1 state, get q2&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Second yield:&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;q2&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;q3&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;send&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ALIVE&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;            &lt;span class="c"&gt;# Send q2 state, get q3&lt;/span&gt;
&lt;span class="c"&gt;# ...&lt;/span&gt;
&lt;span class="k"&gt;try&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;count&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;send&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;EMPTY&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;     &lt;span class="c"&gt;# Send q8 state, retrieve count&lt;/span&gt;
&lt;span class="k"&gt;except&lt;/span&gt; &lt;span class="ne"&gt;StopIteration&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="n"&gt;e&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Count: &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;e&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;  &lt;span class="c"&gt;# Value from return statement&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
First yield:  Query(y=11, x=5)
Second yield: Query(y=11, x=6)
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Now I need the ability to indicate that a cell will transition to a new state in response to the neighbor count that it found from &lt;code&gt;count_neighbors&lt;/code&gt;. To do this, I define another coroutine called &lt;code&gt;step_cell&lt;/code&gt;. This generator will indicate transitions in a cell&amp;#8217;s state by yielding &lt;code&gt;Transition&lt;/code&gt; objects. This is another class that I define, just like the &lt;code&gt;Query&lt;/code&gt; class.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;Transition&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;namedtuple&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Transition&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;y&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;x&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;state&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The &lt;code&gt;step_cell&lt;/code&gt; coroutine receives its coordinates in the grid as arguments. It yields a &lt;code&gt;Query&lt;/code&gt; to get the initial state of those coordinates. It runs &lt;code&gt;count_neighbors&lt;/code&gt; to inspect the cells around it. It runs the game logic to determine what state the cell should have for the next clock tick. Finally, it yields a &lt;code&gt;Transition&lt;/code&gt; object to tell the environment the cell&amp;#8217;s next&amp;nbsp;state.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;game_logic&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;neighbors&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="c"&gt;# ...&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;step_cell&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;state&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;yield&lt;/span&gt; &lt;span class="n"&gt;Query&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;neighbors&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;yield from&lt;/span&gt; &lt;span class="n"&gt;count_neighbors&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;next_state&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;game_logic&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;neighbors&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;yield&lt;/span&gt; &lt;span class="n"&gt;Transition&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;next_state&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Importantly, the call to &lt;code&gt;count_neighbors&lt;/code&gt; uses the &lt;code&gt;yield from&lt;/code&gt; expression. This expression allows Python to compose generator coroutines together, making it easy to reuse smaller pieces of functionality and build complex coroutines from simpler ones. When &lt;code&gt;count_neighbors&lt;/code&gt; is exhausted, the final value it returns (with the &lt;code&gt;return&lt;/code&gt; statement) will be passed to &lt;code&gt;step_cell&lt;/code&gt; as the result of the &lt;code&gt;yield from&lt;/code&gt; expression.&lt;/p&gt;
&lt;p&gt;Now I can finally define the simple game logic for Conway&amp;#8217;s Game of Life. There are only three&amp;nbsp;rules.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;game_logic&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;neighbors&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;state&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;ALIVE&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;neighbors&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;EMPTY&lt;/span&gt;     &lt;span class="c"&gt;# Die: Too few&lt;/span&gt;
        &lt;span class="k"&gt;elif&lt;/span&gt; &lt;span class="n"&gt;neighbors&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;EMPTY&lt;/span&gt;     &lt;span class="c"&gt;# Die: Too many&lt;/span&gt;
    &lt;span class="k"&gt;else&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;neighbors&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;ALIVE&lt;/span&gt;     &lt;span class="c"&gt;# Regenerate&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;state&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;I can drive the &lt;code&gt;step_cell&lt;/code&gt; with fake data to test&amp;nbsp;it.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;it&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;step_cell&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;10&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;q0&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;next&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;           &lt;span class="c"&gt;# Initial location query&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Me:      &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;q0&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;q1&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;send&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ALIVE&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;     &lt;span class="c"&gt;# Send my status, get neighbor query&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Q1:      &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;q1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="c"&gt;# ...&lt;/span&gt;
&lt;span class="n"&gt;t1&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;send&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;EMPTY&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;     &lt;span class="c"&gt;# Send for q8, get game decision&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Outcome: &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;t1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
Me:       Query(y=10, x=5)
Q1:       Query(y=11, x=5)
Outcome:  Transition(y=10, x=5, state=&amp;#39;-&amp;#39;)
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The goal of the game is to run this logic for a whole grid of cells in lockstep. To do this, I can further compose the &lt;code&gt;step_cell&lt;/code&gt; coroutine into a &lt;code&gt;simulate&lt;/code&gt; coroutine. This coroutine progresses the grid of cells forward by yielding from &lt;code&gt;step_cell&lt;/code&gt; many times. After progressing every coordinate, it yields a &lt;code&gt;TICK&lt;/code&gt; object to indicate that the current generation of cells have all&amp;nbsp;transitioned.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;TICK&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;object&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;simulate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;height&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;width&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;while&lt;/span&gt; &lt;span class="bp"&gt;True&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="nb"&gt;range&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;height&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
            &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="nb"&gt;range&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;width&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
                &lt;span class="k"&gt;yield from&lt;/span&gt; &lt;span class="n"&gt;step_cell&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;yield&lt;/span&gt; &lt;span class="n"&gt;TICK&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;What&amp;#8217;s impressive about &lt;code&gt;simulate&lt;/code&gt; is that it&amp;#8217;s completely disconnected from the surrounding environment. I still haven&amp;#8217;t defined how the grid is represented in Python objects, how &lt;code&gt;Query&lt;/code&gt;, &lt;code&gt;Transition&lt;/code&gt;, and &lt;code&gt;TICK&lt;/code&gt; values are handled on the outside, nor how the game gets its initial state. But the logic is clear. Each cell will transition by running &lt;code&gt;step_cell&lt;/code&gt;. Then the game clock will tick. This will continue forever, as long as the &lt;code&gt;simulate&lt;/code&gt; coroutine is&amp;nbsp;advanced.&lt;/p&gt;
&lt;p&gt;This is the beauty of coroutines. They help you focus on the logic of what you&amp;#8217;re trying to accomplish. They decouple your code&amp;#8217;s instructions for the environment from the implementation that carries out your wishes. This enables you to run coroutines seemingly in parallel. This also allows you to improve the implementation of following those instructions over time without changing the&amp;nbsp;coroutines.&lt;/p&gt;
&lt;p&gt;Now I want to run &lt;code&gt;simulate&lt;/code&gt; in a real environment. To do that, I need to represent the state of each cell in the grid. Here I define a class to contain the&amp;nbsp;grid.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Grid&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;object&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;height&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;width&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;height&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;height&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;width&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;width&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;rows&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[]&lt;/span&gt;
        &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="nb"&gt;range&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;height&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
            &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;rows&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;append&lt;/span&gt;&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="n"&gt;EMPTY&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;width&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__str__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="c"&gt;# ...&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The grid allows you to get and set the value of any coordinate. Coordinates that are out of bounds will wrap around, making the the grid act like infinite looping&amp;nbsp;space.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;query&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;rows&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt; &lt;span class="o"&gt;%&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;height&lt;/span&gt;&lt;span class="p"&gt;][&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;%&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;width&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;assign&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;rows&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt; &lt;span class="o"&gt;%&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;height&lt;/span&gt;&lt;span class="p"&gt;][&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;%&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;width&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;state&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;At last, I can define the function that interprets the values yielded from &lt;code&gt;simulate&lt;/code&gt; and all of its interior coroutines. This function turns the instructions from the coroutines into interactions with the surrounding environment. It progresses the whole grid of cells forward a single step and then returns a new grid containing the next&amp;nbsp;state.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;live_a_generation&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;grid&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;sim&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;progeny&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;Grid&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;grid&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;height&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;grid&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;width&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;item&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;next&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;sim&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;while&lt;/span&gt; &lt;span class="n"&gt;item&lt;/span&gt; &lt;span class="ow"&gt;is&lt;/span&gt; &lt;span class="ow"&gt;not&lt;/span&gt; &lt;span class="n"&gt;TICK&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="nb"&gt;isinstance&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;item&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;Query&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
            &lt;span class="n"&gt;state&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;grid&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;query&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;item&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;item&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="n"&gt;item&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;sim&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;send&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;else&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;  &lt;span class="c"&gt;# Must be a Transition&lt;/span&gt;
            &lt;span class="n"&gt;progeny&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assign&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;item&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;item&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;item&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="n"&gt;item&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;next&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;sim&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;progeny&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;To see this function in action, I need to create a grid and set its initial state. Here I make a classic shape called a&amp;nbsp;glider.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;grid&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;Grid&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;9&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;grid&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assign&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;ALIVE&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="c"&gt;# ...&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;grid&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Now I can progress this grid forward one generation at a time. You can see how the glider moves down and to the right on the grid based on the simple rules from the &lt;code&gt;game_logic&lt;/code&gt; function.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;ColumnPrinter&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;object&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="c"&gt;# ...&lt;/span&gt;
&lt;span class="n"&gt;columns&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;ColumnPrinter&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="n"&gt;sim&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;simulate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;grid&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;height&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;grid&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;width&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;i&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="nb"&gt;range&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;columns&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;append&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;str&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;grid&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
    &lt;span class="n"&gt;grid&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;live_a_generation&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;grid&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;sim&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;columns&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
---*----- | --------- | --------- | --------- | ---------
----*---- | --*-*---- | ----*---- | ---*----- | ----*----
--***---- | ---**---- | --*-*---- | ----**--- | -----*---
--------- | ---*----- | ---**---- | ---**---- | ---***---
--------- | --------- | --------- | --------- | ---------
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The best part about this approach is that I can change the &lt;code&gt;game_logic&lt;/code&gt; function without having to update the code that surrounds it. I can change the rules or add larger spheres of influence with the existing mechanics of &lt;code&gt;Query&lt;/code&gt;, &lt;code&gt;Transition&lt;/code&gt;, and &lt;code&gt;TICK&lt;/code&gt;. This demonstrates how coroutines enable the separation of concerns, which is an important design&amp;nbsp;principle.&lt;/p&gt;
&lt;h3&gt;Coroutines in Python&amp;nbsp;2&lt;/h3&gt;
&lt;p&gt;Unfortunately, Python 2 is missing some of the syntactical sugar that makes coroutines so elegant in Python 3. There are two limitations. First, there is no &lt;code&gt;yield from&lt;/code&gt; expression. That means when you want to compose generator coroutines in Python 2, you need to include an additional loop at the delegation&amp;nbsp;point.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="c"&gt;# Python 2&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;delegated&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
    &lt;span class="k"&gt;yield&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;
    &lt;span class="k"&gt;yield&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;composed&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
    &lt;span class="k"&gt;yield&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;A&amp;#39;&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;delegated&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;  &lt;span class="c"&gt;# yield from in Python 3&lt;/span&gt;
        &lt;span class="k"&gt;yield&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt;
    &lt;span class="k"&gt;yield&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;B&amp;#39;&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="nb"&gt;list&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;composed&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
[&amp;#39;A&amp;#39;, 1, 2, &amp;#39;B&amp;#39;]
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The second limitation is that there is no support for the &lt;code&gt;return&lt;/code&gt; statement in Python 2 generators. To get the same behavior that interacts correctly with &lt;code&gt;try&lt;/code&gt;/&lt;code&gt;except&lt;/code&gt;/&lt;code&gt;finally&lt;/code&gt; blocks, you need to define your own exception type and raise it when you want to return a&amp;nbsp;value.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="c"&gt;# Python 2&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;MyReturn&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ne"&gt;Exception&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;delegated&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
    &lt;span class="k"&gt;yield&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;
    &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="n"&gt;MyReturn&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;  &lt;span class="c"&gt;# return 2 in Python 3&lt;/span&gt;
    &lt;span class="k"&gt;yield&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;Not reached&amp;#39;&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;composed&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
    &lt;span class="k"&gt;try&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;delegated&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
            &lt;span class="k"&gt;yield&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt;
    &lt;span class="k"&gt;except&lt;/span&gt; &lt;span class="n"&gt;MyReturn&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="n"&gt;e&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;output&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;e&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;
    &lt;span class="k"&gt;yield&lt;/span&gt; &lt;span class="n"&gt;output&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="mi"&gt;4&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt; &lt;span class="nb"&gt;list&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;composed&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;Things to&amp;nbsp;Remember&lt;/h3&gt;
&lt;li&gt;Coroutines provide an efficient way to run tens of thousands of functions seemingly at the same&amp;nbsp;time.&lt;/li&gt;
&lt;li&gt;Within a generator, the value of the &lt;code&gt;yield&lt;/code&gt; expression will be whatever value was passed to the generator&amp;#8217;s &lt;code&gt;send&lt;/code&gt; method from the exterior&amp;nbsp;code.&lt;/li&gt;
&lt;li&gt;Coroutines give you a powerful tool for separating the core logic of your program from its interaction with the surrounding&amp;nbsp;environment.&lt;/li&gt;
&lt;li&gt;Python 2 doesn&amp;#8217;t support &lt;code&gt;yield from&lt;/code&gt; or &lt;code&gt;return&lt;/code&gt; within&amp;nbsp;generators.&lt;/li&gt;
&lt;/ul&gt;</summary></entry><entry><title>The Book Is Published</title><link href="http://www.effectivepython.com/2015/03/06/books-is-published/" rel="alternate"></link><updated>2015-03-06T14:00:00-08:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2015-03-06:2015/03/06/books-is-published/</id><summary type="html">&lt;p&gt;Printed, physical copies of the &lt;em&gt;Effective Python&lt;/em&gt; book are now for sale! &lt;a href="http://goo.gl/mpVxz2"&gt;Follow this link to buy directly from the publisher&lt;/a&gt; (free shipping in the &lt;span class="caps"&gt;USA&lt;/span&gt;). The publisher also has ePub and &lt;span class="caps"&gt;PDF&lt;/span&gt; versions available. &lt;a href="http://amzn.to/1ylkKmc"&gt;Follow this link to buy from Amazon&lt;/a&gt;.  Amazon also has a Kindle edition&amp;nbsp;available.&lt;/p&gt;</summary></entry><entry><title>Digital Editions Now Available</title><link href="http://www.effectivepython.com/2015/02/15/digital-editions-now-available/" rel="alternate"></link><updated>2015-02-15T13:00:00-08:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2015-02-15:2015/02/15/digital-editions-now-available/</id><summary type="html">&lt;p&gt;Digital editions of &lt;em&gt;Effective Python&lt;/em&gt; are now available. &lt;a href="http://click.linksynergy.com/link?id=YvEWtFaKGwg&amp;amp;offerid=145238.2235742&amp;amp;type=2&amp;amp;murl=http%3A%2F%2Fwww.informit.com%2Ftitle%2F9780134034423"&gt;Follow this link to buy the ePub or &lt;span class="caps"&gt;PDF&lt;/span&gt; version&lt;/a&gt;. &lt;a href="http://amzn.to/1AFwumA"&gt;Follow this link to buy the Kindle edition&lt;/a&gt;. The print copy is due out on March&amp;nbsp;6th.&lt;/p&gt;</summary></entry><entry><title>Item 23: Accept Functions for Simple Interfaces Instead of Classes</title><link href="http://www.effectivepython.com/2015/02/12/accept-functions-for-simple-interfaces-instead-of-classes/" rel="alternate"></link><updated>2015-02-12T10:20:00-08:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2015-02-12:2015/02/12/accept-functions-for-simple-interfaces-instead-of-classes/</id><summary type="html">&lt;p&gt;&lt;em&gt;The following is a sample from the new book &lt;a href="/"&gt;Effective Python&lt;/a&gt;.&lt;/em&gt;&lt;br&gt;&lt;br&gt;&lt;/p&gt;
&lt;p&gt;Many of Python&amp;#8217;s built-in APIs allow you to customize behavior by passing in a function. These &lt;em&gt;hooks&lt;/em&gt; are used by APIs to call back your code while they execute. For example, the &lt;code&gt;list&lt;/code&gt; type&amp;#8217;s &lt;code&gt;sort&lt;/code&gt; method takes an optional &lt;code&gt;key&lt;/code&gt; argument that&amp;#8217;s used to determine each index&amp;#8217;s value for sorting. Here I sort a list of names based on their lengths by providing a &lt;code&gt;lambda&lt;/code&gt; expression as the &lt;code&gt;key&lt;/code&gt; hook.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;names&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Socrates&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;Archimedes&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;Plato&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;Aristotle&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="n"&gt;names&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;sort&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="k"&gt;lambda&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;names&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
[&amp;#39;Plato&amp;#39;, &amp;#39;Socrates&amp;#39;, &amp;#39;Aristotle&amp;#39;, &amp;#39;Archimedes&amp;#39;]
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;In other languages, you might expect hooks to be defined by an abstract class. In Python, many hooks are just stateless functions with well-defined arguments and return values. Functions are ideal for hooks because they are easier to describe and simpler to define than classes. Functions work as hooks because Python has &lt;em&gt;first-class&lt;/em&gt; functions: Functions and methods can be passed around and referenced like any other value in the&amp;nbsp;language.&lt;/p&gt;
&lt;p&gt;For example, say you want to customize the behavior of the &lt;code&gt;defaultdict&lt;/code&gt; class. This data structure allows you to supply a function that will be called each time a missing key is accessed. The function must return the default value the missing key should have in the dictionary. Here I define a hook that logs each time a key is missing and returns &lt;code&gt;0&lt;/code&gt; for the default&amp;nbsp;value.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;log_missing&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
    &lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Key added&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Given an initial dictionary and a set of desired increments, I can cause the &lt;code&gt;log_missing&lt;/code&gt; function to run and print twice (for &lt;code&gt;'red'&lt;/code&gt; and &lt;code&gt;'orange'&lt;/code&gt;).&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;current&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;green&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;12&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;blue&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="n"&gt;increments&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
    &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;red&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
    &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;blue&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;17&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
    &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;orange&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;9&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;defaultdict&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;log_missing&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;current&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Before:&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;dict&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;amount&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;increments&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;+=&lt;/span&gt; &lt;span class="n"&gt;amount&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;After: &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;dict&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
Before: {&amp;#39;blue&amp;#39;: 3, &amp;#39;green&amp;#39;: 12}
After:  {&amp;#39;red&amp;#39;: 5, &amp;#39;green&amp;#39;: 12, &amp;#39;blue&amp;#39;: 20, &amp;#39;orange&amp;#39;: 9}
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Supplying functions like &lt;code&gt;log_missing&lt;/code&gt; makes APIs easy to build and test because it separates side effects from deterministic behavior. For example, say you now want the default value hook passed to &lt;code&gt;defaultdict&lt;/code&gt; to count the total number of keys that were missing. One way to achieve this is using a stateful closure (see [Item 15 for details). Here I define a helper function that uses such a closure as the default value&amp;nbsp;hook.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;increment_with_report&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;current&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;increments&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;added_count&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;missing&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
        &lt;span class="n"&gt;nonlocal&lt;/span&gt; &lt;span class="n"&gt;added_count&lt;/span&gt;  &lt;span class="c"&gt;# Stateful closure&lt;/span&gt;
        &lt;span class="n"&gt;added_count&lt;/span&gt; &lt;span class="o"&gt;+=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;
    &lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;defaultdict&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;missing&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;current&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;amount&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;increments&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;+=&lt;/span&gt; &lt;span class="n"&gt;amount&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;added_count&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Running this function produces the expected result (&lt;code&gt;2&lt;/code&gt;), even though the &lt;code&gt;defaultdict&lt;/code&gt; has no idea that the &lt;code&gt;missing&lt;/code&gt; hook maintains state. This is another benefit of accepting simple functions for interfaces. It&amp;#8217;s easy to add functionality later by hiding state in a&amp;nbsp;closure.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;count&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;increment_with_report&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;current&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;increments&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="n"&gt;count&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The problem with defining a closure for stateful hooks is that it&amp;#8217;s harder to read than the stateless function example. Another approach is to define a small class that encapsulates the state you want to&amp;nbsp;track.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;CountMissing&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;object&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;added&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;missing&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;added&lt;/span&gt; &lt;span class="o"&gt;+=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;In other languages, you might expect that now &lt;code&gt;defaultdict&lt;/code&gt; would have to be modified to accommodate the interface of &lt;code&gt;CountMissing&lt;/code&gt;. But in Python, thanks to first-class functions, you can reference the &lt;code&gt;CountMissing.missing&lt;/code&gt; method directly on an object and pass it to &lt;code&gt;defaultdict&lt;/code&gt; as the default value hook. It&amp;#8217;s trivial to have a method satisfy a function&amp;nbsp;interface.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;counter&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;CountMissing&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;defaultdict&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;counter&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;missing&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;current&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;  &lt;span class="c"&gt;# Method reference&lt;/span&gt;
&lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;amount&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;increments&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;+=&lt;/span&gt; &lt;span class="n"&gt;amount&lt;/span&gt;
&lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="n"&gt;counter&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;added&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Using a helper class like this to provide the behavior of a stateful closure is clearer than the &lt;code&gt;increment_with_report&lt;/code&gt; function above. However, in isolation it&amp;#8217;s still not immediately obvious what the purpose of the &lt;code&gt;CountMissing&lt;/code&gt; class is. Who constructs a &lt;code&gt;CountMissing&lt;/code&gt; object? Who calls the &lt;code&gt;missing&lt;/code&gt; method? Will the class need other public methods to be added in the future? Until you see its usage with &lt;code&gt;defaultdict&lt;/code&gt; the class is a&amp;nbsp;mystery.&lt;/p&gt;
&lt;p&gt;To clarify this situation, Python allows classes to define the &lt;code&gt;__call__&lt;/code&gt; special method. &lt;code&gt;__call__&lt;/code&gt; allows an object to be called just like a function. It also causes the &lt;code&gt;callable&lt;/code&gt; built-in function to return &lt;code&gt;True&lt;/code&gt; for such an&amp;nbsp;instance.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;BetterCountMissing&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;object&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;added&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__call__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;added&lt;/span&gt; &lt;span class="o"&gt;+=&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;
&lt;span class="n"&gt;counter&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;BetterCountMissing&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="n"&gt;counter&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="nb"&gt;callable&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;counter&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Here I use a &lt;code&gt;BetterCountMissing&lt;/code&gt; instance as the default value hook for a &lt;code&gt;defaultdict&lt;/code&gt; to track the number of missing keys that were&amp;nbsp;added.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;counter&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;BetterCountMissing&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;defaultdict&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;counter&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;current&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;  &lt;span class="c"&gt;# Relies on __call__&lt;/span&gt;
&lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;amount&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;increments&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;+=&lt;/span&gt; &lt;span class="n"&gt;amount&lt;/span&gt;
&lt;span class="k"&gt;assert&lt;/span&gt; &lt;span class="n"&gt;counter&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;added&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;This is much clearer than the &lt;code&gt;CountMissing.missing&lt;/code&gt; example. The &lt;code&gt;__call__&lt;/code&gt; method indicates that a class&amp;#8217;s instances will be used somewhere a function argument would also be suitable (like &lt;span class="caps"&gt;API&lt;/span&gt; hooks). It directs new readers of the code to the entry point that&amp;#8217;s responsible for the class&amp;#8217;s primary behavior. It provides a strong hint that the goal of the class is to act as a stateful&amp;nbsp;closure.&lt;/p&gt;
&lt;p&gt;Best of all, &lt;code&gt;defaultdict&lt;/code&gt; still has no view into what&amp;#8217;s going on when you use &lt;code&gt;__call__&lt;/code&gt;. All that &lt;code&gt;defaultdict&lt;/code&gt; requires is a function for the default value hook. Python provides many different ways to satisfy a simple function interface depending on what you need to&amp;nbsp;accomplish.&lt;/p&gt;
&lt;h3&gt;Things to&amp;nbsp;Remember&lt;/h3&gt;
&lt;li&gt;Instead of defining and instantiating classes, functions are often all you need for simple interfaces between components in&amp;nbsp;Python.&lt;/li&gt;
&lt;li&gt;References to functions and methods in Python are first-class, meaning they can be used in expressions like any other&amp;nbsp;type.&lt;/li&gt;
&lt;li&gt;The &lt;code&gt;__call__&lt;/code&gt; special method enables instances of a class to be called like plain Python&amp;nbsp;functions.&lt;/li&gt;
&lt;li&gt;When you need a function to maintain state, consider defining a class that provides the &lt;code&gt;__call__&lt;/code&gt; method instead of defining a stateful&amp;nbsp;closure.&lt;/li&gt;
&lt;/ul&gt;</summary></entry><entry><title>Item 34: Register Class Existence with Metaclasses</title><link href="http://www.effectivepython.com/2015/02/02/register-class-existence-with-metaclasses/" rel="alternate"></link><updated>2015-02-02T22:22:00-08:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2015-02-02:2015/02/02/register-class-existence-with-metaclasses/</id><summary type="html">&lt;p&gt;&lt;em&gt;The following is a sample from the new book &lt;a href="/"&gt;Effective Python&lt;/a&gt;.&lt;/em&gt;&lt;br&gt;&lt;br&gt;&lt;/p&gt;
&lt;p&gt;A common use of metaclasses is to automatically register types in your program. Registration is useful for doing reverse lookups, where you need to map a simple identifier back to a corresponding class.&lt;/p&gt;
&lt;p&gt;For example, say you want to implement your own serialized representation of a Python object using &lt;span class="caps"&gt;JSON&lt;/span&gt;. You need a way to take an object and turn it into a &lt;span class="caps"&gt;JSON&lt;/span&gt; string. Here I do this generically by defining a base class that records the constructor parameters and turns them into a &lt;span class="caps"&gt;JSON&lt;/span&gt;&amp;nbsp;dictionary.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Serializable&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;object&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;serialize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;dumps&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;args&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;})&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;This class makes it easy to serialize simple, immutable data structures like &lt;code&gt;Point2D&lt;/code&gt; to a&amp;nbsp;string.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Point2D&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Serializable&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="nb"&gt;super&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__repr__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;Point2D(&lt;/span&gt;&lt;span class="si"&gt;%d&lt;/span&gt;&lt;span class="s"&gt;, &lt;/span&gt;&lt;span class="si"&gt;%d&lt;/span&gt;&lt;span class="s"&gt;)&amp;#39;&lt;/span&gt; &lt;span class="o"&gt;%&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;point&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;Point2D&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Object:    &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;point&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Serialized:&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;point&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;serialize&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
Object:     Point2D(5, 3)
Serialized: {&amp;quot;args&amp;quot;: [5, 3]}
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Now I need to deserialize this &lt;span class="caps"&gt;JSON&lt;/span&gt; string and construct the &lt;code&gt;Point2D&lt;/code&gt; object it represents. Here I define another class that can deserialize the data from its &lt;code&gt;Serializable&lt;/code&gt; parent&amp;nbsp;class.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Deserializable&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Serializable&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="nd"&gt;@classmethod&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;deserialize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;cls&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;json_data&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="n"&gt;params&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;loads&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;json_data&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;cls&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;params&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;args&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Using &lt;code&gt;Deserializable&lt;/code&gt; makes it easy to serialize and deserialize simple, immutable objects in a generic&amp;nbsp;way.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;BetterPoint2D&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Deserializable&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="c"&gt;# ...&lt;/span&gt;
&lt;span class="n"&gt;point&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;BetterPoint2D&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Before:    &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;point&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;data&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;point&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;serialize&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Serialized:&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;after&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;BetterPoint2D&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;deserialize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;After:     &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;after&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
Before:     BetterPoint2D(5, 3)
Serialized: {&amp;quot;args&amp;quot;: [5, 3]}
After:      BetterPoint2D(5, 3)
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The problem with this approach is it only works if you know the intended type of the serialized data ahead of time (e.g., &lt;code&gt;Point2D&lt;/code&gt;, &lt;code&gt;BetterPoint2D&lt;/code&gt;). Ideally you&amp;#8217;d have a large number of classes serializing to &lt;span class="caps"&gt;JSON&lt;/span&gt; and one common function that could deserialize any of them back to a corresponding Python&amp;nbsp;object.&lt;/p&gt;
&lt;p&gt;To do this, I can include the serialized object&amp;#8217;s class name in the &lt;span class="caps"&gt;JSON&lt;/span&gt;&amp;nbsp;data.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;BetterSerializable&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;object&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;serialize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;dumps&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;
            &lt;span class="s"&gt;&amp;#39;class&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;__class__&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;__name__&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
            &lt;span class="s"&gt;&amp;#39;args&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="p"&gt;})&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__repr__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="c"&gt;# ...&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Then I can maintain a mapping of class names back to constructors for those objects. The general &lt;code&gt;deserialize&lt;/code&gt; function will work for any classes passed to &lt;code&gt;register_class&lt;/code&gt;.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;registry&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{}&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;register_class&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;target_class&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;registry&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;target_class&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;__name__&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;target_class&lt;/span&gt;
&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;deserialize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;params&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;loads&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;params&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;class&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="n"&gt;target_class&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;registry&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;target_class&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;params&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;args&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;To ensure &lt;code&gt;deserialize&lt;/code&gt; always works properly, I must call &lt;code&gt;register_class&lt;/code&gt; for every class I may want to deserialize in the&amp;nbsp;future.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;EvenBetterPoint2D&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;BetterSerializable&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="nb"&gt;super&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;
&lt;span class="n"&gt;register_class&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;EvenBetterPoint2D&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Now I can deserialize an arbitrary &lt;span class="caps"&gt;JSON&lt;/span&gt; string without having to know which class it&amp;nbsp;contains.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;point&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;EvenBetterPoint2D&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Before:    &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;point&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;data&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;point&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;serialize&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Serialized:&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;after&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;deserialize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;After:     &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;after&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
Before:     EvenBetterPoint2D(5, 3)
Serialized: {&amp;quot;class&amp;quot;: &amp;quot;EvenBetterPoint2D&amp;quot;, &amp;quot;args&amp;quot;: [5, 3]}
After:      EvenBetterPoint2D(5, 3)
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The problem with this approach is that you can forget to call &lt;code&gt;register_class&lt;/code&gt;.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Point3D&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;BetterSerializable&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;z&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="nb"&gt;super&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;z&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;z&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;z&lt;/span&gt;
&lt;span class="c"&gt;# Forgot to call register_class! Whoops!&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;This will cause your code to break at runtime, when you finally try to deserialize an object of a class you forgot to&amp;nbsp;register.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;point&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;Point3D&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;9&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;4&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;data&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;point&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;serialize&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="n"&gt;deserialize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
KeyError: &amp;#39;Point3D&amp;#39;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Even though you chose to subclass &lt;code&gt;BetterSerializable&lt;/code&gt;, you won&amp;#8217;t actually get all of its features if you forget to call &lt;code&gt;register_class&lt;/code&gt; after your &lt;code&gt;class&lt;/code&gt; statement body. This approach is error prone and especially challenging for beginners. The same omission can happen with &lt;em&gt;class decorators&lt;/em&gt; in Python&amp;nbsp;3.&lt;/p&gt;
&lt;p&gt;What if you could somehow act on the programmer&amp;#8217;s intent to use &lt;code&gt;BetterSerializable&lt;/code&gt; and ensure &lt;code&gt;register_class&lt;/code&gt; is called in all cases? Metaclasses enable this by intercepting the &lt;code&gt;class&lt;/code&gt; statement when subclasses are defined. This lets you register the new type immediately after the class&amp;#8217;s&amp;nbsp;body.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Meta&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;type&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__new__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;meta&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;bases&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;class_dict&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="n"&gt;cls&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;type&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;__new__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;meta&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;bases&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;class_dict&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;register_class&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;cls&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;cls&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;RegisteredSerializable&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;BetterSerializable&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;metaclass&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;Meta&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;pass&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;When I define a subclass of &lt;code&gt;RegisteredSerializable&lt;/code&gt;, I can be confident that the call to &lt;code&gt;register_class&lt;/code&gt; happened and &lt;code&gt;deserialize&lt;/code&gt; will always work as&amp;nbsp;expected.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Vector3D&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;RegisteredSerializable&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;z&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="nb"&gt;super&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;z&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;z&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;z&lt;/span&gt;
&lt;span class="n"&gt;v3&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;Vector3D&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;10&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;7&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Before:    &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;v3&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;data&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;v3&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;serialize&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Serialized:&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;After:     &amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;deserialize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
Before:     Vector3D(10, -7, 3)
Serialized: {&amp;quot;class&amp;quot;: &amp;quot;Vector3D&amp;quot;, &amp;quot;args&amp;quot;: [10, -7, 3]}
After:      Vector3D(10, -7, 3)
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Using metaclasses for class registration ensures that you&amp;#8217;ll never miss a class as long as the inheritance tree is right. This works well for serialization, as I&amp;#8217;ve shown, and also applies to Database ORMs, plug-in systems, and system&amp;nbsp;hooks.&lt;/p&gt;
&lt;h3&gt;Things to&amp;nbsp;Remember&lt;/h3&gt;
&lt;li&gt;Class registration is a helpful pattern for building modular Python&amp;nbsp;programs.&lt;/li&gt;
&lt;li&gt;Metaclasses let you run registration code automatically each time your base class is subclassed in a&amp;nbsp;program.&lt;/li&gt;
&lt;li&gt;Using metaclasses for class registration avoids errors by ensuring that you never miss a registration&amp;nbsp;call.&lt;/li&gt;
&lt;/ul&gt;</summary></entry><entry><title>Item 53: Use Virtual Environments for Isolated and Reproducible Dependencies</title><link href="http://www.effectivepython.com/2015/01/21/use-virtual-environments-for-isolated-and-reproducible-dependencies/" rel="alternate"></link><updated>2015-01-21T19:45:00-08:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2015-01-21:2015/01/21/use-virtual-environments-for-isolated-and-reproducible-dependencies/</id><summary type="html">&lt;p&gt;&lt;em&gt;The following is a sample from the new book &lt;a href="/"&gt;Effective Python&lt;/a&gt;.&lt;/em&gt;&lt;br&gt;&lt;br&gt;&lt;/p&gt;
&lt;p&gt;Building larger and more complex programs often leads you to rely on various packages from the Python community. You&amp;#8217;ll find yourself running &lt;code&gt;pip&lt;/code&gt; to install packages like &lt;code&gt;pytz&lt;/code&gt;, &lt;code&gt;numpy&lt;/code&gt;, and many&amp;nbsp;others.&lt;/p&gt;
&lt;p&gt;The problem is that by default &lt;code&gt;pip&lt;/code&gt; installs new packages in a global location. That causes all Python programs on your system to be affected by these installed modules. In theory, this shouldn&amp;#8217;t be an issue. If you install a package and never &lt;code&gt;import&lt;/code&gt; it, how could it affect your programs?&lt;/p&gt;
&lt;p&gt;The trouble comes from transitive dependencies: the packages that the packages you install depend on. For example, you can see what the &lt;code&gt;Sphinx&lt;/code&gt; package depends on after installing it by asking &lt;code&gt;pip&lt;/code&gt;.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;$ pip3 show Sphinx
Name: Sphinx
Version: 1.2.2
Location: /usr/local/lib/python3.4/site-packages
Requires: docutils, Jinja2, Pygments
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;If you install another package like &lt;code&gt;flask&lt;/code&gt;, you can see that it too depends on the &lt;code&gt;Jinja2&lt;/code&gt; package.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;$ pip3 show flask
Name: Flask
Version: 0.10.1
Location: /usr/local/lib/python3.4/site-packages
Requires: Werkzeug, Jinja2, itsdangerous
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The conflict arises as &lt;code&gt;Sphinx&lt;/code&gt; and &lt;code&gt;flask&lt;/code&gt; diverge over time. Perhaps right now they both require the same version of &lt;code&gt;Jinja2&lt;/code&gt; and everything is fine. But six months or a year from now, &lt;code&gt;Jinja2&lt;/code&gt; may release a new version that makes breaking changes to users of the library. If you update your global version of &lt;code&gt;Jinja2&lt;/code&gt; with &lt;code&gt;pip install --upgrade&lt;/code&gt;, you may find that &lt;code&gt;Sphinx&lt;/code&gt; breaks while &lt;code&gt;flask&lt;/code&gt; keeps&amp;nbsp;working.&lt;/p&gt;
&lt;p&gt;The cause of this breakage is that Python can only have a single global version of a module installed at a time. If one of your installed packages must use the new version and another package must use the old version, your system isn&amp;#8217;t going to work&amp;nbsp;properly.&lt;/p&gt;
&lt;p&gt;Such breakage can even happen when package maintainers try their best to preserve &lt;span class="caps"&gt;API&lt;/span&gt; compatibility between releases. New versions of a library can subtly change behaviors that &lt;span class="caps"&gt;API&lt;/span&gt; consuming code relies on. Users on a system may upgrade one package to a new version but not others, breaking dependencies. There&amp;#8217;s a constant risk of the ground moving beneath your&amp;nbsp;feet.&lt;/p&gt;
&lt;p&gt;These difficulties are magnified when you collaborate with other developers who do their work on separate computers. It&amp;#8217;s reasonable to assume that the versions of Python and global packages they have installed on their machines will be slightly different than your own. This can cause frustrating situations where a codebase works perfectly on one programmer&amp;#8217;s machine and is completely broken on&amp;nbsp;another&amp;#8217;s.&lt;/p&gt;
&lt;p&gt;The solution to all of these problems is a tool called &lt;code&gt;pyvenv&lt;/code&gt;, which provides &lt;em&gt;virtual environments&lt;/em&gt;. Since Python 3.4, the &lt;code&gt;pyvenv&lt;/code&gt; command-line tool is available by default along with the Python installation (it&amp;#8217;s also accessible with &lt;code&gt;python -m venv&lt;/code&gt;). Prior versions of Python require installing a separate package (with &lt;code&gt;pip install virtualenv&lt;/code&gt;) and using a command-line tool called &lt;code&gt;virtualenv&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;pyvenv&lt;/code&gt; allows you to create isolated versions of the Python environment. Using &lt;code&gt;pyvenv&lt;/code&gt;, you can have many different versions of the same package installed on the same system at the same time without conflicts. This lets you work on many different projects and use many different tools on the same&amp;nbsp;computer.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;pyvenv&lt;/code&gt; does this by installing explicit versions of packages and their dependencies into completely separate directory structures. This makes it possible to reproduce a Python environment that you know will work with your code. It&amp;#8217;s a reliable way to avoid surprising&amp;nbsp;breakages.&lt;/p&gt;
&lt;h3&gt;The &lt;code&gt;pyvenv&lt;/code&gt; Command&lt;/h3&gt;
&lt;p&gt;Here&amp;#8217;s a quick tutorial on how to use &lt;code&gt;pyvenv&lt;/code&gt; effectively. Before using the tool, it&amp;#8217;s important to note the meaning of the &lt;code&gt;python3&lt;/code&gt; command-line on your system. On my computer, &lt;code&gt;python3&lt;/code&gt; is located in the &lt;code&gt;/usr/local/bin&lt;/code&gt; directory and evaluates to version&amp;nbsp;3.4.2.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;$ which python3
/usr/local/bin/python3
$ python3 --version
Python 3.4.2
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;To demonstrate the setup of my environment, I can test that running a command to import the &lt;code&gt;pytz&lt;/code&gt; module doesn&amp;#8217;t cause an error. This works because I already have the &lt;code&gt;pytz&lt;/code&gt; package installed as a global&amp;nbsp;module.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;$ python3 -c &amp;#39;import pytz&amp;#39;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Now I use &lt;code&gt;pyvenv&lt;/code&gt; to create a new virtual environment called &lt;code&gt;myproject&lt;/code&gt;. Each virtual environment must live in its own unique directory. The result of the command is a tree of directories and&amp;nbsp;files.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;$ pyvenv /tmp/myproject
$ cd /tmp/myproject
bin     include     lib     pyvenv.cfg
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;To start using the virtual environment, I use the &lt;code&gt;source&lt;/code&gt; command from my shell on the &lt;code&gt;bin/activate&lt;/code&gt; script. &lt;code&gt;activate&lt;/code&gt; modifies all of my environment variables to match the virtual environment. It also updates my command-line prompt to include the virtual environment name (&lt;code&gt;'myproject'&lt;/code&gt;) to make it extremely clear what I&amp;#8217;m working&amp;nbsp;on.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;$ source bin/activate
(myproject)$
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;After activation, you can see that the path to the &lt;code&gt;python3&lt;/code&gt; command-line tool has moved to within the virtual environment&amp;nbsp;directory.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;(myproject)$ which python3
/tmp/myproject/bin/python3
(myproject)$ ls -l /tmp/myproject/bin/python3
... -&amp;gt; /tmp/myproject/bin/python3.4
(myproject)$ ls -l /tmp/myproject/bin/python3.4
... -&amp;gt; /usr/local/bin/python3.4
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;This ensures that changes to the outside system will not affect the virtual environment. Even if the outer system upgrades its default &lt;code&gt;python3&lt;/code&gt; to version 3.5, my virtual environment will still explicitly point at version&amp;nbsp;3.4.&lt;/p&gt;
&lt;p&gt;The virtual environment I created with &lt;code&gt;pyvenv&lt;/code&gt; starts with no packages installed except for &lt;code&gt;pip&lt;/code&gt; and &lt;code&gt;setuptools&lt;/code&gt;. Trying to use the &lt;code&gt;pytz&lt;/code&gt; package that was installed as a global module in the outside system will fail because it&amp;#8217;s unknown to the virtual&amp;nbsp;environment.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;(myproject)$ python3 -c &amp;#39;import pytz&amp;#39;
Traceback (most recent call last):
  File &amp;quot;&amp;lt;string&amp;gt;&amp;quot;, line 1, in &amp;lt;module&amp;gt;
ImportError: No module named &amp;#39;pytz&amp;#39;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;I can use &lt;code&gt;pip&lt;/code&gt; to install the &lt;code&gt;pytz&lt;/code&gt; module into my virtual&amp;nbsp;environment.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;(myproject)$ pip3 install pytz
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Once it&amp;#8217;s installed, I can verify it&amp;#8217;s working with the same test import&amp;nbsp;command.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;(myproject)$ python3 -c &amp;#39;import pytz&amp;#39;
(myproject)$
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;When you&amp;#8217;re done with a virtual environment and want to go back to your default system, you use the &lt;code&gt;deactivate&lt;/code&gt; command. This restores your environment to the system defaults, including the location of the &lt;code&gt;python3&lt;/code&gt; command-line&amp;nbsp;tool.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;(myproject)$ deactivate
$ which python3
/usr/local/bin/python3
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;If you ever want to work in the &lt;code&gt;myproject&lt;/code&gt; environment again, you can just run &lt;code&gt;source bin/activate&lt;/code&gt; in the directory like&amp;nbsp;before.&lt;/p&gt;
&lt;h3&gt;Reproducing&amp;nbsp;Dependencies&lt;/h3&gt;
&lt;p&gt;Once you have a virtual environment, you can continue installing packages with &lt;code&gt;pip&lt;/code&gt; as you need them. Eventually, you may want to copy your environment somewhere else. For example, say you want to reproduce your development environment on a production server. Or maybe you want to clone someone else&amp;#8217;s environment on your own machine so you can run their&amp;nbsp;code.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;pyvenv&lt;/code&gt; makes these situations easy. You can use the &lt;code&gt;pip freeze&lt;/code&gt; command to save all of your explicit package dependencies into a file. By convention this file is named &lt;code&gt;requirements.txt&lt;/code&gt;.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;(myproject)$ pip3 freeze &amp;gt; requirements.txt
(myproject)$ cat requirements.txt
numpy==1.8.2
pytz==2014.4
requests==2.3.0
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Now imagine you&amp;#8217;d like to have another virtual environment that matches the &lt;code&gt;myproject&lt;/code&gt; environment. You can create a new directory like before using &lt;code&gt;pyvenv&lt;/code&gt; and &lt;code&gt;activate&lt;/code&gt; it.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;$ pyvenv /tmp/otherproject
$ cd /tmp/otherproject
$ source bin/activate
(otherproject)$
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The new environment will have no extra packages&amp;nbsp;installed.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;(otherproject)$ pip3 list
pip (1.5.6)
setuptools (2.1)
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;You can install all of the packages from the first environment by running &lt;code&gt;pip install&lt;/code&gt; on the &lt;code&gt;requirements.txt&lt;/code&gt; that you generated with the &lt;code&gt;pip freeze&lt;/code&gt; command.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;(otherproject)$ pip3 install -r /tmp/myproject/requirements.txt
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;This command will crank along for a little while as it retrieves and installs all of the packages required to reproduce the first environment. Once it&amp;#8217;s done, listing the set of installed packages in the second virtual environment will produce the same list of dependencies found in the first virtual&amp;nbsp;environment.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;(otherproject)$ pip list
numpy (1.8.2)
pip (1.5.6)
pytz (2014.4)
requests (2.3.0)
setuptools (2.1)
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Using a &lt;code&gt;requirements.txt&lt;/code&gt; file is ideal for collaborating with others through a revision control system. You can commit changes to your code at the same time you update your list of package dependencies, ensuring they move in&amp;nbsp;lockstep.&lt;/p&gt;
&lt;p&gt;The gotcha with virtual environments is that moving them breaks everything because all of the paths, like &lt;code&gt;python3&lt;/code&gt;, are hard-coded to the environment&amp;#8217;s install directory. But that doesn&amp;#8217;t matter. The whole purpose of virtual environments is to make it easy to reproduce the same setup. Instead of moving a virtual environment directory, just &lt;code&gt;freeze&lt;/code&gt; the old one, create a new one somewhere else, and reinstall everything from the &lt;code&gt;requirements.txt&lt;/code&gt; file.&lt;/p&gt;
&lt;h3&gt;Things to&amp;nbsp;Remember&lt;/h3&gt;
&lt;li&gt;Virtual environments allow you to use &lt;code&gt;pip&lt;/code&gt; to install many different versions of the same package on the same machine without&amp;nbsp;conflicts.&lt;/li&gt;
&lt;li&gt;Virtual environments are created with &lt;code&gt;pyvenv&lt;/code&gt;, enabled with &lt;code&gt;source bin/activate&lt;/code&gt;, and disabled with &lt;code&gt;deactivate&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;You can dump all of the requirements of an environment with &lt;code&gt;pip freeze&lt;/code&gt;. You can reproduce the environment by supplying the &lt;code&gt;requirements.txt&lt;/code&gt; file to &lt;code&gt;pip install -r&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;In versions of Python before 3.4, the &lt;code&gt;pyvenv&lt;/code&gt; tool must be downloaded and installed separately. The command-line tool is called &lt;code&gt;virtualenv&lt;/code&gt; instead of &lt;code&gt;pyvenv&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;</summary></entry><entry><title>Item 17: Be Defensive When Iterating Over Arguments</title><link href="http://www.effectivepython.com/2015/01/03/be-defensive-when-iterating-over-arguments/" rel="alternate"></link><updated>2014-12-05T23:30:00-08:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2015-01-03:2015/01/03/be-defensive-when-iterating-over-arguments/</id><summary type="html">&lt;p&gt;&lt;em&gt;The following is a sample from the new book &lt;a href="/"&gt;Effective Python&lt;/a&gt;.&lt;/em&gt;&lt;br&gt;&lt;br&gt;&lt;/p&gt;
&lt;p&gt;When a function takes a list of objects as a parameter, it&amp;#8217;s often important to iterate over that list multiple times. For example, say you want to analyze tourism numbers for the &lt;span class="caps"&gt;U.S.&lt;/span&gt; State of Texas. Imagine the data set is the number of visitors to each city (in millions per year). You&amp;#8217;d like to figure out what percentage of overall tourism each city&amp;nbsp;receives.&lt;/p&gt;
&lt;p&gt;To do this you need a normalization function. It sums the inputs to figure out the total number of tourists per year. Then it divides each city&amp;#8217;s individual visitor count by the total to find that city&amp;#8217;s contribution to the&amp;nbsp;whole.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;normalize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;numbers&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;total&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;sum&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;numbers&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[]&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;numbers&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;percent&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;100&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="n"&gt;total&lt;/span&gt;
        &lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;append&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;percent&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;result&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;This function works when given a list of&amp;nbsp;visits.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;visits&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;15&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;35&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;80&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="n"&gt;percentages&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;normalize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;visits&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;percentages&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;To scale this up, I need to read the data from a file that contains every city in all of Texas. I define a generator to do this because then I can reuse the same function later when I want to compute tourism numbers for the whole world, a much larger data&amp;nbsp;set.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;read_visits&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data_path&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;with&lt;/span&gt; &lt;span class="nb"&gt;open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data_path&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;line&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;yield&lt;/span&gt; &lt;span class="nb"&gt;int&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;line&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Surprisingly, calling &lt;code&gt;normalize&lt;/code&gt; on the generator&amp;#8217;s return value produces no&amp;nbsp;results.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;it&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;read_visits&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;/tmp/my_numbers.txt&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;percentages&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;normalize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;percentages&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The cause of this behavior is that an iterator only produces its results a single time. If you iterate over an iterator or generator that has already raised a &lt;code&gt;StopIteration&lt;/code&gt; exception, you won&amp;#8217;t get any results the second time&amp;nbsp;around.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;it&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;read_visits&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;/tmp/my_numbers.txt&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;list&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;list&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;  &lt;span class="c"&gt;# Already exhausted&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
[15, 35, 80]
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;What&amp;#8217;s confusing is that you also won&amp;#8217;t get any errors when you iterate over an already-exhausted iterator. &lt;code&gt;for&lt;/code&gt; loops, the &lt;code&gt;list&lt;/code&gt; constructor, and many other functions throughout the Python standard library expect the &lt;code&gt;StopIteration&lt;/code&gt; exception to be raised during normal operation. These functions can&amp;#8217;t tell the difference between an iterator that has no output and an iterator that had output and is now&amp;nbsp;exhausted.&lt;/p&gt;
&lt;p&gt;To solve this problem, you can explicitly exhaust an input iterator and keep a copy of its entire contents in a list. You can then iterate over the list version of the data as many times as you need to. Here&amp;#8217;s the same function as before, but it defensively copies the input&amp;nbsp;iterator.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;normalize_copy&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;numbers&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;numbers&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;list&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;numbers&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;  &lt;span class="c"&gt;# Copy the iterator&lt;/span&gt;
    &lt;span class="n"&gt;total&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;sum&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;numbers&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[]&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;numbers&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;percent&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;100&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="n"&gt;total&lt;/span&gt;
        &lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;append&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;percent&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;result&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Now the function works correctly on a generator&amp;#8217;s return&amp;nbsp;value.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;it&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;read_visits&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;/tmp/my_numbers.txt&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;percentages&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;normalize_copy&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;percentages&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The problem with this approach is the copy of the input iterator&amp;#8217;s contents could be large. Copying the iterator could cause your program to run out of memory and crash. One way around this is to accept a function that returns a new iterator each time it&amp;#8217;s&amp;nbsp;called. &lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;normalize_func&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;get_iter&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;total&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;sum&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;get_iter&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;   &lt;span class="c"&gt;# New iterator&lt;/span&gt;
    &lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[]&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;get_iter&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;  &lt;span class="c"&gt;# New iterator&lt;/span&gt;
        &lt;span class="n"&gt;percent&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;100&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="n"&gt;total&lt;/span&gt;
        &lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;append&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;percent&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;result&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;To use &lt;code&gt;normalize_func&lt;/code&gt;, you can pass in a &lt;code&gt;lambda&lt;/code&gt; expression that calls the generator and produces a new iterator each&amp;nbsp;time.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;percentages&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;normalize_func&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;lambda&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;read_visits&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;Though it works, having to pass a lambda function like this is clumsy. The better way to achieve the same result is to provide a new container class that implements the &lt;em&gt;iterator protocol&lt;/em&gt;.&lt;/p&gt;
&lt;p&gt;The iterator protocol is how Python &lt;code&gt;for&lt;/code&gt; loops and related expressions traverse the contents of a container type. When Python sees a statement like &lt;code&gt;for x in foo&lt;/code&gt; it will actually call &lt;code&gt;iter(foo)&lt;/code&gt;. The &lt;code&gt;iter&lt;/code&gt; built-in function calls the &lt;code&gt;foo.__iter__&lt;/code&gt; special method in turn. The &lt;code&gt;__iter__&lt;/code&gt; method must return an iterator object (which itself implements the &lt;code&gt;__next__&lt;/code&gt; special method). Then the &lt;code&gt;for&lt;/code&gt; loop repeatedly calls the &lt;code&gt;next&lt;/code&gt; built-in function on the iterator object until it&amp;#8217;s exhausted (and raises a &lt;code&gt;StopIteration&lt;/code&gt; exception).&lt;/p&gt;
&lt;p&gt;It sounds complicated, but practically speaking you can achieve all of this behavior for your classes by implementing the &lt;code&gt;__iter__&lt;/code&gt; method as a generator. Here I define an iterable container class that reads the files containing tourism&amp;nbsp;data.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;ReadVisits&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;object&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;data_path&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;data_path&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;data_path&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__iter__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="k"&gt;with&lt;/span&gt; &lt;span class="nb"&gt;open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="bp"&gt;self&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;data_path&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;line&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
                &lt;span class="k"&gt;yield&lt;/span&gt; &lt;span class="nb"&gt;int&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;line&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;This new container type works correctly when passed to the original function without any&amp;nbsp;modifications.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;visits&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;ReadVisits&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;percentages&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;normalize&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;visits&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;percentages&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;This works because the &lt;code&gt;sum&lt;/code&gt; method in &lt;code&gt;normalize&lt;/code&gt; will call &lt;code&gt;ReadVisits.__iter__&lt;/code&gt; to allocate a new iterator object. The &lt;code&gt;for&lt;/code&gt; loop to normalize the numbers will also call &lt;code&gt;__iter__&lt;/code&gt; to allocate a second iterator object. Each of those iterators will be advanced and exhausted independently, ensuring that each unique iteration sees all of the input data values. The only downside of this approach is it reads the input data multiple&amp;nbsp;times.&lt;/p&gt;
&lt;p&gt;Now that you know how containers like &lt;code&gt;ReadVisits&lt;/code&gt; work, you can write your functions to ensure that parameters aren&amp;#8217;t just iterators. The protocol states that when an iterator is passed to the &lt;code&gt;iter&lt;/code&gt; built-in function, &lt;code&gt;iter&lt;/code&gt; will return the iterator itself. In contrast, when a container type is passed to &lt;code&gt;iter&lt;/code&gt;, a new iterator object will be returned each time. Thus, you can test an input value for this behavior and raise a &lt;code&gt;TypeError&lt;/code&gt; to reject&amp;nbsp;iterators.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;normalize_defensive&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;numbers&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="nb"&gt;iter&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;numbers&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="ow"&gt;is&lt;/span&gt; &lt;span class="nb"&gt;iter&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;numbers&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;  &lt;span class="c"&gt;# An iterator -- bad!&lt;/span&gt;
        &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="ne"&gt;TypeError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;&amp;#39;Must supply a container&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;total&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;sum&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;numbers&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[]&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;numbers&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;percent&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;100&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="n"&gt;total&lt;/span&gt;
        &lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;append&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;percent&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;result&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;This is ideal if you you don&amp;#8217;t want to copy the full input iterator like &lt;code&gt;normalize_copy&lt;/code&gt; above, but you also need to iterate over the input data multiple times. This function works as expected for &lt;code&gt;list&lt;/code&gt; and &lt;code&gt;ReadVisits&lt;/code&gt; inputs because they are containers. It will work for any type of container that follows the iterator&amp;nbsp;protocol.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;visits&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;15&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;35&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;80&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="n"&gt;normalize_defensive&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;visits&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;  &lt;span class="c"&gt;# No error&lt;/span&gt;
&lt;span class="n"&gt;visits&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;ReadVisits&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;path&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;normalize_defensive&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;visits&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;  &lt;span class="c"&gt;# No error&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;p&gt;The function will raise an exception if the input is iterable but not a&amp;nbsp;container.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&lt;span class="n"&gt;it&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nb"&gt;iter&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;visits&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;normalize_defensive&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;it&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;div class="highlight"&gt;&lt;pre&gt;&amp;gt;&amp;gt;&amp;gt;
TypeError: Must supply a container
&lt;/pre&gt;&lt;/div&gt;
&lt;h3&gt;Things to&amp;nbsp;Remember&lt;/h3&gt;
&lt;li&gt;Beware of functions that iterate over input arguments multiple times. If these arguments are iterators you may see strange behavior and missing&amp;nbsp;values.&lt;/li&gt;
&lt;li&gt;Python&amp;#8217;s iterator protocol defines how containers and iterators interact with the &lt;code&gt;iter&lt;/code&gt; and &lt;code&gt;next&lt;/code&gt; built-in functions, &lt;code&gt;for&lt;/code&gt; loops, and related&amp;nbsp;expressions.&lt;/li&gt;
&lt;li&gt;You can easily define your own iterable container type by implementing the &lt;code&gt;__iter__&lt;/code&gt; method as a&amp;nbsp;generator.&lt;/li&gt;
&lt;li&gt;You can detect that a value is an iterator (instead of a container) if calling &lt;code&gt;iter&lt;/code&gt; on it twice produces the same result, which can then be progress with the &lt;code&gt;next&lt;/code&gt; built-in&amp;nbsp;function.&lt;/li&gt;
&lt;/ul&gt;</summary></entry><entry><title>The Rough Cut Is Online</title><link href="http://www.effectivepython.com/2014/12/18/rough-cut-is-online/" rel="alternate"></link><updated>2014-12-18T19:15:00-08:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2014-12-18:2014/12/18/rough-cut-is-online/</id><summary type="html">&lt;p&gt;Can&amp;#8217;t wait until next year for the book to be published? The rough cut is now &lt;a href="http://safari.informit.com/9780134034416"&gt;available on Safari Books Online&lt;/a&gt;. This is an early preview of the full content of the book before editing has been&amp;nbsp;completed.&lt;/p&gt;</summary></entry><entry><title>Now Available for Preorder</title><link href="http://www.effectivepython.com/2014/12/04/preorder-the-book/" rel="alternate"></link><updated>2014-12-04T23:45:00-08:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2014-12-04:2014/12/04/preorder-the-book/</id><summary type="html">&lt;p&gt;&lt;em&gt;Effective Python&lt;/em&gt; is now available for preorder on Amazon. &lt;a href="http://amzn.to/1ylkKmc"&gt;Follow this link to buy your copy in advance&lt;/a&gt;. It will ship in early 2015 once the book is&amp;nbsp;published.&lt;/p&gt;</summary></entry><entry><title>Final Draft Done</title><link href="http://www.effectivepython.com/2014/11/16/final-draft-done/" rel="alternate"></link><updated>2014-11-16T00:30:00-08:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2014-11-16:2014/11/16/final-draft-done/</id><summary type="html">&lt;p&gt;The final draft of the book is done. It&amp;#8217;s 55,000 words, 250+ pages, 8 chapters, 59 items. Reviewers spent a lot of time looking over earlier drafts to ensure that the book will be useful. Now it&amp;#8217;s off to production to be turned into a printable&amp;nbsp;layout.&lt;/p&gt;</summary></entry><entry><title>Welcome</title><link href="http://www.effectivepython.com/2014/08/18/welcome-to-effective-python/" rel="alternate"></link><updated>2014-08-18T09:45:00-07:00</updated><author><name>Brett Slatkin</name></author><id>tag:www.effectivepython.com,2014-08-18:2014/08/18/welcome-to-effective-python/</id><summary type="html">&lt;p&gt;This website is now live! Here you&amp;#8217;ll find updates about my progress towards &lt;em&gt;Effective Python&lt;/em&gt;&amp;#8216;s eventual publishing by Addison-Wesley. You can find other books from the &lt;em&gt;Effective&lt;/em&gt; series &lt;a href="http://www.informit.com/imprint/series_detail.aspx?st=61267"&gt;in Pearson&amp;#8217;s online store&lt;/a&gt;.&lt;/p&gt;</summary></entry></feed>
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

atom.xml

Latest commit

History

atom.xml

File metadata and controls
