Community Data Science Workshops (Fall 2015)/Day 1 lecture

Welcome to the Saturday lecture section of the Community Data Science Workshop! For about 2 hours, we'll work through an introduction to the Python programming language via both a lecture and hand-on exercises.

At the beginning of the lecture, we'll give a short pre-lecture talk to motivate the sessions.

Resources

 * Python data types cheat sheet
 * Python loops cheat sheet
 * state_capitals.py -- the state capitals example.
 * Lecture Recording/Screencast — The file is in OGV/Theora format. If you have trouble playing it, you can install the free software VLC software which runs on Mac OSX, Windows and Linux and should be able to play the video.

Review Friday material

 * math: using python as a calculator
 * addition, subtraction, multiplication, division
 * division shows something different:  versus
 * type
 * there are different types of things in python (called objects)
 * variables that "know about the decimal place" (int) and variables that don't (floats)
 * variables
 * assignment of variaibles
 * e.g., math with variables: scale up a recipe, into an assignment
 * you can assign to a variable and it will replace the old value
 * strings
 * things within quotation marks
 * adding strings with "concatination" (smushing things together)
 * e.g.,
 * concatenating strings and integers don't work (e.g., )
 * 1 is different than "1"; name is different than "name"
 * single quotes versus double quotes (python doesn't care)
 * you can also multiply strings! (although it's not clear why you want to weird)
 * booleans
 * comparisons (e.g.,  or  )
 * you can compare strings (case sensative!)
 * also >, <, and !=
 * type shows that the output of True or False is
 * e.g.,
 * e.g.,
 * if/elif/else (move to external file)
 * if, something that evaluates to a boolean, and then colon
 * e.g.,
 * e.g., adding else example:
 * e.g., tempreature range
 * e.g., adding elif: fix the bug in the previous program if they were the same age
 * indent with spaces (we use 4 spaces!)
 * functions
 * has a parentheses
 * we've already learnd examples of this: exit, help, type

Lists

 * purpose
 * Stores things in order
 * initialization
 * making a list called my list:
 * comma separated elements. in python they can be a mix of any kind of types
 * len review
 * accessing elements
 * indexing like my_list[0]
 * indexing starts from the front and we start counting at 0 (now you understand all the zeros we've been using
 * we go from the end with negative numbers
 * what happens if we try to move outside of the range? ('error!)
 * adding elements
 * using the the  function
 * the  function is a special kind of function that lists know about
 * changing elements
 * replacing elements like
 * finding elements in list
 * e.g.,
 * slicing lists
 * the colon inside the [] is the slicing syntax
 * e.g.,  is 0th up to, but not including, the 2nd
 * e.g.,
 * e.g.,
 * e.g.,
 * strings are like lists
 * we can slice lists
 * len
 * length of the empty string
 * many other interesting functions for lists
 * e.g.,  and
 * e.g., create a list of names and sort it
 * e.g., create a list of names and sort it

loops and more flow control

 * for loops
 * e.g.,
 * e.g.,
 * Super powerful because it can do something many many times. Data science is about doing tedious things very quickly. For is the workhorse that makes this possible.
 * Look and see name is after we're done looping.
 * Move to editor.
 * if statements inside for loops
 * e.g.,  then print "starts with a vowel"
 * show we can test things outside the loop to show how the comparisons are working
 * add an else statement to capture words that start with a consonant
 * append to a list within a for loop
 * create a counter within a for loop (keep track)
 * build up a sentence
 * nested for</tt> loops
 * range</tt>
 * while</tt> loops
 * infinite loops
 * if</tt> statements inside while</tt> loops
 * break</tt>
 * input</tt>

dictionaries

 * purpose
 * initialization
 * accessing elements
 * adding elements
 * changing elements
 * keys</tt> and values</tt>

modules

 * purpose
 * builtins
 * imports
 * import random</tt>
 * random.randint</tt>
 * random.choice</tt>

walk through state_capitals.py
Where state_capitals.py from http://mako.cc/teaching/2015/cdsw-spring/state_capitals.py is the grand finale and synthesis of lecture material.