python_demo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Demo\n",
    "Because live coding sucks and you should very rarely do it, I've premade some things to go through. This assumes you have the basic principles of coding down and just need an intro to the new language. Also, I'm using Python 3 which might annoy some people but it is the latest version shipped with Anaconda. Eventually everyone should just use this.\n",
    "\n",
    "To start, let's begin with the stereotypical \"Hello World!\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well that was easy, here is the comparable C++ code:\n",
    "```c++\n",
    "#include <iostream>\n",
    "using namespace std;\n",
    "int main(int argc, char *argv[]) {\n",
    "    cout << \"Hello World!\" << endl;\n",
    "    return 0;\n",
    "}\n",
    "```\n",
    "\n",
    "Let's make it a bit more fun and add some variables. Notice how I don't use a keyword to declare variables, I just declare them. Also, variables can become different things. Welcome to python, where the syntax is made up and the types don't matter!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "86.75309\n",
      "500\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# single quotes or double quotes -- it doesn't matter\n",
    "# as long as you are consistent with the opening and closing\n",
    "str_val = 'Hello World!'\n",
    "int_val = 10\n",
    "float_val = 86.75309\n",
    "bool_val = True\n",
    "\n",
    "# don't do this if you aren't sure you are working with primitive data types!\n",
    "str_val = int_val\n",
    "int_val = float_val\n",
    "float_val = 500\n",
    "\n",
    "print(str_val)\n",
    "print(int_val)\n",
    "print(float_val)\n",
    "print(bool_val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even though I did it there, its generally good practice to be clear on what a variable is supposed to be, semantically at least. If you are transforming an object a bunch of times into different things, you can use the same variable. Just be wary, dynamic typing can bite you if you don't know what an object is!\n",
    "\n",
    "Now a few useful tips about the types I mentioned above:\n",
    "\n",
    "* Strings are immutable. If you want to be able to change a string, use a MutableString."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "str_val = 'Hello World!'\n",
    "# this will error:\n",
    "#str_val[0] = \"F\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Going from a string to any of those types or any of those types to a string  is extremely easy. It also supports different bases (so converting from an int to hex is really easy!) though I don't demonstrate that here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "990\n",
      "73.5\n",
      "7373.73 Hello!\n",
      "65\n",
      "A\n"
     ]
    }
   ],
   "source": [
    "# all the basic arithmetic operations are supported\n",
    "# with the exception of pre-increment and post-increment\n",
    "int_val = int(\"982\")\n",
    "int_val += 8\n",
    "print(int_val)\n",
    "\n",
    "float_val = \"73.2\"\n",
    "float_val = float(float_val)\n",
    "float_val += .3\n",
    "print(float_val)\n",
    "\n",
    "str_val = str(7373.73)\n",
    "str_val = str_val + \" Hello!\" # note that this works because it is returning a completely new string\n",
    "print(str_val)\n",
    "\n",
    "print(ord(\"A\"))\n",
    "print(chr(65))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We failed\n"
     ]
    }
   ],
   "source": [
    "# every value can be of type None -- useful for checking to see if a value has been set\n",
    "test = None\n",
    "\n",
    "if test is not None:\n",
    "    print(\"We did it!\")\n",
    "else:\n",
    "    print(\"We failed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More complicated native data structures\n",
    "Python has some other nice built-in data structures that you might want to be aware of:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['42', 42, 'The answer to the ultimate question of life, the universe, and everything']\n",
      "[['42', 42, 'The answer to the ultimate question of life, the universe, and everything'], ['one', 1, 1.0]]\n",
      "dict_keys(['Tyler', 'Jacob', 'Camille'])\n",
      "([['42', 42, 'The answer to the ultimate question of life, the universe, and everything'], ['one', 1, 1.0]], {'Tyler': 42, 'Jacob': 0, 'Camille': 17})\n",
      "It's in!\n",
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "# lists -- basically a vector but with more features\n",
    "# elements can be anything and don't have to be the same thing\n",
    "fourty_two = [\"42\", 42, \n",
    "              \"The answer to the ultimate question of life, the universe, and everything\"]\n",
    "print(fourty_two)\n",
    "\n",
    "# demo slices here\n",
    "\n",
    "# you can have lists of lists\n",
    "numbers = [fourty_two, [\"one\", 1, 1.0]]\n",
    "print(numbers)\n",
    "\n",
    "# basically you can do just about anything with lists\n",
    "# but the next data structure is even nicer\n",
    "\n",
    "# dictionary -- essentially a unique keyed map (implemented as a hash map)\n",
    "id_dict = {\"Tyler\": 42, \"Jacob\": 0}\n",
    "id_dict[\"Camille\"] = 17\n",
    "other_dict = dict() \n",
    "print(id_dict.keys()) # notice that the keys are not in any order\n",
    "\n",
    "\n",
    "\n",
    "# these are incredibly useful\n",
    "# keys can be anything that can be hashed, and values can be anything\n",
    "\n",
    "# tuples -- sort of like lists, but immutable\n",
    "tup = (numbers, id_dict)\n",
    "print(tup)\n",
    "\n",
    "# sets -- pretty much a set, but again no order. Implemented similarly to a dictionary\n",
    "set_thing = set()\n",
    "set_thing.add(1)\n",
    "set_thing.add(2)\n",
    "set_thing.add(3)\n",
    "set_thing.add(1)\n",
    "\n",
    "if 1 in set_thing:\n",
    "    print(\"It's in!\")\n",
    "print(set_thing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Looping and flow control\n",
    "Python, like every other language, has a variety of flow control options:\n",
    "#### For loops ####\n",
    "These are a bit different than what you are probably used to with C++. These two statements are equivalent:\n",
    "```c++\n",
    "//C++\n",
    "for(i = 0; i < 10; i++) {\n",
    "    //do something\n",
    "}\n",
    "```\n",
    "\n",
    "```python\n",
    "# python\n",
    "for i in range(10):\n",
    "    # do something\n",
    "```\n",
    "\n",
    "Instead of incrementing a variable, what you are really doing in python is iterating over items in a list. The following example shows why that might be useful:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Greetings\n",
      "Ahoy\n",
      "Hello\n",
      "Greetings\n",
      "Ahoy\n",
      "World 2\n",
      "Hello 1\n"
     ]
    }
   ],
   "source": [
    "greeting_words = [\"Hello\", \"Greetings\", \"Ahoy\"]\n",
    "\n",
    "# very un-pythonic -- don't do this\n",
    "for i in range(len(greeting_words)):\n",
    "    print(greeting_words[i])\n",
    "    \n",
    "# very pythonic -- simple and elegant\n",
    "# do this\n",
    "for i in greeting_words:\n",
    "    print(i)\n",
    "    \n",
    "# you can also iterate over pairs of things -- unpacking arguments\n",
    "new_word_pairs = [(\"Hello\", 1), (\"World\", 2)]\n",
    "for i, j in sorted(new_word_pairs, reverse=True):\n",
    "    print(i, j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### While Loops ####\n",
    "Though fairly un-pythonic, while loops definitely are useful. Here is what they look like in python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 10:\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### If, Elif, and Else #### \n",
    "Python supports normal boolean control flow:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "temp = 12\n",
    "temp1 = 13\n",
    "if temp == 13 or temp1 == 14:\n",
    "    print(\"13\")\n",
    "elif (temp == 12) and temp1 == 13:\n",
    "    print(\"12\")\n",
    "else:\n",
    "    print(\"You stupid\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that Python does not have switch statements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "Python, like pretty much every other language, has functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "88.8\n"
     ]
    }
   ],
   "source": [
    "# function to increment the value passed\n",
    "# notice that it doesn't specify a return type\n",
    "# or a type on the variable it takes\n",
    "\n",
    "def increment(x):\n",
    "    return x+1\n",
    "\n",
    "print(increment(87.8))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can take multiple arguments and return multiple arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 4\n"
     ]
    }
   ],
   "source": [
    "def increment_two(x, y):\n",
    "    return x+1, y+1\n",
    "\n",
    "a, b = increment_two(2, 3)\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, functions are pretty much just objects. They can be passed around and to other functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def exececute_function(arg, func):\n",
    "    return func(arg) \n",
    "\n",
    "# this seems useless, but check out this logging function:\n",
    "def log(arg, func):\n",
    "    print(\"calling function\")\n",
    "    return func(arg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can have both positional and keyword arguments, but once you do a keyword argument everything afterward will have to be keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[0, 2, 4, 6, 8]\n",
      "[3, 6, 9]\n"
     ]
    }
   ],
   "source": [
    "# this probably isn't how it is implemented\n",
    "def my_range(end, start=0, factor=None):\n",
    "    i = start\n",
    "    rv = []\n",
    "    if factor is None:\n",
    "        factor = 1\n",
    "    while i < end:\n",
    "        rv.append(i)\n",
    "        i += factor\n",
    "    return rv\n",
    "\n",
    "print(my_range(10))\n",
    "print(my_range(10, 1, 1))\n",
    "print(my_range(10, factor=2))\n",
    "print(my_range(start=3, end=10, factor=3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can do a ton of stuff, but this is most of what you need to know to write your own. \n",
    "## Classes\n",
    "Python has support for classes. Classes are a huge topic and there are a bunch of different ways to format them, but here is the basic format. Notice that all member variables and functions are public, and they have to take a reference to \"self\" or the object you are trying to act on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tyler: Age 21\n",
      "Tyler: Age 22\n"
     ]
    }
   ],
   "source": [
    "# class to define a person\n",
    "class Person:\n",
    "    # init function -- initializer\n",
    "    # define all of the member variables here\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        \n",
    "    # when you want to print things nicely, \n",
    "    # override the __str__ method\n",
    "    def __str__(self):\n",
    "        # oh crap haven't talked about this yet\n",
    "        return \"{}: Age {}\".format(self.name, self.age)\n",
    "    \n",
    "    def have_birthday(self):\n",
    "        self.age += 1\n",
    "        \n",
    "t = Person(\"Tyler\", 21)\n",
    "print(t)\n",
    "t.have_birthday()\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Error handling\n",
    "Python handles errors through exceptions that you can catch. You do that through try - except clauses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a stupid example\n"
     ]
    }
   ],
   "source": [
    "# simple example -- normally some function that you were calling \n",
    "try:\n",
    "    raise Exception(\"this is a stupid example\")\n",
    "except Exception as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More Advanced Stuff\n",
    "These are some more advanced things about Python that I really like and I find myself using.\n",
    "\n",
    "#### List Comprehensions ####\n",
    "These are incredibly useful when you need to do data transformations on a list. It's similar to functional programming but much more pythonic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[0, 2, 0, 4]\n"
     ]
    }
   ],
   "source": [
    "str_list = [\"1\", \"2\", \"3\", \"4\"]\n",
    "\n",
    "# get a list of normal ints\n",
    "int_list = [int(x) for x in str_list]\n",
    "print(int_list)\n",
    "\n",
    "# you can even add some if statements and things in there\n",
    "even_int_list = [int(x) if int(x) % 2 == 0 else 0 for x in str_list]\n",
    "print(even_int_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lambda Functions ####\n",
    "These are essentially unnamed functions that you can pass as arguments or do a bunch of different things with. For example, say you want to sort based on absolute value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, -1, 1, 4, 10, -15]\n"
     ]
    }
   ],
   "source": [
    "# list of numbers\n",
    "l = [10, 4, -15, -1, 1, 0]\n",
    "l.sort(key=lambda x: abs(x))\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Applications of lambda functions are all over Python, and you definitely will come across them in your development.\n",
    "\n",
    "#### Zip function ####\n",
    "One thing I have found particularly useful when doing data science stuff is the zip function. It essentially takes two lists and pairs them up so you get tuples in the format (x[i], y[i]):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "two 1\n",
      "three 2\n",
      "four 3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "str_list = [\"one\", \"two\", \"three\", \"four\"]\n",
    "int_list = [1, 2, 3]\n",
    "\n",
    "for i, j in zip(str_list[1:], int_list):\n",
    "    print(i, j)\n",
    "    \n",
    "print(len(str_list))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SetAttr ####\n",
    "There's no way to set a variable using just the name as a string, right? Wrong:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Person has the following variables:\n",
      "    name\n",
      "    age\n",
      "Change which variable: title\n",
      "New value: Python Boss\n",
      "Tyler: Age 21\n",
      "    name\n",
      "    age\n",
      "    title\n"
     ]
    }
   ],
   "source": [
    "t = Person(\"Tyler\", 21)\n",
    "print(\"Person has the following variables:\")\n",
    "for i in vars(t):\n",
    "    print(\"    {}\".format(i))\n",
    "    \n",
    "change_var = input(\"Change which variable: \")\n",
    "new_val = input(\"New value: \")\n",
    "\n",
    "setattr(t, change_var, new_val)\n",
    "print(t)\n",
    "\n",
    "for i in vars(t):\n",
    "    print(\"    {}\".format(i))"
   ]
  },
  {
   "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.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}