Stanford DH Asia Python Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Digital Humanities Asia Workshop\n",
    "# Stylometerics and Genre Research in Imperial Chinese Studies\n",
    "# Python Basics\n",
    "## Paul Vierthaler, Boston College\n",
    "### @pvierth, vierthal@bc.edu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Basics\n",
    "We will need to know a little bit about Python in order for the following tutorial to make sense. This will not be a comprehensive introduction to Python. It will be just enough to get us started.\n",
    "\n",
    "## We are using Python 3.\n",
    "Many people are still using Python 2.7. We are using 3 because it is easier to use to study Chinese language. Python 2.7 is no longer being updated (aside from security updates).\n",
    "\n",
    "## Python is case sensitive.\n",
    "\n",
    "A is not the same thing as a.\n",
    "\n",
    "## Python doesn't like Chinese punctuation.\n",
    "You will need to use quotation marks throughout your code. Be careful, if you type commas or quotation marks while typing in Chinese, Python will not know how to handle them.\n",
    "\n",
    "## A # (hashtag) starts a comment.\n",
    "This allows you to tell someone who is reading your code what it does.\n",
    "\n",
    "## Variables\n",
    "A variable can be thought of as a way to contain information. You have to create them in order to use them. They can store any type of information in Python. We can call them ALMOST anything we want. We should avoid reserved words in Python (if, or, file, etc.). It should start with a lowercase letter and not an uppercase one or a number.\n",
    "\n",
    "Variables allow us to save information to reuse it later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# You can store integers\n",
    "x = 10\n",
    "\n",
    "# You can store strings\n",
    "y = \"Hi, my name is Paul\"\n",
    "\n",
    "# A variable can be as long as you like. It is best to use variable names\n",
    "# that express what the variable is.\n",
    "long_variable_names_work_too = 1.3\n",
    "\n",
    "hi = 'hello'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Printing\n",
    "This statement allows you to print (display) something to the console. This is not sending anything to your printer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It will change\n"
     ]
    }
   ],
   "source": [
    "print(\"It will change\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A Few Data Types\n",
    "\n",
    "## Integers\n",
    "Whole numbers. This behave a bit differently than expected when you divide them. Integer division drops the remainder. By default, Python 3 performs float division. Two slashes (//) allow for Integer division (we will see it later)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5000"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Here are some integers:\n",
    "2\n",
    "5\n",
    "5000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Here is some regular division:\n",
    "5/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Here is some integer division:\n",
    "5//2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Floats\n",
    "Floating Point Numbers (decimal numbers). These need to be treated with care as well, as they are estimations of precise numbers. Remember, under the hood, the computer uses binary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.008"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Here are some floating point numbers:\n",
    "1.4\n",
    "200.12\n",
    ".008"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "76.93461538461538"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Here is some floating point number division:\n",
    "1000.15/13"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the trailing numbers. They are not extremely precise. Be careful"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "Words. These are denoted using either single or double quotation marks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is also a string.'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"This is a string.\"\n",
    "'This is also a string.'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting a substring\n",
    "You can get a single character, or a substring by refering the index of the desired characters by number. Python is 0 index (meaning 0 is the first place, not 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T\n",
      "stri\n",
      "ing.\n"
     ]
    }
   ],
   "source": [
    "my_string = \"This is my string.\"\n",
    "print(my_string[0])\n",
    "print(my_string[11:15])\n",
    "print(my_string[-4:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boolean Values\n",
    "True and False are important values. They allow us to create logic in our programs.\n",
    "\n",
    "### Checking Boolean Values\n",
    "#### <\n",
    "is less than\n",
    "#### >\n",
    "is greater than\n",
    "#### <=\n",
    "is less than or equal to\n",
    "#### >=\n",
    "is greater than or equal to\n",
    "#### ==\n",
    "is equal to\n",
    "#### !=\n",
    "is not equal to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(1<5)\n",
    "print(2>5)\n",
    "print(4==4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "This is an object that can store information. It is ordered and very useful. Denoted with square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is an empty list:\n",
    "[]\n",
    "\n",
    "# This is a list with some information.\n",
    "[1, 2, 3, 4, 5, 6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Retriving Information From Lists\n",
    "You can get information out of a list by calling an item's index. Python is 0 indexed (meaning the first element is a 0 not a 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "numbers = [1,2,3,4,5,6]\n",
    "print(numbers[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "Dictionaries also store information but are not ordered. They use keys to refer to values. They are denoted with curly brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Halloween': 'October 31st',\n",
       " 'Independence Day': 'July 4th',\n",
       " 'Labor Day 2016': 'September 6th'}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is an empty list:\n",
    "{}\n",
    "\n",
    "# This is a list with some information:\n",
    "{\"Independence Day\":\"July 4th\", \"Halloween\":\"October 31st\", \"Labor Day 2016\":\"September 6th\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Retreiving information from a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "October 31st\n"
     ]
    }
   ],
   "source": [
    "holiday_dates = {\"Independence Day\":\"July 4th\", \"Halloween\":\"October 31st\", \"Labor Day 2016\":\"September 6th\"}\n",
    "\n",
    "print(holiday_dates[\"Halloween\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Structure\n",
    "Python uses indentation to denote code blocks. Some languages use keywords, like \"end\"\n",
    "\n",
    "## Loops\n",
    "loops allow you to run the same piece of code over and over.\n",
    "\n",
    "### While loops\n",
    "While a statment is true, execute the code inside the block:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 4:\n",
    "    print(i)\n",
    "    \n",
    "    # Increase i by one. This can also be written i += 1\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For loops\n",
    "Iterate through each item in a list (or other enumerable object)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tiger\n",
      "lion\n",
      "monkey\n",
      "pig\n"
     ]
    }
   ],
   "source": [
    "animals = [\"tiger\", \"lion\", \"monkey\", \"pig\"]\n",
    "for animal in animals:\n",
    "    print(animal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Libraries\n",
    "We can use code other people have written by importing libraries. These extend the basic functionality of Python. They are not automatically imported into the namespace for efficiency reasons. Anaconda comes with many libraries that will make our life much easier. We will import them as needed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import math, os, re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}