1.1_2_variables_functions_and_loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quick and dirty calculations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If python is your first programming language, that is worth mentioning that you can use it as a stupid calculator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "5*6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mem = 5*6\n",
    "mem = mem + 10\n",
    "mem / 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also manipulate text:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "basic_text = \"basic text\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#append something to the text\n",
    "basic_text = basic_text + \" and something after the text\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# display the content of a stored variable : use print\n",
    "print(basic_text)\n",
    "\n",
    "# print also works for number\n",
    "print(mem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Have a look at this code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "age = 21\n",
    "bank_balance = 500\n",
    "name = \"Wang Xiaoming\"\n",
    "\n",
    "\n",
    "print(name + \", \" + str(age) + \" years old\") #we can transform a number into a text containing that number using 'str'\n",
    "\n",
    "# Xiaoming gets one year older\n",
    "age = age + 1\n",
    "print (\"Times goes by \" + name + \" is \" + str(age) + \" years old now\")\n",
    "print(name + \" has \" + str(bank_balance) + \" in his account\")\n",
    "\n",
    "# Payday\n",
    "bank_balance = bank_balance + 30000 #Xiaoming is a data scientist he just had his first job\n",
    "print(name + \" has \" + str(bank_balance) + \" in his account\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "age, bank_balance, name are \"variables\". Variables are everywhere in programming, they name \"a content\". \n",
    "\n",
    "In Python you can write anything in a varible: a number, a text, or other more complicated data.\n",
    "\n",
    "You can modify and reuse this content anywhere in your code provided the variable exist.\n",
    "\n",
    "You can create variables almost without restrictions just like this:\n",
    "* variable_name = \"value\"\n",
    "\n",
    "Here a few restrictions:\n",
    "* the name of a variable can only contain letters, underscore '_' and numbers\n",
    "* a variable name cannot strat with a number\n",
    "\n",
    "Examples:\n",
    "* \"3friends\" is not valid name, \n",
    "* \"age_of_Xiaoming\", \"age2\" are valid names.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loops is what actually make computers work for us. Looping means repeating. I can make python count until ten for me:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    print i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yes, it is not a mistake, it starts from 0 and ends at 9. This is something you will find in many programming languages, so better get used to it: *counting starts at 0*.\n",
    "\n",
    "**Exercice:** Make python count from one to ten."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The one thing you wanna learn here is the syntax for \"looping\":\n",
    "\n",
    "**for** *variable_name* **in** *[list of values]* :\n",
    "  \n",
    "  (Write the repeated code with 4 spaces indent)\n",
    "  the variable_name takes one by one each value in the given list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Other example:\n",
    "for value in [5, \"five\", 6, \"six\"]: # a list is between brakets [] and elements are separated by a coma \",\"\n",
    "    print value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remark:** range(10) is actually also a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print range(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# If statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I would say that if statements along with loops are the elementary concepts that make programming possible. \n",
    "\n",
    "If statements might be the first step for machines to be just a bit intelligent, this is what get them out from just repearting things.\n",
    "\n",
    "But first you need just a simple concept: booleans.\n",
    "A boolean can only have two possible values : True and False.\n",
    "I really mean \"True\" and \"False\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "my_boolean = True\n",
    "print(my_boolean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "my_boolean = False\n",
    "print(my_boolean)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course it is not interesting just as is: \n",
    "It becomes interesting when a boolean can be used as a condition for something you do only *if* the condition is met.\n",
    "\n",
    "A condition is a computation that outputs a boolean.\n",
    "\n",
    "You already know some of the most basic operators that produce booleans: '<' '>'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "my_boolean = 5 > 3 #this is True\n",
    "print my_boolean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "my_boolean = 5 < 3 #this is False\n",
    "print my_boolean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is one thing missing here, you might want to test if two variables are equal. \n",
    "\n",
    "It is not just \"=\". Because '=' is already taken for assignement:\n",
    "\"a = 5\" means write 5 into variable \"a\"\n",
    "\n",
    "But \"==\" is the one you want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 5\n",
    "print(a = 5) #python will not understand that"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 5\n",
    "print(a == 5) #much better\n",
    "\n",
    "#you can also test \"not equal\"\n",
    "print(a != 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# And finally the if statement, I will combine it with a loop, because you can already understand everything\n",
    "\n",
    "for j in [47, 56, 1, 9, 5, 45, 32]: #don't forget the \":\" after the \"for\"\n",
    "    if j > 25: #don't forget the \":\" after a if\n",
    "        print(str(j) + \" is higher than 25\") #don't forget to indent\n",
    "    else:\n",
    "        print(str(j) + \" is lower than 25\")\n",
    "        \n",
    "        \n",
    "# the rule of thumb to know when you should add \":\" is: \"When you need to indent things.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So the syntax is:\n",
    "\n",
    "**if** *boolean variable, or condition outputing a boolean value* :\n",
    "\n",
    "(the code you want to write under that condition under 4 spaces indent)\n",
    "\n",
    "**else**: (the else is optional)\n",
    "\n",
    "(the code you want to write when that condition is false under 4 spaces indent)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conditional loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conditional loops is the easier way to block your program.... Use with care.\n",
    "\n",
    "Conditional loops, are not supposed to be infinite, but they can be if you don't design your code correctly.\n",
    "\n",
    "An \"conditional loop\", is like a loop except that instead of looping for a pre-defined number of values, conditional loops, keep looping while a condition is met.\n",
    "\n",
    "They may become infinite loops, if the condition is never met. This is how you can block your program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#bad example where you should not use an inifinite loop\n",
    "i = 0\n",
    "while i < 5:\n",
    "    print i\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It was a bad example: you should not use conditional when you can tell beforehand how many times you want your program to loop.\n",
    "\n",
    "Use it only when really really, after thinking a lot you conclude that it is impossible to say how many times your loop is gonna be reapeated. \n",
    "\n",
    "Usually this happends when the condition that make the loop stop depends on some event external to your program such as the user actions.\n",
    "\n",
    "Which mean for now you don't need it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions is what makes programming tidy and powerfull. \n",
    "So far we had just shown some instructions.\n",
    "\n",
    "But when you spend a lot of time working on some instructions and you are statisfied with the result, you may want to group them together and reuse them without copy-pasting.\n",
    "\n",
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def print_account_balance(name, bank_balance):\n",
    "    print(name + \" has \" + str(bank_balance) + \" in his account\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print_account_balance('Momo', 100000000000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function needs a name and a balance, and prints out the balance in a formated shape.\n",
    "\n",
    "**Exercise:** Try out different content in that function, you can change the number of inputs, for instance insert a familly name. The function can also say hello to the person owning the account"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One other very useful feature of functions is the \"return\" value. \n",
    "So far we were just printing this on the console which is good for testing and debugging.\n",
    "But once you are confident that your function is working you just want to get the output in a variable.\n",
    "\n",
    "I offer you the first example: this function outputs the sum of the values given in the first parameter that is a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_list(input_list):\n",
    "    sum = 0\n",
    "    for elt in input_list:\n",
    "        sum = sum + elt\n",
    "    return sum\n",
    "\n",
    "result = sum_list([0,1,12,4])\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The advantage of functions, is that you can reuse blocs of instructions everywhere you need them.\n",
    "\n",
    "For instance do you remember how to calculate the grades of a student ? \n",
    "You just compute the average of his grades at each exams.\n",
    "\n",
    "Lets say the grades are 80/100, 75/100, 90/100:  The average is (80 + 75 + 90) / 3 / 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "81\n"
     ]
    }
   ],
   "source": [
    "average = (80+75+90) / 3\n",
    "print average"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise: ** Make a function compute_average that take **one** list as input parameter, the functions loops what is inside the list and computes the average of the numbers inside the list.\n",
    "We call the function just like this:\n",
    "\n",
    "compute_average([80,75,90])\n",
    "\n",
    "compute_average([80,75,90,78,60]) #should also work\n",
    "\n",
    "\n",
    "**Exercise: ** In that function check that every grade is between 0 and 100 and print a message if this assumption is wrong, in that case ignore that grade and continue to compute the grade of the other grades.\n",
    "Test the function with inputs such as:\n",
    "[80,75,-96,159,78]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def compute_average(list_of_grades):\n",
    "    #write your code here\n",
    "        \n",
    "\n",
    "print compute_average([80,75,90]) #output should be 81\n",
    "print compute_average([80,75,90,78,60]) #output should be 76\n",
    "\n",
    "print compute_average([80,75,-96,159,78]) #output should be 77"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}