housewife_hackerhttp://housewifehacker.com/2021-04-21T00:00:00-04:00Python Mutability and Side Effects2021-04-21T00:00:00-04:002021-04-21T00:00:00-04:00Jessie Andersontag:housewifehacker.com,2021-04-21:/python-mutability-and-side-effects.html<p>I am back in school, to finally get my Bachelor's degree. This started as a writing assignment on void functions for my Programming fundamentals class, but I couldn't let it stop there.</p>
<p>If a Python function does not return a result, the output from a function is None and that …</p><p>I am back in school, to finally get my Bachelor's degree. This started as a writing assignment on void functions for my Programming fundamentals class, but I couldn't let it stop there.</p>
<p>If a Python function does not return a result, the output from a function is None and that function is a void function. Print is an example of a voidfunction. Although it adds text to the standard output, that printed value isn’t stored when assigned to a value:</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="n">r</span> <span class="o">=</span> <span class="k">print</span><span class="p">(</span><span class="s1">'r'</span><span class="p">)</span>
<span class="s1">'r'</span>
<span class="o">>>></span> <span class="n">r</span>
<span class="o">>>></span>
</pre></div>
<p>Most Python data types are immutable, meaning their value cannot be modified without changing the object reference. See Python <a class="reference external" href="https://docs.python.org/3/library/stdtypes.html">official documentation</a>for more info on Python's built-in types.As a high level language, Python is taking care of our objects behind the scenes. We can continue to modify the same variable name, but the ID of the object changes when Python creates another object. This immutability has an effect of protecting a local value within afunction from modifying the value of a variable outside of a function. In the following example, x references an integer that is modified with math, causing x to be recreated with a different value and ID:</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="n">x</span> <span class="o">=</span> <span class="mi">10</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="mi">2428003641936</span>
<span class="o">>>></span> <span class="n">x</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="mi">2428003641968</span>
</pre></div>
<p>We can pass x as an argument that is modified within the function, without modifyingthe value of x outside of the function:</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="n">x</span> <span class="o">=</span> <span class="mi">2</span>
<span class="o">>>></span> <span class="k">def</span> <span class="nf">add_two</span><span class="p">(</span><span class="n">y</span><span class="p">):</span>
<span class="o">...</span> <span class="n">y</span> <span class="o">+=</span> <span class="mi">2</span>
<span class="o">...</span> <span class="k">return</span> <span class="n">y</span>
<span class="o">...</span>
<span class="o">>>></span> <span class="n">add_two</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="mi">4</span>
<span class="o">>>></span> <span class="n">x</span>
<span class="mi">2</span>
</pre></div>
<p>However, dictionaries and lists are mutable. Notice how the ID is the same after a modification:</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="n">r</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">]</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">r</span><span class="p">)</span>
<span class="mi">2428004605312</span>
<span class="o">>>></span> <span class="n">r</span> <span class="o">+=</span> <span class="p">[</span><span class="mi">3</span><span class="p">]</span>
<span class="o">>>></span> <span class="n">r</span>
<span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">r</span><span class="p">)</span>
<span class="mi">2428004605312</span>
</pre></div>
<p>This leads to a very interesting possibility of a void function with a side effect. Side effects make a change to something other than what it’s output is assigned to. The following shows the same mutability for a dictionary and then an example of a void function with a side effect of changing the dictionary:</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="n">r</span> <span class="o">=</span> <span class="p">{}</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">r</span><span class="p">)</span>
<span class="mi">2428004605824</span>
<span class="o">>>></span> <span class="n">r</span><span class="p">[</span><span class="s1">'name'</span><span class="p">]</span> <span class="o">=</span> <span class="s1">'Jessie'</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">r</span><span class="p">)</span>
<span class="mi">2428004605824</span>
<span class="o">>>></span> <span class="k">def</span> <span class="nf">set_no_name</span><span class="p">(</span><span class="n">myDict</span><span class="p">):</span>
<span class="o">...</span> <span class="k">if</span> <span class="ow">not</span> <span class="n">myDict</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">'name'</span><span class="p">):</span>
<span class="o">...</span> <span class="n">myDict</span><span class="p">[</span><span class="s1">'name'</span><span class="p">]</span> <span class="o">=</span> <span class="s1">'stranger'</span>
<span class="o">...</span>
<span class="o">>>></span> <span class="n">stranger</span> <span class="o">=</span> <span class="p">{}</span>
<span class="o">>>></span> <span class="n">set_no_name</span><span class="p">(</span><span class="n">stranger</span><span class="p">)</span>
<span class="o">>>></span> <span class="n">stranger</span>
<span class="p">{</span><span class="s1">'name'</span><span class="p">:</span> <span class="s1">'stranger'</span><span class="p">}</span>
<span class="o">>>></span> <span class="n">jess</span> <span class="o">=</span> <span class="p">{</span><span class="s1">'name'</span><span class="p">:</span> <span class="s1">'Jess'</span><span class="p">}</span>
<span class="o">>>></span> <span class="n">set_no_name</span><span class="p">(</span><span class="n">jess</span><span class="p">)</span>
<span class="o">>>></span> <span class="n">jess</span>
<span class="p">{</span><span class="s1">'name'</span><span class="p">:</span> <span class="s1">'Jess'</span><span class="p">}</span>
</pre></div>
<p>To add further complexity (to both our objects and understanding), the object types of lists, tuples, and dictionaries are container objects. The items within them are stored by reference (to the IDs), not value. In the following example, a tuple is an immutable type containing a mutable list and an immutable integer. When we modify the list and the integer, the value of the list inside the tuple is changed and the value of the integer is not changed.The IDs of both the mutablle list and the immutable integer in the tuple are unchanged.</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="n">r</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">]</span>
<span class="o">>>></span> <span class="n">s</span> <span class="o">=</span> <span class="mi">3</span>
<span class="o">>>></span> <span class="n">t</span> <span class="o">=</span> <span class="p">(</span><span class="n">r</span><span class="p">,</span> <span class="n">s</span><span class="p">)</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">r</span><span class="p">)</span>
<span class="mi">2428009990336</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
<span class="mi">2428003641712</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>
<span class="mi">2428009991424</span>
<span class="o">>>></span> <span class="n">r</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="o">>>></span> <span class="n">s</span><span class="o">+=</span><span class="mi">1</span>
<span class="o">>>></span> <span class="n">t</span>
<span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">],</span> <span class="mi">3</span><span class="p">)</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>
<span class="mi">2428009991424</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">t</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
<span class="mi">2428009990336</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">t</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span>
<span class="mi">2428003641712</span>
</pre></div>
<p>The JavaScript community often uses “purity” to discuss side effects. A function with a side effect is impure, versus no side effects is called pure. Impure functions can be harder to test and harder to debug if the developer doesn’t realize there is a sideeffect. Functions with side effects are useful.Personally, I am fine with using side effects if it is a void function.A code comment of returning nothing would be useful for future me or someone else to understand the code, while a function with both a return and a side effect is a little messy. My confidence in this stance is boosted by how Python core uses this strategy for appending to a list:</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="n">s</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">]</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
<span class="mi">2428009990336</span>
<span class="o">>>></span> <span class="n">s</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="o">>>></span> <span class="n">s</span>
<span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
<span class="mi">2428009990336</span>
</pre></div>
Authentication Browser Storage Options2019-09-10T00:00:00-03:002019-09-10T00:00:00-03:00Jessie Andersontag:housewifehacker.com,2019-09-10:/authentication-browser-storage-options.html<p>Before the invention of client side rendering and AJAX, there were web apps that required visiting multiple pages. To keep the auth data in the browser for navigating to other pages, cookies were invented. Even with single page apps, browser storage is important to allow a user to remain authenticated …</p><p>Before the invention of client side rendering and AJAX, there were web apps that required visiting multiple pages. To keep the auth data in the browser for navigating to other pages, cookies were invented. Even with single page apps, browser storage is important to allow a user to remain authenticated if they refresh the page and possibly if they use multiple tabs or windows (depending on implementation). The browser retains the data needed to verify who is using the web app and their access. The newer browser storage options are local storage and session storage, thanks to HTML5. The collective name for Session Storage and Local Storage is Web Storage. Regardless of if you choose to use a JWT (JSON Web Token) or not, you still have to decide where to put the auth data. Below are some areas to consider when comparing the options.</p>
<blockquote>
<ul class="simple">
<li>Storage Capacity: This is unlikely to be the deciding factor for auth data, but web storage holds significantly more than cookies. The 4 Kilobytes of storage per cookie is plenty for effective auth.</li>
<li>Browser limitations: Browsers limit the number of cookies being stored. The limit depends on the browser and version, but typical limits are 300 cookies in total and 20 cookies per domain. Web Storage allows requesting more storage. Browsers may prompt users to request a certain amount of storage, and the hard drive could be a limiting factor, depending on their device and what else they are doing on it at the same time.</li>
<li>Browser support: According to current canIUse data, web storage is known to be supported by ~97% of global browser use. Nearly all of the remaining browser use is unknown. In my opinion, we have reached a point to safely consider any of the storage options without concern of browser support.</li>
<li>Network traffic: Cookies are attached to each request for your domain. Web storage only lives client side. With web storage, you would use the HTTP Authorization Header and the Bearer scheme to send the auth token. The difference in the size of your auth data with each request would depend on what you are storing. If you have requests that don't need auth data, the cookies (all of the ones for your domain) would be sent regardless. Alternatively with web storage, the Authorization headers from your web storage could exclude data that is irrelevant for each request.</li>
<li>Security: Security is a very complicated topic. All options have vulnerabilities and defenses to protect against "sniffing" (collecting data to read or use). Possible defenses include HTTPS, encrypted data that requires
data from the server to decrypt, CSRF tokens, and setting cookie headers to HTTPOnly.</li>
<li>Persistence: All options can be cleared by a user (or their software). Web storage does not expire. Cookies can optionally be given an expiration date. JWTs can also be given an expiration datei, which
could then be used with web storage to give the data an expiration date. This is where sessionStorage and localStorage have different behavior. The sessionStorage is cleared when the session ends. Refreshing the browser does not end the session, but closing the tab does. The session is only available for one tab, so multi-tab use would require re-authenticating the user. The localStorage is persistant across multiple tabs, including after closing a tab.</li>
</ul>
</blockquote>
Authentication Cases You Could Handle2019-09-08T00:00:00-04:002019-09-08T00:00:00-04:00Jessie Andersontag:housewifehacker.com,2019-09-08:/authentication-cases-you-could-handle.html<p>Authentication is a big job at the start of building a web application. These days, there are a lot of options on how to do it. The technical implementation and possibly 3rd party service you choose can depend on what use cases you want to support. This is the start …</p><p>Authentication is a big job at the start of building a web application. These days, there are a lot of options on how to do it. The technical implementation and possibly 3rd party service you choose can depend on what use cases you want to support. This is the start of a series on authentication and authorization. Authentication is determining "who" is using the app, while authorization is determining "what" that person can access within the app.</p>
<p>Below are some cases that you could choose to handle or not worry about with designing your authentication.</p>
<blockquote>
<ul class="simple">
<li>User is able to enable staying logged in or remembering username the next time they visit</li>
<li>Logging in or out in one tab is reflected in other browser tabs</li>
<li>Enable users to log out of all devices</li>
<li>A user can request a password change or password reset</li>
<li>Changing password logs out all devices</li>
<li>Failed password attempts are handled to increase wait time and decrease remaining attempts on all devices</li>
<li>An excessive amount of failed attempts forces a password change and logs out all devices</li>
<li>Force a user to change a password for an expiration date on the password</li>
<li>Force a user to change a compromised password</li>
<li>Automatically log out a user for inactivity</li>
<li>Allow users to enable or require 2 factor Authentication</li>
<li>Detect IP to require additional authentication steps on a computer the user hasn't used previously</li>
<li>Oauth option with multiple providers available that result in same user</li>
<li>Allow Active Directory</li>
<li>Set rules on passwords that can include a variety of possibly good or terrible restrictions</li>
<li>Encrypt password wherever a browser user or server hacker could access them</li>
</ul>
</blockquote>
Github Search Users2019-08-14T00:00:00-04:002019-08-14T00:00:00-04:00Jessie Andersontag:housewifehacker.com,2019-08-14:/github-search-users.html<ul class="simple">
<li>Search for Github users and view some profile details, utilizing Github's GraphQL API</li>
<li>Serverless React app</li>
<li>Styled with Material-UI</li>
<li>'Concurrent Mode' with debounce to reduce fetching and rendering with React hooks</li>
<li>Technologies: React, Axios, Material-UI</li>
</ul>
<p><a class="reference external" href="http://www.github.com/housewifehacker/GithubUserSearch/">Github</a></p>
Confirm Destruction Modal2019-06-22T00:00:00-04:002019-06-22T00:00:00-04:00Jessie Andersontag:housewifehacker.com,2019-06-22:/confirm-destruction-modal.html<p>Confirmation modal for users to reduce accidental destruction. Uses React, Reactstrap, and Font Awesome.</p>
<p><a class="reference external" href="https://codepen.io/HousewifeHacker/pen/EBQLyW">CodePen</a></p>
Sprite Viewer2015-08-31T00:00:00-03:002015-08-31T00:00:00-03:00Jessie Andersontag:housewifehacker.com,2015-08-31:/sprite-viewer.html<p>Given an image composed of sprites evenly spaced with the same dimensions, slide through viewing individual sprites. Uses ES6, HTML5 Canvas, and JQuery-UI Slider.</p>
<p><a class="reference external" href="http://codepen.io/HousewifeHacker/pen/jbNqXz/">CodePen</a></p>
FlightBookr2014-10-26T00:00:00-03:002014-10-26T00:00:00-03:00Jessie Andersontag:housewifehacker.com,2014-10-26:/flightbookr.html<ul class="simple">
<li>Flask backend provides API to Backbone.js from a JSON file of flight information</li>
<li>Client-side form validations with Parsley.js</li>
<li>Marionette managed composite views and events</li>
<li>Technologies: Flask, Flask-Assets, Backbone.js, Marionette, Foundation, Parsely, Syphon, Momentjs, JST templates, Jinja2, HTML, CSS</li>
</ul>
<p><a class="reference external" href="http://flightbookr.herokuapp.com/">Live</a>
<a class="reference external" href="http://www.github.com/housewifehacker/flightbookr/">Github</a></p>
Python's Dictionary Get2014-10-16T00:00:00-03:002014-10-16T00:00:00-03:00Jessie Andersontag:housewifehacker.com,2014-10-16:/pythons-dictionary-get.html<p>In a Python dictionary, one way to return the value for a specific key is a_dictionary[key]. Another way is to use the get method: a_dictionary.get(key). The difference is when the key is not in the dictionary. The bracket method returns an error, but the get method is …</p><p>In a Python dictionary, one way to return the value for a specific key is a_dictionary[key]. Another way is to use the get method: a_dictionary.get(key). The difference is when the key is not in the dictionary. The bracket method returns an error, but the get method is silent. Get is a method that not only returns the value at a key, but also sets a default return value. When not specified, the default is None, which is why it was silent. If you wrap a_dictionary.get("absent_key") in a print call, it prints None. An empty list or 0 are the default values I've used most.</p>
<p>A common exercise for a dictionary is an anagram detector. I've seen this problem so many times, but only recently discovered the get method to make it cleaner and more efficient. First, the solution from earlier times. This was from a blog post of mine in 2012:</p>
<div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">get_dict</span><span class="p">(</span><span class="n">word</span><span class="p">,</span> <span class="n">count</span><span class="p">):</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">word</span><span class="o">.</span><span class="n">lower</span><span class="p">():</span>
<span class="k">if</span> <span class="n">count</span><span class="o">.</span><span class="n">has_key</span><span class="p">(</span><span class="n">i</span><span class="p">):</span>
<span class="n">count</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">count</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">count</span>
<span class="k">def</span> <span class="nf">main</span><span class="p">():</span>
<span class="n">word1</span> <span class="o">=</span> <span class="nb">raw_input</span><span class="p">(</span><span class="s2">"What is the first word? </span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
<span class="n">word2</span> <span class="o">=</span> <span class="nb">raw_input</span><span class="p">(</span><span class="s2">"What is the second? </span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
<span class="n">count1</span> <span class="o">=</span> <span class="p">{}</span>
<span class="n">count2</span> <span class="o">=</span> <span class="p">{}</span>
<span class="n">count1</span> <span class="o">=</span> <span class="n">get_dict</span><span class="p">(</span><span class="n">word1</span><span class="p">,</span> <span class="n">count1</span><span class="p">)</span>
<span class="n">count2</span> <span class="o">=</span> <span class="n">get_dict</span><span class="p">(</span><span class="n">word2</span><span class="p">,</span> <span class="n">count2</span><span class="p">)</span>
<span class="k">if</span> <span class="n">count1</span> <span class="o">==</span> <span class="n">count2</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s2">"Yes, those are anagrams!</span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s2">"No, you've failed </span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s2">"__main__"</span><span class="p">:</span>
<span class="n">main</span><span class="p">()</span>
</pre></div>
<p>Actually, Python 3 no longer includes: a_dictionary.has_key("example"). A suggested alternative mentioned in Dive Into Python 3 is: "example" in a_dictionary. That's great if you want a boolean returned, but we want to modify the value regardless. If the key exists, add 1. If it doesn't exist, add 1 to 0. We need a default value of 0 if the key does not already exist, which is what the get method does for us. Now just a small change to the helper get_dict function from 2012 version:</p>
<div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">get_dict</span><span class="p">(</span><span class="n">word</span><span class="p">,</span> <span class="n">count</span><span class="p">):</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">word</span><span class="o">.</span><span class="n">lower</span><span class="p">():</span>
<span class="n">count</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">count</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">count</span>
</pre></div>
<p>Passing in an empty dictionary is kind of silly. So one more change:</p>
<div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">get_dict</span><span class="p">(</span><span class="n">word</span><span class="p">):</span>
<span class="n">count</span> <span class="o">=</span> <span class="p">{}</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">word</span><span class="o">.</span><span class="n">lower</span><span class="p">():</span>
<span class="n">count</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">count</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">count</span>
<span class="k">def</span> <span class="nf">main</span><span class="p">():</span>
<span class="n">word1</span> <span class="o">=</span> <span class="nb">raw_input</span><span class="p">(</span><span class="s2">"What is the first word? </span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
<span class="n">word2</span> <span class="o">=</span> <span class="nb">raw_input</span><span class="p">(</span><span class="s2">"What is the second? </span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
<span class="n">count1</span> <span class="o">=</span> <span class="n">get_dict</span><span class="p">(</span><span class="n">word1</span><span class="p">)</span>
<span class="n">count2</span> <span class="o">=</span> <span class="n">get_dict</span><span class="p">(</span><span class="n">word2</span><span class="p">)</span>
<span class="k">if</span> <span class="n">count1</span> <span class="o">==</span> <span class="n">count2</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s2">"Yes, those are anagrams!</span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s2">"No, you've failed </span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s2">"__main__"</span><span class="p">:</span>
<span class="n">main</span><span class="p">()</span>
</pre></div>
Asteroids2014-10-13T00:00:00-03:002014-10-13T00:00:00-03:00Jessie Andersontag:housewifehacker.com,2014-10-13:/asteroids.html<p>Client-side JavaScript game drawn on an HTML5 Canvas</p>
<p><a class="reference external" href="http://housewifehacker.com/asteroids/">Live</a>
<a class="reference external" href="http://www.github.com/housewifehacker/asteroids/">Github</a></p>
Bcrypt with Rails2014-10-13T00:00:00-03:002014-10-13T00:00:00-03:00Jessie Andersontag:housewifehacker.com,2014-10-13:/bcrypt-with-rails.html<p>Bcrypt is an algorithm for hashing passwords that can be implemented in many programming languages. When a user signs up or logs in, the password they entered is sent to the server. SSL should be used for this stage, but that is separate from bcrypt. Bcrypt's job is to protect …</p><p>Bcrypt is an algorithm for hashing passwords that can be implemented in many programming languages. When a user signs up or logs in, the password they entered is sent to the server. SSL should be used for this stage, but that is separate from bcrypt. Bcrypt's job is to protect the password when it gets in the database. It does its job pretty well. Despite being first introduced in 1999 and being extremely popular, it has still not been compromised.</p>
<p>Each new password sent to the database is salted and ciphered before being stored as a hash. In our database, the password hash is stored as password_digest. To verify a password on login, the password attempt is also ciphered to check if the hashes come from the same string, the actual password. A password hash is never unciphered. If someone does get the database, they could only try to guess each password, but bcrypt would actually slow down the more they try.</p>
<p>Many auth libraries do use bcrypt, but the bcrypt gem makes it simple enough to roll our own auth in Rails. First, our Users table needs to have a password digest column.</p>
<div class="highlight"><pre><span></span>rails g model user username password_digest
rake db:migrate
</pre></div>
<p>We need to add the bcrypt gem in our Gemfile. It is probably in your Gemfile already, but commented out. If so, you can just uncomment it. Don't forget bundle install after the change. This gem gives us methods we will use in our user model.</p>
<div class="highlight"><pre><span></span><span class="n">gem</span> <span class="s1">'bcrypt'</span>
</pre></div>
<p>Our User model needs a method to cipher the password when it is created. It also needs a method to cipher password attempts and return a boolean for if it is a match.</p>
<div class="highlight"><pre><span></span><span class="c1"># app/models/user.rb</span>
<span class="k">class</span> <span class="nc">User</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="k">def</span> <span class="nf">password</span><span class="o">=</span><span class="p">(</span><span class="n">password</span><span class="p">)</span>
<span class="nb">self</span><span class="o">.</span><span class="n">password_digest</span> <span class="o">=</span> <span class="no">BCrypt</span><span class="o">::</span><span class="no">Password</span><span class="o">.</span><span class="n">create</span><span class="p">(</span><span class="n">password</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">is_password?</span><span class="p">(</span><span class="n">password</span><span class="p">)</span>
<span class="no">BCrypt</span><span class="o">::</span><span class="no">Password</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="nb">self</span><span class="o">.</span><span class="n">password_digest</span><span class="p">)</span> <span class="o">==</span> <span class="n">password</span>
<span class="k">end</span>
<span class="k">end</span>
</pre></div>
<p>Now in our rails console, create a user. We can view it's password digest, and use the is_password? method. All bcrypt password digests start with "$2a$" or "2y".</p>
<div class="highlight"><pre><span></span>irb<span class="o">(</span>main<span class="o">)</span>:001:0> <span class="nv">u</span> <span class="o">=</span> User.new<span class="o">({</span>username: <span class="s2">"jessie"</span>, password: <span class="s2">"jessiejessie"</span><span class="o">})</span>
<span class="o">=</span>> <span class="c1">#<User id: nil, username: "jessie", password_digest: "$2a$10$Q5UXCiS7hTHCJmL.ZBKVXeTxdyLij8.pdwYqlIR81bT...", created_at: nil, updated_at: nil></span>
irb<span class="o">(</span>main<span class="o">)</span>:002:0> u.save
<span class="o">(</span><span class="m">0</span>.3ms<span class="o">)</span> begin transaction
Binary data inserted <span class="k">for</span> <span class="sb">`</span>string<span class="sb">`</span> <span class="nb">type</span> on column <span class="sb">`</span>password_digest<span class="sb">`</span>
SQL <span class="o">(</span><span class="m">0</span>.4ms<span class="o">)</span> INSERT INTO <span class="s2">"users"</span> <span class="o">(</span><span class="s2">"created_at"</span>, <span class="s2">"password_digest"</span>, <span class="s2">"updated_at"</span>, <span class="s2">"username"</span><span class="o">)</span> VALUES <span class="o">(</span>?, ?, ?, ?<span class="o">)</span> <span class="o">[[</span><span class="s2">"created_at"</span>, <span class="s2">"2014-10-14 00:41:45.144329"</span><span class="o">]</span>, <span class="o">[</span><span class="s2">"password_digest"</span>, <span class="s2">"</span><span class="nv">$2</span><span class="s2">a</span><span class="nv">$10$Q5UXCiS7hTHCJmL</span><span class="s2">.ZBKVXeTxdyLij8.pdwYqlIR81bT6E.33WchK6"</span><span class="o">]</span>, <span class="o">[</span><span class="s2">"updated_at"</span>, <span class="s2">"2014-10-14 00:41:45.144329"</span><span class="o">]</span>, <span class="o">[</span><span class="s2">"username"</span>, <span class="s2">"jessie"</span><span class="o">]]</span>
<span class="o">(</span><span class="m">19</span>.5ms<span class="o">)</span> commit <span class="nv">transaction</span>
<span class="o">=</span>> <span class="nb">true</span>
irb<span class="o">(</span>main<span class="o">)</span>:003:0> <span class="nv">u</span>
<span class="o">=</span>> <span class="c1">#<User id: 1, username: "jessie", password_digest: "$2a$10$Q5UXCiS7hTHCJmL.ZBKVXeTxdyLij8.pdwYqlIR81bT...", created_at: "2014-10-14 00:41:45", updated_at: "2014-10-14 00:41:45"></span>
irb<span class="o">(</span>main<span class="o">)</span>:004:0> u.is_password?<span class="o">(</span><span class="s2">"jessiejessie"</span><span class="o">)</span>
<span class="o">=</span>> <span class="nb">true</span>
irb<span class="o">(</span>main<span class="o">)</span>:005:0> u.is_password?<span class="o">(</span><span class="s2">"jessie"</span><span class="o">)</span>
<span class="o">=</span>> <span class="nb">false</span>
</pre></div>
<p>That's it, in it's simplest form of course. You'd most likely want a controller and view with a form on an actual project. A more robust auth would also include session tokens stored in the user table and in the client's cookies, which would be compared to each other and reset for logging in and logging out.</p>
PollTheWorld2014-10-12T00:00:00-03:002014-10-12T00:00:00-03:00Jessie Andersontag:housewifehacker.com,2014-10-12:/polltheworld.html<ul class="simple">
<li>Create polls, vote, and view responses summary.</li>
<li>Heroku hosted Backbone.js application consuming RESTful Rails API</li>
<li>Custom user authentication system with hashed passwords, session token and guest login</li>
<li>Infinite scroll appends next page's Backbone collection on scroll off event</li>
<li>Extends Backbone's model parsing to include relations</li>
<li>Custom Backbone composite view …</li></ul><ul class="simple">
<li>Create polls, vote, and view responses summary.</li>
<li>Heroku hosted Backbone.js application consuming RESTful Rails API</li>
<li>Custom user authentication system with hashed passwords, session token and guest login</li>
<li>Infinite scroll appends next page's Backbone collection on scroll off event</li>
<li>Extends Backbone's model parsing to include relations</li>
<li>Custom Backbone composite view adds and removes subviews and their listeners</li>
<li>Technologies: Rails, Backbone.js, SQL, Jbuilder, Capybara, Heroku, jQuery, AJAX, Chart.js, Bootstrap, HTML, CSS, Kaminari</li>
</ul>
<p><a class="reference external" href="http://www.polltheworld.website/">Live</a>
<a class="reference external" href="http://www.github.com/housewifehacker/polltheworld/">Github</a></p>
The Practice of Programming2012-06-10T00:00:00-04:002012-06-10T00:00:00-04:00Jessie Andersontag:housewifehacker.com,2012-06-10:/the-practice-of-programming.html<p>Disclaimer: This book does not have any python examples. But even before I began dabbling in C, I believe this book made me a better programmer. I recommend this book for the intermediate programmer who knows how to code, but may not be very good at coding with others. Someone …</p><p>Disclaimer: This book does not have any python examples. But even before I began dabbling in C, I believe this book made me a better programmer. I recommend this book for the intermediate programmer who knows how to code, but may not be very good at coding with others. Someone who can write code that works, but their code is not pretty to look at later for debugging, learning, or changing code. Someone fresh out of college who needs to work on code with other developers for perhaps the first time. After reading this, I went back through all my old posts and changed spacing and naming (wasn't a big deal because I moved my blog to my new domain from blogger). I now run pep8 against my python code. My programs are easier to read and follow logically. My variables make sense and are easy to remember. I feel that I have surpassed one of the beginner hurdles to becoming a good developer.</p>
<p>Get it on Amazon <a class="reference external" href="http://www.amazon.com/gp/product/020161586X/ref=as_li_qf_sp_asin_il_tl?ie=UTF8&tag=gypsyc-20&linkCode=as2&camp=1789&creative=9325&creativeASIN=020161586X">here</a></p>
Intermediate Guess Number Python Game2012-06-02T00:00:00-04:002012-06-02T00:00:00-04:00Jessie Andersontag:housewifehacker.com,2012-06-02:/intermediate-guess-number-python-game.html<p>In my first month of learning python, I wrote a simple guess the number game. It did not include exception handling, was not pep8 compliant, and was organized somewhat poorly. It also needed updating because it used what I like to call "C Print Formatting," which used to be correct …</p><p>In my first month of learning python, I wrote a simple guess the number game. It did not include exception handling, was not pep8 compliant, and was organized somewhat poorly. It also needed updating because it used what I like to call "C Print Formatting," which used to be correct in python but is now being replaced. <a class="reference external" href="http://www.python.org/dev/peps/pep-3101/">http://www.python.org/dev/peps/pep-3101/</a> discusses why. I decided to include a little of my coding process in this post as a way to pre-empt debugging.</p>
<p>The following code example was my first iteration. I knew that the user would be making multiple guesses, so my prompt for guess had to be a separate function called multiple times. I also included exception handling with my prompt so that the guess had to be a number within range and not a letter. I didn't know yet if generating the random integer would be complicated, so I hard coded a value for the correct answer and had the program print when completed, so I knew if the program reached the final step. In this version, you get one guess and the program doesn't know if you are wrong or right.</p>
<div class="highlight"><pre><span></span><span class="n">minm</span> <span class="o">=</span> <span class="mi">1</span>
<span class="n">maxm</span> <span class="o">=</span> <span class="mi">20</span>
<span class="n">max_guesses</span> <span class="o">=</span> <span class="mi">6</span>
<span class="k">def</span> <span class="nf">randomize</span><span class="p">():</span>
<span class="k">return</span> <span class="mi">4</span>
<span class="k">def</span> <span class="nf">prompt_for_guess</span><span class="p">():</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">message</span> <span class="o">=</span> <span class="s2">"Guess a number between {:d} and {:d} </span><span class="se">\n</span><span class="s2">"</span>
<span class="n">guess</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="nb">raw_input</span><span class="p">(</span><span class="n">message</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">minm</span><span class="p">,</span> <span class="n">maxm</span><span class="p">)))</span>
<span class="k">if</span> <span class="n">guess</span> <span class="ow">not</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">minm</span><span class="p">,</span> <span class="n">maxm</span> <span class="o">+</span> <span class="mi">1</span><span class="p">):</span>
<span class="k">return</span> <span class="n">prompt_for_guess</span><span class="p">()</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="n">guess</span>
<span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s2">"Must be a number."</span><span class="p">)</span>
<span class="k">return</span> <span class="n">prompt_for_guess</span><span class="p">()</span>
<span class="k">def</span> <span class="nf">main</span><span class="p">():</span>
<span class="n">message</span> <span class="o">=</span> <span class="s2">"I'm thinking of a number. I'll give you {:d} guesses"</span>
<span class="k">print</span><span class="p">(</span><span class="n">message</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">max_guesses</span><span class="p">))</span>
<span class="n">guess</span> <span class="o">=</span> <span class="n">prompt_for_guess</span><span class="p">()</span>
<span class="n">answer</span> <span class="o">=</span> <span class="n">randomize</span><span class="p">()</span>
<span class="k">print</span><span class="p">(</span><span class="s2">"The answer was {:d}"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">answer</span><span class="p">))</span>
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s2">"__main__"</span><span class="p">:</span>
<span class="n">main</span><span class="p">()</span>
</pre></div>
<p>Running the program with inputs of a letter, a number out of range, and a number within range verified that my exception handling worked. At this time, I imported random in my terminal and read the directory and help to review use of randint. Randint includes the last boundary, unlike the built in python range. Because it was only one line of code, I decided it did not need its own function. Also because I only needed to use it one time. My next attempt looked like this:</p>
<div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">random</span>
<span class="c1"># configs</span>
<span class="n">minm</span> <span class="o">=</span> <span class="mi">1</span>
<span class="n">maxm</span> <span class="o">=</span> <span class="mi">20</span>
<span class="n">max_guesses</span> <span class="o">=</span> <span class="mi">6</span>
<span class="n">guesses_taken</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">def</span> <span class="nf">prompt_for_guess</span><span class="p">():</span>
<span class="sd">"""Asks for a guess and repeats if input is not a number in range"""</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">message</span> <span class="o">=</span> <span class="s2">"Guess a number between {:d} and {:d}. </span><span class="se">\n</span><span class="s2">"</span>
<span class="n">guess</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="nb">raw_input</span><span class="p">(</span><span class="n">message</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">minm</span><span class="p">,</span> <span class="n">maxm</span><span class="p">)))</span>
<span class="k">if</span> <span class="n">guess</span> <span class="ow">not</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">minm</span><span class="p">,</span> <span class="n">maxm</span> <span class="o">+</span> <span class="mi">1</span><span class="p">):</span>
<span class="k">return</span> <span class="n">prompt_for_guess</span><span class="p">()</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="n">guess</span>
<span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s2">"Must be a number."</span><span class="p">)</span>
<span class="k">return</span> <span class="n">prompt_for_guess</span><span class="p">()</span>
<span class="k">def</span> <span class="nf">main</span><span class="p">():</span>
<span class="n">message</span> <span class="o">=</span> <span class="s2">"I'm thinking of a number. I'll give you {:d} guesses"</span>
<span class="k">print</span><span class="p">(</span><span class="n">message</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">max_guesses</span><span class="p">))</span>
<span class="n">answer</span> <span class="o">=</span> <span class="n">random</span><span class="o">.</span><span class="n">randint</span><span class="p">(</span><span class="n">minm</span><span class="p">,</span> <span class="n">maxm</span><span class="p">)</span>
<span class="k">if</span> <span class="n">guesses_taken</span> <span class="o"><=</span> <span class="n">max_guesses</span><span class="p">:</span>
<span class="n">guess</span> <span class="o">=</span> <span class="n">prompt_for_guess</span><span class="p">()</span>
<span class="k">if</span> <span class="n">guess</span> <span class="o">==</span> <span class="n">answer</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s2">"That's it! You win!"</span><span class="p">)</span>
<span class="k">break</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">if</span> <span class="n">answer</span> <span class="o">></span> <span class="n">guess</span><span class="p">:</span>
<span class="n">reason</span> <span class="o">=</span> <span class="s2">"low"</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">reason</span> <span class="o">=</span> <span class="s2">"high"</span>
<span class="k">print</span><span class="p">(</span><span class="s2">"Your guess is too {:s}"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">reason</span><span class="p">))</span>
<span class="n">guesses_taken</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">print</span><span class="p">(</span><span class="s2">"The answer was {:d}"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">answer</span><span class="p">))</span>
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s2">"__main__"</span><span class="p">:</span>
<span class="n">main</span><span class="p">()</span>
</pre></div>
<p>But this had some errors. First, my guesses taken cannot be assigned outside my main function without making it a global variable. Unlike my minm, maxm, and max guesses, I want to edit the value of guesses taken. My second error was using an if statement instead of a while loop for guesses taken less than max guesses. I want my loop to continue until the user exceeds the number of allowed guesses or they get the answer right. My third mistake was my final print statement. It was useful for my initial attempt to write the program, but now I only want to reveal the answer if the user loses.</p>
<p>Now The Final Code</p>
<div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">random</span>
<span class="c1"># configs</span>
<span class="n">minm</span> <span class="o">=</span> <span class="mi">1</span>
<span class="n">maxm</span> <span class="o">=</span> <span class="mi">20</span>
<span class="n">max_guesses</span> <span class="o">=</span> <span class="mi">6</span>
<span class="k">def</span> <span class="nf">prompt_for_guess</span><span class="p">():</span>
<span class="sd">"""Asks for a guess and repeats if input is not a number in range"""</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">message</span> <span class="o">=</span> <span class="s2">"Guess a number between {:d} and {:d}. </span><span class="se">\n</span><span class="s2">"</span>
<span class="n">guess</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="nb">raw_input</span><span class="p">(</span><span class="n">message</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">minm</span><span class="p">,</span> <span class="n">maxm</span><span class="p">)))</span>
<span class="k">if</span> <span class="n">guess</span> <span class="ow">not</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">minm</span><span class="p">,</span> <span class="n">maxm</span> <span class="o">+</span> <span class="mi">1</span><span class="p">):</span>
<span class="k">return</span> <span class="n">prompt_for_guess</span><span class="p">()</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="n">guess</span>
<span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s2">"Must be a number."</span><span class="p">)</span>
<span class="k">return</span> <span class="n">prompt_for_guess</span><span class="p">()</span>
<span class="k">def</span> <span class="nf">main</span><span class="p">():</span>
<span class="n">message</span> <span class="o">=</span> <span class="s2">"I'm thinking of a number. I'll give you {:d} guesses"</span>
<span class="k">print</span><span class="p">(</span><span class="n">message</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">max_guesses</span><span class="p">))</span>
<span class="n">answer</span> <span class="o">=</span> <span class="n">random</span><span class="o">.</span><span class="n">randint</span><span class="p">(</span><span class="n">minm</span><span class="p">,</span> <span class="n">maxm</span><span class="p">)</span>
<span class="n">guesses_taken</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">while</span> <span class="n">guesses_taken</span> <span class="o"><=</span> <span class="n">max_guesses</span><span class="p">:</span>
<span class="n">guess</span> <span class="o">=</span> <span class="n">prompt_for_guess</span><span class="p">()</span>
<span class="k">if</span> <span class="n">guess</span> <span class="o">==</span> <span class="n">answer</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s2">"That's it! You win!"</span><span class="p">)</span>
<span class="k">break</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">if</span> <span class="n">answer</span> <span class="o">></span> <span class="n">guess</span><span class="p">:</span>
<span class="n">reason</span> <span class="o">=</span> <span class="s2">"low"</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">reason</span> <span class="o">=</span> <span class="s2">"high"</span>
<span class="k">print</span><span class="p">(</span><span class="s2">"Your guess is too {:s}"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">reason</span><span class="p">))</span>
<span class="n">guesses_taken</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">if</span> <span class="n">guesses_taken</span> <span class="o">></span> <span class="n">max_guesses</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s2">"The answer was {:d}"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">answer</span><span class="p">))</span>
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s2">"__main__"</span><span class="p">:</span>
<span class="n">main</span><span class="p">()</span>
</pre></div>
Easy Anagram Dictionaries Practice2012-05-15T00:00:00-04:002012-05-15T00:00:00-04:00Jessie Andersontag:housewifehacker.com,2012-05-15:/easy-anagram-dictionaries-practice.html<p>I do not use dictionaries very often. Friday, I was without internet all day, so I took the opportunity to play with dir() and help() to discover some dictionary properties. My short-lived obsession with Draw Something on the iPhone has gotten me interested in anagrams (kicked the habit by reading …</p><p>I do not use dictionaries very often. Friday, I was without internet all day, so I took the opportunity to play with dir() and help() to discover some dictionary properties. My short-lived obsession with Draw Something on the iPhone has gotten me interested in anagrams (kicked the habit by reading programming books). I believe using dictionaries is the fastest and most accurate way to determine if two words are anagrams of each other, at least without importing any other modules.</p>
<p>A dictionary is an unordered set of key: value pairs. Keys must be an immutable type. Values can be anything. Being unordered causes some interesting properties for working with dictionaries, different from any other python data structure. Instead of being indexed by numbers, dictionaries are indexed by keys. Because they are indexed by keys, each key is unique within it's dictionary. If two dictionaries with the same keys are added to each other, the values of the same data type combine. This is convenient for our anagram activity. But first, some dictionary review.</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="n">sample_dict</span> <span class="o">=</span> <span class="p">{}</span> <span class="c1"># creates an empty dictionary</span>
<span class="o">>>></span> <span class="nb">type</span><span class="p">(</span> <span class="n">sample_dict</span> <span class="p">)</span>
<span class="o"><</span><span class="nb">type</span> <span class="s1">'dict'</span><span class="o">></span>
<span class="o">>>></span> <span class="n">sample_dict</span><span class="p">[</span><span class="s1">'Name'</span><span class="p">]</span> <span class="o">=</span> <span class="s1">'Jessie'</span> <span class="c1"># creating a key:value pair</span>
<span class="o">>>></span> <span class="n">sample_dict</span><span class="p">[</span><span class="s1">'Age'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">23</span> <span class="c1"># another key:value pair</span>
<span class="o">>>></span> <span class="n">sample_dict</span>
<span class="p">{</span><span class="s1">'Age'</span><span class="p">:</span> <span class="mi">23</span><span class="p">,</span> <span class="s1">'Name'</span><span class="p">:</span> <span class="s1">'Jessie'</span><span class="p">}</span>
<span class="o">>>></span> <span class="n">sample_dict2</span> <span class="o">=</span> <span class="p">{</span><span class="s1">'Name'</span><span class="p">:</span> <span class="s1">'Jessie'</span><span class="p">,</span> <span class="s1">'Age'</span><span class="p">:</span> <span class="mi">23</span><span class="p">}</span> <span class="c1"># another way to create dict</span>
<span class="o">>>></span> <span class="nb">type</span> <span class="p">(</span><span class="n">sample_dict2</span><span class="p">)</span>
<span class="o"><</span><span class="nb">type</span> <span class="s1">'dict'</span><span class="o">></span>
<span class="o">>>></span> <span class="n">sample_dict2</span>
<span class="p">{</span><span class="s1">'Age'</span><span class="p">:</span> <span class="mi">23</span><span class="p">,</span> <span class="s1">'Name'</span><span class="p">:</span> <span class="s1">'Jessie'</span><span class="p">}</span>
<span class="o">>>></span> <span class="n">sample_dict</span> <span class="o">+</span> <span class="n">sample_dict2</span> <span class="c1"># cannot add dictionaries, only values</span>
<span class="n">Traceback</span> <span class="p">(</span><span class="n">most</span> <span class="n">recent</span> <span class="n">call</span> <span class="n">last</span><span class="p">):</span>
<span class="n">File</span> <span class="s2">"<console>"</span><span class="p">,</span> <span class="n">line</span> <span class="mi">1</span><span class="p">,</span> <span class="ow">in</span> <span class="o"><</span><span class="n">module</span><span class="o">></span>
<span class="ne">TypeError</span><span class="p">:</span> <span class="n">unsupported</span> <span class="n">operand</span> <span class="nb">type</span><span class="p">(</span><span class="n">s</span><span class="p">)</span> <span class="k">for</span> <span class="o">+</span><span class="p">:</span> <span class="s1">'dict'</span> <span class="ow">and</span> <span class="s1">'dict'</span>
<span class="o">>>></span> <span class="n">sample_dict</span><span class="p">[</span><span class="s1">'Age'</span><span class="p">]</span> <span class="o">+</span> <span class="n">sample_dict2</span><span class="p">[</span><span class="s1">'Age'</span><span class="p">]</span> <span class="c1"># adds values</span>
<span class="mi">46</span>
<span class="o">>>></span> <span class="n">sample_dict</span><span class="o">.</span><span class="n">keys</span><span class="p">()</span>
<span class="p">[</span><span class="s1">'Age'</span><span class="p">,</span> <span class="s1">'Name'</span><span class="p">]</span>
<span class="o">>>></span> <span class="n">sample_dict</span><span class="o">.</span><span class="n">values</span><span class="p">()</span>
<span class="p">[</span><span class="mi">23</span><span class="p">,</span> <span class="s1">'Jessie'</span><span class="p">]</span>
<span class="o">>>></span> <span class="nb">type</span><span class="p">(</span> <span class="n">sample_dict</span><span class="o">.</span><span class="n">values</span><span class="p">()</span> <span class="p">)</span> <span class="c1"># keys and values are returned as lists</span>
<span class="o"><</span><span class="nb">type</span> <span class="s1">'list'</span><span class="o">></span>
<span class="o">>>></span> <span class="n">sample_dict</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">'Age'</span><span class="p">)</span> <span class="c1"># gets the value at a specific key</span>
<span class="mi">23</span>
<span class="o">>>></span> <span class="nb">type</span><span class="p">(</span> <span class="n">sample_dict</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">'Age'</span><span class="p">))</span> <span class="c1"># value maintains data type in dictionary</span>
<span class="o"><</span><span class="nb">type</span> <span class="s1">'int'</span><span class="o">></span>
<span class="o">>>></span> <span class="n">sample_dict</span><span class="o">.</span><span class="n">has_key</span><span class="p">(</span><span class="s1">'Age'</span><span class="p">)</span> <span class="c1"># D.has_key() returns boolean</span>
<span class="bp">True</span>
<span class="o">>>></span> <span class="n">sample_dict3</span> <span class="o">=</span> <span class="p">{</span><span class="s1">'Children'</span><span class="p">:</span> <span class="s1">'Graham'</span><span class="p">}</span>
<span class="o">>>></span> <span class="n">sample_dict3</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="n">sample_dict</span><span class="p">)</span> <span class="c1"># update keys and values</span>
<span class="o">>>></span> <span class="n">sample_dict</span>
<span class="p">{</span><span class="s1">'Age'</span><span class="p">:</span> <span class="mi">23</span><span class="p">,</span> <span class="s1">'Name'</span><span class="p">:</span> <span class="s1">'Jessie'</span><span class="p">}</span>
<span class="o">>>></span> <span class="n">sample_dict3</span> <span class="c1"># Children field is added as a key:value pair</span>
<span class="p">{</span><span class="s1">'Age'</span><span class="p">:</span> <span class="mi">23</span><span class="p">,</span> <span class="s1">'Children'</span><span class="p">:</span> <span class="s1">'Graham'</span><span class="p">,</span> <span class="s1">'Name'</span><span class="p">:</span> <span class="s1">'Jessie'</span><span class="p">}</span>
<span class="o">>>></span> <span class="p">{</span><span class="s1">'Age'</span><span class="p">:</span> <span class="mi">23</span><span class="p">,</span> <span class="s1">'Name'</span><span class="p">:</span> <span class="s1">'Jessie'</span><span class="p">}</span> <span class="o">==</span> <span class="p">{</span><span class="s1">'Name'</span><span class="p">:</span> <span class="s1">'Jessie'</span><span class="p">,</span> <span class="s1">'Age'</span><span class="p">:</span> <span class="mi">23</span><span class="p">}</span> <span class="c1"># different order is equal</span>
<span class="bp">True</span>
</pre></div>
<p>How do we know if two words are anagrams? Consider the anagrams odor and door. We could say that they are reshuffled strings. Each word uses the same letters, but in a different order: 2 o's, 1 r, and 1 d. My simple program creates empty dictionaries for the two words being compared, stores the letters as keys, and adds to the value for each occurrence of the same letter, then checks that the dictionaries are equivalent. I have not included exception handling and I made the design decision to count white space as part of the anagram such that 'abc def' is not an anagram of 'fdeabc,' but is an anagram of 'abc fed.'</p>
<div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">get_dict</span><span class="p">(</span><span class="n">word</span><span class="p">,</span> <span class="n">count</span><span class="p">):</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">word</span><span class="o">.</span><span class="n">lower</span><span class="p">():</span>
<span class="k">if</span> <span class="n">count</span><span class="o">.</span><span class="n">has_key</span><span class="p">(</span><span class="n">i</span><span class="p">):</span>
<span class="n">count</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">count</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">count</span>
<span class="k">def</span> <span class="nf">main</span><span class="p">():</span>
<span class="n">word1</span> <span class="o">=</span> <span class="nb">raw_input</span><span class="p">(</span><span class="s2">"What is the first word? </span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
<span class="n">word2</span> <span class="o">=</span> <span class="nb">raw_input</span><span class="p">(</span><span class="s2">"What is the second? </span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
<span class="n">count1</span> <span class="o">=</span> <span class="p">{}</span>
<span class="n">count2</span> <span class="o">=</span> <span class="p">{}</span>
<span class="n">count1</span> <span class="o">=</span> <span class="n">get_dict</span><span class="p">(</span><span class="n">word1</span><span class="p">,</span> <span class="n">count1</span><span class="p">)</span>
<span class="n">count2</span> <span class="o">=</span> <span class="n">get_dict</span><span class="p">(</span><span class="n">word2</span><span class="p">,</span> <span class="n">count2</span><span class="p">)</span>
<span class="k">if</span> <span class="n">count1</span> <span class="o">==</span> <span class="n">count2</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s2">"Yes, those are anagrams!</span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s2">"No, you've failed </span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s2">"__main__"</span><span class="p">:</span>
<span class="n">main</span><span class="p">()</span>
</pre></div>
Mutable versus Immutable Object Types2012-05-07T00:00:00-04:002012-05-07T00:00:00-04:00Jessie Andersontag:housewifehacker.com,2012-05-07:/mutable-versus-immutable-object-types.html<p>Strings, lists, tuples, integers, float, dictionaries, and sets are all types of python objects with different properties and uses. When using an object in a program or in your terminal, your session assigns an Id to access the computer's memory. The Id will be unique each session and on each …</p><p>Strings, lists, tuples, integers, float, dictionaries, and sets are all types of python objects with different properties and uses. When using an object in a program or in your terminal, your session assigns an Id to access the computer's memory. The Id will be unique each session and on each computer, so the actual number returned by the id() function is irrelevant. What is relevant is when that number changes. If the id changes as the value changes, the computer had to assign a new id to the immutable object. If the id stays the same, then it is a mutable object, because the value associated with the id can be changed without changing the id. Integers are immutable:</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="n">x</span> <span class="o">=</span> <span class="mi">5</span>
<span class="o">>>></span> <span class="n">y</span> <span class="o">=</span> <span class="n">x</span> <span class="c1"># direct the reference of y to be the reference of x</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">==</span> <span class="nb">id</span><span class="p">(</span><span class="n">y</span><span class="p">)</span> <span class="c1"># x and y point to same reference</span>
<span class="bp">True</span>
<span class="o">>>></span> <span class="n">x</span> <span class="o">=</span> <span class="mi">4</span> <span class="c1"># change the value of x</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">==</span> <span class="nb">id</span><span class="p">(</span><span class="n">y</span><span class="p">)</span> <span class="c1"># the id of x changed when the value changed</span>
<span class="bp">False</span>
<span class="o">>>></span> <span class="n">x</span> <span class="o">==</span> <span class="n">y</span> <span class="c1"># the value of y did not change with x</span>
<span class="bp">False</span>
</pre></div>
<p>I'm the type of learner that skims through vocabulary lessons to get to the action, but understanding this next part will save you some headaches when trying to manipulate mutable objects. Look what happens when I try to do the same thing I just did to the integers, but now to a list:</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="n">x</span> <span class="o">=</span> <span class="p">[</span><span class="mi">5</span><span class="p">]</span>
<span class="o">>>></span> <span class="n">y</span> <span class="o">=</span> <span class="n">x</span> <span class="c1"># direct the reference of y to be the reference of x</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">==</span> <span class="nb">id</span><span class="p">(</span><span class="n">y</span><span class="p">)</span> <span class="c1"># x and y point to the same reference</span>
<span class="bp">True</span>
<span class="o">>>></span> <span class="n">x</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span> <span class="c1">#change x from [5] to [5, 4]</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">==</span> <span class="nb">id</span><span class="p">(</span><span class="n">y</span><span class="p">)</span> <span class="c1"># x and y still point to the same reference</span>
<span class="bp">True</span>
<span class="o">>>></span> <span class="n">x</span> <span class="o">==</span> <span class="n">y</span> <span class="c1"># y changed with x</span>
<span class="bp">True</span>
<span class="o">>>></span> <span class="n">y</span>
<span class="p">[</span><span class="mi">5</span><span class="p">,</span> <span class="mi">4</span><span class="p">]</span>
<span class="o">>>></span> <span class="n">z</span> <span class="o">=</span> <span class="p">[</span><span class="mi">5</span><span class="p">,</span> <span class="mi">5</span><span class="p">]</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">z</span><span class="p">)</span> <span class="c1"># will be a different number for everyone</span>
<span class="il">3075316972L</span>
<span class="o">>>></span> <span class="n">z</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span> <span class="c1"># z is now [5, 5, 3]</span>
<span class="o">>>></span> <span class="nb">id</span><span class="p">(</span><span class="n">z</span><span class="p">)</span> <span class="c1"># id is constant, the list is mutable</span>
<span class="il">3075316972L</span>
</pre></div>
<p>I stumbled upon this while using random.shuffle on a list, while wishing to keep a copy of the list in it's original form. As you can see by assigning x equal to y, the lists changed together. That was an ineffective way to make a copy because all I did was assign the same Id two different names. Try determining if the other object types are mutable or immutable. I don't want to spoil the fun for you.</p>
Structure and Interpretation of Computer Programs2012-03-10T00:00:00-03:002012-03-10T00:00:00-03:00Jessie Andersontag:housewifehacker.com,2012-03-10:/structure-and-interpretation-of-computer-programs.html<p>Probably the most popular, I mean cult inspiring, computer programming book of all time. This book created a movement circa the year 2000. All the major universities that prided themselves on producing technical talent adopted this textbook into their curriculum. It began as a Scheme and Intro to Programming course …</p><p>Probably the most popular, I mean cult inspiring, computer programming book of all time. This book created a movement circa the year 2000. All the major universities that prided themselves on producing technical talent adopted this textbook into their curriculum. It began as a Scheme and Intro to Programming course at MIT. Now, many passionate programmers own a copy to reread at their leisure. Although Scheme isn't very useful anymore, lessons from this book can be applied to other languages, including python. If you aren't infatuated with math and theorems, the least you should do is read the first chapter free at <a class="reference external" href="http://mitpress.mit.edu/sicp/full-text/book/book.html">http://mitpress.mit.edu/sicp/full-text/book/book.html</a> . Actually, the whole book is available for free online. I still prefer physical books however. Unplugging a little each day is healthy. I recommend buying a copy to take to the park, or wherever. If you do love math, then you will love this book. At the very least, my physical copy is a great conversation starter among programmers. Guys don't expect a mom to be reading SICP I guess.</p>
<p>My Amazon Affiliate Link: <a class="reference external" href="http://www.amazon.com/gp/product/0070004846/ref=as_li_qf_sp_asin_il_tl?ie=UTF8&tag=gypsyc-20&linkCode=as2&camp=1789&creative=9325&creativeASIN=0070004846">SICP</a></p>
2010 Guess The Number Game2010-10-25T00:00:00-03:002010-10-25T00:00:00-03:00Jessie Andersontag:housewifehacker.com,2010-10-25:/2010-guess-the-number-game.html<p>During my first month of learning python, I wrote a game to guess a number between 1 and 20 with six attempts. This simple game is good practice for a beginner. A better written and more advanced version can be found at <a class="reference external" href="http://housewifehacker.com/intermediate-guess-number-python-game.html">http://housewifehacker.com/intermediate-guess-number-python-game.html</a>. This example is …</p><p>During my first month of learning python, I wrote a game to guess a number between 1 and 20 with six attempts. This simple game is good practice for a beginner. A better written and more advanced version can be found at <a class="reference external" href="http://housewifehacker.com/intermediate-guess-number-python-game.html">http://housewifehacker.com/intermediate-guess-number-python-game.html</a>. This example is written in Python 2.6.</p>
<div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">random</span>
<span class="n">guessesTaken</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">print</span> <span class="s1">'Hello! What is your name?'</span>
<span class="n">myName</span> <span class="o">=</span> <span class="nb">raw_input</span><span class="p">()</span> <span class="c1">#get user name</span>
<span class="n">number</span> <span class="o">=</span> <span class="n">random</span><span class="o">.</span><span class="n">randint</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">20</span><span class="p">)</span> <span class="c1">#random number between 1 and 20</span>
<span class="k">print</span> <span class="s1">'</span><span class="si">%s</span><span class="s1"> I am thinking of a number between 1 and 20.'</span> <span class="o">%</span> <span class="n">myName</span>
<span class="k">while</span> <span class="n">guessesTaken</span> <span class="o"><</span> <span class="mi">6</span><span class="p">:</span>
<span class="k">print</span> <span class="s1">'Take a guess.'</span>
<span class="n">guess</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="nb">raw_input</span><span class="p">())</span>
<span class="n">guessesTaken</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">if</span> <span class="n">guess</span> <span class="o"><</span> <span class="n">number</span><span class="p">:</span>
<span class="k">print</span> <span class="s1">'Your guess is too low.'</span>
<span class="k">elif</span> <span class="n">guess</span> <span class="o">></span> <span class="n">number</span><span class="p">:</span>
<span class="k">print</span> <span class="s1">'Your guess is too high.'</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">break</span> <span class="c1">#breaks out of loop</span>
<span class="k">if</span> <span class="n">guess</span> <span class="o">==</span> <span class="n">number</span><span class="p">:</span>
<span class="k">if</span> <span class="n">guessesTaken</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">print</span> <span class="s1">'Good Job, </span><span class="si">%s</span><span class="s1">! You guessed my number in 1 guess!'</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">print</span> <span class="s1">'Good Job, </span><span class="si">%s</span><span class="s1">! You guessed my number in </span><span class="si">%d</span><span class="s1"> guesses!'</span> <span class="o">%</span> <span class="p">(</span><span class="n">myName</span><span class="p">,</span><span class="n">guessesTaken</span><span class="p">)</span>
<span class="k">if</span> <span class="n">guess</span> <span class="o">!=</span> <span class="n">number</span><span class="p">:</span>
<span class="k">print</span> <span class="s1">'No. The number I was thinking of was </span><span class="si">%d</span><span class="s1">'</span> <span class="o">%</span> <span class="n">number</span>
</pre></div>
Decimal to Change Number Precision2010-10-22T00:00:00-03:002010-10-22T00:00:00-03:00Jessie Andersontag:housewifehacker.com,2010-10-22:/decimal-to-change-number-precision.html<p>The built in math functions in Python use binary approximations, giving some funky results when dealing with numbers containing decimals:</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="o">.</span><span class="mi">1</span> <span class="o">+</span> <span class="o">.</span><span class="mi">2</span>
<span class="mf">0.30000000000000004</span>
<span class="o">>>></span> <span class="nb">round</span><span class="p">(</span><span class="mf">100.00</span> <span class="o">/</span> <span class="mf">3.000</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="mf">33.333300000000001</span>
</pre></div>
<p>One way to appropriately find the sum of decimals is to use strings</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="nb">str</span><span class="p">(</span><span class="o">.</span><span class="mi">1</span> <span class="o">+</span> <span class="o">.</span><span class="mi">2</span><span class="p">)</span>
<span class="s1">'0.3 …</span></pre></div><p>The built in math functions in Python use binary approximations, giving some funky results when dealing with numbers containing decimals:</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="o">.</span><span class="mi">1</span> <span class="o">+</span> <span class="o">.</span><span class="mi">2</span>
<span class="mf">0.30000000000000004</span>
<span class="o">>>></span> <span class="nb">round</span><span class="p">(</span><span class="mf">100.00</span> <span class="o">/</span> <span class="mf">3.000</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="mf">33.333300000000001</span>
</pre></div>
<p>One way to appropriately find the sum of decimals is to use strings</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="nb">str</span><span class="p">(</span><span class="o">.</span><span class="mi">1</span> <span class="o">+</span> <span class="o">.</span><span class="mi">2</span><span class="p">)</span>
<span class="s1">'0.3'</span>
</pre></div>
<p>Also, the default is to round to the nearest whole number when dividing</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="mi">1</span> <span class="o">/</span> <span class="mi">3</span>
<span class="mi">0</span>
<span class="o">>>></span> <span class="mi">100</span> <span class="o">/</span> <span class="mi">3</span>
<span class="mi">33</span>
</pre></div>
<p>The decimal library is a useful tool for floating point arithmetic. Instead of the command 'from decimal import * ' that would import everything from decimal, all I need to import is Decimal and getcontext. When importing modules, simplicity is preferred. There are less problems with naming in your code and you can be more aware of the tools at your disposal. I already imported decimal and looked through the directory to determine which modules I wanted. I'm only going to show the precision feature of decimal. You may want to import the entire library if you want to use other functions.</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="kn">from</span> <span class="nn">decimal</span> <span class="kn">import</span> <span class="n">getcontext</span>
<span class="o">>>></span> <span class="kn">from</span> <span class="nn">decimal</span> <span class="kn">import</span> <span class="n">Decimal</span>
<span class="o">>>></span> <span class="n">getcontext</span><span class="p">()</span>
<span class="n">Context</span><span class="p">(</span><span class="n">prec</span><span class="o">=</span><span class="mi">28</span><span class="p">,</span> <span class="n">rounding</span><span class="o">=</span><span class="n">ROUND_HALF_UP</span><span class="p">,</span> <span class="n">Emin</span><span class="o">=-</span><span class="mi">999999999</span><span class="p">,</span>
<span class="n">Emax</span><span class="o">=</span><span class="mi">999999999</span><span class="p">,</span> <span class="n">capitals</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">flags</span><span class="o">=</span><span class="p">[</span><span class="n">Inexact</span><span class="p">,</span> <span class="n">Rounded</span><span class="p">],</span>
<span class="n">traps</span><span class="o">=</span><span class="p">[</span><span class="n">DivisionByZero</span><span class="p">,</span> <span class="n">Overflow</span><span class="p">,</span> <span class="n">InvalidOperation</span><span class="p">])</span>
<span class="o">>>></span> <span class="c1">#our precision is also known as significant figures, applied after arithmetic</span>
<span class="o">...</span> <span class="c1">#let's change our precision</span>
<span class="o">...</span>
<span class="o">>>></span> <span class="n">getcontext</span><span class="p">()</span><span class="o">.</span><span class="n">prec</span> <span class="o">=</span> <span class="mi">6</span>
<span class="o">>>></span> <span class="n">Decimal</span><span class="p">(</span><span class="s1">'1'</span><span class="p">)</span> <span class="o">/</span> <span class="n">Decimal</span><span class="p">(</span><span class="s1">'7'</span><span class="p">)</span> <span class="c1"># can be performed to strings</span>
<span class="n">Decimal</span><span class="p">(</span><span class="s1">'0.142857'</span><span class="p">)</span>
<span class="o">>>></span> <span class="n">Decimal</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o">/</span> <span class="n">Decimal</span><span class="p">(</span><span class="mi">7</span><span class="p">)</span> <span class="c1"># can be performed to integers</span>
<span class="n">Decimal</span><span class="p">(</span><span class="s1">'0.142857'</span><span class="p">)</span>
<span class="o">>>></span> <span class="n">Decimal</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span> <span class="o">/</span> <span class="n">Decimal</span><span class="p">(</span><span class="mi">7</span><span class="p">)</span>
<span class="n">Decimal</span><span class="p">(</span><span class="s1">'1.42857'</span><span class="p">)</span> <span class="c1"># notice that 6 is the total number of figures, not the number after the decimal</span>
<span class="o">>>></span> <span class="n">Decimal</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span> <span class="o">/</span> <span class="n">Decimal</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="n">Decimal</span><span class="p">(</span><span class="s1">'2'</span><span class="p">)</span> <span class="c1"># not '2.00000,' which is considered more accurate than 2 by the science community</span>
</pre></div>
<p>As someone with a science background, I found the decimal library's use of 'significant figures' interesting. Decimal can also be used in financial reporting or billing. You can also find maximums and minimums, change rounding properties, and do anything that you can do with the math library. I personally prefer the math library for the algebraic functions performed by decimal, because math's syntax is simpler. To learn more about decimal, go to <a class="reference external" href="http://docs.python.org/library/decimal.html">http://docs.python.org/library/decimal.html</a></p>
Map Function in Python2010-10-20T00:00:00-03:002010-10-20T00:00:00-03:00Jessie Andersontag:housewifehacker.com,2010-10-20:/map-function-in-python.html<p>Today I discovered the map function in Python. Map causes some simple for loops to be verbose and unnecessary. Let's look at how to change a list of integers to a list of strings. First we'll use a for loop:</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="nb">list</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">]</span>
<span class="o">>>></span> <span class="n">index</span> <span class="o">=</span> <span class="mi">0</span>
<span class="o">>>></span> <span class="k">for</span> <span class="n">x …</span></pre></div><p>Today I discovered the map function in Python. Map causes some simple for loops to be verbose and unnecessary. Let's look at how to change a list of integers to a list of strings. First we'll use a for loop:</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="nb">list</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">]</span>
<span class="o">>>></span> <span class="n">index</span> <span class="o">=</span> <span class="mi">0</span>
<span class="o">>>></span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">list</span><span class="p">:</span>
<span class="o">...</span> <span class="nb">list</span><span class="p">[</span><span class="n">index</span><span class="p">]</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="nb">list</span><span class="p">[</span><span class="n">index</span><span class="p">])</span>
<span class="o">...</span> <span class="n">index</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="o">...</span>
<span class="o">>>></span> <span class="k">print</span> <span class="nb">list</span>
<span class="p">[</span><span class="s1">'1'</span><span class="p">,</span> <span class="s1">'2'</span><span class="p">,</span> <span class="s1">'3'</span><span class="p">,</span> <span class="s1">'4'</span><span class="p">,</span> <span class="s1">'5'</span><span class="p">]</span>
</pre></div>
<p>Now we'll use the map function and we'll define our 1-5 list using the range function</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="n">list1</span> <span class="o">=</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">6</span><span class="p">)</span>
<span class="o">>>></span> <span class="nb">map</span><span class="p">(</span><span class="nb">str</span><span class="p">,</span> <span class="n">list1</span><span class="p">)</span> <span class="c1"># performs str to each index of list1</span>
<span class="p">[</span><span class="s1">'1'</span><span class="p">,</span> <span class="s1">'2'</span><span class="p">,</span> <span class="s1">'3'</span><span class="p">,</span> <span class="s1">'4'</span><span class="p">,</span> <span class="s1">'5'</span><span class="p">]</span>
</pre></div>
<p>You can also make your list within the map function, such as splitting a string into a list. The following example shows how you can define a method using else, elif (else if), and if statements, then run your method to a single string with the map function, resulting in a list with the method performed to each index.</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="k">def</span> <span class="nf">pluralize</span><span class="p">(</span><span class="n">word</span><span class="p">):</span>
<span class="o">...</span> <span class="k">if</span> <span class="n">word</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="o">==</span> <span class="s1">'y'</span><span class="p">:</span>
<span class="o">...</span> <span class="k">return</span> <span class="n">word</span><span class="p">[:</span><span class="nb">len</span><span class="p">(</span><span class="n">word</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">+</span> <span class="s1">'ies'</span> <span class="c1"># replaces y with ies</span>
<span class="o">...</span> <span class="k">elif</span> <span class="n">word</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="o">==</span> <span class="s1">'s'</span><span class="p">:</span>
<span class="o">...</span> <span class="k">return</span> <span class="n">word</span> <span class="o">+</span> <span class="s1">'es'</span>
<span class="o">...</span> <span class="k">else</span><span class="p">:</span>
<span class="o">...</span> <span class="k">return</span> <span class="n">word</span> <span class="o">+</span> <span class="s1">'s'</span>
<span class="o">...</span>
<span class="o">>>></span> <span class="nb">map</span><span class="p">(</span> <span class="n">pluralize</span><span class="p">,</span> <span class="s2">"The sexy waitress brought me a beer"</span><span class="o">.</span><span class="n">split</span><span class="p">())</span>
<span class="p">[</span><span class="s1">'Thes'</span><span class="p">,</span> <span class="s1">'sexies'</span><span class="p">,</span> <span class="s1">'waitresses'</span><span class="p">,</span> <span class="s1">'broughts'</span><span class="p">,</span> <span class="s1">'mes'</span><span class="p">,</span> <span class="s1">'as'</span><span class="p">,</span> <span class="s1">'beers'</span><span class="p">]</span>
<span class="o">>>></span><span class="c1"># my husband chose the sentence</span>
</pre></div>
<p>I simplified my method to not account for every scenario put into it. Although this specific example does not produce correct English, the map function correctly split the string on the whitespace and carried out the method on each index of the list.</p>
Indexes, Strings, and Lists2010-10-18T00:00:00-03:002010-10-18T00:00:00-03:00Jessie Andersontag:housewifehacker.com,2010-10-18:/indexes-strings-and-lists.html<p>A Python string's properties can be best understood by using sentences and words, although numbers can also be stored as strings. Be careful not to name a string as 'str' or 'string', because these are built in functions in Python. Let's play with some basic functions you can do to …</p><p>A Python string's properties can be best understood by using sentences and words, although numbers can also be stored as strings. Be careful not to name a string as 'str' or 'string', because these are built in functions in Python. Let's play with some basic functions you can do to strings</p>
<div class="highlight"><pre><span></span><span class="p">[</span><span class="n">gypsychemist</span><span class="nd">@inspidell</span> <span class="o">~</span><span class="p">]</span><span class="err">$</span> <span class="n">python</span>
<span class="n">Python</span> <span class="mf">2.6</span><span class="o">.</span><span class="mi">4</span> <span class="p">(</span><span class="n">r264</span><span class="p">:</span><span class="mi">75706</span><span class="p">,</span> <span class="n">Jun</span> <span class="mi">4</span> <span class="mi">2010</span><span class="p">,</span> <span class="mi">18</span><span class="p">:</span><span class="mi">20</span><span class="p">:</span><span class="mi">16</span><span class="p">)</span>
<span class="p">[</span><span class="n">GCC</span> <span class="mf">4.4</span><span class="o">.</span><span class="mi">4</span> <span class="mi">20100503</span> <span class="p">(</span><span class="n">Red</span> <span class="n">Hat</span> <span class="mf">4.4</span><span class="o">.</span><span class="mi">4</span><span class="o">-</span><span class="mi">2</span><span class="p">)]</span> <span class="n">on</span> <span class="n">linux2</span>
<span class="n">Type</span> <span class="s2">"help"</span><span class="p">,</span> <span class="s2">"copyright"</span><span class="p">,</span> <span class="s2">"credits"</span> <span class="ow">or</span> <span class="s2">"license"</span> <span class="k">for</span> <span class="n">more</span>
<span class="n">information</span><span class="o">.</span>
<span class="o">>>></span> <span class="n">sentence1</span> <span class="o">=</span> <span class="s1">'This is two strings '</span>
<span class="o">>>></span> <span class="n">sentence2</span> <span class="o">=</span> <span class="s1">'combined.'</span>
<span class="o">>>></span> <span class="n">sentence1</span> <span class="o">+</span> <span class="n">sentence2</span>
<span class="s1">'This is two strings combined.'</span>
<span class="o">>>></span> <span class="n">s</span> <span class="o">=</span> <span class="n">sentence1</span> <span class="o">+</span> <span class="n">sentence2</span>
<span class="o">>>></span> <span class="k">print</span> <span class="n">s</span>
<span class="n">This</span> <span class="ow">is</span> <span class="n">two</span> <span class="n">strings</span> <span class="n">combined</span><span class="o">.</span>
<span class="o">>>></span> <span class="n">r</span> <span class="o">=</span> <span class="s1">'''Three quotes will</span>
<span class="s1">... preserve the formatting</span>
<span class="s1">... for multiple lines'''</span>
<span class="o">>>></span> <span class="k">print</span> <span class="n">r</span>
<span class="n">Three</span> <span class="n">quotes</span> <span class="n">will</span>
<span class="n">preserve</span> <span class="n">the</span> <span class="n">formatting</span>
<span class="k">for</span> <span class="n">multiple</span> <span class="n">lines</span>
<span class="o">>>></span> <span class="n">s</span><span class="o">.</span><span class="n">split</span><span class="p">()</span>
<span class="p">[</span><span class="s1">'This'</span><span class="p">,</span> <span class="s1">'is'</span><span class="p">,</span> <span class="s1">'two'</span><span class="p">,</span> <span class="s1">'strings'</span><span class="p">,</span> <span class="s1">'combined.'</span><span class="p">]</span>
<span class="o">>>></span> <span class="n">r</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s1">'e'</span><span class="p">)</span>
<span class="p">[</span><span class="s1">'Thr'</span><span class="p">,</span> <span class="s1">''</span><span class="p">,</span> <span class="s1">' quot'</span><span class="p">,</span> <span class="s1">'s will</span><span class="se">\n</span><span class="s1">pr'</span><span class="p">,</span> <span class="s1">'s'</span><span class="p">,</span> <span class="s1">'rv'</span><span class="p">,</span> <span class="s1">' th'</span><span class="p">,</span>
<span class="s1">' formatting</span><span class="se">\n</span><span class="s1">for multipl'</span><span class="p">,</span> <span class="s1">' lin'</span><span class="p">,</span> <span class="s1">'s'</span><span class="p">]</span>
</pre></div>
<p>The split command divides a string into a list based on the delimiter you define. In the example of splitting the s string, leaving the delimiter blank causes splitting on all white spaces (tab, enter, space). Anything can be the delimiter, such as using 'e' in the splitting of r example. 'n' is a new line.</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="n">p</span> <span class="o">=</span> <span class="s2">" The extra white space on the ends "</span>
<span class="o">>>></span> <span class="n">p</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span><span class="o">+</span><span class="s1">' is removed by the strip function'</span>
<span class="s1">'The extra white space on the ends is removed by the</span>
<span class="n">strip</span> <span class="n">function</span><span class="s1">'</span>
</pre></div>
<p>Indexes are useful for both strings and lists. The letters or numbers in a string begin with the index 0, or you can work from the back with index of -1. When selecting a range of indexes, the last number is excluded.</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="n">f</span> <span class="o">=</span> <span class="s1">'hello'</span>
<span class="o">>>></span> <span class="n">f</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">2</span><span class="p">]</span>
<span class="s1">'he'</span>
<span class="o">>>></span> <span class="n">f</span><span class="p">[:</span><span class="mi">2</span><span class="p">]</span> <span class="c1"># a starting index of 0 is assumed</span>
<span class="s1">'he'</span>
<span class="o">>>></span> <span class="n">f</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span>
<span class="s1">'l'</span>
<span class="o">>>></span> <span class="n">f</span><span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="p">:]</span> <span class="c1"># completing until the end is assumed</span>
<span class="s1">'lo'</span>
<span class="o">>>></span> <span class="n">f</span><span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="p">:</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
<span class="s1">'l'</span>
<span class="o">>>></span> <span class="n">f</span><span class="p">[:</span><span class="mi">2</span><span class="p">]</span> <span class="o">+</span> <span class="n">f</span><span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="p">:]</span>
<span class="s1">'helo'</span>
<span class="o">>>></span> <span class="nb">list</span><span class="o">=</span><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">]</span>
<span class="o">>>></span> <span class="nb">list</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
<span class="mi">1</span>
<span class="o">>>></span> <span class="nb">list</span><span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="p">:</span><span class="mi">0</span><span class="p">]</span> <span class="c1"># doesn't work</span>
<span class="p">[]</span>
<span class="o">>>></span> <span class="nb">list</span><span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="p">:]</span>
<span class="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">]</span>
<span class="o">>>></span> <span class="nb">list</span><span class="p">[:</span><span class="mi">1</span><span class="p">]</span>
<span class="p">[</span><span class="mi">0</span><span class="p">]</span>
</pre></div>
<p>'#' is used in Python to write comments. They are ignored in programs and are very useful to solve problems, either to write out a plan or to type in a literal translation of how you expect your code to perform. If your code does not work correctly, you can go back through your notes to quickly find where your logic or syntax may be incorrect.</p>
<p>As I mentioned briefly in the beginning, a number can also be a string. If a number is a string, it will be used a returned with quotation marks surrounding it. In Python, single quotes and double quotes act the same; however, the opening and closing ends need to be the same. The example below shows why you may want to change a number to a string:</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="n">pi</span> <span class="o">=</span> <span class="mf">3.14</span>
<span class="o">>>></span> <span class="c1"># cannot add an integer to a string</span>
<span class="o">>>></span> <span class="k">print</span> <span class="s1">'The value of pi is often rounded to '</span> <span class="o">+</span> <span class="n">pi</span>
<span class="n">Traceback</span> <span class="p">(</span><span class="n">most</span> <span class="n">recent</span> <span class="n">call</span> <span class="n">last</span><span class="p">):</span>
<span class="n">File</span> <span class="s2">""</span><span class="p">,</span> <span class="n">line</span> <span class="mi">1</span><span class="p">,</span> <span class="ow">in</span>
<span class="ne">TypeError</span><span class="p">:</span> <span class="n">cannot</span> <span class="n">concatenate</span> <span class="s1">'str'</span> <span class="ow">and</span> <span class="s1">'float'</span> <span class="n">objects</span>
<span class="o">>>></span> <span class="c1"># so we change pi to a string</span>
<span class="o">>>></span><span class="k">print</span> <span class="s1">'The value of pi is often rounded to '</span> <span class="o">+</span> <span class="nb">str</span><span class="p">(</span><span class="n">pi</span><span class="p">)</span>
<span class="n">The</span> <span class="n">value</span> <span class="n">of</span> <span class="n">pi</span> <span class="ow">is</span> <span class="n">often</span> <span class="n">rounded</span> <span class="n">to</span> <span class="mf">3.14</span>
<span class="o">>>></span> <span class="c1"># you can include a number after a string by using a comma</span>
<span class="o">>>></span><span class="k">print</span> <span class="s1">'The value of pi is often rounded to'</span><span class="p">,</span><span class="mf">3.14</span>
<span class="n">The</span> <span class="n">value</span> <span class="n">of</span> <span class="n">pi</span> <span class="ow">is</span> <span class="n">often</span> <span class="n">rounded</span> <span class="n">to</span> <span class="mf">3.14</span>
</pre></div>
<p>You can change a list of numbers to be a list of strings by using a for loop.</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="nb">list</span><span class="o">=</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">]</span>
<span class="o">>>></span> <span class="nb">str</span><span class="p">(</span><span class="nb">list</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span> <span class="c1"># returns the list index as a string without \</span>
<span class="n">changing</span> <span class="n">the</span> <span class="nb">list</span>
<span class="s1">'2'</span>
<span class="o">>>></span> <span class="nb">list</span> <span class="c1"># list is still composed of integers</span>
<span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">]</span>
<span class="o">>>></span> <span class="n">index</span> <span class="o">=</span> <span class="mi">0</span> <span class="c1"># setting a variable to start at 0 because \</span>
<span class="n">index</span> <span class="n">starts</span> <span class="n">at</span> <span class="mi">0</span>
<span class="o">>>></span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">list</span><span class="p">:</span> <span class="c1">#begins with index 0</span>
<span class="o">...</span> <span class="nb">list</span><span class="p">[</span><span class="n">index</span><span class="p">]</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="nb">list</span><span class="p">[</span><span class="n">index</span><span class="p">])</span> <span class="c1"># assigns index 0 integer \</span>
<span class="k">as</span> <span class="n">a</span> <span class="n">string</span> <span class="n">of</span> <span class="n">the</span> <span class="n">previous</span> <span class="nb">list</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="o">...</span> <span class="n">index</span> <span class="o">+=</span> <span class="mi">1</span> <span class="c1"># after the previous command is performed on \</span>
<span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">it</span> <span class="n">will</span> <span class="n">be</span> <span class="n">performed</span> <span class="n">on</span> <span class="p">[</span><span class="mi">1</span><span class="p">]</span>
<span class="o">...</span> <span class="c1">#for loop continues through indexes 1 to 4 after index 0</span>
<span class="o">>>></span> <span class="nb">list</span> <span class="c1"># our list is now changed to be strings</span>
<span class="p">[</span><span class="s1">'1'</span><span class="p">,</span> <span class="s1">'2'</span><span class="p">,</span> <span class="s1">'3'</span><span class="p">,</span> <span class="s1">'4'</span><span class="p">,</span> <span class="s1">'5'</span><span class="p">]</span>
</pre></div>
<p>Now lets play with some list commands that are nondiscriminate against strings or integers:</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="n">list1</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'8'</span><span class="p">,</span> <span class="s1">'9'</span><span class="p">,</span> <span class="s1">'10'</span><span class="p">]</span>
<span class="o">>>></span> <span class="nb">list</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="n">list1</span><span class="p">)</span> <span class="c1"># add list1 to end of list, list + list1</span>
<span class="o">>>></span> <span class="k">print</span> <span class="nb">list</span>
<span class="p">[</span><span class="s1">'3'</span><span class="p">,</span> <span class="s1">'4'</span><span class="p">,</span> <span class="s1">'5'</span><span class="p">,</span> <span class="s1">'6'</span><span class="p">,</span> <span class="s1">'7'</span><span class="p">,</span> <span class="s1">'8'</span><span class="p">,</span> <span class="s1">'9'</span><span class="p">,</span> <span class="s1">'10'</span><span class="p">]</span>
<span class="o">>>></span> <span class="nb">list</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="s1">'3'</span><span class="p">)</span> <span class="c1"># inserts '3' at index 2</span>
<span class="o">>>></span> <span class="k">print</span> <span class="nb">list</span>
<span class="p">[</span><span class="s1">'3'</span><span class="p">,</span> <span class="s1">'4'</span><span class="p">,</span> <span class="s1">'3'</span><span class="p">,</span> <span class="s1">'5'</span><span class="p">,</span> <span class="s1">'6'</span><span class="p">,</span> <span class="s1">'7'</span><span class="p">,</span> <span class="s1">'8'</span><span class="p">,</span> <span class="s1">'9'</span><span class="p">,</span> <span class="s1">'10'</span><span class="p">]</span>
<span class="o">>>></span> <span class="nb">list</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">)</span> <span class="c1"># now we'll insert an integer</span>
<span class="o">>>></span> <span class="k">print</span> <span class="nb">list</span> <span class="c1"># list can have combination of strings & non \</span>
<span class="n">strings</span>
<span class="p">[</span><span class="s1">'3'</span><span class="p">,</span> <span class="s1">'4'</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="s1">'3'</span><span class="p">,</span> <span class="s1">'5'</span><span class="p">,</span> <span class="s1">'6'</span><span class="p">,</span> <span class="s1">'7'</span><span class="p">,</span> <span class="s1">'8'</span><span class="p">,</span> <span class="s1">'9'</span><span class="p">,</span> <span class="s1">'10'</span><span class="p">]</span>
</pre></div>
<p>For more documentation and to try writing example programs, visit Google's Python classroom: <a class="reference external" href="http://code.google.com/edu/languages/google-python-class/index.html">http://code.google.com/edu/languages/google-python-class/index.html</a></p>
Math With Python2010-10-18T00:00:00-03:002010-10-18T00:00:00-03:00Jessie Andersontag:housewifehacker.com,2010-10-18:/math-with-python.html<p>If this is your first time using Python in Windows, you will have to download it from python.org. Every operating system includes a terminal, which we will be using to practice and test. Google "How to open terminal" and your operating system name to find specific information about opening …</p><p>If this is your first time using Python in Windows, you will have to download it from python.org. Every operating system includes a terminal, which we will be using to practice and test. Google "How to open terminal" and your operating system name to find specific information about opening your terminal. You will also need either VIM, WING, Eclipse, or another editor to save and run your programs, though we do not need to use it for this tutorial. This article will focus on math capabilities within Python, either performing calculations as a common calculator or within logic commands. So open your terminal and play with me.</p>
<p>I start my code with telling my terminal that I would be working in python. [<a class="reference external" href="mailto:gypsychemist@inspidell">gypsychemist@inspidell</a> ~]$ is my shell prompt, "python" is what I typed, and the next three lines are showing that python is installed and open for me to use.</p>
<div class="highlight"><pre><span></span><span class="p">[</span><span class="n">gypsychemist</span><span class="nd">@inspidell</span> <span class="o">~</span><span class="p">]</span><span class="err">$</span> <span class="n">python</span>
<span class="n">Python</span> <span class="mf">2.6</span><span class="o">.</span><span class="mi">4</span> <span class="p">(</span><span class="n">r264</span><span class="p">:</span><span class="mi">75706</span><span class="p">,</span> <span class="n">Jun</span> <span class="mi">4</span> <span class="mi">2010</span><span class="p">,</span> <span class="mi">18</span><span class="p">:</span><span class="mi">20</span><span class="p">:</span><span class="mi">16</span><span class="p">)</span>
<span class="p">[</span><span class="n">GCC</span> <span class="mf">4.4</span><span class="o">.</span><span class="mi">4</span> <span class="mi">20100503</span> <span class="p">(</span><span class="n">Red</span> <span class="n">Hat</span> <span class="mf">4.4</span><span class="o">.</span><span class="mi">4</span><span class="o">-</span><span class="mi">2</span><span class="p">)]</span> <span class="n">on</span> <span class="n">linux2</span>
<span class="n">Type</span> <span class="s2">"help"</span><span class="p">,</span> <span class="s2">"copyright"</span><span class="p">,</span> <span class="s2">"credits"</span> <span class="ow">or</span> <span class="s2">"license"</span> <span class="k">for</span> <span class="n">more</span>
<span class="n">information</span><span class="o">.</span>
<span class="o">>>></span> <span class="mi">3</span> <span class="o">+</span> <span class="mi">2</span>
<span class="mi">5</span>
<span class="o">>>></span> <span class="mi">3</span> <span class="o">*</span> <span class="mi">2</span>
<span class="mi">6</span>
<span class="o">>>></span> <span class="mi">6</span> <span class="o">/</span> <span class="mi">2</span>
<span class="mi">3</span>
<span class="o">>>></span> <span class="mi">3</span> <span class="o">-</span> <span class="mi">2</span>
<span class="mi">1</span>
<span class="o">>>></span> <span class="mi">3</span> <span class="o">*</span> <span class="p">(</span><span class="mi">3</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span>
<span class="mi">6</span>
<span class="o">>>></span> <span class="n">pi</span> <span class="o">=</span> <span class="mf">3.14</span>
<span class="o">>>></span> <span class="mi">3</span> <span class="o">*</span> <span class="n">pi</span>
<span class="mf">9.4199999999999999</span>
<span class="o">>>></span> <span class="nb">abs</span><span class="p">(</span><span class="mi">2</span> <span class="o">-</span> <span class="mi">3</span><span class="p">)</span>
<span class="mi">1</span>
<span class="o">>>></span> <span class="nb">pow</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="mi">9</span>
<span class="o">>>></span> <span class="mi">3</span><span class="o">**</span><span class="mi">2</span>
<span class="mi">9</span>
</pre></div>
<p>Basic math commands are shown above. '+' is for addition, '-' for subtraction. '*' for multiplication, and '/' for division. The basic math rules regarding parenthesis and order of operations are followed correctly. You can also store numbers as words or letters to perform math equations on, such as the example with pi. In Python, '=' is used to assign and does not imply equivalency. The absolute value function and two alternative ways to find a number with an exponent (also known as power) are shown.</p>
<p>A useful tool in python is the math library. To see the functions you can use within math, type 'import math' and 'dir(math)' on the next line. You just told the terminal you are opening the library and viewing the directory. The terminal will show you the commands including different trigonometric functions, advanced algebra, and rounding options. To learn more about a command (such as floor rounding), you can type 'help(math.floor)'. Press 'q' to exit help.</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="kn">import</span> <span class="nn">math</span>
<span class="o">>>></span> <span class="nb">dir</span><span class="p">(</span><span class="n">math</span><span class="p">)</span>
<span class="p">[</span><span class="s1">'__doc__'</span><span class="p">,</span> <span class="s1">'__file__'</span><span class="p">,</span> <span class="s1">'__name__'</span><span class="p">,</span> <span class="s1">'__package__'</span><span class="p">,</span> <span class="s1">'acos'</span><span class="p">,</span> <span class="s1">'acosh'</span><span class="p">,</span>
<span class="s1">'asin'</span><span class="p">,</span> <span class="s1">'asinh'</span><span class="p">,</span> <span class="s1">'atan'</span><span class="p">,</span> <span class="s1">'atan2'</span><span class="p">,</span> <span class="s1">'atanh'</span><span class="p">,</span> <span class="s1">'ceil'</span><span class="p">,</span> <span class="s1">'copysign'</span><span class="p">,</span><span class="s1">'cos'</span><span class="p">,</span>
<span class="s1">'cosh'</span><span class="p">,</span> <span class="s1">'degrees'</span><span class="p">,</span> <span class="s1">'e'</span><span class="p">,</span> <span class="s1">'exp'</span><span class="p">,</span> <span class="s1">'fabs'</span><span class="p">,</span> <span class="s1">'factorial'</span><span class="p">,</span> <span class="s1">'floor'</span><span class="p">,</span> <span class="s1">'fmod'</span><span class="p">,</span>
<span class="s1">'frexp'</span><span class="p">,</span> <span class="s1">'fsum'</span><span class="p">,</span> <span class="s1">'hypot'</span><span class="p">,</span> <span class="s1">'isinf'</span><span class="p">,</span> <span class="s1">'isnan'</span><span class="p">,</span> <span class="s1">'ldexp'</span><span class="p">,</span> <span class="s1">'log'</span><span class="p">,</span> <span class="s1">'log10'</span><span class="p">,</span>
<span class="s1">'log1p'</span><span class="p">,</span> <span class="s1">'modf'</span><span class="p">,</span> <span class="s1">'pi'</span><span class="p">,</span> <span class="s1">'pow'</span><span class="p">,</span> <span class="s1">'radians'</span><span class="p">,</span> <span class="s1">'sin'</span><span class="p">,</span> <span class="s1">'sinh'</span><span class="p">,</span> <span class="s1">'sqrt'</span><span class="p">,</span>
<span class="s1">'tan'</span><span class="p">,</span> <span class="s1">'tanh'</span><span class="p">,</span> <span class="s1">'trunc'</span><span class="p">]</span>
<span class="o">>>></span> <span class="n">help</span><span class="p">(</span><span class="n">math</span><span class="o">.</span><span class="n">floor</span><span class="p">)</span>
<span class="o">>>></span> <span class="n">math</span><span class="o">.</span><span class="n">floor</span><span class="p">(</span><span class="mf">4.5</span><span class="p">)</span>
<span class="mf">4.0</span>
</pre></div>
<p>You can also test to determine if one number is divisible by another, such as when you want to execute commands on only the even indexes in a list. To determine if 3 is evenly divisible by 2, type '3 %2'. Python returns '1' because there is a remainder of 1 when you divide 3 by 2. If 0 is a result, then numbers are evenly divisible.</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="mi">3</span> <span class="o">%</span> <span class="mi">2</span>
<span class="mi">1</span>
<span class="o">>>></span> <span class="mi">3</span> <span class="o">%</span> <span class="mi">3</span>
<span class="mi">0</span>
</pre></div>
<p>If given a list of numbers and you want to perform math functions such as adding the numbers together, you can use a for loop. Follow the below example:</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="nb">list</span><span class="o">=</span><span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">6</span><span class="p">]</span>
<span class="o">>>></span> <span class="nb">sum</span><span class="o">=</span><span class="mi">0</span>
<span class="o">>>></span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">list</span><span class="p">:</span>
<span class="o">...</span> <span class="nb">sum</span> <span class="o">+=</span> <span class="n">x</span>
<span class="o">...</span>
<span class="o">>>></span> <span class="nb">sum</span>
<span class="mi">28</span>
</pre></div>
<p>In Python, spacing of indentions and capitalization are very important. After any statement ending with ':' , indent by a consistent amount (two spaces, four spaces, tab, will all work, but four is the standard).'sum += x' is the same as 'sum = sum + x'. 'x' is the value at the index as it goes through the list. So this code just said 0 + 2 + 3 + 6 + 7 + 4 + 6 = 28. Now that you understand how to do it with a basic for loop, the quicker way is to use the built in sum function. Because I used the variable 'sum', already, I need to first reinstate sum to its built in function.</p>
<div class="highlight"><pre><span></span><span class="o">>>></span> <span class="kn">from</span> <span class="nn">__builtin__</span> <span class="kn">import</span> <span class="nb">sum</span>
<span class="o">>>></span> <span class="nb">sum</span><span class="p">(</span><span class="nb">list</span><span class="p">)</span>
<span class="mi">28</span>
</pre></div>
<p>Using built in functions as variables should be avoided. As you learn more Python, you will learn safe and understandable variables to use in your code. For more information on numbers and math, you can visit <a class="reference external" href="http://docs.python.org/library/numeric.html">http://docs.python.org/library/numeric.html</a></p>