00_introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check online documentation on jupyter [here](http://nbviewer.jupyter.org/urls/bitbucket.org/ipre/calico/raw/master/notebooks/Documentation/Reference%20Guide/Reference%20Guide.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is python, programming is fun again\n"
     ]
    }
   ],
   "source": [
    "print(\"this is python, programming is fun again\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This b.t.w is a comment\n",
    "\n",
    "variable = \"2\"\n",
    "print(variable)\n",
    "type(variable)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the function `print` allows also more powerful way of outputting numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Art:   453, Prince per unit:    59.06\n"
     ]
    }
   ],
   "source": [
    "print (\"Art: %5d, Prince per unit: %8.2f\"% (453, 59.058))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'51'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a, b = 5,\"1\"# a python trick to assign values to more than one variable\n",
    "print (a,b)\n",
    "str(a)+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set the value of x18\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "x=input(\"set the value of x\")\n",
    "print (x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "try to sum a and b; if it doesn't work, cast one of the two and repeat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators\n",
    "the usual stuff.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "#print(3/4)\n",
    "#print(3.0 / 4.0)\n",
    "#print(3%4)\n",
    "#print(3//4)\n",
    "#print(3**4)\n",
    "#print(pow(3,4))\n",
    "\n",
    "x=1\n",
    "print(type(x))\n",
    "y=1.0\n",
    "print(type(y))\n",
    "#a,b = int(3), int(4)\n",
    "#print(a/b)\n",
    "#print(float(a)/float(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterators\n",
    "very similar to all other languages. Start exploring the `range` and `enumerate` functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,10): print (i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i < 10:\n",
    "    print(i)\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 4\n",
      "1 5\n",
      "2 2\n",
      "3 7\n"
     ]
    }
   ],
   "source": [
    "for i, j in enumerate([4,5,2,7]): print(i,j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional Statements\n",
    "Mind the indentation! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "elif\n"
     ]
    }
   ],
   "source": [
    "a = 21\n",
    "if a >= 22: \n",
    "    print(\"if\")\n",
    "elif a >= 21:\n",
    "    print(\"elif\")\n",
    "else:\n",
    "    print(\"else\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "try/except: a very important and powerful type of conditional expression, use it and use it with care "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "try:\n",
    "  b = a + 2\n",
    "  print (b)\n",
    "except:\n",
    "  print(a, \" is not a number\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def my_function(a,b=2):\n",
    "    result = a+2*b\n",
    "    return result\n",
    "\n",
    "my_function(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the function does not specify the types of the arguments, like you would see in statically typed languages. This is both useful and dangerous. Use the try/except construction to make it safe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists, Tuples, Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "Lists are exactly as the name implies. They are lists of objects. The objects can be any data type (including lists), and it is allowed to mix data types. In this way they are much more flexible than arrays. It is possible to append, delete, insert and count elements and to sort, reverse, etc. the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'B', 'F', 'G', 'd', 'x', 'c', [1, 2, 3, 'this is a string', 5.3], 3]\n"
     ]
    }
   ],
   "source": [
    "a_list = [1,2,3,\"this is a string\",5.3]\n",
    "b_list = [\"A\",\"B\",\"F\",\"G\",\"d\",\"x\",\"c\",a_list,3]\n",
    "print(b_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Manipulations of list is rather intuitive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "10\n",
      "[3, 4]\n",
      "[7, 5, 3]\n",
      "[4, 10]\n",
      "[4, 10]\n",
      "[5, 10]\n"
     ]
    }
   ],
   "source": [
    "a = [7,5,3,4,10]\n",
    "print(a[0])\n",
    "print(a[-1])\n",
    "print(a[2:4])\n",
    "print(a[:3])\n",
    "print(a[3:])\n",
    "print(a[3:len(a)])\n",
    "print(a[1::3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 7, 5, 3, 4, 10]\n",
      "[0, 7, 5, 3, 4, 10, 8]\n",
      "[8, 10, 4, 3, 5, 7, 0]\n",
      "[0, 3, 4, 5, 7, 8, 10]\n",
      "[0, 3, 4, 5, 7, 8]\n",
      "[0, 4, 5, 7, 8]\n",
      "[0, 4, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "a.insert(0,0)\n",
    "print(a)\n",
    "a.append(8)\n",
    "print(a)\n",
    "a.reverse()\n",
    "print(a)\n",
    "a.sort()\n",
    "print(a)\n",
    "a.pop()\n",
    "print(a)\n",
    "a.remove(3)\n",
    "print(a)\n",
    "a.remove(a[4])\n",
    "print(a)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Very fancy operations are possibile (known as list [comprehensions](https://docs.python.org/2/tutorial/datastructures.html?highlight=comprehensions))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]\n"
     ]
    }
   ],
   "source": [
    "even_numbers = [x for x in range(20) if x % 2 == 0]\n",
    "print (even_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "strings are lists and feature all operations permitted on strings, comprehensions as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['I', 't', ' ', 'w', 'a', 's', ' ', 'a', ' ', 'd', 'a', 'r', 'k', ' ', 'a', 'n', 'd', ' ', 's', 't', 'o', 'r', 'm', 'y', ' ', 'n', 'i', 'g', 'h', 't', '.']\n"
     ]
    }
   ],
   "source": [
    "first_sentence = \"It was a dark and stormy night.\"\n",
    "characters = [x for x in first_sentence]\n",
    "print(characters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "Tuples are like lists with one very important difference. Tuples are not changeable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4)\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-50-69d310c07e2c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "a = (1,2,3,4)\n",
    "print(a)\n",
    "a[1] = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "Dictionaries are of paramount importance and a major asset of python.\n",
    "They are unordered, keyed lists. Lists are ordered, and the index may be viewed as a key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n"
     ]
    }
   ],
   "source": [
    "a = {'anItem': \"A\", 'anotherItem': [\"a,bc\"],3:\"C\",'afourthItem':7} # dictionary example\n",
    "print(a['anItem'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in a: print (i,a[i]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings and String Handling\n",
    "One of the most important features of Python is its powerful and easy handling of strings. Defining strings is simple enough in most languages. But in Python, it is easy to search and replace, convert cases, concatenate, or access elements. We’ll discuss a few of these here. For a complete list, see this [tutorial]( http://www.tutorialspoint.com/python/python_strings.htm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"A string of characters, with newline \\n CAPITALS, etc.\"\n",
    "print(a)\n",
    "b=5.0\n",
    "newstring = a + \"\\n We can format strings for printing %.2f\"\n",
    "print(newstring %b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operations are easy (remember strings are lists!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"ABC DEFG\"\n",
    "print(a[1:3])\n",
    "print(a[0:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"ABC defg\"\n",
    "print(a.lower())\n",
    "print(a.upper())\n",
    "print(a.find('d'))\n",
    "print(a.replace('de','a'))\n",
    "print(a)\n",
    "b = a.replace('def','aaa')\n",
    "print(b)\n",
    "b = b.replace('a','c')\n",
    "print(b)\n",
    "b.count('c')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc defg'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"ABC defg\".lower()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}