├── requirements.txt ├── notebooks ├── images │ ├── favicon-0.png │ ├── favicon.png │ ├── globe_poor.png │ ├── en_logged_in.png │ ├── en_login_page.png │ ├── en_submit_page.png │ ├── hn_home_page.png │ ├── defender_rocket.png │ ├── django_it_worked.png │ ├── ed_news_homepage.png │ ├── en_minimal_style.png │ ├── en_profile_page.png │ ├── en_registerhtml.png │ ├── basemap_simpletest.png │ ├── en_password_change.png │ ├── en_username_header.png │ ├── pygame_empty_window.png │ ├── defender_rocket_50px.png │ ├── defender_ship_appears.png │ ├── en_admin_userprofile.png │ ├── en_homepage_bootstrap.png │ ├── earthquake_plot_titled.png │ └── en_homepage_responsive.png ├── multiplying.py ├── my_templates │ ├── include_jquery.html │ ├── index.tpl │ ├── intro_python_base.tpl │ ├── intro_python_header.html │ ├── index_body.html │ └── navbar.html ├── css │ ├── show_all_style.css │ ├── nb3_overrides.css │ ├── site_styles.css │ ├── bootstrap_overrides.css │ └── non-responsive.css ├── js │ ├── nbconvert_js.js │ ├── show_hide_output.js │ ├── html5shiv.js │ ├── respond.min.js │ └── bootstrap.min.js ├── rocket.py ├── programming_competencies.ipynb ├── exceptions.ipynb ├── testing.ipynb ├── hello_world.ipynb ├── index.ipynb ├── syllabus.ipynb ├── web_apps.ipynb ├── resources.ipynb ├── programming_environment.ipynb ├── programming_environment_osx.ipynb ├── programming_environment_linux.ipynb ├── programming_environment_extras.ipynb ├── programming_environment_windows.ipynb ├── contents.ipynb └── introducing_functions.ipynb ├── .gitignore ├── scripts ├── highlight_inline_code.sh ├── build_index.py ├── convert_home_links.sh ├── remove_input_references.py ├── create_common_html.sh ├── build_html_pages.sh ├── show_hide_output.py ├── highlight_code.py └── build_all_exercises_page.py ├── LICENSE.md ├── tests └── test_links.py ├── README.md └── html_resources └── index.html /requirements.txt: -------------------------------------------------------------------------------- 1 | ipython[all]==1.1.0 2 | requests==2.0.0 3 | matplotlib==1.3.1 4 | -------------------------------------------------------------------------------- /notebooks/images/favicon-0.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/favicon-0.png -------------------------------------------------------------------------------- /notebooks/images/favicon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/favicon.png -------------------------------------------------------------------------------- /notebooks/images/globe_poor.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/globe_poor.png -------------------------------------------------------------------------------- /notebooks/images/en_logged_in.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/en_logged_in.png -------------------------------------------------------------------------------- /notebooks/images/en_login_page.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/en_login_page.png -------------------------------------------------------------------------------- /notebooks/images/en_submit_page.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/en_submit_page.png -------------------------------------------------------------------------------- /notebooks/images/hn_home_page.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/hn_home_page.png -------------------------------------------------------------------------------- /notebooks/images/defender_rocket.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/defender_rocket.png -------------------------------------------------------------------------------- /notebooks/images/django_it_worked.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/django_it_worked.png -------------------------------------------------------------------------------- /notebooks/images/ed_news_homepage.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/ed_news_homepage.png -------------------------------------------------------------------------------- /notebooks/images/en_minimal_style.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/en_minimal_style.png -------------------------------------------------------------------------------- /notebooks/images/en_profile_page.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/en_profile_page.png -------------------------------------------------------------------------------- /notebooks/images/en_registerhtml.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/en_registerhtml.png -------------------------------------------------------------------------------- /notebooks/images/basemap_simpletest.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/basemap_simpletest.png -------------------------------------------------------------------------------- /notebooks/images/en_password_change.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/en_password_change.png -------------------------------------------------------------------------------- /notebooks/images/en_username_header.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/en_username_header.png -------------------------------------------------------------------------------- /notebooks/images/pygame_empty_window.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/pygame_empty_window.png -------------------------------------------------------------------------------- /notebooks/images/defender_rocket_50px.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/defender_rocket_50px.png -------------------------------------------------------------------------------- /notebooks/images/defender_ship_appears.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/defender_ship_appears.png -------------------------------------------------------------------------------- /notebooks/images/en_admin_userprofile.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/en_admin_userprofile.png -------------------------------------------------------------------------------- /notebooks/images/en_homepage_bootstrap.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/en_homepage_bootstrap.png -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | notes/* 2 | *~ 3 | *.ipynb_checkpoints 4 | *# 5 | notebooks/*.html* 6 | notebooks/__pycache__ 7 | notebooks/my_templates/ignored_templates 8 | -------------------------------------------------------------------------------- /notebooks/images/earthquake_plot_titled.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/earthquake_plot_titled.png -------------------------------------------------------------------------------- /notebooks/images/en_homepage_responsive.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ehmatthes/intro_programming/HEAD/notebooks/images/en_homepage_responsive.png -------------------------------------------------------------------------------- /notebooks/multiplying.py: -------------------------------------------------------------------------------- 1 | # Save as multiplying.py 2 | 3 | def double(x): 4 | return 2*x 5 | 6 | def triple(x): 7 | return 3*x 8 | 9 | def quadruple(x): 10 | return 4*x 11 | -------------------------------------------------------------------------------- /notebooks/my_templates/include_jquery.html: -------------------------------------------------------------------------------- 1 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /notebooks/my_templates/index.tpl: -------------------------------------------------------------------------------- 1 | {%- block header -%} 2 | {% include "intro_python_header.html" %} 3 | {%- endblock header -%} 4 | 5 | {% block body %} 6 | 7 | {% include "navbar.html" %} 8 | {% include "index_body.html" %} 9 | 10 | {%- endblock body %} 11 | 12 | {% block footer %} 13 | {% include "include_jquery.html" %} 14 | 15 | {% endblock footer %} 16 | 17 | -------------------------------------------------------------------------------- /notebooks/css/show_all_style.css: -------------------------------------------------------------------------------- 1 | /* Style sheet for pages that should start out with all output 2 | displayed, such as Mapping Global Earthquake Activity. */ 3 | 4 | /* --- Show/ Hide output --- */ 5 | /* Start out with show buttons not displayed. */ 6 | button.show_output { 7 | display: none; 8 | } 9 | 10 | button.hide_output { 11 | display: inline; 12 | } 13 | 14 | /* Start out with output shown. */ 15 | div.output { 16 | display: inline; 17 | } 18 | -------------------------------------------------------------------------------- /notebooks/my_templates/intro_python_base.tpl: -------------------------------------------------------------------------------- 1 | {%- extends 'basic.tpl' -%} 2 | {% from 'mathjax.tpl' import mathjax %} 3 | 4 | 5 | {%- block header -%} 6 | {% include "my_templates/intro_python_header.html" %} 7 | {%- endblock header -%} 8 | 9 | {% block body %} 10 | 11 | {% include "my_templates/navbar.html" %} 12 |
13 | {{ super() }} 14 |
15 | 16 | {%- endblock body %} 17 | 18 | {% block footer %} 19 | {% include "my_templates/include_jquery.html" %} 20 | 21 | {% endblock footer %} -------------------------------------------------------------------------------- /notebooks/js/nbconvert_js.js: -------------------------------------------------------------------------------- 1 | init_mathjax = function() { 2 | if (window.MathJax) { 3 | // MathJax loaded 4 | MathJax.Hub.Config({ 5 | tex2jax: { 6 | inlineMath: [ ['$','$'], ["\\(","\\)"] ], 7 | displayMath: [ ['$$','$$'], ["\\[","\\]"] ] 8 | }, 9 | displayAlign: 'left', // Change this to 'center' to center equations. 10 | "HTML-CSS": { 11 | styles: {'.MathJax_Display': {"margin": 0}} 12 | } 13 | }); 14 | MathJax.Hub.Queue(["Typeset",MathJax.Hub]); 15 | } 16 | } 17 | init_mathjax(); 18 | -------------------------------------------------------------------------------- /scripts/highlight_inline_code.sh: -------------------------------------------------------------------------------- 1 | # This script runs through all the html files in notebooks/, and 2 | # modifies tags to 3 | # Rationale: 4 | # Inline code blocks are much easier to recognize when they are highlighted, 5 | # in a manner similar to stackoverflow. 6 | 7 | printf "\nHighlighting inline code blocks...\n" 8 | 9 | old_string='' 10 | new_string='' 11 | 12 | if [ -e "../notebooks/" ] 13 | then 14 | find ../notebooks -iname '*.html' | xargs sed -i "s/$old_string/$new_string/g" 15 | else 16 | find notebooks -iname '*.html' | xargs sed -i "s/$old_string/$new_string/g" 17 | fi 18 | 19 | 20 | printf " Highlighted inline code blocks.\n" 21 | -------------------------------------------------------------------------------- /scripts/build_index.py: -------------------------------------------------------------------------------- 1 | from jinja2 import Environment, FileSystemLoader 2 | 3 | # Load index template. 4 | my_template_path = '/srv/projects/intro_programming/intro_programming/notebooks/my_templates' 5 | my_template_base_path = '/srv/projects/intro_programming/intro_programming/notebooks' 6 | ipython_template_path = '/srv/projects/intro_programming/venv/lib/python3.4/site-packages/IPython/nbconvert/templates/html' 7 | 8 | my_loader = FileSystemLoader( 9 | [my_template_path, my_template_base_path, ipython_template_path]) 10 | env = Environment(loader=my_loader) 11 | 12 | index_template = my_loader.load(env, 'index.tpl') 13 | 14 | # Render template to file. 15 | notebooks_path = '/srv/projects/intro_programming/intro_programming/notebooks/' 16 | filepath = notebooks_path + 'index.html' 17 | with open(filepath, 'w') as f: 18 | f.write(index_template.render()) 19 | -------------------------------------------------------------------------------- /scripts/convert_home_links.sh: -------------------------------------------------------------------------------- 1 | # This script runs through all the html files in notebooks/, and 2 | # modifies index.html links to ./ 3 | # Rationale: 4 | # ipynb files need to link to index notebook. 5 | # But html sites are better off linking to root, which will call index.html. 6 | # Calling index.html leads user to end up using two names for the index page, 7 | # which is confusing for tracking. 8 | 9 | printf "\nConverting home links to ./ now...\n" 10 | 11 | old_string="href='index.html'" 12 | old_string_2='href="index.html"' 13 | new_string="href='.\/'" 14 | 15 | if [ -e "../notebooks/" ] 16 | then 17 | find ../notebooks -iname '*.html' | xargs sed -i "s/$old_string/$new_string/" 18 | find ../notebooks -iname '*.html' | xargs sed -i "s/$old_string_2/$new_string/" 19 | else 20 | find notebooks -iname '*.html' | xargs sed -i "s/$old_string/$new_string/" 21 | find notebooks -iname '*.html' | xargs sed -i "s/$old_string_2/$new_string/" 22 | fi 23 | 24 | printf " Converted home links.\n" 25 | -------------------------------------------------------------------------------- /notebooks/rocket.py: -------------------------------------------------------------------------------- 1 | from math import sqrt 2 | 3 | class Rocket(): 4 | # Rocket simulates a rocket ship for a game, 5 | # or a physics simulation. 6 | 7 | def __init__(self, x=0, y=0): 8 | # Each rocket has an (x,y) position. 9 | self.x = x 10 | self.y = y 11 | 12 | def move_rocket(self, x_increment=0, y_increment=1): 13 | # Move the rocket according to the paremeters given. 14 | # Default behavior is to move the rocket up one unit. 15 | self.x += x_increment 16 | self.y += y_increment 17 | 18 | def get_distance(self, other_rocket): 19 | # Calculates the distance from this rocket to another rocket, 20 | # and returns that value. 21 | distance = sqrt((self.x-other_rocket.x)**2+(self.y-other_rocket.y)**2) 22 | return distance 23 | 24 | 25 | class Shuttle(Rocket): 26 | # Shuttle simulates a space shuttle, which is really 27 | # just a reusable rocket. 28 | 29 | def __init__(self, x=0, y=0, flights_completed=0): 30 | super().__init__(x, y) 31 | self.flights_completed = flights_completed 32 | -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) {{2013}} {{Eric Matthes}} 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of 6 | this software and associated documentation files (the "Software"), to deal in 7 | the Software without restriction, including without limitation the rights to 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 9 | the Software, and to permit persons to whom the Software is furnished to do so, 10 | subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /notebooks/css/nb3_overrides.css: -------------------------------------------------------------------------------- 1 | /* Overrides of notebook CSS for static HTML export */ 2 | body { 3 | overflow: visible; 4 | padding: 8px; 5 | } 6 | 7 | div#notebook { 8 | overflow: visible; 9 | border-top: none; 10 | } 11 | 12 | @media print { 13 | div.cell { 14 | display: block; 15 | page-break-inside: avoid; 16 | } 17 | div.output_wrapper { 18 | display: block; 19 | page-break-inside: avoid; 20 | } 21 | div.output { 22 | display: block; 23 | page-break-inside: avoid; 24 | } 25 | } 26 | 27 | /* Site doesn't use input or output prompts. */ 28 | 29 | div.prompt { 30 | min-width: 0ex; 31 | padding: 0em; 32 | } 33 | 34 | /* Most relevant on earthquake visualization now. */ 35 | img { 36 | max-width: 100%; 37 | } 38 | 39 | /* Use bootstrap-style headings. */ 40 | div.rendered_html h1 { 41 | font-weight: 500; 42 | font-size: 36px; 43 | } 44 | 45 | div.rendered_html h2 { 46 | font-weight: 500; 47 | font-size: 30px; 48 | } 49 | 50 | div.rendered_html h3 { 51 | font-weight: 500; 52 | font-size: 24px; 53 | } 54 | 55 | div.rendered_html h4 { 56 | font-weight: 500; 57 | font-size: 18px; 58 | } 59 | -------------------------------------------------------------------------------- /notebooks/css/site_styles.css: -------------------------------------------------------------------------------- 1 | /* Styles for the overall site. 2 | These styles are unrelated to bootstrap, etc. */ 3 | 4 | /* --- Show/ Hide output --- */ 5 | /* Start out with hide buttons not displayed. */ 6 | button.hide_output { 7 | display: none; 8 | } 9 | 10 | button.hide_output, button.show_output { 11 | width: 100px; 12 | margin: 5px 0px 0px 0px; 13 | } 14 | 15 | button.show_output_all { 16 | margin-right: 10px; 17 | } 18 | 19 | /* Start out with output hidden. */ 20 | div.output { 21 | display: none; 22 | } 23 | 24 | 25 | /* Twitter share button */ 26 | div.twitter-share-button { 27 | float: right; 28 | margin-top: 14px; 29 | margin-right: -40px; 30 | } 31 | 32 | /* Twitter follow button */ 33 | div.twitter-follow-button { 34 | float: right; 35 | margin-top: 14px; 36 | margin-right: 15px; 37 | border: solid 0px black; 38 | } 39 | 40 | 41 | /* Highlighting code */ 42 | div.highlighted_code_line { 43 | background-color: #e3e3e3; 44 | } 45 | 46 | code.inline_code { 47 | background-color: #f0f0f0; 48 | padding: 2px; 49 | margin: 1px; 50 | } 51 | 52 | 53 | /* all_exercises_challenges */ 54 | h3.contents_level_two { 55 | margin-left: 20px; 56 | margin-bottom: 0px; 57 | } 58 | 59 | pre code { 60 | display: block; 61 | border-radius: 4px; 62 | } -------------------------------------------------------------------------------- /notebooks/js/show_hide_output.js: -------------------------------------------------------------------------------- 1 | // Show all output 2 | $(document).ready(function(){ 3 | $("button.show_output_all").click(function(){ 4 | // Make all output visible 5 | $("div.output").show(); 6 | // Make sure all buttons toggled to 'hide output' 7 | $("button.show_output").hide(); 8 | $("button.hide_output").show(); 9 | }); 10 | }); 11 | 12 | // Hide all output 13 | $(document).ready(function(){ 14 | $("button.hide_output_all").click(function(){ 15 | // Hide all output 16 | $("div.output").hide(); 17 | // Make sure all buttons toggled to 'show output' 18 | $("button.show_output").show(); 19 | $("button.hide_output").hide(); 20 | }); 21 | }); 22 | 23 | // Show single output 24 | $(document).ready(function(){ 25 | $("button.show_output").click(function(){ 26 | var id_num = $(this).attr('target') 27 | $("#output_"+id_num).show(); 28 | $("button#show_output_"+id_num).hide(); 29 | $("button#hide_output_"+id_num).show(); 30 | }); 31 | }); 32 | 33 | // Hide single output 34 | $(document).ready(function(){ 35 | $("button.hide_output").click(function(){ 36 | var id_num = $(this).attr('target') 37 | $("#output_"+id_num).hide(); 38 | $("button#hide_output_"+id_num).hide(); 39 | $("button#show_output_"+id_num).show(); 40 | }); 41 | }); -------------------------------------------------------------------------------- /scripts/remove_input_references.py: -------------------------------------------------------------------------------- 1 | # This script removes the input reference numbers from html pages. 2 | # They play a useful role in scientific notebooks, but they are really 3 | # just visual clutter in this project. 4 | # Could be an nbconvert setting, but it's an easy enough scripting job. 5 | 6 | import os 7 | import sys 8 | 9 | print("\nStripping input reference numbers from code cells...") 10 | 11 | # Find all files to work with. 12 | path_to_notebooks = '/srv/projects/intro_programming/intro_programming/notebooks/' 13 | filenames = [] 14 | for filename in os.listdir(path_to_notebooks): 15 | if '.html' in filename and filename != 'index.html': 16 | filenames.append(filename) 17 | 18 | # one file for testing: 19 | #filenames = ['hello_world.html'] 20 | 21 | for filename in filenames: 22 | 23 | f = open(path_to_notebooks + filename, 'r') 24 | lines = f.readlines() 25 | f.close() 26 | 27 | f = open(path_to_notebooks + filename, 'wb') 28 | for line in lines: 29 | # Unwanted lines have opening and closing div on same line, 30 | # with input reference number between them. 31 | if ('
' in line 32 | and '
' in line): 33 | # Don't write this line. 34 | continue 35 | else: 36 | # Regular line, write it. 37 | f.write(line.encode('utf-8')) 38 | 39 | f.close() 40 | 41 | print(" Stripped input reference numbers.\n") 42 | 43 | -------------------------------------------------------------------------------- /notebooks/programming_competencies.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "metadata": { 3 | "name": "programming_competencies" 4 | }, 5 | "nbformat": 3, 6 | "nbformat_minor": 0, 7 | "worksheets": [ 8 | { 9 | "cells": [ 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Programming Competencies\n", 15 | "===\n", 16 | "What should your goals be if you want to become a strong programmer?" 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "Programming Environment\n", 24 | "---\n", 25 | "- Know the strengths and weaknesses of your OS and distribution.\n", 26 | "- Know how to rebuild your system from scratch, when you break your build." 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "Programming Essentials\n", 34 | "---\n", 35 | "- Know the basics in your language.\n", 36 | "- Continue to develop your programming toolbox, within your language of choice." 37 | ] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": {}, 42 | "source": [ 43 | "Project Focus\n", 44 | "---\n", 45 | "- Know your main interest in programming: If you had infinite programming skills, what would you want to build?" 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "metadata": {}, 51 | "source": [ 52 | "Other skills and knowledge areas\n", 53 | "---\n", 54 | "- Databases\n", 55 | "- Sysadmin skills" 56 | ] 57 | } 58 | ], 59 | "metadata": {} 60 | } 61 | ] 62 | } -------------------------------------------------------------------------------- /notebooks/css/bootstrap_overrides.css: -------------------------------------------------------------------------------- 1 | /* Prevent double-highlighting of code cells. */ 2 | pre { 3 | border: 0px solid #999; 4 | background-color: #f7f7f7; 5 | } 6 | 7 | /* Probably unnecessary; was helping highlight active elements. */ 8 | ul.navbar-nav { 9 | border: 0px solid #333; 10 | padding-top: 7px; 11 | padding-bottom: 7px; 12 | } 13 | 14 | /* Disable highlighting of navbar elements for active sections. */ 15 | .navbar-default .navbar-nav > .active > a { 16 | background-color: #f8f8f8; 17 | } 18 | 19 | /* For now, I like the fixed navbar. Will re-evaluate. 20 | /* Don't fix the navbar to the top of the screen. 21 | .navbar.navbar-default.navbar-fixed-top { 22 | position: static; 23 | margin-top: -70px; 24 | } 25 | */ 26 | 27 | /* --- INDEX PAGE STYLES --- */ 28 | /* a sub-hero unit, for sections lower on the page */ 29 | .my_hero_unit_2 { 30 | padding: 15px; 31 | padding-bottom: 5px; 32 | border: 0px solid #333; 33 | margin-bottom: 10px; 34 | } 35 | 36 | /* Headers for the main sections on the index page. */ 37 | .section_label { 38 | font-size: 24px; 39 | } 40 | 41 | p.lead { 42 | margin-bottom: 0px; 43 | } 44 | 45 | hr { 46 | margin-top: 5px; 47 | margin-bottom: 5px; 48 | border-top: 1px solid #999; 49 | } 50 | 51 | .section_button { 52 | margin-top: 10px; 53 | margin-bottom: 5px; 54 | width: 400px; 55 | } 56 | 57 | .btn_home_action { 58 | margin-top: 3px; 59 | padding-top: 2px; 60 | padding-bottom: 2px; 61 | font-size: 14px; 62 | width: 200px; 63 | } 64 | 65 | .dropdown-menu .divider { 66 | margin-left: 10px; 67 | margin-right: 10px; 68 | border-bottom: 1px solid #ddd; 69 | } 70 | -------------------------------------------------------------------------------- /notebooks/my_templates/intro_python_header.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | Introduction to Python: An open resource for students and teachers 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 32 | 33 | 34 | 37 | 38 | 39 | 40 | 41 | {% include "my_templates/ignored_templates/ga.tpl" ignore missing %} 42 | 43 | -------------------------------------------------------------------------------- /notebooks/exceptions.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "metadata": { 3 | "name": "exceptions" 4 | }, 5 | "nbformat": 3, 6 | "nbformat_minor": 0, 7 | "worksheets": [ 8 | { 9 | "cells": [ 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Exceptions\n", 15 | "===\n", 16 | "Every program has errors while it runs, and has to deal with unexpected behavior and bad input. Exceptions provide a clean way to deal with these situations." 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "[Previous: Classes](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/classes.ipynb) | \n", 24 | "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb) | \n", 25 | "[Next: Testing](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/testing.ipynb)" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "Contents\n", 33 | "===" 34 | ] 35 | }, 36 | { 37 | "cell_type": "markdown", 38 | "metadata": {}, 39 | "source": [ 40 | "[top](#)" 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "metadata": {}, 46 | "source": [ 47 | "- - -\n", 48 | "[Previous: Classes](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/classes.ipynb) | \n", 49 | "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb) | \n", 50 | "[Next: Testing](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/testing.ipynb)" 51 | ] 52 | } 53 | ], 54 | "metadata": {} 55 | } 56 | ] 57 | } -------------------------------------------------------------------------------- /notebooks/testing.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "metadata": { 3 | "name": "testing" 4 | }, 5 | "nbformat": 3, 6 | "nbformat_minor": 0, 7 | "worksheets": [ 8 | { 9 | "cells": [ 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Testing\n", 15 | "===\n", 16 | "The programs that we write can quickly become complicated, and with complexity comes bugs. Programmers have long accepted that every program will have its share of bugs. To deal with this, we have come up with many ways to defend against avoidable bugs. Learning to write tests is one of the best things you can do to guard against avoidable bugs creeping into your own programs. Basically, you write a set of tests that you then run against your program every time you or someone else changes the program. These tests, if written correctly, prove that changes to the code do not break anything that was working previously." 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "[Previous: Exceptions](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/exceptions.ipynb) | \n", 24 | "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb)" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "Contents\n", 32 | "===" 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": {}, 38 | "source": [ 39 | "[top](#)" 40 | ] 41 | }, 42 | { 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "- - -\n", 47 | "[Previous: Exceptions](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/exceptions.ipynb) | \n", 48 | "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb)" 49 | ] 50 | } 51 | ], 52 | "metadata": {} 53 | } 54 | ] 55 | } -------------------------------------------------------------------------------- /notebooks/js/html5shiv.js: -------------------------------------------------------------------------------- 1 | /* 2 | HTML5 Shiv v3.6.2pre | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed 3 | */ 4 | (function(l,f){function m(){var a=e.elements;return"string"==typeof a?a.split(" "):a}function i(a){var b=n[a[o]];b||(b={},h++,a[o]=h,n[h]=b);return b}function p(a,b,c){b||(b=f);if(g)return b.createElement(a);c||(c=i(b));b=c.cache[a]?c.cache[a].cloneNode():r.test(a)?(c.cache[a]=c.createElem(a)).cloneNode():c.createElem(a);return b.canHaveChildren&&!s.test(a)?c.frag.appendChild(b):b}function t(a,b){if(!b.cache)b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag(); 5 | a.createElement=function(c){return!e.shivMethods?b.createElem(c):p(c,a,b)};a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+m().join().replace(/\w+/g,function(a){b.createElem(a);b.frag.createElement(a);return'c("'+a+'")'})+");return n}")(e,b.frag)}function q(a){a||(a=f);var b=i(a);if(e.shivCSS&&!j&&!b.hasCSS){var c,d=a;c=d.createElement("p");d=d.getElementsByTagName("head")[0]||d.documentElement;c.innerHTML="x"; 6 | c=d.insertBefore(c.lastChild,d.firstChild);b.hasCSS=!!c}g||t(a,b);return a}var k=l.html5||{},s=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,r=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,j,o="_html5shiv",h=0,n={},g;(function(){try{var a=f.createElement("a");a.innerHTML="";j="hidden"in a;var b;if(!(b=1==a.childNodes.length)){f.createElement("a");var c=f.createDocumentFragment();b="undefined"==typeof c.cloneNode|| 7 | "undefined"==typeof c.createDocumentFragment||"undefined"==typeof c.createElement}g=b}catch(d){g=j=!0}})();var e={elements:k.elements||"abbr article aside audio bdi canvas data datalist details figcaption figure footer header hgroup mark meter nav output progress section summary time video",version:"3.6.2pre",shivCSS:!1!==k.shivCSS,supportsUnknownElements:g,shivMethods:!1!==k.shivMethods,type:"default",shivDocument:q,createElement:p,createDocumentFragment:function(a,b){a||(a=f);if(g)return a.createDocumentFragment(); 8 | for(var b=b||i(a),c=b.frag.cloneNode(),d=0,e=m(),h=e.length;d li { 78 | float: left; 79 | } 80 | .navbar-nav > li > a { 81 | padding: 15px; 82 | } 83 | 84 | /* Redeclare since we override the float above */ 85 | .navbar-nav.navbar-right { 86 | float: right; 87 | } 88 | 89 | /* Undo custom dropdowns */ 90 | .navbar .open .dropdown-menu { 91 | position: absolute; 92 | float: left; 93 | background-color: #fff; 94 | border: 1px solid #cccccc; 95 | border: 1px solid rgba(0, 0, 0, 0.15); 96 | border-width: 0 1px 1px; 97 | border-radius: 0 0 4px 4px; 98 | -webkit-box-shadow: 0 6px 12px rgba(0, 0, 0, 0.175); 99 | box-shadow: 0 6px 12px rgba(0, 0, 0, 0.175); 100 | } 101 | .navbar .open .dropdown-menu > li > a { 102 | color: #333; 103 | } 104 | .navbar .open .dropdown-menu > li > a:hover, 105 | .navbar .open .dropdown-menu > li > a:focus, 106 | .navbar .open .dropdown-menu > .active > a, 107 | .navbar .open .dropdown-menu > .active > a:hover, 108 | .navbar .open .dropdown-menu > .active > a:focus { 109 | color: #fff !important; 110 | background-color: #428bca !important; 111 | } 112 | .navbar .open .dropdown-menu > .disabled > a, 113 | .navbar .open .dropdown-menu > .disabled > a:hover, 114 | .navbar .open .dropdown-menu > .disabled > a:focus { 115 | color: #999 !important; 116 | background-color: transparent !important; 117 | } 118 | -------------------------------------------------------------------------------- /scripts/build_html_pages.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # This script builds the entire html page. 4 | # Assumes need to build from basic html, and construct custom-defined pages. 5 | # 6 | # When starting out, need to run a full nbconvert, and then pull out css and js 7 | # files into 'css' and 'js' directories, in the 'notebooks' dir. This is manual 8 | # right now, but it would be good to automate this and create a flag such as 9 | # '--initial'. 10 | # 11 | # Core of script involves running 12 | # 'ipython nbconvert --template intro_python_base.tpl' 13 | # Then adds appropriate sections through other templates, and scripting. 14 | # Also modifies some styles for better static html output. 15 | # Script is meant to be fairly straightforward to modify, so users can 16 | # build the static pages they care to make from the core notebooks. 17 | # 18 | # This is meant to work well through a post-commit-hook, although you can also 19 | # run the script manually when you want a snapshot of the notebooks in html 20 | # format. 21 | # 22 | # All html files are ignored by git. 23 | 24 | 25 | if [ -e scripts/ ] 26 | then 27 | # Probably running as a commit hook. 28 | path_to_scripts="scripts/" 29 | path_to_notebooks="notebooks/" 30 | else 31 | # Probably running directly from /scripts directory. 32 | path_to_scripts="" 33 | path_to_notebooks="../notebooks/" 34 | fi 35 | printf "\npath to scripts: $path_to_scripts" 36 | printf "\npath to notebooks: $path_to_notebooks\n" 37 | 38 | # Build basic pages. 39 | source "$path_to_scripts"create_common_html.sh 40 | wait 41 | 42 | # Add stylesheet to make output display initially on Mapping Global Earthquake Activity. 43 | printf "\n\nMake output display by default on specified notebooks..." 44 | #before_string="" 45 | before_string="" 46 | css_js_link_string="\n" 47 | sed -i "s/$before_string/$before_string\n\n$css_js_link_string\n/" "$path_to_notebooks/visualization_earthquakes.html" 48 | printf "\n Finished.\n\n" 49 | 50 | # Add elements to toggle output on each page. 51 | printf "Adding ability to toggle output on each page...\n" 52 | python "$prefix"show_hide_output.py 53 | wait 54 | printf " Added toggling ability.\n\n" 55 | 56 | # Convert index.html links to ./ 57 | source "$prefix"convert_home_links.sh 58 | wait 59 | 60 | # Highlight lines of code. 61 | python "$prefix"highlight_code.py 62 | wait 63 | 64 | # Highlight inline blocks of code. 65 | source "$prefix"highlight_inline_code.sh 66 | wait 67 | 68 | # Strip input references from code cells. 69 | python "$prefix"remove_input_references.py 70 | wait 71 | 72 | # Build index page. 73 | printf "\nBuilding index page...\n" 74 | python "$prefix"build_index.py 75 | wait 76 | printf " Built index page.\n" 77 | 78 | # Build all exercises page. 79 | # DEV: Holding off on this until project is more mature, 80 | # but don't want to lose sight of it. 81 | #python "$prefix"build_all_exercises_page.py 82 | #wait 83 | -------------------------------------------------------------------------------- /notebooks/index.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "Introduction to Python\n", 8 | "===\n", 9 | "Introduction to Python is a resource for students who want to learn Python as their first language, and for teachers who want a free and open curriculum to use with their students.\n", 10 | "\n", 11 | "If you are viewing the project through IPython Notebook Viewer, you might want to visit the student-facing pages at [introtopython.org](http://introtopython.org). There is a cleaner navigation there, and some better overall styling." 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": {}, 17 | "source": [ 18 | "Start Learning Python\n", 19 | "---\n", 20 | "If your computer is already set up to run Python programs, you can get started with [Hello World](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/hello_world.ipynb), your very first Python program." 21 | ] 22 | }, 23 | { 24 | "cell_type": "markdown", 25 | "metadata": {}, 26 | "source": [ 27 | "Set Up Your Programming Environment\n", 28 | "---\n", 29 | "If your computer is not yet set up to run Python programs, we can show you how to [get Python up and running](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/programming_environment.ipynb)." 30 | ] 31 | }, 32 | { 33 | "cell_type": "markdown", 34 | "metadata": {}, 35 | "source": [ 36 | "Contribute\n", 37 | "---\n", 38 | "If you already know Python and would like to help build Introduction to Python, see the project's [GitHub page](https://github.com/ehmatthes/intro_programming). You might want to look at [Issue 17](https://github.com/ehmatthes/intro_programming/issues/17), which discusses a few specific ways you can contribute to the project." 39 | ] 40 | }, 41 | { 42 | "cell_type": "markdown", 43 | "metadata": {}, 44 | "source": [ 45 | "Feedback\n", 46 | "---\n", 47 | "If you have any questions or comments, feel free to get in touch:\n", 48 | "\n", 49 | "Overall feedback: [Issue 10](https://github.com/ehmatthes/intro_programming/issues/10) on GitHub.\n", 50 | "Twitter: [@ehmatthes](https://twitter.com/ehmatthes)\n", 51 | "Email: ehmatthes at gmail dot com" 52 | ] 53 | }, 54 | { 55 | "cell_type": "markdown", 56 | "metadata": {}, 57 | "source": [ 58 | "About\n", 59 | "---\n", 60 | "I teach high school math and science, and I also teach an Introduction to Programming class each fall. This project started as a series of IPython Notebooks I wrote when teaching this year's programming class." 61 | ] 62 | } 63 | ], 64 | "metadata": { 65 | "kernelspec": { 66 | "display_name": "Python 3", 67 | "language": "python", 68 | "name": "python3" 69 | }, 70 | "language_info": { 71 | "codemirror_mode": { 72 | "name": "ipython", 73 | "version": 3 74 | }, 75 | "file_extension": ".py", 76 | "mimetype": "text/x-python", 77 | "name": "python", 78 | "nbconvert_exporter": "python", 79 | "pygments_lexer": "ipython3", 80 | "version": "3.4.3" 81 | } 82 | }, 83 | "nbformat": 4, 84 | "nbformat_minor": 0 85 | } 86 | -------------------------------------------------------------------------------- /notebooks/my_templates/index_body.html: -------------------------------------------------------------------------------- 1 |
2 |
3 |

Introduction to Python

4 |

Introduction to Python is a resource for students who want to learn Python as their first language, and for teachers who want a free and open curriculum to use with their students.

5 |
6 | 7 | 8 | 9 | 16 | 17 | 18 | 19 |

Start Learning Python

20 |

If your computer is already set up to run Python programs, you can get started with Hello World, your very first Python program.

21 |

Hello World »

22 | 23 |

Set Up Your Programming Environment

24 |

If your computer is not yet set up to run Python programs, we can show you how to get Python up and running.

25 |

Environment »

26 | 27 |

Contribute

28 |

If you already know Python and would like to help build Introduction to Python, see the project's GitHub page. You might want to look at Issue 17, which discusses a few specific ways you can contribute to the project.

29 |

Contribute »

30 | 31 |

Support

32 |

If you would like to support this project, you can visit my Gratipay page. Even if you don't support me specifically, you might want to check out the Gratipay homepage and about page. It's a wonderful and important project to be aware of.

33 |

Gratipay »

34 | 35 |

Feedback

36 |

If you have any questions or comments, feel free to get in touch:

37 |
    38 |
  • Overall feedback: Issue 10 on GitHub.
    • 39 |
  • Twitter: @ehmatthes 40 |
  • Email: ehmatthes at gmail dot com
    • 41 |
42 | 43 |

About

44 |

I teach high school math and science, and I also teach an Introduction to Programming class each fall. This project started as a series of IPython Notebooks I wrote when teaching this year's programming class.

45 | 46 |

47 |

48 | 49 |
50 | -------------------------------------------------------------------------------- /scripts/show_hide_output.py: -------------------------------------------------------------------------------- 1 | # This script runs through all the html files in notebooks/, and adds 2 | # in code to allow toggling of output. 3 | 4 | import os 5 | import re 6 | import sys 7 | 8 | # Find all files to work with. 9 | path_to_notebooks = '/srv/projects/intro_programming/intro_programming/notebooks/' 10 | filenames = [] 11 | for filename in os.listdir(path_to_notebooks): 12 | if '.html' in filename and filename != 'index.html': 13 | filenames.append(filename) 14 | 15 | # Test with one simple file. 16 | #filenames = ['hello_world.html'] 17 | 18 | 19 | def generate_button(id_number): 20 | # Generate the button code to place before each div.output 21 | button_string = "
\n" 22 | button_string += " \n" % (id_number, id_number) 23 | button_string += " \n" % (id_number, id_number) 24 | button_string += "
\n" 25 | return button_string 26 | 27 | def generate_show_hide_all_buttons(): 28 | # Generate the buttons that show or hide all output. 29 | button_string = "
\n" 30 | button_string += " \n" 31 | button_string += " \n" 32 | button_string += "
\n" 33 | return button_string 34 | 35 | # Determine which files have output. Only add buttons to files with output. 36 | files_with_output = [] 37 | for filename in filenames: 38 | f = open(path_to_notebooks + filename, 'r') 39 | lines = f.readlines() 40 | f.close() 41 | 42 | target_string = '
" in line or '
' in line: 64 | # Add show_all hide_all buttons in second container. 65 | container_number += 1 66 | f.write(line.encode('utf-8')) 67 | if container_number == 2: 68 | f.write(generate_show_hide_all_buttons().encode('utf-8')) 69 | 70 | elif target_string in line: 71 | # If this line has a div.output, add an id 72 | replacement_string = '
2 |
3 |
4 |
5 | 10 |
11 |
12 | 65 | 66 | {% include "my_templates/ignored_templates/twitter_buttons.html" ignore missing %} 67 | 68 |
69 |
70 |
71 | 72 |
73 | -------------------------------------------------------------------------------- /notebooks/js/respond.min.js: -------------------------------------------------------------------------------- 1 | /*! matchMedia() polyfill - Test a CSS media type/query in JS. Authors & copyright (c) 2012: Scott Jehl, Paul Irish, Nicholas Zakas. Dual MIT/BSD license */ 2 | /*! NOTE: If you're already including a window.matchMedia polyfill via Modernizr or otherwise, you don't need this part */ 3 | window.matchMedia=window.matchMedia||function(a){"use strict";var c,d=a.documentElement,e=d.firstElementChild||d.firstChild,f=a.createElement("body"),g=a.createElement("div");return g.id="mq-test-1",g.style.cssText="position:absolute;top:-100em",f.style.background="none",f.appendChild(g),function(a){return g.innerHTML='­',d.insertBefore(f,e),c=42===g.offsetWidth,d.removeChild(f),{matches:c,media:a}}}(document); 4 | 5 | /*! Respond.js v1.1.0: min/max-width media query polyfill. (c) Scott Jehl. MIT/GPLv2 Lic. j.mp/respondjs */ 6 | (function(a){"use strict";function x(){u(!0)}var b={};a.respond=b,b.update=function(){},b.mediaQueriesSupported=a.matchMedia&&a.matchMedia("only all").matches,b.mediaQueriesSupported;var q,r,t,c=a.document,d=c.documentElement,e=[],f=[],g=[],h={},i=30,j=c.getElementsByTagName("head")[0]||d,k=c.getElementsByTagName("base")[0],l=j.getElementsByTagName("link"),m=[],n=function(){for(var b=0;l.length>b;b++){var c=l[b],d=c.href,e=c.media,f=c.rel&&"stylesheet"===c.rel.toLowerCase();d&&f&&!h[d]&&(c.styleSheet&&c.styleSheet.rawCssText?(p(c.styleSheet.rawCssText,d,e),h[d]=!0):(!/^([a-zA-Z:]*\/\/)/.test(d)&&!k||d.replace(RegExp.$1,"").split("/")[0]===a.location.host)&&m.push({href:d,media:e}))}o()},o=function(){if(m.length){var a=m.shift();v(a.href,function(b){p(b,a.href,a.media),h[a.href]=!0,setTimeout(function(){o()},0)})}},p=function(a,b,c){var d=a.match(/@media[^\{]+\{([^\{\}]*\{[^\}\{]*\})+/gi),g=d&&d.length||0;b=b.substring(0,b.lastIndexOf("/"));var h=function(a){return a.replace(/(url\()['"]?([^\/\)'"][^:\)'"]+)['"]?(\))/g,"$1"+b+"$2$3")},i=!g&&c;b.length&&(b+="/"),i&&(g=1);for(var j=0;g>j;j++){var k,l,m,n;i?(k=c,f.push(h(a))):(k=d[j].match(/@media *([^\{]+)\{([\S\s]+?)$/)&&RegExp.$1,f.push(RegExp.$2&&h(RegExp.$2))),m=k.split(","),n=m.length;for(var o=0;n>o;o++)l=m[o],e.push({media:l.split("(")[0].match(/(only\s+)?([a-zA-Z]+)\s?/)&&RegExp.$2||"all",rules:f.length-1,hasquery:l.indexOf("(")>-1,minw:l.match(/\(min\-width:[\s]*([\s]*[0-9\.]+)(px|em)[\s]*\)/)&&parseFloat(RegExp.$1)+(RegExp.$2||""),maxw:l.match(/\(max\-width:[\s]*([\s]*[0-9\.]+)(px|em)[\s]*\)/)&&parseFloat(RegExp.$1)+(RegExp.$2||"")})}u()},s=function(){var a,b=c.createElement("div"),e=c.body,f=!1;return b.style.cssText="position:absolute;font-size:1em;width:1em",e||(e=f=c.createElement("body"),e.style.background="none"),e.appendChild(b),d.insertBefore(e,d.firstChild),a=b.offsetWidth,f?d.removeChild(e):e.removeChild(b),a=t=parseFloat(a)},u=function(a){var b="clientWidth",h=d[b],k="CSS1Compat"===c.compatMode&&h||c.body[b]||h,m={},n=l[l.length-1],o=(new Date).getTime();if(a&&q&&i>o-q)return clearTimeout(r),r=setTimeout(u,i),void 0;q=o;for(var p in e)if(e.hasOwnProperty(p)){var v=e[p],w=v.minw,x=v.maxw,y=null===w,z=null===x,A="em";w&&(w=parseFloat(w)*(w.indexOf(A)>-1?t||s():1)),x&&(x=parseFloat(x)*(x.indexOf(A)>-1?t||s():1)),v.hasquery&&(y&&z||!(y||k>=w)||!(z||x>=k))||(m[v.media]||(m[v.media]=[]),m[v.media].push(f[v.rules]))}for(var B in g)g.hasOwnProperty(B)&&g[B]&&g[B].parentNode===j&&j.removeChild(g[B]);for(var C in m)if(m.hasOwnProperty(C)){var D=c.createElement("style"),E=m[C].join("\n");D.type="text/css",D.media=C,j.insertBefore(D,n.nextSibling),D.styleSheet?D.styleSheet.cssText=E:D.appendChild(c.createTextNode(E)),g.push(D)}},v=function(a,b){var c=w();c&&(c.open("GET",a,!0),c.onreadystatechange=function(){4!==c.readyState||200!==c.status&&304!==c.status||b(c.responseText)},4!==c.readyState&&c.send(null))},w=function(){var b=!1;try{b=new a.XMLHttpRequest}catch(c){b=new a.ActiveXObject("Microsoft.XMLHTTP")}return function(){return b}}();n(),b.update=n,a.addEventListener?a.addEventListener("resize",x,!1):a.attachEvent&&a.attachEvent("onresize",x)})(this); 7 | -------------------------------------------------------------------------------- /notebooks/syllabus.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "metadata": { 3 | "name": "syllabus" 4 | }, 5 | "nbformat": 3, 6 | "nbformat_minor": 0, 7 | "worksheets": [ 8 | { 9 | "cells": [ 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Syllabus\n", 15 | "===" 16 | ] 17 | }, 18 | { 19 | "cell_type": "markdown", 20 | "metadata": {}, 21 | "source": [ 22 | "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb)" 23 | ] 24 | }, 25 | { 26 | "cell_type": "markdown", 27 | "metadata": {}, 28 | "source": [ 29 | "Introduction\n", 30 | "---\n", 31 | "- What is programming?\n", 32 | "- What is not programming?\n", 33 | "- what kinds of things can programmers build?" 34 | ] 35 | }, 36 | { 37 | "cell_type": "markdown", 38 | "metadata": {}, 39 | "source": [ 40 | "Setting up our programming environment\n", 41 | "---\n", 42 | "- [Programming Environment](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/programming_environment.ipynb)\n", 43 | " - Dual-booting Ubuntu\n", 44 | " - Maintaining Ubuntu\n", 45 | " - Configuring Ubuntu for Python 3.3" 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "metadata": {}, 51 | "source": [ 52 | "Python Basics\n", 53 | "---\n", 54 | "- [Hello World](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/hello_world.ipynb)\n", 55 | "- [Variables, strings, and Numbers](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/var_string_num.ipynb)\n", 56 | "- [Lists and Tuples](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/lists_tuples.ipynb)\n", 57 | "- [Introducing Functions](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/introducing_functions.ipynb)\n", 58 | "- [If Statements](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/if_statements.ipynb)\n", 59 | "- [While Loops and Input](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/while_input.ipynb)\n", 60 | "- [Basic Terminal Apps](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/terminal_apps.ipynb)\n", 61 | "- [Dictionaries](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/dictionaries.ipynb)\n", 62 | "- [More Functions](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/more_functions.ipynb)\n", 63 | "- [Classes](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/classes.ipynb)\n", 64 | "- [Exceptions](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/exceptions.ipynb)\n", 65 | "- [Testing](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/testing.ipynb)" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "Projects in Python\n", 73 | "---\n", 74 | "- Text-based Adventure Game\n", 75 | "- Video Game\n", 76 | " - 2-dimensional, straight-line motion game\n", 77 | "- Visualization\n", 78 | " - see [Data is Beautiful](http://www.reddit.com/r/dataisbeautiful) for examples\n", 79 | " - [Mapping Global Earthquake Activity](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/visualization_earthquakes.ipynb)\n", 80 | "- Simple web application\n", 81 | " - for example, a blog that you can make posts to" 82 | ] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": {}, 87 | "source": [ 88 | "- - -\n", 89 | "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb)" 90 | ] 91 | } 92 | ], 93 | "metadata": {} 94 | } 95 | ] 96 | } -------------------------------------------------------------------------------- /notebooks/web_apps.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "metadata": { 3 | "name": "" 4 | }, 5 | "nbformat": 3, 6 | "nbformat_minor": 0, 7 | "worksheets": [ 8 | { 9 | "cells": [ 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Web Applications\n", 15 | "===\n", 16 | "Many people who want to learn Python these days are looking to write web applications. Web apps are web sites that do something unique. If you understand how to develop web apps, you can ask for any input you want from users, and you can do just about anything you want with that input." 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb)" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "Contents\n", 31 | "===\n", 32 | "- [What is a web app?](#what)\n", 33 | "- [How web appts work](#how)\n", 34 | "- [Python web frameworks](#python_frameworks)" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": {}, 40 | "source": [ 41 | "[top](#)" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "What is a web app?\n", 49 | "---\n", 50 | "A web app takes in data from users, and does something with that data. There are all kinds of examples of web apps:\n", 51 | "\n", 52 | "- [Dropbox](http://dropbox.com) takes in files from users, and makes them available to that user and perhaps other users.\n", 53 | "- [Gittip](http://gittip.org) allows people to create recurring tips to people who are doing projects that benefit others.\n", 54 | "- [Twitter](http://twitter.com) allows people to send short messages to followers.\n", 55 | "\n", 56 | "These examples all go beyond just managing content online. If you are just looking to manage content, you should be looking at a content-management system (CMS)." 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "[top](#)" 64 | ] 65 | }, 66 | { 67 | "cell_type": "markdown", 68 | "metadata": {}, 69 | "source": [ 70 | "How web apps work\n", 71 | "---\n", 72 | "Web apps tie together lots of different kinds of programming. To understand what kinds of things you will get into in creating a web app, consider how a typical app works:\n", 73 | "\n", 74 | "- Pull together different bits of data in order to present a set of pages to the user\n", 75 | "- Take in new data from the user\n", 76 | "- Clean and process all data that is received\n", 77 | "- Store relevant parts of the data in a database\n", 78 | "\n", 79 | "In order to make all of this happen, you need to develop some understanding of:\n", 80 | "\n", 81 | "- Web architecture (html, css, javascript)\n", 82 | "- Web protocols (http requests)\n", 83 | "- Security issues (unpredictable and untrustworthy data, ongoing attacks by countless bots)\n", 84 | "- Database maintenance issues\n", 85 | "- Server infrastructure\n", 86 | "\n", 87 | "Modern frameworks take care of a lot of the lower-level details of these aspects, but if you are going to make decent web apps you will end up learning a good deal about all of this. The good news is it can be pretty interesting, and even fun to pull all of these pieces together to solve real problems for your users." 88 | ] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "[top](#)" 95 | ] 96 | }, 97 | { 98 | "cell_type": "markdown", 99 | "metadata": {}, 100 | "source": [ 101 | "Python web frameworks\n", 102 | "---\n", 103 | "Python has a number of frameworks that can help you create and maintain a web app:\n", 104 | "\n", 105 | "- Django\n", 106 | "- Flask\n", 107 | "- Pyramid" 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "- - -\n", 115 | "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb)" 116 | ] 117 | } 118 | ], 119 | "metadata": {} 120 | } 121 | ] 122 | } -------------------------------------------------------------------------------- /notebooks/resources.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "metadata": { 3 | "name": "", 4 | "signature": "sha256:03447244b00fb07cf98b889b75f7fab4e489c8c614a7d3880a264f6cbe54caed" 5 | }, 6 | "nbformat": 3, 7 | "nbformat_minor": 0, 8 | "worksheets": [ 9 | { 10 | "cells": [ 11 | { 12 | "cell_type": "markdown", 13 | "metadata": {}, 14 | "source": [ 15 | "Resources\n", 16 | "---\n", 17 | "\n" 18 | ] 19 | }, 20 | { 21 | "cell_type": "markdown", 22 | "metadata": {}, 23 | "source": [ 24 | "A preliminary list of tutorials, talks, and challenges is provided below. This page will be updated frequently.\n" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "Documentation\n", 32 | "---\n", 33 | "\n", 34 | "For information related to Python programming, always refer to the [official Python documentation](https://docs.python.org/3/) (v3.4)." 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": {}, 40 | "source": [ 41 | "---" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "Tutorials\n", 49 | "--\n", 50 | "\n", 51 | "- Google Python class - YouTube videos\n", 52 | "\n", 53 | " [Part 1(1)](https://www.youtube.com/watch?v=tKTZoB2Vjuk) - Introduction to Python and strings\n", 54 | " \n", 55 | " [Part 1(2)](https://www.youtube.com/watch?v=EPYupizJYQI) - Working with lists, tuples and sorting\n", 56 | " \n", 57 | " [Part 1(3)](https://www.youtube.com/watch?v=haycL41dAhg) - Working with dictionaries and files\n", 58 | " \n", 59 | " [Part 2(1)](https://www.youtube.com/watch?v=kWyoYtvJpe4) - Regular expressions\n", 60 | " \n", 61 | " [Part 2(2)](https://www.youtube.com/watch?v=uKZ8GBKmeDM) - Using modules, system commands\n", 62 | " \n", 63 | " [Part 2(3)](https://www.youtube.com/watch?v=Nn2KQmVF5Og) - Exceptions, parsing URLs\n", 64 | " \n", 65 | " [Part 2(4)](https://www.youtube.com/watch?v=IcteAbMC1Ok) - List comprehensions\n", 66 | "\n", 67 | "\n", 68 | "- [Guide for beginners who are non-programmers](https://wiki.python.org/moin/BeginnersGuide/NonProgrammers)\n", 69 | "\n", 70 | " Python's wiki page lists several resources for beginners.\n", 71 | "\n", 72 | "\n", 73 | "- [Python Tutor](http://pythontutor.com/)\n", 74 | "\n", 75 | " Python Tutor visually helps understand how code executes on a computer." 76 | ] 77 | }, 78 | { 79 | "cell_type": "markdown", 80 | "metadata": {}, 81 | "source": [ 82 | "---" 83 | ] 84 | }, 85 | { 86 | "cell_type": "markdown", 87 | "metadata": {}, 88 | "source": [ 89 | "Talks\n", 90 | "--\n", 91 | "\n", 92 | "Pyvideos - Videos related to Python programming in different events including [Pycon](http://www.pycon.org/), [Scipy](https://conference.scipy.org/).\n", 93 | "\n", 94 | "Example: [Fast Python, Slow Python at Pycon 2014](http://pyvideo.org/video/2627/fast-python-slow-python)" 95 | ] 96 | }, 97 | { 98 | "cell_type": "markdown", 99 | "metadata": {}, 100 | "source": [ 101 | "---" 102 | ] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "metadata": {}, 107 | "source": [ 108 | "Challenges\n", 109 | "--\n", 110 | "\n", 111 | "If you are equipped with basics of Python, taking up challenges is a great way to implement the skills.\n", 112 | "\n", 113 | "- [Google Python class exercises](https://developers.google.com/edu/python/exercises/basic)\n", 114 | "\n", 115 | " Four exercises are provided as part of the Python class by Google. \n", 116 | " \n", 117 | " Level - Basic/intermediate\n", 118 | " \n", 119 | "\n", 120 | "- [Project Euler](https://projecteuler.net/)\n", 121 | "\n", 122 | " Project Euler is a project of mathematical/programming challenges aimed at designing efficient solutions. Project Euler is a good place to challenge your mathematical and programming skills. Most of the problems can be solved within few seconds provided you have an efficient solution.\n", 123 | "\n", 124 | " Level - Advanced | Requires knowledge of mathematics.\n", 125 | "\n", 126 | "\n", 127 | "- [Python Challenge](http://www.pythonchallenge.com/)\n", 128 | "\n", 129 | " Level - Intermediate/Advanced\n", 130 | "\n", 131 | "\n", 132 | "\n" 133 | ] 134 | } 135 | ], 136 | "metadata": {} 137 | } 138 | ] 139 | } 140 | -------------------------------------------------------------------------------- /tests/test_links.py: -------------------------------------------------------------------------------- 1 | import requests 2 | import re 3 | import os, subprocess, signal, sys 4 | from getopt import getopt 5 | from time import sleep 6 | 7 | # This test runs through all html files in /notebooks, 8 | # and verifies that links are working. 9 | 10 | # to do 11 | # check anchor tags as well 12 | # accept flag to check deployed pages 13 | # should I be using beautifulsoup to parse html? 14 | 15 | # Get command-line arguments 16 | # -r --root: The root directory that files are served from 17 | # (not yet implemented) -d --directory: The directory where files are stored locally 18 | # Should clarify that this test currently pulls links from local files, 19 | # but can test deployed version of files. That only makes sense 20 | # if deployed version matches current local version. 21 | # Should either pull links locally, and test locally, or 22 | # pull from deployed site, and test deployed site. 23 | 24 | root = 'http://localhost:8000/' 25 | opts, args = getopt(sys.argv[1:], "r:", ["root=",]) 26 | for opt, arg in opts: 27 | if opt in ('--root', '-r'): 28 | root = arg + '/' 29 | print("Using root: ", root) 30 | 31 | 32 | def get_links_in_line(line): 33 | # Returns a list of links contained in a line of code. 34 | links = [] 35 | 36 | # Split lines so they start with links. 37 | # ie, segments will be ~ ="hello_world.html">blah 38 | link_re = """=(["'])(.*?)(["'].*)""" 39 | p = re.compile(link_re) 40 | for segment in line.split('a href'): 41 | m = p.match(segment) 42 | if m: 43 | #print 'match: ', m.group(2) 44 | links.append(m.group(2)) 45 | return links 46 | 47 | def get_links_in_file(root_dir, filename): 48 | # Returns a list of all the links in a file. 49 | f = open(root_dir + filename, 'r') 50 | lines = f.readlines() 51 | f.close() 52 | 53 | links_to_check = [] 54 | for line in lines: 55 | if 'a href' in line: 56 | for link in get_links_in_line(line): 57 | # Ignore anchor tags for now 58 | if 'html' in link: 59 | links_to_check.append(link) 60 | return links_to_check 61 | 62 | def check_links(filename, links, bad_links, links_tested): 63 | # Checks all links given, and adds bad links to bad_links. 64 | print("links to check: ", links) 65 | for link in links: 66 | print("Checking link: %s..." % link) 67 | 68 | # Only check links that haven't already been checked: 69 | if link in links_tested: 70 | continue 71 | 72 | # External links don't need our root. 73 | if 'http' in link: 74 | url = link 75 | else: 76 | url = root + link 77 | print('checking url: ', url) 78 | r = requests.get(url) 79 | print('Status code: ', r.status_code) 80 | if r.status_code != 200: 81 | bad_links[filename + '---' + link] = r.status_code 82 | else: 83 | links_tested.append(link) 84 | 85 | # Location of html files 86 | # Assume all files in this directory, no nesting 87 | root_dir = '/srv/projects/intro_programming/intro_programming/notebooks/' 88 | 89 | # Get all html filenames in this directory. 90 | # Use os.walk if files end up nested. 91 | filenames = [] 92 | for filename in os.listdir(root_dir): 93 | if 'html' in filename: 94 | filenames.append(filename) 95 | 96 | 97 | # Start a server locally, in the notebooks directory. 98 | print("Starting server...") 99 | cmd = 'chdir /srv/projects/intro_programming/intro_programming/notebooks/ && ' 100 | cmd += 'python -m SimpleHTTPServer' 101 | pro = subprocess.Popen(cmd, shell=True, preexec_fn=os.setsid) 102 | 103 | # Make sure server has a chance to start before making request. 104 | print("SLEEPING...") 105 | sleep(1) 106 | 107 | # Report on progress as test runs, but store bad links for final report. 108 | # dict: {page---link: status_code} 109 | bad_links = {} 110 | 111 | # Only test each unique link once. 112 | links_tested = [] 113 | num_links_checked = 0 114 | 115 | # Check links in all files. 116 | #filenames = ['var_string_num.html'] 117 | for filename in filenames: 118 | links_to_check = get_links_in_file(root_dir, filename) 119 | check_links(filename, links_to_check, bad_links, links_tested) 120 | num_links_checked += len(links_to_check) 121 | 122 | # Kill the server process 123 | os.killpg(pro.pid, signal.SIGTERM) 124 | 125 | # Report on bad links. 126 | print("\n\n*** Bad Links ***") 127 | if bad_links: 128 | for link in bad_links: 129 | print('\n', bad_links[link], link) 130 | else: 131 | print("Congratulations, all links are working.") 132 | print("\n") 133 | 134 | print("Checked %d links." % num_links_checked) 135 | print("Tested %d unique links." % len(links_tested)) 136 | -------------------------------------------------------------------------------- /scripts/highlight_code.py: -------------------------------------------------------------------------------- 1 | # This script runs through all the html files in notebooks/, and 2 | # converts `###highlight=[1,2,10,11,12]` directives to style directives 3 | # for highlighting lines of code in code cells. 4 | 5 | # To highlight lines of code in a cell, add a comment on the first 6 | # line of the cell, starting with three pound symbols, the word 7 | # 'highlight', and an equals sign with no space. Then write a Python 8 | # list, with each line to be highlighted listed. The script only reads 9 | # comma-separated values, not grouped values. 10 | 11 | # yes: '###highlight=[1,2,7,8,9]' 12 | # no: '###highlight=[1,2,7-9]' 13 | 14 | # You can turn line numbering on in the notebook, and just use the line 15 | # numbers that are displayed. The script adjusts for the first line 16 | # being taken up by the ###highlight= comment. The script also removes 17 | # the ###highlight= comment from the html file, but does not remove 18 | # the highlighting directive from the notebook itself. 19 | 20 | # The script adds the style directive 21 | #
...current code html...
22 | # to the selected code lines. 23 | 24 | # The script assumes all html files are not nested, in a directory called 25 | # 'notebooks'. 26 | 27 | # You will need to specificy path_to_notebooks. 28 | # I'm happy to hear feedback, and accept improvements: 29 | # https://github.com/ehmatthes/intro_programming 30 | # ehmatthes@gmail.com, @ehmatthes 31 | 32 | 33 | import os, sys 34 | import ast 35 | 36 | print("\nHighlighting code...") 37 | 38 | # Find all files to work with. 39 | # Replace with your path. 40 | path_to_notebooks = '/srv/projects/intro_programming/intro_programming/notebooks/' 41 | 42 | filenames = [] 43 | for filename in os.listdir(path_to_notebooks): 44 | if '.html' in filename and filename != 'index.html': 45 | filenames.append(filename) 46 | 47 | # Uncomment to use just one file for testing: 48 | #filenames = ['visualization_earthquakes.html'] 49 | 50 | 51 | # Process each file. 52 | for filename in filenames: 53 | 54 | # Grab the lines from this html file. 55 | f = open(path_to_notebooks + filename, 'r') 56 | lines = f.readlines() 57 | f.close() 58 | 59 | # Open the file for rewriting. 60 | f = open(path_to_notebooks + filename, 'wb') 61 | 62 | # Create an empty list for the lines that will need to be highlighted. 63 | highlight_lines = [] 64 | # True when in a code block that has some highlighting left to be done. 65 | highlighting_active = False 66 | 67 | # Next line to highlight; starts at 0 in each code block. 68 | # This takes into account the ###highlight= line, so you don't have 69 | # to do a bunch of subtracting while composing notebooks. 70 | highlight_line = None 71 | 72 | for line in lines: 73 | if '###highlight' in line: 74 | # Get lines to highlight, stored as a list. 75 | # Lines are in a list, after the equals sign. 76 | try: 77 | highlight_lines = ast.literal_eval(line[line.index('highlight=')+10:line.index(']')+1]) 78 | except: 79 | print("Problem finding lines to highlight in %s near line %d" % (filename, lines.index(line))) 80 | 81 | # We have some lines to highlight. Start tracking lines, 82 | # and highlight appropriate lines. 83 | line_number = 0 84 | highlighting_active = True 85 | 86 | if highlighting_active: 87 | # We are in a code block, with some lines left to highlight. 88 | if line_number == 0: 89 | # We are on the ###highlight= line, and we don't need this entire line. 90 | # We do need some of the line, which sets up the code block. 91 | # sample line: 
###highlight=[2,3]
 92 |                 # becomes: 
 93 |                 # keep until start of '>>\n",
 57 |     "From this output, we can see that Python is installed, and the currently installed version is Python 2.7.6. You're now running a Python terminal session. You can start typing Python commands here, and you'll see your output immediately:\n",
 58 |     "\n",
 59 |     "    >>> print(\"Hello Python world!\")\n",
 60 |     "    Hello Python world!\n",
 61 |     "    >>> "
 62 |    ]
 63 |   },
 64 |   {
 65 |    "cell_type": "markdown",
 66 |    "metadata": {},
 67 |    "source": [
 68 |     "Installing Python 3\n",
 69 |     "---\n",
 70 |     "There's a small chance Python 3 is already installed on your system. To find out, open a terminal and enter the command `python3`. You'll probably get an error message. If you find that Python 3 is already installed, you can skip ahead to the section about [installing Sublime Text](Installing-Sublime-Text).\n",
 71 |     "\n",
 72 |     "### Installing Homebrew\n",
 73 |     "[*Homebrew*](http://brew.sh) is a package manager for OS X, which makes it easy to set up a development environment on your system. Homebrew depends on Apple's xcode, so open a terminal and issue the following command:\n",
 74 |     "\n",
 75 |     "    $ xcode-select --install\n",
 76 |     "This command will take a little while to run, depending on your connection speed. When it's finished, you can install Homebrew:\n",
 77 |     "\n",
 78 |     "    $ ruby -e \"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)\"\n",
 79 |     "This will install Homebrew, which is written in the Ruby programming language. Be careful when running commands like this; the `-e` flag tells your system to execute whatever follows. You should only execute code that you download from a trusted source. If you have any doubts about this, visit the [Homebrew](http://brew.sh) site yourself and follow the instructions there.\n",
 80 |     "\n",
 81 |     "Once you have Homebrew installed, check its status and then install Python 3:\n",
 82 |     "\n",
 83 |     "    $ brew doctor\n",
 84 |     "    Your system is ready to brew.\n",
 85 |     "    $ brew install python3\n",
 86 |     "Now you should be able to run Python 3 in a terminal session:\n",
 87 |     "\n",
 88 |     "    $ python3\n",
 89 |     "    >>> print(\"Hello Python 3 World!\")\n",
 90 |     "    Hello Python 3 World!\n",
 91 |     "    >>>\n",
 92 |     "To leave the Python session and return to a terminal prompt, enter Command-D."
 93 |    ]
 94 |   },
 95 |   {
 96 |    "cell_type": "markdown",
 97 |    "metadata": {},
 98 |    "source": [
 99 |     "[top](#)"
100 |    ]
101 |   },
102 |   {
103 |    "cell_type": "markdown",
104 |    "metadata": {},
105 |    "source": [
106 |     "Installing Sublime Text\n",
107 |     "===\n",
108 |     "Sublime Text is a simple text editor, which makes it easy to run Python programs. Output is displayed in an embedded terminal window, which allows you to easily see the results of your programs. Sublime Text is not free software, but it has a liberal trial policy. Try it out; if you like it, please purchase a license. Sublime Text is one of the few editors that's friendly enough to be perfectly appropriate for beginners, but fully-featured enough for many professionals as well.\n",
109 |     "\n",
110 |     "To install Sublime Text, go to the [Downloads](http://www.sublimetext.com/3) page, and click on the OS X installer. Once it's installed, you should be ready to write [Hello World](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/hello_world.ipynb), your first Python program."
111 |    ]
112 |   },
113 |   {
114 |    "cell_type": "markdown",
115 |    "metadata": {},
116 |    "source": [
117 |     "[top](#)"
118 |    ]
119 |   },
120 |   {
121 |    "cell_type": "markdown",
122 |    "metadata": {},
123 |    "source": [
124 |     "- - -\n",
125 |     "[Previous: Programming Environment](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/programming_environment.ipynb) | \n",
126 |     "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb) | \n",
127 |     "[Next: Hello World](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/hello_world.ipynb)"
128 |    ]
129 |   }
130 |  ],
131 |  "metadata": {
132 |   "kernelspec": {
133 |    "display_name": "Python 3",
134 |    "language": "python",
135 |    "name": "python3"
136 |   },
137 |   "language_info": {
138 |    "codemirror_mode": {
139 |     "name": "ipython",
140 |     "version": 3
141 |    },
142 |    "file_extension": ".py",
143 |    "mimetype": "text/x-python",
144 |    "name": "python",
145 |    "nbconvert_exporter": "python",
146 |    "pygments_lexer": "ipython3",
147 |    "version": "3.4.3"
148 |   }
149 |  },
150 |  "nbformat": 4,
151 |  "nbformat_minor": 0
152 | }
153 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | A collection of IPython Notebooks for teaching Python.
  2 | ---
  3 | 
  4 | This project is the basis of [introtopython.org](http://introtopython.org), an open resource for teaching and learning Python. The site teaches the basics of Python, and then teaches people to build projects in Python. If you know how to work with IPython notebooks, you can contribute to the project.
  5 | 
  6 | You can also view the raw notebooks using the IPython Notebook Viewer ([home page](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb). The content is almost identical on both sites, but the [introtopython.org](http://introtopython.org) version is easier to navigate, and has some dynamic js features such as collapsible output.
  7 | 
  8 | Contents
  9 | ---
 10 | - [Goals](#goals)
 11 | - [Contributing - Brief](#contributing)
 12 |     - [Using Miniconda to set up a development environment](#miniconda)
 13 |     - [Using virtualenv to set up a development environment](#virtualenv)
 14 |     - [Open the notebooks](#open_notebooks)
 15 |     - [Creating html versions of the notebooks](#html)
 16 |     - [Editing Python 2.7 examples](#python2.7)
 17 |     - [Questions](#questions)
 18 | 
 19 | Goals:
 20 | ---
 21 | - Introduce students as quickly as possible to the basics of programming, and then help them choose an interesting project that they're capable of completing.
 22 | - Introduce best practice as early as possible, while remaining accessible to students with no background in programming at all.
 23 | - Help teachers who know little about programming start teaching Python to their students.
 24 | - Make it easy for experienced Python programmers to conduct a code review of the project.
 25 | 
 26 | Contributing - Brief:
 27 | ---
 28 | Contributing to this project requires IPython version 3.0 or higher. These instructions are written based on setting up a development environment on Ubuntu 14.04, but they should be adaptable to any modern system with a Python environment already set up. If you have any questions about getting your development environment set up for contributing to this project, please drop a note in [Issue 11](https://github.com/ehmatthes/intro_programming/issues/11), or get in touch with me directly. I can be reached by email, ehmatthes at gmail, or on twitter [@ehmatthes](https://twitter.com/ehmatthes).
 29 | 
 30 | If you would like to start contributing and aren't sure what to do, there is a list of places to start in [Issue 17](https://github.com/ehmatthes/intro_programming/issues/17).
 31 | 
 32 | These notebooks are written primarily in Python 3. If the default Python on your system is Python 3, then you'll have a simpler time contributing to the project. If you only have Python 2, you might want to consider adding Python 3 to your system. You can contribute to the project using Python 2, since there is so much overlap between the two versions of Python, especially when working on the more basic notebooks. To fully contribute to the project, you will need to have both Python 2 and Python 3 available.
 33 | 
 34 | ### Using Miniconda to set up a development environment
 35 | 
 36 | The first visualization project ([Mapping Global Earthquake Activity](http://introtopython.org/visualization_earthquakes)) uses packages that are most conveniently installed using Conda.
 37 | 
 38 | The easiest way to do this is using Miniconda. Go to the [Miniconda home page](http://conda.pydata.org/miniconda.html). Download and run the appropriate installer for your system. The following commands will get conda set up on a 32-bit Linux system:
 39 | 
 40 |     ~$ wget http://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86.sh
 41 |     ~$ bash Miniconda3-latest-Linux-x86.sh
 42 |     ~$   # Say yes to the prompt for prepending Miniconda3 install location to PATH
 43 |     ~$ exec bash
 44 | 
 45 | #### Create a conda environment
 46 | Once you've got conda installed, use it to make an environment for this project. Make a directory for this project, and start a conda environment that includes ipython and ipython notebook:
 47 | 
 48 |     $ mkdir introprogramming && cd introprogramming
 49 |     intro_programming$ conda create -n ip_env python=3 ipython ipython-notebook
 50 |     intro_programming$ source activate ip_env
 51 |     (ip_env)intro_programming$ 
 52 | 
 53 | From this point, the project works the same as using virtualenv. Skip ahead to [Open the notebooks](#open_notebooks)
 54 | 
 55 | ### Using virtualenv to set up a development environment
 56 | You can also use virtualenv to set up a development environment.
 57 | 
 58 | #### Install pandoc
 59 | Pandoc is used by IPython Notebook to convert from the *.ipynb* format to *.html*.
 60 | 
 61 |     $ sudo apt-get install pandoc
 62 | 
 63 | Now we'll set up the virtualenv:
 64 | 
 65 |     $ mkdir intro_programming && cd intro_programming
 66 |     intro_programming$ virtualenv -p python3 venv
 67 |     intro_programming$ source venv/bin/activate
 68 |     (venv)intro_programming$ git clone https://github.com/ehmatthes/intro_programming
 69 | 
 70 |     # Required to access the notebooks:
 71 |     (venv)intro_programming$ pip install ipython[all]==3 jsonschema
 72 | 
 73 |     # Required for testing links within the project:
 74 |     (venv)intro_programming$ pip install requests==2.0.0
 75 | 
 76 | ### Open the notebooks:
 77 |     (venv)intro_programming$ cd intro_programming/notebooks
 78 |     (venv)intro_programming/intro_programming/notebooks$ ipython notebook
 79 | 
 80 | This will open a browser, and you can click on the notebook you'd like to edit.
 81 | 
 82 | #### Creating html versions of the notebooks:
 83 | 
 84 |     (venv)intro_programming$ cd intro_programming/scripts
 85 |     (venv)intro_programming/intro_programming/scripts$ ./build_html_pages
 86 | 
 87 | After this, you should see an .html file for each .ipynb file in the `notebooks` directory. The html files are ignored by git for this project. If you want to build your own custom site based off this project, look at the source for `/scripts/build_html_pages.sh`. If you're not sure how to modify the script for your own purposes, I'm happy to help clarify how the conversion process works.
 88 | 
 89 | #### View your html pages
 90 | To view your html pages, start a server in the intro_programming/notebooks directory, and then access the pages locally:
 91 | 
 92 |     (venv)intro_programming$ cd intro_programming/notebooks
 93 |     (venv)intro_programming/intro_programming/notebooks$ python -m http.server
 94 | 
 95 | Then go to [http://localhost:8000](http://localhost:8000), and you should see the index page. (By the way, if you're using an index page with social plugins, you can see all the people who have accidentally tweeted or shared a local development version of their project. :)
 96 | 
 97 | ### Editing Python 2.7 examples
 98 | 
 99 | To edit the Python 2 examples in some of the notebooks, it's helpful to have a separate virtualenv that is built using Python 2.7. The steps to set up this virtualenv are identical to the steps above, except
100 | 
101 |     $ mkdir intro_programming && cd intro_programming
102 |     intro_programming$ virtualenv -p python3 venv
103 | 
104 | becomes
105 | 
106 |     $ mkdir intro_programming2.7 && cd intro_programming2.7
107 |     intro_programming2.7$ virtualenv -p python2.7 venv
108 | 
109 | There may be a bit more involved in a full setup, depending on which versions of Python you have on your system, but that should get you up and running.
110 | 
111 | ### Questions
112 | If you have any questions about getting the project running locally, drop a note in [Issue 11](https://github.com/ehmatthes/intro_programming/issues/11), or get in touch with me directly. I can be reached by email, ehmatthes at gmail, or on twitter [@ehmatthes](https://twitter.com/ehmatthes).
113 | 
114 | Thanks for looking!
115 | 


--------------------------------------------------------------------------------
/notebooks/programming_environment_linux.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "Programming Environment: Linux\n",
  8 |     "===\n",
  9 |     "This section will show you how to run your first Python program on a Linux computer."
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "[Previous: Programming Environment](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/programming_environment.ipynb) | \n",
 17 |     "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb) | \n",
 18 |     "[Next: Hello World](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/hello_world.ipynb)"
 19 |    ]
 20 |   },
 21 |   {
 22 |    "cell_type": "markdown",
 23 |    "metadata": {},
 24 |    "source": [
 25 |     "Contents\n",
 26 |     "===\n",
 27 |     "- [Python on Linux](#Python-on-Linux)\n",
 28 |     "- [Installing Python](#Installing-Python)\n",
 29 |     "    - [Python 3](#Python-3)\n",
 30 |     "    - [Installing Python 3](#Installing-Python-3)\n",
 31 |     "- [Installing Geany](#Installing-Geany)\n",
 32 |     "    - [Configuring Geany to use Python 3](#Configuring-Geany-to-use-Python-3)"
 33 |    ]
 34 |   },
 35 |   {
 36 |    "cell_type": "markdown",
 37 |    "metadata": {},
 38 |    "source": [
 39 |     "Python on Linux\n",
 40 |     "===\n",
 41 |     "Python on Linux is pretty straightforward, because the people who develop Linux want you to write your own programs."
 42 |    ]
 43 |   },
 44 |   {
 45 |    "cell_type": "markdown",
 46 |    "metadata": {},
 47 |    "source": [
 48 |     "Installing Python\n",
 49 |     "===\n",
 50 |     "Python is probably already installed on your system. To find out if it is installed, open a terminal and type the word `python`. You'll probably see output that looks something like this:"
 51 |    ]
 52 |   },
 53 |   {
 54 |    "cell_type": "markdown",
 55 |    "metadata": {},
 56 |    "source": [
 57 |     "    $ python\n",
 58 |     "    Python 2.7.6 (default, Mar 22 2014, 22:59:38) \n",
 59 |     "    [GCC 4.8.2] on linux2\n",
 60 |     "    Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
 61 |     "    >>> "
 62 |    ]
 63 |   },
 64 |   {
 65 |    "cell_type": "markdown",
 66 |    "metadata": {},
 67 |    "source": [
 68 |     "From this output, we can see that Python is installed, and the currently installed version is Python 2.7.6. You're now running a Python terminal session. You can start typing Python commands here, and you'll see your output immediately:"
 69 |    ]
 70 |   },
 71 |   {
 72 |    "cell_type": "markdown",
 73 |    "metadata": {},
 74 |    "source": [
 75 |     "    >>> print(\"Hello Python world!\")\n",
 76 |     "    Hello Python world!\n",
 77 |     "    >>> "
 78 |    ]
 79 |   },
 80 |   {
 81 |    "cell_type": "markdown",
 82 |    "metadata": {},
 83 |    "source": [
 84 |     "To exit the Python session and return to a terminal prompt, enter Control-D."
 85 |    ]
 86 |   },
 87 |   {
 88 |    "cell_type": "markdown",
 89 |    "metadata": {},
 90 |    "source": [
 91 |     "Python 3\n",
 92 |     "---\n",
 93 |     "Python 3 is also installed on many newer Linux distributions. To see if you also have Python 3, enter `python3` at a terminal prompt:"
 94 |    ]
 95 |   },
 96 |   {
 97 |    "cell_type": "markdown",
 98 |    "metadata": {},
 99 |    "source": [
100 |     "    $ python3\n",
101 |     "    Python 3.4.0 (default, Apr 11 2014, 13:05:18) \n",
102 |     "    [GCC 4.8.2] on linux\n",
103 |     "    Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
104 |     "    >>>"
105 |    ]
106 |   },
107 |   {
108 |    "cell_type": "markdown",
109 |    "metadata": {},
110 |    "source": [
111 |     "Installing Python 3\n",
112 |     "---\n",
113 |     "If your system doesn't have Python 3 installed, you can install it yourself. Here's how you can get Python 3 running on Ubuntu 12.04:\n",
114 |     "\n",
115 |     "Add the \"deadsnakes\" package archive (ppa) to your system. This archive has a number of older and newer versions of Python, including Python 3.4.\n",
116 |     "\n",
117 |     "    sudo apt-get install python-software-properties\n",
118 |     "    sudo add-apt-repository ppa:fkrull/deadsnakes\n",
119 |     "    sudo apt-get update\n",
120 |     "    sudo apt-get install python3.4\n",
121 |     "    \n",
122 |     "Now that Python 3.4 is installed on your system, you have two options. You can start a default Python 2.7 session by running the command 'python' in a terminal. You can start a Python 3.3 session by running the command 'python3.4' in a terminal."
123 |    ]
124 |   },
125 |   {
126 |    "cell_type": "markdown",
127 |    "metadata": {},
128 |    "source": [
129 |     "    $ python3.4\n",
130 |     "    Python 3.4.0 (default, Apr 11 2014, 13:05:18) \n",
131 |     "    [GCC 4.8.2] on linux\n",
132 |     "    Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
133 |     "    >>>"
134 |    ]
135 |   },
136 |   {
137 |    "cell_type": "markdown",
138 |    "metadata": {},
139 |    "source": [
140 |     "[top](#)"
141 |    ]
142 |   },
143 |   {
144 |    "cell_type": "markdown",
145 |    "metadata": {},
146 |    "source": [
147 |     "Installing Geany\n",
148 |     "===\n",
149 |     "Geany is a simple text editor, which makes it easy to run Python programs. Output is displayed in a separate terminal window, which gets you used to working in terminals as well."
150 |    ]
151 |   },
152 |   {
153 |    "cell_type": "markdown",
154 |    "metadata": {},
155 |    "source": [
156 |     "- Open a terminal, and install the package 'geany': `sudo apt-get install geany`\n",
157 |     "- Press the windows button, and type 'geany'.\n",
158 |     "- Drag the geany icon to the task bar on the left side of the screen. This creates a shortcut you can use to start geany.\n",
159 |     "- Write a [Hello World](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/hello_world.ipynb) program, and save it as 'hello.py'.\n",
160 |     "- There are three ways you can run a program in Geany:\n",
161 |     "    - Build > Execute\n",
162 |     "    - Press F5\n",
163 |     "    - Click the icon with three gears on it\n",
164 |     "- You should see a terminal window pop up, with your output in it:"
165 |    ]
166 |   },
167 |   {
168 |    "cell_type": "markdown",
169 |    "metadata": {},
170 |    "source": [
171 |     "    Hello Python world!\n",
172 |     "\n",
173 |     "\n",
174 |     "    ------------------\n",
175 |     "    (program exited with code: 0)\n",
176 |     "    Press return to continue\n"
177 |    ]
178 |   },
179 |   {
180 |    "cell_type": "markdown",
181 |    "metadata": {},
182 |    "source": [
183 |     "Configuring Geany to use Python 3\n",
184 |     "---\n",
185 |     "You may have to configure Geany to use Python 3.\n",
186 |     "\n",
187 |     "Open Geany, and open a Python [Hello World](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/hello_world.ipynb) program. If you don't have one on your system, write one and save it as *hello.py*, and run the program. This makes sure Geany is trying to run Python programs. When you have a running *hello.py* program, go to Build >> Set Build Commands.\n",
188 |     "\n",
189 |     "Under 'Python commands', look for the 'Compile' line. Enter the following in the 'Command' box. Make sure you get the spaces right. You should have 'python3' followed by a space, and the rest of the command. If you have 'python 3', with a space between *python* and *3*, Geany will not be able to run your code.\n",
190 |     "\n",
191 |     "    python3 -m py_compile \"%f\"\n",
192 |     "\n",
193 |     "Under 'Execute commands', look for the 'Execute' line. Enter the following in the 'Command' box, paying attention once again to the spaces.\n",
194 |     "\n",
195 |     "    python3 \"%f\"\n",
196 |     "\n",
197 |     "Test your setup by running *hello.py* again."
198 |    ]
199 |   },
200 |   {
201 |    "cell_type": "markdown",
202 |    "metadata": {},
203 |    "source": [
204 |     "[top](#)"
205 |    ]
206 |   },
207 |   {
208 |    "cell_type": "markdown",
209 |    "metadata": {},
210 |    "source": [
211 |     "- - -\n",
212 |     "[Previous: Programming Environment](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/programming_environment.ipynb) | \n",
213 |     "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb) | \n",
214 |     "[Next: Hello World](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/hello_world.ipynb)"
215 |    ]
216 |   }
217 |  ],
218 |  "metadata": {
219 |   "kernelspec": {
220 |    "display_name": "Python 3",
221 |    "language": "python",
222 |    "name": "python3"
223 |   },
224 |   "language_info": {
225 |    "codemirror_mode": {
226 |     "name": "ipython",
227 |     "version": 3
228 |    },
229 |    "file_extension": ".py",
230 |    "mimetype": "text/x-python",
231 |    "name": "python",
232 |    "nbconvert_exporter": "python",
233 |    "pygments_lexer": "ipython3",
234 |    "version": "3.4.3"
235 |   }
236 |  },
237 |  "nbformat": 4,
238 |  "nbformat_minor": 0
239 | }
240 | 


--------------------------------------------------------------------------------
/notebooks/programming_environment_extras.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "Programming Environment Extras\n",
  8 |     "===\n",
  9 |     "We use Ubuntu Linux as our main programming environment, for a number of reasons. This page covers a number of things we need to be aware of to help use and maintain a Linux computer."
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb)"
 17 |    ]
 18 |   },
 19 |   {
 20 |    "cell_type": "markdown",
 21 |    "metadata": {},
 22 |    "source": [
 23 |     "Contents\n",
 24 |     "===\n",
 25 |     "- [Ubuntu Shortcuts](#Ubuntu-Shortcuts)\n",
 26 |     "- [Updating Ubuntu](#Updating-Ubuntu)\n",
 27 |     "- [Basic Terminal Commands](#Basic-Terminal-Commands)\n",
 28 |     "- [Terminal Shortcuts](#Terminal-Shortcuts)\n",
 29 |     "- [Installing Python 3.3 on Ubuntu 12.04](#Installing-Python-3.3-on-Ubuntu-12.04)\n",
 30 |     "- [Installing Geany](#Installing-Geany)"
 31 |    ]
 32 |   },
 33 |   {
 34 |    "cell_type": "markdown",
 35 |    "metadata": {},
 36 |    "source": [
 37 |     "Ubuntu Shortcuts\n",
 38 |     "===\n",
 39 |     "Knowing some simple shortcuts will help you do your programming work in linux.\n",
 40 |     "\n",
 41 |     "Switch windows\n",
 42 |     "\n",
 43 |     "    Alt-tab"
 44 |    ]
 45 |   },
 46 |   {
 47 |    "cell_type": "markdown",
 48 |    "metadata": {},
 49 |    "source": [
 50 |     "[top](#)"
 51 |    ]
 52 |   },
 53 |   {
 54 |    "cell_type": "markdown",
 55 |    "metadata": {},
 56 |    "source": [
 57 |     "Updating Ubuntu\n",
 58 |     "===\n",
 59 |     "Running updates is a good idea; it keeps your computer functioning appropriately."
 60 |    ]
 61 |   },
 62 |   {
 63 |    "cell_type": "markdown",
 64 |    "metadata": {},
 65 |    "source": [
 66 |     "From the terminal\n",
 67 |     "---\n",
 68 |     "By taking this class, you have some interest in working with computers in a powerful way. The terminal is the most powerful way to use a linux computer, so let's jump in and use it whenever possible.\n",
 69 |     "\n",
 70 |     "Open a terminal using the keyboard shortcut Ctrl-Alt-T.\n",
 71 |     "\n",
 72 |     "Type the following command, and press enter:\n",
 73 |     "\n",
 74 |     "    sudo apt-get update\n",
 75 |     "\n",
 76 |     "You will have to enter your password. Do this, and watch the information scroll by. Your computer is looking to find out which packages can be updated.\n",
 77 |     "\n",
 78 |     "Type the following command, and press enter:\n",
 79 |     "\n",
 80 |     "    sudo apt-get dist-upgrade\n",
 81 |     "\n",
 82 |     "When you run this command, your computer downloads and installs all of the updates that were identified by the previous command."
 83 |    ]
 84 |   },
 85 |   {
 86 |    "cell_type": "markdown",
 87 |    "metadata": {},
 88 |    "source": [
 89 |     "[top](#)"
 90 |    ]
 91 |   },
 92 |   {
 93 |    "cell_type": "markdown",
 94 |    "metadata": {},
 95 |    "source": [
 96 |     "Basic Terminal Commands\n",
 97 |     "===\n",
 98 |     "\n",
 99 |     "Packages\n",
100 |     "---\n",
101 |     "Install a package:\n",
102 |     "\n",
103 |     "    sudo apt-get install package_name\n",
104 |     "\n",
105 |     "Uninstall a package, but keep its configuration files (dependencies?):\n",
106 |     "\n",
107 |     "    sudo apt-get remove package_name\n",
108 |     "\n",
109 |     "Remove a package, and its configuration files (dependencies?):\n",
110 |     "\n",
111 |     "    sudo apt-get remove --purge package_name\n",
112 |     "\n",
113 |     "Python\n",
114 |     "---\n",
115 |     "Start a Python interpreter, using the default version of Python on your system:\n",
116 |     "\n",
117 |     "    python\n",
118 |     "\n",
119 |     "Start a Python interpreter, using a specific version of Python:\n",
120 |     "\n",
121 |     "    python3.3\n",
122 |     "\n",
123 |     "Exit out of the Python interpreter:\n",
124 |     "\n",
125 |     "    Ctrl-D"
126 |    ]
127 |   },
128 |   {
129 |    "cell_type": "markdown",
130 |    "metadata": {},
131 |    "source": [
132 |     "[top](#)"
133 |    ]
134 |   },
135 |   {
136 |    "cell_type": "markdown",
137 |    "metadata": {},
138 |    "source": [
139 |     "Terminal Shortcuts\n",
140 |     "===\n",
141 |     "There are a few things that will help you become comfortable using the terminal.\n",
142 |     "\n",
143 |     "Open a terminal:\n",
144 |     "\n",
145 |     "    Ctrl-Alt-T\n",
146 |     "\n",
147 |     "Scroll through your previous terminal commands:\n",
148 |     "\n",
149 |     "    up arrow, down arrow\n",
150 |     "\n",
151 |     "Clear output from your terminal screen. You will still be able to scroll up and see previous output.\n",
152 |     "\n",
153 |     "    Ctrl-L\n"
154 |    ]
155 |   },
156 |   {
157 |    "cell_type": "markdown",
158 |    "metadata": {},
159 |    "source": [
160 |     "[top](#)"
161 |    ]
162 |   },
163 |   {
164 |    "cell_type": "markdown",
165 |    "metadata": {},
166 |    "source": [
167 |     "Installing Python 3.3 on Ubuntu 12.04\n",
168 |     "===\n",
169 |     "Ubuntu is still using Python 2.7 by default. It is fairly easy to install Python 3.3, however, and then be able to choose the version of Python you want to use.\n",
170 |     "\n",
171 |     "Add the \"deadsnakes\" package archive (ppa) to your system. This archive has a number of older and newer versions of Python. Then install python3.3.\n",
172 |     "\n",
173 |     "    sudo apt-get install python-software-properties\n",
174 |     "    sudo add-apt-repository ppa:fkrull/deadsnakes\n",
175 |     "    sudo apt-get update\n",
176 |     "    sudo apt-get install python3.3\n",
177 |     "\n",
178 |     "Now that Python 3.3 is installed on your system, you have two options. You can start a default Python 2.7 session by running the command 'python' in a terminal. You can start a Python 3.3 session by running the command 'python3.3' in a terminal."
179 |    ]
180 |   },
181 |   {
182 |    "cell_type": "markdown",
183 |    "metadata": {},
184 |    "source": [
185 |     "[top](#)"
186 |    ]
187 |   },
188 |   {
189 |    "cell_type": "markdown",
190 |    "metadata": {},
191 |    "source": [
192 |     "Installing Geany\n",
193 |     "===\n",
194 |     "Geany is one of the text editors we will use for writing programs. Geany is a simple editor, which makes it easy to run programs. Output is shown in a separate terminal window, which gets you used to working in terminals as well."
195 |    ]
196 |   },
197 |   {
198 |    "cell_type": "markdown",
199 |    "metadata": {},
200 |    "source": [
201 |     "Open a terminal.\n",
202 |     "\n",
203 |     "    sudo apt-get install geany\n",
204 |     "\n",
205 |     "Press the windows button, and type 'geany'.\n",
206 |     "\n",
207 |     "Drag the geany icon to the task bar on the left side of the screen. This creates a shortcut you can use to start geany.\n",
208 |     "\n",
209 |     "Write a Hello World program, and save it as 'hello.py'.\n",
210 |     "\n",
211 |     "There are three ways you can run a program in Geany:\n",
212 |     "\n",
213 |     "- Build > Execute\n",
214 |     "- Press F5\n",
215 |     "- Click the icon with three gears on it\n",
216 |     "\n",
217 |     "You should see a terminal window pop up, with your output in it."
218 |    ]
219 |   },
220 |   {
221 |    "cell_type": "markdown",
222 |    "metadata": {},
223 |    "source": [
224 |     "Configuring Geany to use Python3.3\n",
225 |     "---\n",
226 |     "Open Geany, and open a Python [*Hello World*](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/hello_world.ipynb) program. If you don't have one on your system, write one and save it as *hello.py*, and run the program. This makes sure that Geany is trying to run Python programs. When you have a running *hello.py* program, go to Build >> Set Build Commands.\n",
227 |     "\n",
228 |     "Under 'Python commands', look for the 'Compile' line. Enter the following in the 'Command' box. Make sure you get the spaces right. You should have 'python3.3' followed by a space, and the rest of the command. If you have 'python 3.3', with a space between *python* and *3.3*, Geany will not be able to run your code.\n",
229 |     "\n",
230 |     "    python3.3 -m py_compile \"%f\"\n",
231 |     "\n",
232 |     "Under 'Execute commands', look for the 'Execute' line. Enter the following in the 'Command' box, paying attention once again to the spaces.\n",
233 |     "\n",
234 |     "    python3.3 \"%f\"\n",
235 |     "\n",
236 |     "Test your setup with a hello.py file, using Python 3.3 syntax."
237 |    ]
238 |   },
239 |   {
240 |    "cell_type": "markdown",
241 |    "metadata": {},
242 |    "source": [
243 |     "[top](#)"
244 |    ]
245 |   },
246 |   {
247 |    "cell_type": "markdown",
248 |    "metadata": {},
249 |    "source": [
250 |     "- - -\n",
251 |     "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb)"
252 |    ]
253 |   }
254 |  ],
255 |  "metadata": {
256 |   "kernelspec": {
257 |    "display_name": "Python 3",
258 |    "language": "python",
259 |    "name": "python3"
260 |   },
261 |   "language_info": {
262 |    "codemirror_mode": {
263 |     "name": "ipython",
264 |     "version": 3
265 |    },
266 |    "file_extension": ".py",
267 |    "mimetype": "text/x-python",
268 |    "name": "python",
269 |    "nbconvert_exporter": "python",
270 |    "pygments_lexer": "ipython3",
271 |    "version": "3.4.0"
272 |   }
273 |  },
274 |  "nbformat": 4,
275 |  "nbformat_minor": 0
276 | }
277 | 


--------------------------------------------------------------------------------
/html_resources/index.html:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 |   
  4 |     
  5 |     
  6 |     
  7 | 
  8 |     
  9 | 
 10 |     
 11 | 
 12 |     Introduction to Python: An open resource for students and teachers
 13 | 
 14 | 	 
 15 | 	 
 16 | 	 
 17 | 
 18 |     
 19 |     
 20 | 
 21 |     
 22 |     
 23 | 
 24 | 	 
 25 | 	 
 26 | 	 
 27 | 
 28 |     
 29 |     
 33 |   
 34 | 
 35 |   
 36 | 
 37 |     
 38 |     

 39 |       

 40 |         

 41 |           
 46 |         

 47 |         

 48 |           
108 | 
109 | 			 
110 | 			 
111 | 			 
112 | 
113 |             
114 |             

115 | 
116 |             
117 |             
118 |             
119 | 
120 |         

121 |       

122 |     

123 | 
124 |     

125 | 
126 |       

127 |         
Introduction to Python

128 |         
Introduction to Python is a resource for students who want to learn Python as their first language, and for teachers who want a free and open curriculum to use with their students.

129 |       

130 | 
131 | 
132 | 		
133 | 		
140 | 
141 | 
142 | 
143 | 		
Start Learning Python

144 |       
If your computer is already set up to run Python programs, you can get started with Hello World, your very first Python program.

145 |       
Hello World »

146 | 
147 | 		
Set Up Your Programming Environment

148 |       
If your computer is not yet set up to run Python programs, we can show you how to get Python up and running.

149 |       
Environment »

150 | 
151 |       
Contribute

152 |       
If you already know Python and would like to help build Introduction to Python, see the project's GitHub page. You might want to look at Issue 17, which discusses a few specific ways you can contribute to the project.

153 |       
Contribute »

154 | 
155 |       
Support

156 |       
If you would like to support this project, you can visit my Gittip page. Even if you don't support me specifically, you might want to check out the Gittip homepage and about page. It's a wonderful and important project to be aware of.

157 |       
Gittip »

158 | 
159 |       
Feedback

160 |       
If you have any questions or comments, feel free to get in touch:

161 | 		
    
162 | 		  
  • Overall feedback: Issue 10 on GitHub.
    • 
163 | 		  
  • Twitter: @ehmatthes
164 | 		  
  • Email: ehmatthes at gmail dot com
    • 
165 | 	   

166 | 
167 |       
About

168 |       
I teach high school math and science, and I also teach an Introduction to Programming class each fall. This project started as a series of IPython Notebooks I wrote when teaching this year's programming class.

169 | 
170 |       

171 |       

172 | 
173 |     
 
174 | 
175 | 
176 |     
178 |     
179 |     
180 |     
181 |   
182 | 
183 | 


--------------------------------------------------------------------------------
/notebooks/programming_environment_windows.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "Programming Environment: Windows\n",
  8 |     "===\n",
  9 |     "This section will show you how to run your first Python program on a Windows computer."
 10 |    ]
 11 |   },
 12 |   {
 13 |    "cell_type": "markdown",
 14 |    "metadata": {},
 15 |    "source": [
 16 |     "[Previous: Programming Environment](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/programming_environment.ipynb) | \n",
 17 |     "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb) | \n",
 18 |     "[Next: Hello World](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/hello_world.ipynb)"
 19 |    ]
 20 |   },
 21 |   {
 22 |    "cell_type": "markdown",
 23 |    "metadata": {},
 24 |    "source": [
 25 |     "Contents\n",
 26 |     "===\n",
 27 |     "- [Python on Windows](#Python-on-Windows)\n",
 28 |     "- [Installing Python](#Installing-Python)\n",
 29 |     "    - [Installing Python 3](#Installing-Python-3)\n",
 30 |     "    - [Installing Python 2](#Installing-Python-2)\n",
 31 |     "- [Installing Geany](#Installing-Geany)\n",
 32 |     "    - [Telling Geany how to find Python](#Telling-Geany-how-to-find-Python)\n",
 33 |     "        - [Python 3](#Python-3)\n",
 34 |     "        - [Python 2](#Python-2)\n",
 35 |     "        - [Troubleshooting](#Troubleshooting)"
 36 |    ]
 37 |   },
 38 |   {
 39 |    "cell_type": "markdown",
 40 |    "metadata": {},
 41 |    "source": [
 42 |     "Python on Windows\n",
 43 |     "===\n",
 44 |     "If you use Windows, you can install Python and start writing your own programs pretty quickly. You shouldn't have too much trouble as you're learning, but at some point you might notice that some of the resources you'd like to use are written for Linux or Mac users. At that point you'll have a number of options, and we'll help you work through those issues when they come up."
 45 |    ]
 46 |   },
 47 |   {
 48 |    "cell_type": "markdown",
 49 |    "metadata": {},
 50 |    "source": [
 51 |     "Installing Python\n",
 52 |     "===\n",
 53 |     "Python is not usually installed by default on Windows systems. To find out if it's installed, open a terminal and type the word `python`. If you haven't used a terminal before, go to your Start menu and start typing the word 'command'. You'll see an icon for the Windows command console. You can also hold the Shift button while right-clicking the mouse.\n",
 54 |     "\n",
 55 |     "Enter the word `python` in the terminal, and press Enter. You'll probably get a message that Windows does not recognize 'python' as a command.\n",
 56 |     "\n",
 57 |     "If you do have Python installed, you can skip to the section on [installing Geany](#installing_geany)."
 58 |    ]
 59 |   },
 60 |   {
 61 |    "cell_type": "markdown",
 62 |    "metadata": {},
 63 |    "source": [
 64 |     "Installing Python 3\n",
 65 |     "---\n",
 66 |     "Since you're installing Python yourself starting out fresh, it's a good idea to just install the newest stable version of Python. Most people who still use Python 2 do so because they have to maintain large projects that were originally written for Python 2. Unless you know you'll have to maintain a large existing project, you're better off learning Python 3 from the beginning.\n",
 67 |     "\n",
 68 |     "The main Python website has a section written just for [beginners who are trying to install Python](https://wiki.python.org/moin/BeginnersGuide/Download). If you get stuck, take a look at that page and see if anything seems to make sense for your particular system.\n",
 69 |     "\n",
 70 |     "Go to the [Download](https://www.python.org/downloads/windows/) page on [python.org](http://python.org), and download an installer that's appropriate for your system. Look for a Python 3.4 installer. It's helpful to know whether you're running a 32-bit or 64-bit version of Windows; if you don't know, download a 32-bit installer. 32-bit installers will work on any system; 64-bit installers will only work on 64-bit systems."
 71 |    ]
 72 |   },
 73 |   {
 74 |    "cell_type": "markdown",
 75 |    "metadata": {},
 76 |    "source": [
 77 |     "Testing your Python installation\n",
 78 |     "---\n",
 79 |     "Once Python has finished installing, you'll want to make sure it's working. There are several ways to do this.\n",
 80 |     "\n",
 81 |     "- Start Menu > Python (command line) OR Start Menu > Python > Python (command line)\n",
 82 |     "    - This should open up a terminal window, with Python running.\n",
 83 |     "    - Type `print(\"Hello Python world!\")`, and press Enter.\n",
 84 |     "    - You should see your message displayed back to you in the terminal window.\n",
 85 |     "- Open a command window (Start Menu > type \"command\", and click the black terminal icon)\n",
 86 |     "    - Type `C:\\Python34\\python`, and press Enter\n",
 87 |     "    - You should see a Python prompt.\n",
 88 |     "    - Type `print(\"Hello Python world!\")`, and press Enter.\n",
 89 |     "    - You should see your message displayed back to you in the terminal window."
 90 |    ]
 91 |   },
 92 |   {
 93 |    "cell_type": "markdown",
 94 |    "metadata": {},
 95 |    "source": [
 96 |     "[top](#)"
 97 |    ]
 98 |   },
 99 |   {
100 |    "cell_type": "markdown",
101 |    "metadata": {},
102 |    "source": [
103 |     "Installing Geany\n",
104 |     "===\n",
105 |     "Geany is a simple text editor, which makes it easy to run Python programs. Output is displayed in a separate terminal window, which gets you used to working in terminals as well."
106 |    ]
107 |   },
108 |   {
109 |    "cell_type": "markdown",
110 |    "metadata": {},
111 |    "source": [
112 |     "- Go to Geany's [download page](http://www.geany.org/Download/Releases).\n",
113 |     "- Download the full installer, which is described as *Full Installer including GTK 2.16*.\n",
114 |     "    - This is the current direct link to the installer for [Geany 1.24](http://download.geany.org/geany-1.24_setup.exe).\n",
115 |     "- Write a [Hello World](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/hello_world.ipynb) program, and save it as 'hello.py'.\n",
116 |     "- There are three ways you can run a program in Geany:\n",
117 |     "    - Build > Execute\n",
118 |     "    - Press F5\n",
119 |     "    - Click the icon with three gears on it\n",
120 |     "- We should see a terminal window pop up, with your output in it, but you probably won't see this yet:"
121 |    ]
122 |   },
123 |   {
124 |    "cell_type": "markdown",
125 |    "metadata": {},
126 |    "source": [
127 |     "    Hello Python world!\n",
128 |     "\n",
129 |     "\n",
130 |     "    ------------------\n",
131 |     "    (program exited with code: 0)\n",
132 |     "    Press return to continue"
133 |    ]
134 |   },
135 |   {
136 |    "cell_type": "markdown",
137 |    "metadata": {},
138 |    "source": [
139 |     "You'll probably see an error message, because Geany doesn't know where Python lives on your system. We'll fix that in the next section."
140 |    ]
141 |   },
142 |   {
143 |    "cell_type": "markdown",
144 |    "metadata": {},
145 |    "source": [
146 |     "Telling Geany how to find Python\n",
147 |     "---\n",
148 |     "You probably have to configure Geany to tell it how to find the version of Python that you just installed.\n",
149 |     "\n",
150 |     "Open Geany, and open a Python [Hello World](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/hello_world.ipynb) program. If you don't have one on your system, write one and save it as *hello.py*, and run the program. This makes sure that Geany is trying to run Python programs. When you have a running *hello.py* program, go to Build >> Set Build Commands.\n",
151 |     "\n",
152 |     "### Python 3\n",
153 |     "\n",
154 |     "Under 'Python commands', look for the 'Compile' line. Enter the following in the 'Command' box. Make sure you get the spaces right. You should have 'C:\\Python34\\python' followed by a space, and the rest of the command. If you have 'Python 34', with a space between *Python* and *34*, Geany will not be able to run your code. Also, make sure your capitalization matches what you see here exactly.\n",
155 |     "\n",
156 |     "    C:\\Python34\\python -m py_compile \"%f\"\n",
157 |     "Under 'Execute commands', look for the 'Execute' line. Enter the following in the 'Command' box, paying attention once again to the spaces.\n",
158 |     "\n",
159 |     "    C:\\Python34\\python \"%f\"\n",
160 |     "Test your setup by running *hello.py* again.\n",
161 |     "\n",
162 |     "### Python 2\n",
163 |     "\n",
164 |     "If you installed Python 2.7 instead of Python 3, the commands you want are probably:\n",
165 |     "\n",
166 |     "    C:\\Python27\\python -m py_compile \"%f\"\n",
167 |     "and\n",
168 |     "\n",
169 |     "    C:\\Python27\\python \"%f\"\n",
170 |     "### Troubleshooting\n",
171 |     "\n",
172 |     "If Geany still can't run your *hello.py* program, check to see if your installation of Python is somewhere else.\n",
173 |     "\n",
174 |     "- Open Windows Explorer.\n",
175 |     "- Search for 'python'.\n",
176 |     "- Look for the path to your system's Python. It is probably something like `C:\\Python`*xxx*`\\python`.\n",
177 |     "    - If you find it, that is the path you want to use in the above settings."
178 |    ]
179 |   },
180 |   {
181 |    "cell_type": "markdown",
182 |    "metadata": {},
183 |    "source": [
184 |     "[top](#)"
185 |    ]
186 |   },
187 |   {
188 |    "cell_type": "markdown",
189 |    "metadata": {},
190 |    "source": [
191 |     "- - -\n",
192 |     "[Previous: Programming Environment](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/programming_environment.ipynb) | \n",
193 |     "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb) | \n",
194 |     "[Next: Hello World](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/hello_world.ipynb)"
195 |    ]
196 |   }
197 |  ],
198 |  "metadata": {
199 |   "kernelspec": {
200 |    "display_name": "Python 3",
201 |    "language": "python",
202 |    "name": "python3"
203 |   },
204 |   "language_info": {
205 |    "codemirror_mode": {
206 |     "name": "ipython",
207 |     "version": 3
208 |    },
209 |    "file_extension": ".py",
210 |    "mimetype": "text/x-python",
211 |    "name": "python",
212 |    "nbconvert_exporter": "python",
213 |    "pygments_lexer": "ipython3",
214 |    "version": "3.4.3"
215 |   }
216 |  },
217 |  "nbformat": 4,
218 |  "nbformat_minor": 0
219 | }
220 | 


--------------------------------------------------------------------------------
/notebooks/contents.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "Introduction to Python\n",
  8 |     "==="
  9 |    ]
 10 |   },
 11 |   {
 12 |    "cell_type": "markdown",
 13 |    "metadata": {},
 14 |    "source": [
 15 |     "This is a collection of notebooks that form the \"lecture\" notes for an Introduction to Programming class that I teach each year.\n",
 16 |     "\n",
 17 |     "I put \"lecture\" in quotes because these are really presented as brief mini-lessons. After participating in a mini-lesson, students are presented with a set of exercises and challenges that ask them to use and apply what they have just learned. Students have access to the notebooks as they are working through the exercises and challenges.\n",
 18 |     "\n",
 19 |     "This approach aims to maximize the time students spend applying what they have seen, which is the fun part of programming. This approach minimizes the time students spend asking me to repeat what I showed them in the lesson, which is the boring part of teaching and learning."
 20 |    ]
 21 |   },
 22 |   {
 23 |    "cell_type": "markdown",
 24 |    "metadata": {},
 25 |    "source": [
 26 |     "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb) |\n",
 27 |     "[Next: Hello World](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/hello_world.ipynb)"
 28 |    ]
 29 |   },
 30 |   {
 31 |    "cell_type": "markdown",
 32 |    "metadata": {},
 33 |    "source": [
 34 |     "Contents\n",
 35 |     "===\n",
 36 |     "- [Syllabus, Programming Environment](#Syllabus,-Programming-Environment)\n",
 37 |     "- [Python Essentials](#Python-Essentials)\n",
 38 |     "- [Projects - Data Visualization](#Projects-Data-Visualization)"
 39 |    ]
 40 |   },
 41 |   {
 42 |    "cell_type": "markdown",
 43 |    "metadata": {},
 44 |    "source": [
 45 |     "Syllabus\n",
 46 |     "---\n",
 47 |     "The syllabus for the course.\n",
 48 |     "\n",
 49 |     "[Syllabus notebook](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/syllabus.ipynb)"
 50 |    ]
 51 |   },
 52 |   {
 53 |    "cell_type": "markdown",
 54 |    "metadata": {},
 55 |    "source": [
 56 |     "Programming Environment\n",
 57 |     "---\n",
 58 |     "We use Ubuntu Linux as our main programming environment, for a number of reasons. This page covers a number of things we need to be aware of to help use and maintain a Linux computer.\n",
 59 |     "\n",
 60 |     "[Programming Environment notebook](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/programming_environment.ipynb)"
 61 |    ]
 62 |   },
 63 |   {
 64 |    "cell_type": "markdown",
 65 |    "metadata": {},
 66 |    "source": [
 67 |     "[top](#)"
 68 |    ]
 69 |   },
 70 |   {
 71 |    "cell_type": "markdown",
 72 |    "metadata": {},
 73 |    "source": [
 74 |     "Python Essentials\n",
 75 |     "==="
 76 |    ]
 77 |   },
 78 |   {
 79 |    "cell_type": "markdown",
 80 |    "metadata": {},
 81 |    "source": [
 82 |     "Hello World\n",
 83 |     "---\n",
 84 |     "The classic \"Hello world\" program in Python. Use this to make sure your computer is set up to run Python programs properly.\n",
 85 |     "\n",
 86 |     "[Hello World notebook](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/hello_world.ipynb)"
 87 |    ]
 88 |   },
 89 |   {
 90 |    "cell_type": "markdown",
 91 |    "metadata": {},
 92 |    "source": [
 93 |     "Variables, Strings, and Numbers\n",
 94 |     "---\n",
 95 |     "In this section, you will learn to store information in variables. You will learn about two types of data: strings, which are sets of characters, and numerical data types.\n",
 96 |     "\n",
 97 |     "[Variables Strings Numbers noteboook](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/var_string_num.ipynb)"
 98 |    ]
 99 |   },
100 |   {
101 |    "cell_type": "markdown",
102 |    "metadata": {},
103 |    "source": [
104 |     "Lists and Tuples\n",
105 |     "---\n",
106 |     "In this notebook, you will learn to store more than one valuable in a single variable. This by itself is one of the most powerful ideas in programming, and it introduces a number of other central concepts such as loops. If this section ends up making sense to you, you will be able to start writing some interesting programs, and you can be more confident that you will be able to develop overall competence as a programmer.\n",
107 |     "\n",
108 |     "[Lists and Tuples notebook](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/lists_tuples.ipynb)"
109 |    ]
110 |   },
111 |   {
112 |    "cell_type": "markdown",
113 |    "metadata": {},
114 |    "source": [
115 |     "Introducing Functions\n",
116 |     "---\n",
117 |     "One of the core principles of any programming language is, \"Don't Repeat Yourself\". If you have an action that should occur many times, you can define that action once and then call that code whenever you need to carry out that action.\n",
118 |     "\n",
119 |     "[Introducing Functions notebook](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/introducing_functions.ipynb)"
120 |    ]
121 |   },
122 |   {
123 |    "cell_type": "markdown",
124 |    "metadata": {},
125 |    "source": [
126 |     "If Statements\n",
127 |     "---\n",
128 |     "By allowing you to respond selectively to different situations and conditions, if statements open up whole new possibilities for your programs. In this section, you will learn how to test for certain conditions, and then respond in appropriate ways to those conditions.\n",
129 |     "\n",
130 |     "[If Statements notebook](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/if_statements.ipynb)"
131 |    ]
132 |   },
133 |   {
134 |    "cell_type": "markdown",
135 |    "metadata": {},
136 |    "source": [
137 |     "While Loops and Input\n",
138 |     "---\n",
139 |     "While loops are really useful because they let your program run until a user decides to quit the program. They set up an infinite loop that runs until the user does something to end the loop. This section also introduces the first way to get input from your program's users.\n",
140 |     "\n",
141 |     "[While Loops and Input notebook](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/while_input.ipynb)"
142 |    ]
143 |   },
144 |   {
145 |    "cell_type": "markdown",
146 |    "metadata": {},
147 |    "source": [
148 |     "Basic Terminal Apps\n",
149 |     "---\n",
150 |     "By this point, you have learned enough Python to start building interactive apps. If you are set on the larger projects such as building a video game, making a visualization, or making a web app, you can skip this section. But if you would like to start building some simpler apps that run directly in your terminal, check out this notebook.\n",
151 |     "\n",
152 |     "Terminal apps are a great way to build the core functionality of a program you are interested in, which can then be extended into a more accessible format.\n",
153 |     "\n",
154 |     "[Basic Terminal Apps notebook](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/terminal_apps.ipynb)"
155 |    ]
156 |   },
157 |   {
158 |    "cell_type": "markdown",
159 |    "metadata": {},
160 |    "source": [
161 |     "Dictionaries\n",
162 |     "---\n",
163 |     "Dictionaries allow us to store connected bits of information. For example, you might store a person's name and age together.\n",
164 |     "\n",
165 |     "[Dictionaries notebook](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/dictionaries.ipynb)"
166 |    ]
167 |   },
168 |   {
169 |    "cell_type": "markdown",
170 |    "metadata": {},
171 |    "source": [
172 |     "More Functions\n",
173 |     "---\n",
174 |     "Earlier we learned the most bare-boned versions of functions. In this section we will learn more general concepts about functions, such as how to use functions to return values, and how to pass different kinds of data structures between functions.\n",
175 |     "\n",
176 |     "[More Functions notebook](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/more_functions.ipynb)"
177 |    ]
178 |   },
179 |   {
180 |    "cell_type": "markdown",
181 |    "metadata": {},
182 |    "source": [
183 |     "Classes\n",
184 |     "---\n",
185 |     "So far we have learned about Python's core data types: strings, numbers, lists, tuples, and dictionaries. In this section we learn about the last major data structure, classes. Classes are quite unlike the other data types, in that they are much more flexible. Classes allow you to define the information and behavior that characterize anything you want to model in your program. Classes are a rich topic, so we will learn just enough here to dive into the projects you'd like to get started on.\n",
186 |     "\n",
187 |     "[Classes notebook](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/classes.ipynb)"
188 |    ]
189 |   },
190 |   {
191 |    "cell_type": "markdown",
192 |    "metadata": {},
193 |    "source": [
194 |     "Exceptions\n",
195 |     "---\n",
196 |     "Every program has errors while it runs, and has to deal with unexpected behavior and bad input. Exceptions provide a clean way to deal with these situations.\n",
197 |     "\n",
198 |     "[Exceptions notebook](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/exceptions.ipynb)"
199 |    ]
200 |   },
201 |   {
202 |    "cell_type": "markdown",
203 |    "metadata": {},
204 |    "source": [
205 |     "Testing\n",
206 |     "---\n",
207 |     "The programs that we write can quickly become complicated, and with complexity comes bugs. Programmers have long accepted that every program will have its share of bugs. To deal with this, we have come up with many ways to defend against avoidable bugs. Learning to write tests is one of the best things you can do to guard against avoidable bugs creeping into your own programs. Basically, you write a set of tests that you then run against your program every time you or someone else changes the program. These tests, if written correctly, prove that changes to the code do not break anything that was working previously.\n",
208 |     "\n",
209 |     "[Testing notebook](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/testing.ipynb)"
210 |    ]
211 |   },
212 |   {
213 |    "cell_type": "markdown",
214 |    "metadata": {},
215 |    "source": [
216 |     "[top](#)"
217 |    ]
218 |   },
219 |   {
220 |    "cell_type": "markdown",
221 |    "metadata": {},
222 |    "source": [
223 |     "Projects - Data Visualization\n",
224 |     "===\n",
225 |     "\n",
226 |     "Mapping Global Earthquake Activity\n",
227 |     "---\n",
228 |     "This project introduces the Basemap library, which can be used to create maps and plot geographical datasets.\n",
229 |     "\n",
230 |     "[Mapping Global Earthquake Activity notebook](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/visualization_earthquakes.ipynb)"
231 |    ]
232 |   },
233 |   {
234 |    "cell_type": "markdown",
235 |    "metadata": {},
236 |    "source": [
237 |     "[top](#)"
238 |    ]
239 |   },
240 |   {
241 |    "cell_type": "markdown",
242 |    "metadata": {},
243 |    "source": [
244 |     "- - -\n",
245 |     "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb) |\n",
246 |     "[Next: Hello World](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/hello_world.ipynb)"
247 |    ]
248 |   }
249 |  ],
250 |  "metadata": {
251 |   "kernelspec": {
252 |    "display_name": "Python 3",
253 |    "language": "python",
254 |    "name": "python3"
255 |   },
256 |   "language_info": {
257 |    "codemirror_mode": {
258 |     "name": "ipython",
259 |     "version": 3
260 |    },
261 |    "file_extension": ".py",
262 |    "mimetype": "text/x-python",
263 |    "name": "python",
264 |    "nbconvert_exporter": "python",
265 |    "pygments_lexer": "ipython3",
266 |    "version": "3.4.0"
267 |   }
268 |  },
269 |  "nbformat": 4,
270 |  "nbformat_minor": 0
271 | }
272 | 


--------------------------------------------------------------------------------
/scripts/build_all_exercises_page.py:
--------------------------------------------------------------------------------
  1 | # This script scrapes all html pages, pulls out the exercises
  2 | #  and challenges, and copies them to the all_exercises_challenges.html
  3 | #  page.
  4 | 
  5 | import os, sys, re
  6 | 
  7 | print("\nBuilding all_exercises_challenges.html...")
  8 | 
  9 | path_to_notebooks = '/srv/projects/intro_programming/intro_programming/notebooks/'
 10 | 
 11 | # Work through notebooks in the order listed here.
 12 | filenames = ['var_string_num.html', 'lists_tuples.html',
 13 |              'introducing_functions.html', 'if_statements.html',
 14 |              'while_input.html', 'terminal_apps.html',
 15 |              'dictionaries.html', 'more_functions.html',
 16 |              'classes.html',
 17 |              ]
 18 | 
 19 | # one file for testing:
 20 | #filenames = ['var_string_num.html']
 21 | 
 22 | 
 23 | def add_contents(html_string):
 24 |     # Once all pages have been scraped, parse html_string and 
 25 |     #  build contents.
 26 |     toc_string = '
\n'
 27 |     toc_string += "
Contents
\n"
 28 | 
 29 |     new_html_string = ''
 30 |     section_num = 0
 31 |     ex_ch_num = 0
 32 |     for line in html_string.split("\n"):
 33 |         if '
' in line:
 34 | 
 35 |             # Rewrite the html_string line to have id that I want.
 36 |             #  Pull out section title from line.
 37 |             section_anchor = '' % section_num
 38 |             new_line = line.replace('
', '
%s' % section_anchor)
 39 |             new_html_string += new_line + "\n"
 40 | 
 41 |             section_re = """()(.*)(
)"""
 42 |             p = re.compile(section_re)
 43 |             m = p.match(line)
 44 |             if m:
 45 |                 toc_string += '
%s
\n' % (section_num, m.group(2))
 46 | 
 47 |             section_num += 1
 48 | 
 49 |         elif ('id="exercises' in line 
 50 |             or 'id="challenges' in line
 51 |             or 'id="overall-exercises' in line
 52 |             or 'id="overall-challenges' in line):
 53 | 
 54 |             # Rewrite the html_string line to have id that I want.
 55 |             #  Pull out page title from line.
 56 |             ex_ch_anchor = '' % ex_ch_num
 57 |             new_line = re.sub(r"""""", ex_ch_anchor, line)
 58 |             new_html_string += new_line + "\n"
 59 | 
 60 |             ex_ch_re = """<.*/a>(.*)(.*)"""
 61 |             p = re.compile(ex_ch_re)
 62 |             m = p.match(line)
 63 |             if m:
 64 |                 toc_string += '
%s%s
\n' % (m.group(1), ex_ch_num, m.group(2))
 65 | 
 66 |             ex_ch_num += 1
 67 | 
 68 |         else:
 69 |             new_html_string += line + "\n"
 70 | 
 71 |     toc_string += "
\n"
 72 |     toc_string += "
\n\n"
 73 | 
 74 |     return toc_string + new_html_string
 75 | 
 76 | 
 77 | def anchor_exercises(html_string):
 78 |     # Add an anchor link to each exercise, so people can share any
 79 |     #  individual exercise.
 80 |     # Use name of exercise as anchor, but watch for repeated names.
 81 |     #  If repeated name, add a number to anchor.
 82 |     anchors = []
 83 |     new_html_string = ''
 84 |     for line in html_string.split("\n"):
 85 |         ex_ch_re = """
(.*?)
"""
 86 |         p = re.compile(ex_ch_re)
 87 |         m = p.match(line)
 88 |         if m:
 89 |             anchor = m.group(1)
 90 |             name = m.group(2)
 91 |             if anchor in anchors:
 92 |                 new_anchor = anchor
 93 |                 append_num = 1
 94 |                 while new_anchor in anchors:
 95 |                     new_anchor = anchor + '_%d' % append_num
 96 |                     append_num += 1
 97 |                 anchor = new_anchor
 98 | 
 99 |             # Rewrite line to include anchor tag, and to link to this
100 |             #  anchor tag.
101 |             anchor_tag = '' % anchor
102 |             new_line = '%s
%s
\n' % (anchor_tag, anchor, anchor, name)
103 |             new_html_string += new_line
104 |         else:
105 |             new_html_string += line + "\n"
106 | 
107 |     return new_html_string
108 | 
109 | 
110 | def add_intro(html_string):
111 |     # Add an intro to html_string, before adding any exercises.
112 |     intro_string  = '
\n'
113 |     intro_string += '
All Exercises and Challenges
\n'
114 |     intro_string += '
This page pulls together all of the exercises and challenges from throughout introtopython.org.
\n'
115 |     intro_string += '
Each set of exercises has a link to the relevant section that explains what you need to know to complete those exercises. If you are struggling with an exercise, try reading through the linked material, and see if it helps you solve the exercise you are working on.
\n'
116 |     intro_string += '
Exercises are short, specific tasks that ask you to apply a certain concept in a specific way. Challenges are longer, and they ask you to combine different ideas you have been working with. Challenges also ask you to be a little more creative in the programs you are starting to write.
\n'
117 | 
118 |     intro_string += '
\n'
119 |     intro_string += '
\n'
120 |     return intro_string + html_string
121 | 
122 | 
123 | def get_h1_label(line):
124 |     # Pulls the label out of an h1 header line.
125 |     #  This should be the label for what a set of exercises relates to.
126 |     label_re = "()(.*)(
146 |     #  block in each notebook.
147 |     for line in lines:
148 |         if ')(.*)(' in line:
258 |                 # If next line has a link to top, stop here.
259 |                 if 'top' in lines[index+1]:
260 |                     in_exercises_challenges = False
261 |                     html_string += "\n"
262 |                     continue
263 | 
264 |             # Store the current line
265 |             html_string += line
266 | 
267 |     # Finished scraping a notebook, add a link to top of this page.
268 |     html_string += top_html()
269 | 
270 | # Pages have been scraped; build contents from html_string.
271 | html_string = add_contents(html_string)
272 | # Add an intro.
273 | html_string = add_intro(html_string)
274 | # Add anchor links to each exercise.
275 | html_string = anchor_exercises(html_string)
276 | 
277 | # Read in all_exercises_challenges.html
278 | f = open(path_to_notebooks + 'all_exercises_challenges.html', 'r')
279 | lines = f.readlines()
280 | f.close()
281 | 
282 | 
283 | # DEV
284 | # Write headers.
285 | header_lines = ''
286 | with open(path_to_notebooks + 'my_templates/intro_python_header.html') as f:
287 |     header_lines = f.read()
288 | 
289 | # Write string as it is.
290 | # DEV: This should be done with Jinja templates.
291 | #  Yes! Writing from template writes template tags to the screen.
292 | with open(path_to_notebooks + 'all_exercises_challenges.html', 'wb') as f:
293 |     f.write(header_lines.encode('utf-8'))
294 |     f.write(html_string.encode('utf-8'))
295 | print("  Built all_exercises_challenges.html.")
296 | 
297 | 
298 | sys.exit()
299 | 
300 | # Write html to all_exercises_challenges.html
301 | f = open(path_to_notebooks + 'all_exercises_challenges.html', 'wb')
302 | 
303 | # Want to start writing this after 
304 | for line in lines: 
305 |     if '' in line:
306 |         # Write line, then html_string
307 |         f.write(line.encode('utf-8'))
308 |         f.write(html_string.encode('utf-8'))
309 |         # Don't write this line twice.
310 |         continue
311 |     # Need to write each line back to the file.
312 |     f.write(line.encode('utf-8'))
313 | 
314 | f.close()
315 | 
316 | 
317 | print("  Built all_exercises_challenges.html.")
318 | 


--------------------------------------------------------------------------------
/notebooks/js/bootstrap.min.js:
--------------------------------------------------------------------------------
1 | /**
2 | * bootstrap.js v3.0.0 by @fat and @mdo
3 | * Copyright 2013 Twitter Inc.
4 | * http://www.apache.org/licenses/LICENSE-2.0
5 | */
6 | if(!jQuery)throw new Error("Bootstrap requires jQuery");+function(a){"use strict";function b(){var a=document.createElement("bootstrap"),b={WebkitTransition:"webkitTransitionEnd",MozTransition:"transitionend",OTransition:"oTransitionEnd otransitionend",transition:"transitionend"};for(var c in b)if(void 0!==a.style[c])return{end:b[c]}}a.fn.emulateTransitionEnd=function(b){var c=!1,d=this;a(this).one(a.support.transition.end,function(){c=!0});var e=function(){c||a(d).trigger(a.support.transition.end)};return setTimeout(e,b),this},a(function(){a.support.transition=b()})}(window.jQuery),+function(a){"use strict";var b='[data-dismiss="alert"]',c=function(c){a(c).on("click",b,this.close)};c.prototype.close=function(b){function c(){f.trigger("closed.bs.alert").remove()}var d=a(this),e=d.attr("data-target");e||(e=d.attr("href"),e=e&&e.replace(/.*(?=#[^\s]*$)/,""));var f=a(e);b&&b.preventDefault(),f.length||(f=d.hasClass("alert")?d:d.parent()),f.trigger(b=a.Event("close.bs.alert")),b.isDefaultPrevented()||(f.removeClass("in"),a.support.transition&&f.hasClass("fade")?f.one(a.support.transition.end,c).emulateTransitionEnd(150):c())};var d=a.fn.alert;a.fn.alert=function(b){return this.each(function(){var d=a(this),e=d.data("bs.alert");e||d.data("bs.alert",e=new c(this)),"string"==typeof b&&e[b].call(d)})},a.fn.alert.Constructor=c,a.fn.alert.noConflict=function(){return a.fn.alert=d,this},a(document).on("click.bs.alert.data-api",b,c.prototype.close)}(window.jQuery),+function(a){"use strict";var b=function(c,d){this.$element=a(c),this.options=a.extend({},b.DEFAULTS,d)};b.DEFAULTS={loadingText:"loading..."},b.prototype.setState=function(a){var b="disabled",c=this.$element,d=c.is("input")?"val":"html",e=c.data();a+="Text",e.resetText||c.data("resetText",c[d]()),c[d](e[a]||this.options[a]),setTimeout(function(){"loadingText"==a?c.addClass(b).attr(b,b):c.removeClass(b).removeAttr(b)},0)},b.prototype.toggle=function(){var a=this.$element.closest('[data-toggle="buttons"]');if(a.length){var b=this.$element.find("input").prop("checked",!this.$element.hasClass("active")).trigger("change");"radio"===b.prop("type")&&a.find(".active").removeClass("active")}this.$element.toggleClass("active")};var c=a.fn.button;a.fn.button=function(c){return this.each(function(){var d=a(this),e=d.data("bs.button"),f="object"==typeof c&&c;e||d.data("bs.button",e=new b(this,f)),"toggle"==c?e.toggle():c&&e.setState(c)})},a.fn.button.Constructor=b,a.fn.button.noConflict=function(){return a.fn.button=c,this},a(document).on("click.bs.button.data-api","[data-toggle^=button]",function(b){var c=a(b.target);c.hasClass("btn")||(c=c.closest(".btn")),c.button("toggle"),b.preventDefault()})}(window.jQuery),+function(a){"use strict";var b=function(b,c){this.$element=a(b),this.$indicators=this.$element.find(".carousel-indicators"),this.options=c,this.paused=this.sliding=this.interval=this.$active=this.$items=null,"hover"==this.options.pause&&this.$element.on("mouseenter",a.proxy(this.pause,this)).on("mouseleave",a.proxy(this.cycle,this))};b.DEFAULTS={interval:5e3,pause:"hover",wrap:!0},b.prototype.cycle=function(b){return b||(this.paused=!1),this.interval&&clearInterval(this.interval),this.options.interval&&!this.paused&&(this.interval=setInterval(a.proxy(this.next,this),this.options.interval)),this},b.prototype.getActiveIndex=function(){return this.$active=this.$element.find(".item.active"),this.$items=this.$active.parent().children(),this.$items.index(this.$active)},b.prototype.to=function(b){var c=this,d=this.getActiveIndex();return b>this.$items.length-1||0>b?void 0:this.sliding?this.$element.one("slid",function(){c.to(b)}):d==b?this.pause().cycle():this.slide(b>d?"next":"prev",a(this.$items[b]))},b.prototype.pause=function(b){return b||(this.paused=!0),this.$element.find(".next, .prev").length&&a.support.transition.end&&(this.$element.trigger(a.support.transition.end),this.cycle(!0)),this.interval=clearInterval(this.interval),this},b.prototype.next=function(){return this.sliding?void 0:this.slide("next")},b.prototype.prev=function(){return this.sliding?void 0:this.slide("prev")},b.prototype.slide=function(b,c){var d=this.$element.find(".item.active"),e=c||d[b](),f=this.interval,g="next"==b?"left":"right",h="next"==b?"first":"last",i=this;if(!e.length){if(!this.options.wrap)return;e=this.$element.find(".item")[h]()}this.sliding=!0,f&&this.pause();var j=a.Event("slide.bs.carousel",{relatedTarget:e[0],direction:g});if(!e.hasClass("active")){if(this.$indicators.length&&(this.$indicators.find(".active").removeClass("active"),this.$element.one("slid",function(){var b=a(i.$indicators.children()[i.getActiveIndex()]);b&&b.addClass("active")})),a.support.transition&&this.$element.hasClass("slide")){if(this.$element.trigger(j),j.isDefaultPrevented())return;e.addClass(b),e[0].offsetWidth,d.addClass(g),e.addClass(g),d.one(a.support.transition.end,function(){e.removeClass([b,g].join(" ")).addClass("active"),d.removeClass(["active",g].join(" ")),i.sliding=!1,setTimeout(function(){i.$element.trigger("slid")},0)}).emulateTransitionEnd(600)}else{if(this.$element.trigger(j),j.isDefaultPrevented())return;d.removeClass("active"),e.addClass("active"),this.sliding=!1,this.$element.trigger("slid")}return f&&this.cycle(),this}};var c=a.fn.carousel;a.fn.carousel=function(c){return this.each(function(){var d=a(this),e=d.data("bs.carousel"),f=a.extend({},b.DEFAULTS,d.data(),"object"==typeof c&&c),g="string"==typeof c?c:f.slide;e||d.data("bs.carousel",e=new b(this,f)),"number"==typeof c?e.to(c):g?e[g]():f.interval&&e.pause().cycle()})},a.fn.carousel.Constructor=b,a.fn.carousel.noConflict=function(){return a.fn.carousel=c,this},a(document).on("click.bs.carousel.data-api","[data-slide], [data-slide-to]",function(b){var c,d=a(this),e=a(d.attr("data-target")||(c=d.attr("href"))&&c.replace(/.*(?=#[^\s]+$)/,"")),f=a.extend({},e.data(),d.data()),g=d.attr("data-slide-to");g&&(f.interval=!1),e.carousel(f),(g=d.attr("data-slide-to"))&&e.data("bs.carousel").to(g),b.preventDefault()}),a(window).on("load",function(){a('[data-ride="carousel"]').each(function(){var b=a(this);b.carousel(b.data())})})}(window.jQuery),+function(a){"use strict";var b=function(c,d){this.$element=a(c),this.options=a.extend({},b.DEFAULTS,d),this.transitioning=null,this.options.parent&&(this.$parent=a(this.options.parent)),this.options.toggle&&this.toggle()};b.DEFAULTS={toggle:!0},b.prototype.dimension=function(){var a=this.$element.hasClass("width");return a?"width":"height"},b.prototype.show=function(){if(!this.transitioning&&!this.$element.hasClass("in")){var b=a.Event("show.bs.collapse");if(this.$element.trigger(b),!b.isDefaultPrevented()){var c=this.$parent&&this.$parent.find("> .panel > .in");if(c&&c.length){var d=c.data("bs.collapse");if(d&&d.transitioning)return;c.collapse("hide"),d||c.data("bs.collapse",null)}var e=this.dimension();this.$element.removeClass("collapse").addClass("collapsing")[e](0),this.transitioning=1;var f=function(){this.$element.removeClass("collapsing").addClass("in")[e]("auto"),this.transitioning=0,this.$element.trigger("shown.bs.collapse")};if(!a.support.transition)return f.call(this);var g=a.camelCase(["scroll",e].join("-"));this.$element.one(a.support.transition.end,a.proxy(f,this)).emulateTransitionEnd(350)[e](this.$element[0][g])}}},b.prototype.hide=function(){if(!this.transitioning&&this.$element.hasClass("in")){var b=a.Event("hide.bs.collapse");if(this.$element.trigger(b),!b.isDefaultPrevented()){var c=this.dimension();this.$element[c](this.$element[c]())[0].offsetHeight,this.$element.addClass("collapsing").removeClass("collapse").removeClass("in"),this.transitioning=1;var d=function(){this.transitioning=0,this.$element.trigger("hidden.bs.collapse").removeClass("collapsing").addClass("collapse")};return a.support.transition?(this.$element[c](0).one(a.support.transition.end,a.proxy(d,this)).emulateTransitionEnd(350),void 0):d.call(this)}}},b.prototype.toggle=function(){this[this.$element.hasClass("in")?"hide":"show"]()};var c=a.fn.collapse;a.fn.collapse=function(c){return this.each(function(){var d=a(this),e=d.data("bs.collapse"),f=a.extend({},b.DEFAULTS,d.data(),"object"==typeof c&&c);e||d.data("bs.collapse",e=new b(this,f)),"string"==typeof c&&e[c]()})},a.fn.collapse.Constructor=b,a.fn.collapse.noConflict=function(){return a.fn.collapse=c,this},a(document).on("click.bs.collapse.data-api","[data-toggle=collapse]",function(b){var c,d=a(this),e=d.attr("data-target")||b.preventDefault()||(c=d.attr("href"))&&c.replace(/.*(?=#[^\s]+$)/,""),f=a(e),g=f.data("bs.collapse"),h=g?"toggle":d.data(),i=d.attr("data-parent"),j=i&&a(i);g&&g.transitioning||(j&&j.find('[data-toggle=collapse][data-parent="'+i+'"]').not(d).addClass("collapsed"),d[f.hasClass("in")?"addClass":"removeClass"]("collapsed")),f.collapse(h)})}(window.jQuery),+function(a){"use strict";function b(){a(d).remove(),a(e).each(function(b){var d=c(a(this));d.hasClass("open")&&(d.trigger(b=a.Event("hide.bs.dropdown")),b.isDefaultPrevented()||d.removeClass("open").trigger("hidden.bs.dropdown"))})}function c(b){var c=b.attr("data-target");c||(c=b.attr("href"),c=c&&/#/.test(c)&&c.replace(/.*(?=#[^\s]*$)/,""));var d=c&&a(c);return d&&d.length?d:b.parent()}var d=".dropdown-backdrop",e="[data-toggle=dropdown]",f=function(b){a(b).on("click.bs.dropdown",this.toggle)};f.prototype.toggle=function(d){var e=a(this);if(!e.is(".disabled, :disabled")){var f=c(e),g=f.hasClass("open");if(b(),!g){if("ontouchstart"in document.documentElement&&!f.closest(".navbar-nav").length&&a('
').insertAfter(a(this)).on("click",b),f.trigger(d=a.Event("show.bs.dropdown")),d.isDefaultPrevented())return;f.toggleClass("open").trigger("shown.bs.dropdown"),e.focus()}return!1}},f.prototype.keydown=function(b){if(/(38|40|27)/.test(b.keyCode)){var d=a(this);if(b.preventDefault(),b.stopPropagation(),!d.is(".disabled, :disabled")){var f=c(d),g=f.hasClass("open");if(!g||g&&27==b.keyCode)return 27==b.which&&f.find(e).focus(),d.click();var h=a("[role=menu] li:not(.divider):visible a",f);if(h.length){var i=h.index(h.filter(":focus"));38==b.keyCode&&i>0&&i--,40==b.keyCode&&i').appendTo(document.body),this.$element.on("click.dismiss.modal",a.proxy(function(a){a.target===a.currentTarget&&("static"==this.options.backdrop?this.$element[0].focus.call(this.$element[0]):this.hide.call(this))},this)),d&&this.$backdrop[0].offsetWidth,this.$backdrop.addClass("in"),!b)return;d?this.$backdrop.one(a.support.transition.end,b).emulateTransitionEnd(150):b()}else!this.isShown&&this.$backdrop?(this.$backdrop.removeClass("in"),a.support.transition&&this.$element.hasClass("fade")?this.$backdrop.one(a.support.transition.end,b).emulateTransitionEnd(150):b()):b&&b()};var c=a.fn.modal;a.fn.modal=function(c,d){return this.each(function(){var e=a(this),f=e.data("bs.modal"),g=a.extend({},b.DEFAULTS,e.data(),"object"==typeof c&&c);f||e.data("bs.modal",f=new b(this,g)),"string"==typeof c?f[c](d):g.show&&f.show(d)})},a.fn.modal.Constructor=b,a.fn.modal.noConflict=function(){return a.fn.modal=c,this},a(document).on("click.bs.modal.data-api",'[data-toggle="modal"]',function(b){var c=a(this),d=c.attr("href"),e=a(c.attr("data-target")||d&&d.replace(/.*(?=#[^\s]+$)/,"")),f=e.data("modal")?"toggle":a.extend({remote:!/#/.test(d)&&d},e.data(),c.data());b.preventDefault(),e.modal(f,this).one("hide",function(){c.is(":visible")&&c.focus()})}),a(document).on("show.bs.modal",".modal",function(){a(document.body).addClass("modal-open")}).on("hidden.bs.modal",".modal",function(){a(document.body).removeClass("modal-open")})}(window.jQuery),+function(a){"use strict";var b=function(a,b){this.type=this.options=this.enabled=this.timeout=this.hoverState=this.$element=null,this.init("tooltip",a,b)};b.DEFAULTS={animation:!0,placement:"top",selector:!1,template:'
',trigger:"hover focus",title:"",delay:0,html:!1,container:!1},b.prototype.init=function(b,c,d){this.enabled=!0,this.type=b,this.$element=a(c),this.options=this.getOptions(d);for(var e=this.options.trigger.split(" "),f=e.length;f--;){var g=e[f];if("click"==g)this.$element.on("click."+this.type,this.options.selector,a.proxy(this.toggle,this));else if("manual"!=g){var h="hover"==g?"mouseenter":"focus",i="hover"==g?"mouseleave":"blur";this.$element.on(h+"."+this.type,this.options.selector,a.proxy(this.enter,this)),this.$element.on(i+"."+this.type,this.options.selector,a.proxy(this.leave,this))}}this.options.selector?this._options=a.extend({},this.options,{trigger:"manual",selector:""}):this.fixTitle()},b.prototype.getDefaults=function(){return b.DEFAULTS},b.prototype.getOptions=function(b){return b=a.extend({},this.getDefaults(),this.$element.data(),b),b.delay&&"number"==typeof b.delay&&(b.delay={show:b.delay,hide:b.delay}),b},b.prototype.getDelegateOptions=function(){var b={},c=this.getDefaults();return this._options&&a.each(this._options,function(a,d){c[a]!=d&&(b[a]=d)}),b},b.prototype.enter=function(b){var c=b instanceof this.constructor?b:a(b.currentTarget)[this.type](this.getDelegateOptions()).data("bs."+this.type);return clearTimeout(c.timeout),c.hoverState="in",c.options.delay&&c.options.delay.show?(c.timeout=setTimeout(function(){"in"==c.hoverState&&c.show()},c.options.delay.show),void 0):c.show()},b.prototype.leave=function(b){var c=b instanceof this.constructor?b:a(b.currentTarget)[this.type](this.getDelegateOptions()).data("bs."+this.type);return clearTimeout(c.timeout),c.hoverState="out",c.options.delay&&c.options.delay.hide?(c.timeout=setTimeout(function(){"out"==c.hoverState&&c.hide()},c.options.delay.hide),void 0):c.hide()},b.prototype.show=function(){var b=a.Event("show.bs."+this.type);if(this.hasContent()&&this.enabled){if(this.$element.trigger(b),b.isDefaultPrevented())return;var c=this.tip();this.setContent(),this.options.animation&&c.addClass("fade");var d="function"==typeof this.options.placement?this.options.placement.call(this,c[0],this.$element[0]):this.options.placement,e=/\s?auto?\s?/i,f=e.test(d);f&&(d=d.replace(e,"")||"top"),c.detach().css({top:0,left:0,display:"block"}).addClass(d),this.options.container?c.appendTo(this.options.container):c.insertAfter(this.$element);var g=this.getPosition(),h=c[0].offsetWidth,i=c[0].offsetHeight;if(f){var j=this.$element.parent(),k=d,l=document.documentElement.scrollTop||document.body.scrollTop,m="body"==this.options.container?window.innerWidth:j.outerWidth(),n="body"==this.options.container?window.innerHeight:j.outerHeight(),o="body"==this.options.container?0:j.offset().left;d="bottom"==d&&g.top+g.height+i-l>n?"top":"top"==d&&g.top-l-i<0?"bottom":"right"==d&&g.right+h>m?"left":"left"==d&&g.left-h
'}),b.prototype=a.extend({},a.fn.tooltip.Constructor.prototype),b.prototype.constructor=b,b.prototype.getDefaults=function(){return b.DEFAULTS},b.prototype.setContent=function(){var a=this.tip(),b=this.getTitle(),c=this.getContent();a.find(".popover-title")[this.options.html?"html":"text"](b),a.find(".popover-content")[this.options.html?"html":"text"](c),a.removeClass("fade top bottom left right in"),a.find(".popover-title").html()||a.find(".popover-title").hide()},b.prototype.hasContent=function(){return this.getTitle()||this.getContent()},b.prototype.getContent=function(){var a=this.$element,b=this.options;return a.attr("data-content")||("function"==typeof b.content?b.content.call(a[0]):b.content)},b.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".arrow")},b.prototype.tip=function(){return this.$tip||(this.$tip=a(this.options.template)),this.$tip};var c=a.fn.popover;a.fn.popover=function(c){return this.each(function(){var d=a(this),e=d.data("bs.popover"),f="object"==typeof c&&c;e||d.data("bs.popover",e=new b(this,f)),"string"==typeof c&&e[c]()})},a.fn.popover.Constructor=b,a.fn.popover.noConflict=function(){return a.fn.popover=c,this}}(window.jQuery),+function(a){"use strict";function b(c,d){var e,f=a.proxy(this.process,this);this.$element=a(c).is("body")?a(window):a(c),this.$body=a("body"),this.$scrollElement=this.$element.on("scroll.bs.scroll-spy.data-api",f),this.options=a.extend({},b.DEFAULTS,d),this.selector=(this.options.target||(e=a(c).attr("href"))&&e.replace(/.*(?=#[^\s]+$)/,"")||"")+" .nav li > a",this.offsets=a([]),this.targets=a([]),this.activeTarget=null,this.refresh(),this.process()}b.DEFAULTS={offset:10},b.prototype.refresh=function(){var b=this.$element[0]==window?"offset":"position";this.offsets=a([]),this.targets=a([]);var c=this;this.$body.find(this.selector).map(function(){var d=a(this),e=d.data("target")||d.attr("href"),f=/^#\w/.test(e)&&a(e);return f&&f.length&&[[f[b]().top+(!a.isWindow(c.$scrollElement.get(0))&&c.$scrollElement.scrollTop()),e]]||null}).sort(function(a,b){return a[0]-b[0]}).each(function(){c.offsets.push(this[0]),c.targets.push(this[1])})},b.prototype.process=function(){var a,b=this.$scrollElement.scrollTop()+this.options.offset,c=this.$scrollElement[0].scrollHeight||this.$body[0].scrollHeight,d=c-this.$scrollElement.height(),e=this.offsets,f=this.targets,g=this.activeTarget;if(b>=d)return g!=(a=f.last()[0])&&this.activate(a);for(a=e.length;a--;)g!=f[a]&&b>=e[a]&&(!e[a+1]||b<=e[a+1])&&this.activate(f[a])},b.prototype.activate=function(b){this.activeTarget=b,a(this.selector).parents(".active").removeClass("active");var c=this.selector+'[data-target="'+b+'"],'+this.selector+'[href="'+b+'"]',d=a(c).parents("li").addClass("active");d.parent(".dropdown-menu").length&&(d=d.closest("li.dropdown").addClass("active")),d.trigger("activate")};var c=a.fn.scrollspy;a.fn.scrollspy=function(c){return this.each(function(){var d=a(this),e=d.data("bs.scrollspy"),f="object"==typeof c&&c;e||d.data("bs.scrollspy",e=new b(this,f)),"string"==typeof c&&e[c]()})},a.fn.scrollspy.Constructor=b,a.fn.scrollspy.noConflict=function(){return a.fn.scrollspy=c,this},a(window).on("load",function(){a('[data-spy="scroll"]').each(function(){var b=a(this);b.scrollspy(b.data())})})}(window.jQuery),+function(a){"use strict";var b=function(b){this.element=a(b)};b.prototype.show=function(){var b=this.element,c=b.closest("ul:not(.dropdown-menu)"),d=b.attr("data-target");if(d||(d=b.attr("href"),d=d&&d.replace(/.*(?=#[^\s]*$)/,"")),!b.parent("li").hasClass("active")){var e=c.find(".active:last a")[0],f=a.Event("show.bs.tab",{relatedTarget:e});if(b.trigger(f),!f.isDefaultPrevented()){var g=a(d);this.activate(b.parent("li"),c),this.activate(g,g.parent(),function(){b.trigger({type:"shown.bs.tab",relatedTarget:e})})}}},b.prototype.activate=function(b,c,d){function e(){f.removeClass("active").find("> .dropdown-menu > .active").removeClass("active"),b.addClass("active"),g?(b[0].offsetWidth,b.addClass("in")):b.removeClass("fade"),b.parent(".dropdown-menu")&&b.closest("li.dropdown").addClass("active"),d&&d()}var f=c.find("> .active"),g=d&&a.support.transition&&f.hasClass("fade");g?f.one(a.support.transition.end,e).emulateTransitionEnd(150):e(),f.removeClass("in")};var c=a.fn.tab;a.fn.tab=function(c){return this.each(function(){var d=a(this),e=d.data("bs.tab");e||d.data("bs.tab",e=new b(this)),"string"==typeof c&&e[c]()})},a.fn.tab.Constructor=b,a.fn.tab.noConflict=function(){return a.fn.tab=c,this},a(document).on("click.bs.tab.data-api",'[data-toggle="tab"], [data-toggle="pill"]',function(b){b.preventDefault(),a(this).tab("show")})}(window.jQuery),+function(a){"use strict";var b=function(c,d){this.options=a.extend({},b.DEFAULTS,d),this.$window=a(window).on("scroll.bs.affix.data-api",a.proxy(this.checkPosition,this)).on("click.bs.affix.data-api",a.proxy(this.checkPositionWithEventLoop,this)),this.$element=a(c),this.affixed=this.unpin=null,this.checkPosition()};b.RESET="affix affix-top affix-bottom",b.DEFAULTS={offset:0},b.prototype.checkPositionWithEventLoop=function(){setTimeout(a.proxy(this.checkPosition,this),1)},b.prototype.checkPosition=function(){if(this.$element.is(":visible")){var c=a(document).height(),d=this.$window.scrollTop(),e=this.$element.offset(),f=this.options.offset,g=f.top,h=f.bottom;"object"!=typeof f&&(h=g=f),"function"==typeof g&&(g=f.top()),"function"==typeof h&&(h=f.bottom());var i=null!=this.unpin&&d+this.unpin<=e.top?!1:null!=h&&e.top+this.$element.height()>=c-h?"bottom":null!=g&&g>=d?"top":!1;this.affixed!==i&&(this.unpin&&this.$element.css("top",""),this.affixed=i,this.unpin="bottom"==i?e.top-d:null,this.$element.removeClass(b.RESET).addClass("affix"+(i?"-"+i:"")),"bottom"==i&&this.$element.offset({top:document.body.offsetHeight-h-this.$element.height()}))}};var c=a.fn.affix;a.fn.affix=function(c){return this.each(function(){var d=a(this),e=d.data("bs.affix"),f="object"==typeof c&&c;e||d.data("bs.affix",e=new b(this,f)),"string"==typeof c&&e[c]()})},a.fn.affix.Constructor=b,a.fn.affix.noConflict=function(){return a.fn.affix=c,this},a(window).on("load",function(){a('[data-spy="affix"]').each(function(){var b=a(this),c=b.data();c.offset=c.offset||{},c.offsetBottom&&(c.offset.bottom=c.offsetBottom),c.offsetTop&&(c.offset.top=c.offsetTop),b.affix(c)})})}(window.jQuery);


--------------------------------------------------------------------------------
/notebooks/introducing_functions.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "Introducing Functions\n",
  8 |     "===\n",
  9 |     "One of the core principles of any programming language is, \"Don't Repeat Yourself\". If you have an action that should occur many times, you can define that action once and then call that code whenever you need to carry out that action.\n",
 10 |     "\n",
 11 |     "We are already repeating ourselves in our code, so this is a good time to introduce simple functions. Functions mean less work for us as programmers, and effective use of functions results in code that is less error-prone."
 12 |    ]
 13 |   },
 14 |   {
 15 |    "cell_type": "markdown",
 16 |    "metadata": {},
 17 |    "source": [
 18 |     "[Previous: Lists and Tuples](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/lists_tuples.ipynb) | \n",
 19 |     "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb) |\n",
 20 |     "[Next: If Statements](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/if_statements.ipynb)"
 21 |    ]
 22 |   },
 23 |   {
 24 |    "cell_type": "markdown",
 25 |    "metadata": {},
 26 |    "source": [
 27 |     "Contents\n",
 28 |     "===\n",
 29 |     "- [What are functions?](#What-are-functions)\n",
 30 |     "    - [General Syntax](#General-syntax)\n",
 31 |     "- [Examples](#Examples)\n",
 32 |     "    - [Returning a Value](#Returning-a-Value)\n",
 33 |     "    - [Exercises](#Exercises)\n",
 34 |     "- [Challenges](#Challenges)"
 35 |    ]
 36 |   },
 37 |   {
 38 |    "cell_type": "markdown",
 39 |    "metadata": {},
 40 |    "source": [
 41 |     "What are functions?\n",
 42 |     "===\n",
 43 |     "Functions are a set of actions that we group together, and give a name to. You have already used a number of functions from the core Python language, such as *string.title()* and *list.sort()*. We can define our own functions, which allows us to \"teach\" Python new behavior."
 44 |    ]
 45 |   },
 46 |   {
 47 |    "cell_type": "markdown",
 48 |    "metadata": {},
 49 |    "source": [
 50 |     "General Syntax\n",
 51 |     "---\n",
 52 |     "A general function looks something like this:"
 53 |    ]
 54 |   },
 55 |   {
 56 |    "cell_type": "code",
 57 |    "execution_count": null,
 58 |    "metadata": {
 59 |     "collapsed": false
 60 |    },
 61 |    "outputs": [],
 62 |    "source": [
 63 |     "# Let's define a function.\n",
 64 |     "def function_name(argument_1, argument_2):\n",
 65 |     "\t# Do whatever we want this function to do,\n",
 66 |     "\t#  using argument_1 and argument_2\n",
 67 |     "\n",
 68 |     "# Use function_name to call the function.\n",
 69 |     "function_name(value_1, value_2)"
 70 |    ]
 71 |   },
 72 |   {
 73 |    "cell_type": "markdown",
 74 |    "metadata": {},
 75 |    "source": [
 76 |     "This code will not run, but it shows how functions are used in general.\n",
 77 |     "\n",
 78 |     "- **Defining a function**\n",
 79 |     "    - Give the keyword `def`, which tells Python that you are about to *define* a function.\n",
 80 |     "    - Give your function a name. A variable name tells you what kind of value the variable contains; a function name should tell you what the function does.\n",
 81 |     "    - Give names for each value the function needs in order to do its work.\n",
 82 |     "        - These are basically variable names, but they are only used in the function.\n",
 83 |     "        - They can be different names than what you use in the rest of your program.\n",
 84 |     "        - These are called the function's *arguments*.\n",
 85 |     "    - Make sure the function definition line ends with a colon.\n",
 86 |     "    - Inside the function, write whatever code you need to make the function do its work.\n",
 87 |     "- **Using your function**\n",
 88 |     "    - To *call* your function, write its name followed by parentheses.\n",
 89 |     "    - Inside the parentheses, give the values you want the function to work with.\n",
 90 |     "        - These can be variables such as `current_name` and `current_age`, or they can be actual values such as 'eric' and 5."
 91 |    ]
 92 |   },
 93 |   {
 94 |    "cell_type": "markdown",
 95 |    "metadata": {},
 96 |    "source": [
 97 |     "[top](#)"
 98 |    ]
 99 |   },
100 |   {
101 |    "cell_type": "markdown",
102 |    "metadata": {},
103 |    "source": [
104 |     "Basic Examples\n",
105 |     "===\n",
106 |     "For a simple first example, we will look at a program that compliments people. Let's look at the example, and then try to understand the code. First we will look at a version of this program as we would have written it earlier, with no functions."
107 |    ]
108 |   },
109 |   {
110 |    "cell_type": "code",
111 |    "execution_count": 2,
112 |    "metadata": {
113 |     "collapsed": false
114 |    },
115 |    "outputs": [
116 |     {
117 |      "name": "stdout",
118 |      "output_type": "stream",
119 |      "text": [
120 |       "You are doing good work, Adriana!\n",
121 |       "Thank you very much for your efforts on this project.\n",
122 |       "\n",
123 |       "You are doing good work, Billy!\n",
124 |       "Thank you very much for your efforts on this project.\n",
125 |       "\n",
126 |       "You are doing good work, Caroline!\n",
127 |       "Thank you very much for your efforts on this project.\n"
128 |      ]
129 |     }
130 |    ],
131 |    "source": [
132 |     "print(\"You are doing good work, Adriana!\")\n",
133 |     "print(\"Thank you very much for your efforts on this project.\")\n",
134 |     "\n",
135 |     "print(\"\\nYou are doing good work, Billy!\")\n",
136 |     "print(\"Thank you very much for your efforts on this project.\")\n",
137 |     "\n",
138 |     "print(\"\\nYou are doing good work, Caroline!\")\n",
139 |     "print(\"Thank you very much for your efforts on this project.\")"
140 |    ]
141 |   },
142 |   {
143 |    "cell_type": "markdown",
144 |    "metadata": {},
145 |    "source": [
146 |     "Functions take repeated code, put it in one place, and then you call that code when you want to use it. Here's what the same program looks like with a function."
147 |    ]
148 |   },
149 |   {
150 |    "cell_type": "code",
151 |    "execution_count": 4,
152 |    "metadata": {
153 |     "collapsed": false
154 |    },
155 |    "outputs": [
156 |     {
157 |      "name": "stdout",
158 |      "output_type": "stream",
159 |      "text": [
160 |       "\n",
161 |       "You are doing good work, Adriana!\n",
162 |       "Thank you very much for your efforts on this project.\n",
163 |       "\n",
164 |       "You are doing good work, Billy!\n",
165 |       "Thank you very much for your efforts on this project.\n",
166 |       "\n",
167 |       "You are doing good work, Caroline!\n",
168 |       "Thank you very much for your efforts on this project.\n"
169 |      ]
170 |     }
171 |    ],
172 |    "source": [
173 |     "def thank_you(name):\n",
174 |     "    # This function prints a two-line personalized thank you message.\n",
175 |     "    print(\"\\nYou are doing good work, %s!\" % name)\n",
176 |     "    print(\"Thank you very much for your efforts on this project.\")\n",
177 |     "    \n",
178 |     "thank_you('Adriana')\n",
179 |     "thank_you('Billy')\n",
180 |     "thank_you('Caroline')"
181 |    ]
182 |   },
183 |   {
184 |    "cell_type": "markdown",
185 |    "metadata": {},
186 |    "source": [
187 |     "In our original code, each pair of print statements was run three times, and the only difference was the name of the person being thanked. When you see repetition like this, you can usually make your program more efficient by defining a function.\n",
188 |     "\n",
189 |     "The keyword *def* tells Python that we are about to define a function. We give our function a name, *thank\\_you()* in this case. A variable's name should tell us what kind of information it holds; a function's name should tell us what the variable does.  We then put parentheses. Inside these parenthese we create variable names for any variable the function will need to be given in order to do its job. In this case the function will need a name to include in the thank you message. The variable `name` will hold the value that is passed into the function *thank\\_you()*.\n",
190 |     "\n",
191 |     "To use a function we give the function's name, and then put any values the function needs in order to do its work. In this case we call the function three times, each time passing it a different name."
192 |    ]
193 |   },
194 |   {
195 |    "cell_type": "markdown",
196 |    "metadata": {},
197 |    "source": [
198 |     "### A common error\n",
199 |     "A function must be defined before you use it in your program. For example, putting the function at the end of the program would not work."
200 |    ]
201 |   },
202 |   {
203 |    "cell_type": "code",
204 |    "execution_count": 1,
205 |    "metadata": {
206 |     "collapsed": false
207 |    },
208 |    "outputs": [
209 |     {
210 |      "ename": "NameError",
211 |      "evalue": "name 'thank_you' is not defined",
212 |      "output_type": "error",
213 |      "traceback": [
214 |       "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
215 |       "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mthank_you\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Adriana'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mthank_you\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Billy'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mthank_you\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Caroline'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mthank_you\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
216 |       "\u001b[1;31mNameError\u001b[0m: name 'thank_you' is not defined"
217 |      ]
218 |     }
219 |    ],
220 |    "source": [
221 |     "thank_you('Adriana')\n",
222 |     "thank_you('Billy')\n",
223 |     "thank_you('Caroline')\n",
224 |     "\n",
225 |     "def thank_you(name):\n",
226 |     "    # This function prints a two-line personalized thank you message.\n",
227 |     "    print(\"\\nYou are doing good work, %s!\" % name)\n",
228 |     "    print(\"Thank you very much for your efforts on this project.\")"
229 |    ]
230 |   },
231 |   {
232 |    "cell_type": "markdown",
233 |    "metadata": {},
234 |    "source": [
235 |     "On the first line we ask Python to run the function *thank\\_you()*, but Python does not yet know how to do this function. We define our functions at the beginning of our programs, and then we can use them when we need to."
236 |    ]
237 |   },
238 |   {
239 |    "cell_type": "markdown",
240 |    "metadata": {},
241 |    "source": [
242 |     "A second example\n",
243 |     "---\n",
244 |     "When we introduced the different methods for [sorting a list](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/lists_tuples.ipynb#sorting_list), our code got very repetitive. It takes two lines of code to print a list using a for loop, so these two lines are repeated whenever you want to print out the contents of a list. This is the perfect opportunity to use a function, so let's see how the code looks with a function.\n",
245 |     "\n",
246 |     "First, let's see the code we had without a function:"
247 |    ]
248 |   },
249 |   {
250 |    "cell_type": "code",
251 |    "execution_count": 3,
252 |    "metadata": {
253 |     "collapsed": false
254 |    },
255 |    "outputs": [
256 |     {
257 |      "name": "stdout",
258 |      "output_type": "stream",
259 |      "text": [
260 |       "Our students are currently in alphabetical order.\n",
261 |       "Aaron\n",
262 |       "Bernice\n",
263 |       "Cody\n",
264 |       "\n",
265 |       "Our students are now in reverse alphabetical order.\n",
266 |       "Cody\n",
267 |       "Bernice\n",
268 |       "Aaron\n"
269 |      ]
270 |     }
271 |    ],
272 |    "source": [
273 |     "students = ['bernice', 'aaron', 'cody']\n",
274 |     "\n",
275 |     "# Put students in alphabetical order.\n",
276 |     "students.sort()\n",
277 |     "\n",
278 |     "# Display the list in its current order.\n",
279 |     "print(\"Our students are currently in alphabetical order.\")\n",
280 |     "for student in students:\n",
281 |     "    print(student.title())\n",
282 |     "\n",
283 |     "# Put students in reverse alphabetical order.\n",
284 |     "students.sort(reverse=True)\n",
285 |     "\n",
286 |     "# Display the list in its current order.\n",
287 |     "print(\"\\nOur students are now in reverse alphabetical order.\")\n",
288 |     "for student in students:\n",
289 |     "    print(student.title())"
290 |    ]
291 |   },
292 |   {
293 |    "cell_type": "markdown",
294 |    "metadata": {},
295 |    "source": [
296 |     "Here's what the same code looks like, using a function to print out the list:"
297 |    ]
298 |   },
299 |   {
300 |    "cell_type": "code",
301 |    "execution_count": 9,
302 |    "metadata": {
303 |     "collapsed": false
304 |    },
305 |    "outputs": [
306 |     {
307 |      "name": "stdout",
308 |      "output_type": "stream",
309 |      "text": [
310 |       "Our students are currently in alphabetical order.\n",
311 |       "Aaron\n",
312 |       "Bernice\n",
313 |       "Cody\n",
314 |       "\n",
315 |       "Our students are now in reverse alphabetical order.\n",
316 |       "Cody\n",
317 |       "Bernice\n",
318 |       "Aaron\n"
319 |      ]
320 |     }
321 |    ],
322 |    "source": [
323 |     "###highlight=[2,3,4,5,6,12,16]\n",
324 |     "def show_students(students, message):\n",
325 |     "    # Print out a message, and then the list of students\n",
326 |     "    print(message)\n",
327 |     "    for student in students:\n",
328 |     "        print(student.title())\n",
329 |     "\n",
330 |     "students = ['bernice', 'aaron', 'cody']\n",
331 |     "\n",
332 |     "# Put students in alphabetical order.\n",
333 |     "students.sort()\n",
334 |     "show_students(students, \"Our students are currently in alphabetical order.\")\n",
335 |     "\n",
336 |     "#Put students in reverse alphabetical order.\n",
337 |     "students.sort(reverse=True)\n",
338 |     "show_students(students, \"\\nOur students are now in reverse alphabetical order.\")"
339 |    ]
340 |   },
341 |   {
342 |    "cell_type": "markdown",
343 |    "metadata": {},
344 |    "source": [
345 |     "This is much cleaner code. We have an action we want to take, which is to show the students in our list along with a message. We give this action a name, *show\\_students()*. \n",
346 |     "\n",
347 |     "This function needs two pieces of information to do its work, the list of students and a message to display. Inside the function, the code for printing the message and looping through the list is exactly as it was in the non-function code.\n",
348 |     "\n",
349 |     "Now the rest of our program is cleaner, because it gets to focus on the things we are changing in the list, rather than having code for printing the list. We define the list, then we sort it and call our function to print the list. We sort it again, and then call the printing function a second time, with a different message. This is much more readable code.\n",
350 |     "\n",
351 |     "### Advantages of using functions\n",
352 |     "You might be able to see some advantages of using functions, through this example:\n",
353 |     "\n",
354 |     "- We write a set of instructions once. We save some work in this simple example, and we save even more work in larger programs.\n",
355 |     "- When our function works, we don't have to worry about that code anymore. Every time you repeat code in your program, you introduce an opportunity to make a mistake. Writing a function means there is one place to fix mistakes, and when those bugs are fixed, we can be confident that this function will continue to work correctly.\n",
356 |     "- We can modify our function's behavior, and that change takes effect every time the function is called. This is much better than deciding we need some new behavior, and then having to change code in many different places in our program."
357 |    ]
358 |   },
359 |   {
360 |    "cell_type": "markdown",
361 |    "metadata": {},
362 |    "source": [
363 |     "For a quick example, let's say we decide our printed output would look better with some form of a bulleted list. Without functions, we'd have to change each print statement. With a function, we change just the print statement in the function:"
364 |    ]
365 |   },
366 |   {
367 |    "cell_type": "code",
368 |    "execution_count": 10,
369 |    "metadata": {
370 |     "collapsed": false
371 |    },
372 |    "outputs": [
373 |     {
374 |      "name": "stdout",
375 |      "output_type": "stream",
376 |      "text": [
377 |       "Our students are currently in alphabetical order.\n",
378 |       "- Aaron\n",
379 |       "- Bernice\n",
380 |       "- Cody\n",
381 |       "\n",
382 |       "Our students are now in reverse alphabetical order.\n",
383 |       "- Cody\n",
384 |       "- Bernice\n",
385 |       "- Aaron\n"
386 |      ]
387 |     }
388 |    ],
389 |    "source": [
390 |     "def show_students(students, message):\n",
391 |     "    # Print out a message, and then the list of students\n",
392 |     "    print(message)\n",
393 |     "    for student in students:\n",
394 |     "        print(\"- \" + student.title())\n",
395 |     "\n",
396 |     "students = ['bernice', 'aaron', 'cody']\n",
397 |     "\n",
398 |     "# Put students in alphabetical order.\n",
399 |     "students.sort()\n",
400 |     "show_students(students, \"Our students are currently in alphabetical order.\")\n",
401 |     "\n",
402 |     "#Put students in reverse alphabetical order.\n",
403 |     "students.sort(reverse=True)\n",
404 |     "show_students(students, \"\\nOur students are now in reverse alphabetical order.\")"
405 |    ]
406 |   },
407 |   {
408 |    "cell_type": "markdown",
409 |    "metadata": {},
410 |    "source": [
411 |     "You can think of functions as a way to \"teach\" Python some new behavior. In this case, we taught Python how to create a list of students using hyphens; now we can tell Python to do this with our students whenever we want to."
412 |    ]
413 |   },
414 |   {
415 |    "cell_type": "markdown",
416 |    "metadata": {},
417 |    "source": [
418 |     "Returning a Value\n",
419 |     "---\n",
420 |     "Each function you create can return a value. This can be in addition to the primary work the function does, or it can be the function's main job. The following function takes in a number, and returns the corresponding word for that number:"
421 |    ]
422 |   },
423 |   {
424 |    "cell_type": "code",
425 |    "execution_count": 3,
426 |    "metadata": {
427 |     "collapsed": false
428 |    },
429 |    "outputs": [
430 |     {
431 |      "name": "stdout",
432 |      "output_type": "stream",
433 |      "text": [
434 |       "0 None\n",
435 |       "1 one\n",
436 |       "2 two\n",
437 |       "3 three\n"
438 |      ]
439 |     }
440 |    ],
441 |    "source": [
442 |     "def get_number_word(number):\n",
443 |     "    # Takes in a numerical value, and returns\n",
444 |     "    #  the word corresponding to that number.\n",
445 |     "    if number == 1:\n",
446 |     "        return 'one'\n",
447 |     "    elif number == 2:\n",
448 |     "        return 'two'\n",
449 |     "    elif number == 3:\n",
450 |     "        return 'three'\n",
451 |     "    # ...\n",
452 |     "    \n",
453 |     "# Let's try out our function.\n",
454 |     "for current_number in range(0,4):\n",
455 |     "    number_word = get_number_word(current_number)\n",
456 |     "    print(current_number, number_word)"
457 |    ]
458 |   },
459 |   {
460 |    "cell_type": "markdown",
461 |    "metadata": {},
462 |    "source": [
463 |     "It's helpful sometimes to see programs that don't quite work as they are supposed to, and then see how those programs can be improved. In this case, there are no Python errors; all of the code has proper Python syntax. But there is a logical error, in the first line of the output.\n",
464 |     "\n",
465 |     "We want to either not include 0 in the range we send to the function, or have the function return something other than `None` when it receives a value that it doesn't know. Let's teach our function the word 'zero', but let's also add an `else` clause that returns a more informative message for numbers that are not in the if-chain."
466 |    ]
467 |   },
468 |   {
469 |    "cell_type": "code",
470 |    "execution_count": 5,
471 |    "metadata": {
472 |     "collapsed": false
473 |    },
474 |    "outputs": [
475 |     {
476 |      "name": "stdout",
477 |      "output_type": "stream",
478 |      "text": [
479 |       "0 zero\n",
480 |       "1 one\n",
481 |       "2 two\n",
482 |       "3 three\n",
483 |       "4 I'm sorry, I don't know that number.\n",
484 |       "5 I'm sorry, I don't know that number.\n"
485 |      ]
486 |     }
487 |    ],
488 |    "source": [
489 |     "###highlight=[13,14,17]\n",
490 |     "def get_number_word(number):\n",
491 |     "    # Takes in a numerical value, and returns\n",
492 |     "    #  the word corresponding to that number.\n",
493 |     "    if number == 0:\n",
494 |     "        return 'zero'\n",
495 |     "    elif number == 1:\n",
496 |     "        return 'one'\n",
497 |     "    elif number == 2:\n",
498 |     "        return 'two'\n",
499 |     "    elif number == 3:\n",
500 |     "        return 'three'\n",
501 |     "    else:\n",
502 |     "        return \"I'm sorry, I don't know that number.\"\n",
503 |     "    \n",
504 |     "# Let's try out our function.\n",
505 |     "for current_number in range(0,6):\n",
506 |     "    number_word = get_number_word(current_number)\n",
507 |     "    print(current_number, number_word)"
508 |    ]
509 |   },
510 |   {
511 |    "cell_type": "markdown",
512 |    "metadata": {},
513 |    "source": [
514 |     "If you use a return statement in one of your functions, keep in mind that the function stops executing as soon as it hits a return statement. For example, we can add a line to the *get\\_number\\_word()* function that will never execute, because it comes after the function has returned a value:"
515 |    ]
516 |   },
517 |   {
518 |    "cell_type": "code",
519 |    "execution_count": 7,
520 |    "metadata": {
521 |     "collapsed": false
522 |    },
523 |    "outputs": [
524 |     {
525 |      "name": "stdout",
526 |      "output_type": "stream",
527 |      "text": [
528 |       "0 zero\n",
529 |       "1 one\n",
530 |       "2 two\n",
531 |       "3 three\n",
532 |       "4 I'm sorry, I don't know that number.\n",
533 |       "5 I'm sorry, I don't know that number.\n"
534 |      ]
535 |     }
536 |    ],
537 |    "source": [
538 |     "###highlight=[16,17,18]\n",
539 |     "def get_number_word(number):\n",
540 |     "    # Takes in a numerical value, and returns\n",
541 |     "    #  the word corresponding to that number.\n",
542 |     "    if number == 0:\n",
543 |     "        return 'zero'\n",
544 |     "    elif number == 1:\n",
545 |     "        return 'one'\n",
546 |     "    elif number == 2:\n",
547 |     "        return 'two'\n",
548 |     "    elif number == 3:\n",
549 |     "        return 'three'\n",
550 |     "    else:\n",
551 |     "        return \"I'm sorry, I don't know that number.\"\n",
552 |     "    \n",
553 |     "    # This line will never execute, because the function has already\n",
554 |     "    #  returned a value and stopped executing.\n",
555 |     "    print(\"This message will never be printed.\")\n",
556 |     "    \n",
557 |     "# Let's try out our function.\n",
558 |     "for current_number in range(0,6):\n",
559 |     "    number_word = get_number_word(current_number)\n",
560 |     "    print(current_number, number_word)"
561 |    ]
562 |   },
563 |   {
564 |    "cell_type": "markdown",
565 |    "metadata": {},
566 |    "source": [
567 |     "More Later\n",
568 |     "---\n",
569 |     "There is much more to learn about functions, but we will get to those details later. For now, feel free to use functions whenever you find yourself writing the same code several times in a program. Some of the things you will learn when we focus on functions:\n",
570 |     "\n",
571 |     "- How to give the arguments in your function default values.\n",
572 |     "- How to let your functions accept different numbers of arguments."
573 |    ]
574 |   },
575 |   {
576 |    "cell_type": "markdown",
577 |    "metadata": {},
578 |    "source": [
579 |     "[top](#)"
580 |    ]
581 |   },
582 |   {
583 |    "cell_type": "markdown",
584 |    "metadata": {},
585 |    "source": [
586 |     "Exercises\n",
587 |     "---\n",
588 |     "#### Greeter\n",
589 |     "- Write a function that takes in a person's name, and prints out a greeting.\n",
590 |     "    - The greeting must be at least three lines, and the person's name must be in each line.\n",
591 |     "- Use your function to greet at least three different people.\n",
592 |     "- **Bonus:** Store your three people in a list, and call your function from a `for` loop.\n",
593 |     "\n",
594 |     "#### Full Names\n",
595 |     "- Write a function that takes in a first name and a last name, and prints out a nicely formatted full name, in a sentence. Your sentence could be as simple as, \"Hello, *full\\_name*.\"\n",
596 |     "- Call your function three times, with a different name each time.\n",
597 |     "\n",
598 |     "#### Addition Calculator\n",
599 |     "- Write a function that takes in two numbers, and adds them together. Make your function print out a sentence showing the two numbers, and the result.\n",
600 |     "- Call your function with three different sets of numbers.\n",
601 |     "\n",
602 |     "#### Return Calculator\n",
603 |     "- Modify *Addition Calculator* so that your function returns the sum of the two numbers. The printing should happen outside of the function.\n",
604 |     "\n",
605 |     "#### List Exercises - Functions\n",
606 |     "- Go back and solve each of the following exercises from the section on [Lists and Tuples](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/lists_tuples.ipynb), using functions to avoid repetetive code:\n",
607 |     "    - [Ordered Working List](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/lists_tuples.ipynb#exercises_common_operations)\n",
608 |     "    - [Ordered Numbers](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/lists_tuples.ipynb#exercises_common_operations)\n",
609 |     "\n"
610 |    ]
611 |   },
612 |   {
613 |    "cell_type": "markdown",
614 |    "metadata": {},
615 |    "source": [
616 |     "[top](#)"
617 |    ]
618 |   },
619 |   {
620 |    "cell_type": "markdown",
621 |    "metadata": {},
622 |    "source": [
623 |     "Challenges\n",
624 |     "---\n",
625 |     "#### Lyrics\n",
626 |     "- Many songs follow a familiar variation of the pattern of *verse*, *refrain*, *verse*, *refrain*. The verses are the parts of the song that tell a story - they are not repeated in the song. The refrain is the part of the song that is repeated throughout the song.\n",
627 |     "- Find the lyrics to a [song you like](http://www.metrolyrics.com/dont-stop-believin-lyrics-journey.html) that follows this pattern. Write a program that prints out the lyrics to this song, using as few lines of Python code as possible. [hint](#hint_challenges_lyrics)"
628 |    ]
629 |   },
630 |   {
631 |    "cell_type": "markdown",
632 |    "metadata": {},
633 |    "source": [
634 |     "[top](#)"
635 |    ]
636 |   },
637 |   {
638 |    "cell_type": "markdown",
639 |    "metadata": {},
640 |    "source": [
641 |     "- - -\n",
642 |     "[Previous: Lists and Tuples](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/lists_tuples.ipynb) | \n",
643 |     "[Home](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/index.ipynb) |\n",
644 |     "[Next: If Statements](http://nbviewer.ipython.org/urls/raw.github.com/ehmatthes/intro_programming/master/notebooks/if_statements.ipynb)"
645 |    ]
646 |   },
647 |   {
648 |    "cell_type": "markdown",
649 |    "metadata": {},
650 |    "source": [
651 |     "Hints\n",
652 |     "===\n",
653 |     "These are placed at the bottom, so you can have a chance to solve exercises without seeing any hints.\n",
654 |     "\n",
655 |     "#### Lyrics\n",
656 |     "- Define a function that prints out the lyrics of the refrain. Use this function any time the refrain comes up in the song."
657 |    ]
658 |   }
659 |  ],
660 |  "metadata": {
661 |   "kernelspec": {
662 |    "display_name": "Python 3",
663 |    "language": "python",
664 |    "name": "python3"
665 |   },
666 |   "language_info": {
667 |    "codemirror_mode": {
668 |     "name": "ipython",
669 |     "version": 3
670 |    },
671 |    "file_extension": ".py",
672 |    "mimetype": "text/x-python",
673 |    "name": "python",
674 |    "nbconvert_exporter": "python",
675 |    "pygments_lexer": "ipython3",
676 |    "version": "3.4.0"
677 |   }
678 |  },
679 |  "nbformat": 4,
680 |  "nbformat_minor": 0
681 | }
682 | 


--------------------------------------------------------------------------------