1_Introduction to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction to Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Getting Started with Python\n",
    "\n",
    "Why Python?\n",
    "* high-level language with a clean, clear syntax\n",
    "* excellent first programming language; still a 'serious language'\n",
    "* widely used in:  scientific computing, web applications\n",
    "\n",
    "The latest version of the language, Python 3.5, will be used throughout the whole tutorial as Python 2 is becoming obsolete and soon it will not be supported.\n",
    "\n",
    "Programming is a practical skill: you can only learn it by doing it, it's like learning to ride a bicycle. You need to tackle practical exercises or you won't learn to program.\n",
    "\n",
    "These iPython notebooks allow you to write and compile your code\n",
    "* enter Python expressions in notebook cells\n",
    "* to run the iPython notebook cell containing your code, press CTRL + ENTER and the notebook will compile your code and print the result\n",
    "\n",
    "<u>PLEASE NOTE</u>: **be warned! **\n",
    "\n",
    "Indentation is very important in Python (as we will soon see throughout the tutorial). If you precede your expression with even one stray space character, the Python shell will complain of an Indentation Error and refuse to execute your code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Arithmetic**\n",
    "\n",
    "Begin by entering some arithmetic expressions, after the *print* statements, using the basic arithmetic operators: + (plus), - (minus), * (multiply), / (divide). Try using different mixtures of the arithmetic operators, with and without brackets to fix the scope of operations. For cases without brackets, see if you correctly anticipate the operator scopes that Python assumes. Try expressions that mix float and integer types. (Line beginning with # is a comment and is ignored by Python.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Insert a series of arithmetic expressions after each statement to test everything that is required above\n",
    "\n",
    "print(1+1.7)\n",
    "\n",
    "print(5*3)\n",
    "\n",
    "print()\n",
    "\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Python Data Types**\n",
    "\n",
    "In Python pieces of information (or \"data\") have an associated data type. We've just seen two of these: *integers* (e.g. 2 and 3) and *floats* (e.g. 2.9 and 3.2). Another key Python type is *string*: a string is just a sequence of characters, e.g.  letters, spaces, etc, surrounded by <u>paired</u> quote characters\n",
    "* either single (') or double (\") quotation chars\n",
    "* e.g \"hello world\" and 'see this' are both strings\n",
    "\n",
    "**Basic Printing**\n",
    "\n",
    "The Python print function will print a value to the screen. The value might be a string, integer or float, and it can print multiple values, separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (\"Hello world.\")\n",
    "print(\"Our combined wealth is\", 22.55 + 11.33, 'pounds')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using variables**\n",
    "\n",
    "We can store values using *variables* for future use. A variable is like a named bucket\n",
    "which can hold values and we can later use that bucket's name to access the stored value.\n",
    "\n",
    "Run the following cell to see how Python handles value assignment. We use \"=\" to *assign* a value to a variable (whose name appears to the left of =) in this way:\n",
    "\n",
    "    <varname> = <expression>\n",
    "\n",
    "assigns the result of evaluating $<expression>$ to variable $<varname>$. Elsewhere, when a variable is *evaluated* (e.g. when it appears in an arithmetic expression), its value is accessed and used at that position.\n",
    "\n",
    "Most of the time, it is better to use *meaningful* names for variables, rather than simple names such as **x**. For example, we might use a variable named **balance** to store our bank balance as a foating point number, or a variable named **message** to store a string that is to be printed as a message. Using meaningful variable names makes your code much more readable and understandable, and is a key feature of good programming style. It not only helps someone else to understand your code (e.g. me, if I'm marking it), it also helps **you** understand your own code, which is vital if you're trying to figure out why it doesn't work, or does something that you're not expecting. Note that variable names can contain letters, digits and underscores (i.e. _), but must begin with a letter. Note also that there are some special words, Python's keywords, that cannot be used as variable names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 12.5\n",
    "print(x)\n",
    "\n",
    "y = 3 * x + 2\n",
    "print(y)\n",
    "\n",
    "x = x + 1.1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Strings**\n",
    "\n",
    "As it is mentioned above, strings are just character sequences between paired quotation marks. Python doesn't mind if you use \" or ' for this, as long as you have the same quotation mark at both the start and end of the string. Some of the arithmetic operators, specifically + and \\*, have additional special meanings when used with strings. Below you have two strings, *s1* and *s2*. We can evaluate expressions such as **s1 + s2** and **s1 \\* 10**. Investigate the effects of these operations below. Also, investigate precedence for these operators, e.g. by entering: **s1 + s2 \\* 10**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = \"Hello \"\n",
    "s2 = \"World \"\n",
    "\n",
    "# Insert each expression in bold from above after a print statement\n",
    "\n",
    "print()\n",
    "\n",
    "print()\n",
    "\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 1: Simple printing\n",
    "\n",
    "Try entering some simple print commands. The print command will print a single value, or multiple values that are separated by commas (when it adds a single space between each value printed). By default, print also adds a newline character at the end of what it prints. You can prevent Python from adding a newline at the end of what it prints by adding end='' to the end of the print statement, for example **print(\"hello\", end='')**. You won't be able to see the difference when entering print commands to the interpreter, but the difference matters when you have multiple print statements in a code file. Note that you can add extra linebreaks to what's printed by using the special character \\n, for example try printing the string **\"hello\\n\\nthere\"**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Insert different commands to be printed after each statement\n",
    "# Try to experiment with the commands and follow the instructions from above\n",
    "\n",
    "print()\n",
    "\n",
    "print()\n",
    "\n",
    "print()\n",
    "\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### First Python program\n",
    "\n",
    "The first line (preceded by #) is a comment and it is ignored by Python. The remaining lines are commands that we might have entered at the Python shell. If we call python to run this program (or script), it will execute each line in turn, producing results just as if they had been entered at the shell. Take a short while to study the code, and understand what it does. \n",
    "\n",
    "Clearly, the code takes an initial distance in miles (i.e. the value assigned to the variables miles) and converts it to kilometers, on the basis that a kilometer is five eighths of a mile. The initial and converted distances are then printed, with some 'supporting text'. Now run the cell to compile the script. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Converts distance in miles to kilometers\n",
    "miles = 22.7\n",
    "kilometers = (miles * 8.0) / 5.0\n",
    "print(\"Converting distance in miles to kilometers:\")\n",
    "print(\"Distance in miles: \", miles)\n",
    "print(\"Distance in kilometers:\", kilometers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can set different values for the *miles* variable and re-run to compute a range of different results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Taking input from the user**\n",
    "\n",
    "As it stands, we can only do other distance conversions by editing the script file, so that different initial values are assigned to the miles variable. \n",
    "\n",
    "Python provides the <b>input</b> function for reading what a user types in whilst a program is running. As shown below, this takes a single (optional) argument, which is a string. When called, the function prints this string as a 'prompt', and then reads in whatever text the user types up to the first line return. It expects to find something that look like a single Python type, such as integer or float, in which case it creates this value and returns it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Input example\n",
    "\n",
    "t = input('Introduce a sentence here.')\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#### Exercise 2: Modifying the first Python program\n",
    "\n",
    "To avoid having to edit the function for each different calculation, we could instead use the **input** function to read in the start value for the calculation. Copy the distance conversion algorithm from above into the next cell and modify it so that the user can enter itself a value to be converted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Insert the distance conversion algorithm here and modify so as the user can enter a value every time the function is run"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 3: Writing our first Python program**\n",
    "\n",
    "Using the distance converter script as a template, write in the marked cell bellow a new script for converting temperatures. Your script should do the following. Firstly, it should ask the user for a temperature in degrees celsius (a.k.a. centigrade). Next, it should compute the corresponding temperature values on both the fahrenheit and kelvin scales. It should then print a summary of its results, similar to that of the distance converter program.\n",
    "\n",
    "As you probably know, to convert a celsius temperature to the fahrenheit scale, we multiply it by 9/5 and then add 32. The kelvin scale has the same sized units as the celsius scale, but its zero point corresponds to absolute zero, which is equivalent to -273,15 °C, so converting from celsius to kelvin requires only that we add 273.15."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Insert your first Python program here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Defining a Python Function: reusable functionality**\n",
    "\n",
    "A good way of creating conveniently reusable chunks of functionality is to define a function. Function definitions use the *keyword* **def** and have the following form:\n",
    "\n",
    "    def NAME(LIST-OF-PARAMETERS):\n",
    "        BLOCK-OF-STATEMENTS\n",
    "\n",
    "where:\n",
    "* NAME is the name of the defined function\n",
    "* LIST-OF-PARAMETERS allow us provide inputs to the function (this list may be *empty*)\n",
    "* BLOCK-OF-STATEMENTS is some series of commands whose limit is identified by *indentation*\n",
    "\n",
    "Converting the code of the distance conversion to have the form of a Python function might give the function in the next cell. Here, the first line starts with the keyword **def**, indicating a function definition. What follows the keyword indicates that the function has name *convert_distance* and takes a single argument (parameter). When the function is called, it is invoked by name, and the argument value provided (given in parentheses, immediately after the function name, i.e. with no spaces between the name and the open bracket) is assigned to the variable **miles** (indicated in the brackets of the definition's first line). Note how the *body* of the definition is *indented* relative to the first line (which is not indented). This indentation is crucial because it signals\n",
    "that the indented lines *belong* to the body of the definition. \n",
    "\n",
    "<u>PLEASE NOTE</u>: **be warned!** - getting indentation right is crucial to successful Python programming. You should create indentation by using the TAB key. You should never attempt to indent code 'manually' by using spaces. If you run this code, the interpreter will actually just read and remember the function definitions. We can then call the function as follows, i.e. using the function's name with the required argument value supplied in brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_distance(miles):\n",
    "        kilometers = (miles * 8.0) / 5.0\n",
    "        print(\"Converting distance in miles to kilometers:\")\n",
    "        print(\"Distance in miles: \", miles)\n",
    "        print(\"Distance in kilometers:\", kilometers)\n",
    "        \n",
    "convert_distance(44)\n",
    "\n",
    "convert_distance(125.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Making your function return its values**\n",
    "\n",
    "A common mistake when learning Python is to confuse *printing* a value with *returning* the value. Most commonly, we want a function to **return** its value so it can be used elsewhere. We use the keyword **return** to do this, and it then allows us to assign the value to a variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def next_number(x):\n",
    "    return x+1\n",
    "\n",
    "x = 5\n",
    "y = next_number(x)\n",
    "\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Modify your *convert_distance* function so that it returns the value it computes, i.e. so you can assign the value to a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Insert here your modified version of convert_distance function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Indentation **\n",
    "\n",
    "Note the importance of *indentation* in preceding function definitions; it serves to indicate which command statements make up the *code block* forming the body of the function. Consider the following piece of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def helloGoodbye():\n",
    "    print (\"Hello.\")\n",
    "    print (\"Goodbye.\")\n",
    "    \n",
    "print (\"Au revoir.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first two statements are indented as they belong to the function definition. The third statement is not part of the definition. Try executing the cell - which print statement(s) appear?\n",
    "\n",
    "In Python, indentation is used to signal code blocks throughout. This is a distinctive, and somewhat controversial, feature of Python, which helps to give Python its clean, readable syntax. Most languages use *parentheses* to signal code blocks e.g. braces \"{..}\" used in Java and various other languages. For such languages, indentation does not affect the\n",
    "meaning of code, although 'good indentation' is encouraged for readability.\n",
    "\n",
    "I cannot stress this enough: for Python, good indentation is *compulsory* as incorrectly indented code *will not run*. It is crucial, therefore, to use an indentation aware editor, such as Spyder. With such an editor, using TAB/DEL in an 'indentation area' should\n",
    "move cursor in/out by 'one level of indentation'. By convention, 'one level of indentation' corresponds to 4 spaces (but you shouldn't have to think about that with a good editor)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**How to import your code**\n",
    "\n",
    "The usual way to access pre-existing code, either written by yourself, or code in library module, is to *import* it (i.e. as opposed to simply 'running' the code, as we did above, which doesn't usually make sense). For example, there is a module **math** providing many goodies, such as (e.g. a variable **pi** defined with quite an accurate value of *π*. If we import this module with the statement **import math**, we would need to refer to this variable with the 'long name' **math.pi**. \n",
    "\n",
    "The alternative import statement **from math import** \\* brings everything (\\*) in with a 'local name', i.e. so we could refer to the variable as just **pi**. This saves on typing but is considered bad practice. See http://www.walkingrandomly.com/?p=6209 for a discussion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Insert here your code for the temperature conversion function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Add a series of test calls of your defined function to see how it works"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Other ways to run Python **\n",
    "\n",
    "This tutorial uses Jupyter notebook to run Python, but there are other ways to run Python (these are not necessary for this tutorial and you can skip them if you prefer to).\n",
    "\n",
    "You can run access python in shell mode in various ways:\n",
    "* directly in a terminal/CMD window, by entering \"python\"\n",
    "* with an advanced editor/IDE, such as Spyder or PyCharm\n",
    "\n",
    "On a Windows machine can type *py -3.5* in CMD:\n",
    "\n",
    "    Python 3.5.1 (v3.5.1:37a07cee5969, Dec  6 2015, 01:54:25)\n",
    "    [MSC v.1900 64 bit (AMD64)] on win32\n",
    "    Type \"help\", \"copyright\", \"credits\" or \"license\" for more information\n",
    "    >>>\n",
    "\n",
    "In the above, >>> denotes the Python command prompt. You can enter commands one by one at the command prompt and Python will convert and execute them."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}