takehome/PyCAR_basics_takehome_notebook_complete.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to basic Python types and methods\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Type each command in your interpreter exactly as I describe it. We're going to move very quickly here. Don't worry. We're going to repeat these ideas over and over in the other lessons. This is just to give you a quick overview of the very basics of programming in Python. If you have questions, don't keep them to yourself. Just ask."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "variable = \"nicar\"\n",
    "\n",
    "print(variable)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, you don't have to declare a variable before you assign a value to it. Just give it a name and assign it a value using the = sign."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ".upper() is one of dozens of string method, in many ways similar to the functions you might be familiar with in Excel. What do you think this one does?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "variable.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might notice that the .upper() method doesn't permanently change the \"variable\" variable. We'll get to that in a minute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type(variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The built-in type function tells us what type of Python object our \"variable\" is. In this case, it's a string (or 'str'), which is a core type and brings with it a host of useful methods.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dir(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This produces a list of all the methods that you can perform on a string (an object of the 'str' type), as well as other attributes and names associated with strings. For now, you can ignore the ones that start with a double underscore."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "variable[0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is called slicing, when you use the brackets to 'slice' out characters from a string based on their position. Notice in Python, that we start counting at zero. So variable[0] returns the \"n\" in \"nicar\". The value after the colon is the position that we stop before. So variable[0:2] returns all the characters from position 0 until before position 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "variable[0:2]=\"py\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So you got a `TypeError`, right? Remember when the .upper() method didn't change the variable? A string is immutable. You can't change it in place, so if you want to change it, you have to create a new variable and assign the new value to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "variable.replace(\"ni\",\"py\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See what I mean?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "newvariable = variable.replace(\"ni\",\"py\")\n",
    "\n",
    "newvariable1=newvariable.upper()\n",
    "\n",
    "newvariable1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's use slicing to create a new string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "newvariable2 = newvariable1[0] + newvariable1[1].lower() + newvariable1[2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_A hint if you're using iPython, start typing \"newva\" and hit the tab button. It remembers all the variables you've assigned in your session and offers autocomplete._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "newvariable2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(newvariable2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you know the name of the method you want to use, but don't remember its purpose, or the arguments you need to pass to it, try the help() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "help(newvariable2.lower)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's add the year to our string \"pycar\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ourclass = newvariable2 + 14"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oops, another `TypeError`. You can't concatenate an integer and a string. Let's make that 14 a string by wrapping it in quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ourclass = newvariable2 + \"14\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ourclass * 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are great, but we're data journalists. We like to deal in numbers. So let's take a quick look at integers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mynumber = 14\n",
    "\n",
    "mynumber * 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type(mynumber)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "newnumber = mynumber + 84\n",
    "\n",
    "newnumber"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "newnumber += 500\n",
    "newnumber"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A useful shortcut, if you don't want to keep creating new variables, you can assign the new value to a variable of the same name using the += operator."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of my favorite Python types is the list. A list is an ordered collection of objects (variables, strings, integers, other lists, and more) and is mutable. You create a list by assigning wrapping it in brackets and assigning it to a variable. If you're familiar with JavaScript or Ruby, a Python list is very similar to an array.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mylist = [ourclass, newnumber]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "myname = \"Tom\"\n",
    "\n",
    "mylist.append(myname)\n",
    "\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "yourname = \"Heather\"\n",
    "yournumber = 37\n",
    "ournumber = 18\n",
    "\n",
    "mylist.append(yourname)\n",
    "mylist.append(yournumber)\n",
    "mylist.append(ournumber)\n",
    "\n",
    "mylist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because a list is a sequence (just as a string is a sequence of characters), we can also use the slicing method to pull out specific items from the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mylist[0:1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Probably the most powerful (and potentially dangerous) thing to do with a list is to iterate over it using a for loop, to perform some action on each item in the list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for item in mylist:\n",
    "    print(item * 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One thing that trips up a lot of people when they first dabble in Python is its \"meaningful whitespace.\" The way to tell the loop what actions to perform on each go-round, is to nest those actions underneath the \"for\" declaration. You nest the actions by indenting four spaces. You can technically also use tabs, but you can't mix spaces and tabs, and most Pythonistas prefer four spaces. This makes your loop more readable, but can occasionally make it easy to overlook when an action is incorrectly nested.\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## dicts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last Python type we'll talk about right now is the dictionary. If you're familiar with an object in JavaScript or a hash in Ruby, a dictionary in Python is very similar. It's an object that stores an unordered series of keys and values. You can create one by using the curly brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mydict = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mydict['class_size']=ournumber\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mydict['nerds']='at bar'\n",
    "\n",
    "mydict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mydict['nerds']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mylist.append(mydict)\n",
    "mylist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can nest a dictionary inside a list, if it suits you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mylist[1:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This barely skims the surface of what you can do in Python, but hopefully this overview will make you comfortable in starting the rest of the exercises or other tutorials."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "exit()"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}