Python_basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programming with Python\n",
    "\n",
    "The goal of this workshop is not to teach Python as a programming language, but to introduce the basic concepts that are required to get started. \n",
    "\n",
    "We will be using the contents developped by <a href=\"https://software-carpentry.org/\">Software Carpentry</a>.\n",
    "All Software Carpentry instructional material is made available under the <a href=\"https://creativecommons.org/licenses/by/4.0/\">Creative Commons Attribution license</a>. \n",
    "\n",
    "We will discuss the follwing topics:\n",
    "1. Python Fundamentals\n",
    "2. Repeating Actions with Loops\n",
    "3. Storing Multiple Values in Lists\n",
    "4. Creating Functions\n",
    "    \n",
    "The content covered in this workshop is adapted from the original version. The full course is available at http://swcarpentry.github.io/python-novice-inflammation/."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Fundamentals\n",
    "\n",
    "Python is a high level, general purpose, interpreted programming language. \n",
    "\n",
    "Few things about Python:\n",
    "* Dynamically typed\n",
    "* Case sensitive\n",
    "* Indentations are important\n",
    "\n",
    "\n",
    "### Why Python?\n",
    "* It is free, and open-source.\n",
    "* It has a lot of scientific libraries, and more are constantly being added.\n",
    "* It has a large scientific user community.\n",
    "* Beginner friendly.\n",
    "    \n",
    "\n",
    "    \n",
    "### How to navigate this notebook?\n",
    "    Demo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "Any Python interpreter can be used as a calculator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 + 5 * 4  # this will calculate the result and print to console."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is great but not very interesting. To do anything useful with data, we need to assign its value to a variable. In Python, we can assign a value to a variable, using the equals sign =. For example, to assign value 60 to a variable weight_kg, we would execute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weight_kg = 60"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, variable names:\n",
    "\n",
    "* can include letters, digits, and underscores\n",
    "* cannot start with a digit\n",
    "* cannot contain space\n",
    "* are case sensitive\n",
    "\n",
    "This means that, for example:\n",
    "\n",
    "* weight0 is a valid variable name, whereas 0weight is not\n",
    "* weight and Weight are different variables\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Types of data\n",
    "\n",
    "Python knows various types of data. Three common ones are:\n",
    "\n",
    "* integer numbers\n",
    "* floating point numbers, and\n",
    "* strings.\n",
    "\n",
    "In the example above, variable weight_kg has an integer value of 60. To create a variable with a floating point value, we can execute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weight_kg = 60.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And to create a string, we add single or double quotes around some text, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weight_kg_text = 'weight in kilograms:'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Variables in Python\n",
    "To display the value of a variable to the screen in Python, we can use the print function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(weight_kg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can display multiple things at once using only one print command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(weight_kg_text, weight_kg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To change the value of the weight_kg variable, we have to assign weight_kg a new value using the equals = sign:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weight_kg = 65.0\n",
    "print('weight in kilograms is now:', weight_kg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Repeating Actions with Loops\n",
    "\n",
    "How to print each character in \"Hydrogen\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word = 'Hydrogen'\n",
    "print(word[0])\n",
    "print(word[1])\n",
    "print(word[2])\n",
    "print(word[3])\n",
    "print(word[4])\n",
    "print(word[5])\n",
    "print(word[6])\n",
    "print(word[7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try \"Oxygen\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word = 'Oxygen'\n",
    "print(word[0])\n",
    "print(word[1])\n",
    "print(word[2])\n",
    "print(word[3])\n",
    "print(word[4])\n",
    "print(word[5])\n",
    "print(word[6])\n",
    "print(word[7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above aproach is\n",
    "* Not scalable\n",
    "* Difficult to maintain\n",
    "* Fragile\n",
    "    \n",
    "A better approach:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for char in word:\n",
    "    # note the indentation\n",
    "    print(char)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word = 'Tin'\n",
    "for char in word:\n",
    "    print(char)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for variable in collection:\n",
    "    # do things using variable, such as print"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"data/img/loops_image.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Storing Multiple Values in Lists\n",
    "\n",
    "Similar to a string that can contain many characters, a list is a container that can store many values. We create a list by putting values inside square brackets and separating the values with commas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "odds = [1, 3, 5, 7]\n",
    "print('odds are:', odds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access elements of a list using indices – numbered positions of elements in the list. These positions are numbered starting at 0, so the first element has an index of 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('first element:', odds[0])\n",
    "print('last element:', odds[3])\n",
    "print('\"-1\" element:', odds[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for number in odds:\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List can contain any Python variables, it can even contain other lists.\n",
    "\n",
    "For example, we could represent the products in the shelves of a small grocery shop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [['pepper', 'zucchini', 'onion'],\n",
    "     ['cabbage', 'lettuce', 'garlic'],\n",
    "     ['apple', 'pear', 'banana']]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a visual example of how indexing a list of lists x works:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"data/img/indexing_lists_python.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x[0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Functions\n",
    "\n",
    "A short while ago, we printed every letter in a given word by loop. But whenever we had a new word, we re-wrote the loop.  Cutting and pasting is going to make our code get very long and very repetitive, very quickly. We’d like a way to package our code so that it is easier to reuse, and Python provides for this by letting us define things called ‘functions’ — a shorthand way of re-executing longer pieces of code. Let’s start by defining a function fahr_to_celsius that converts temperatures from Fahrenheit to Celsius:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fahr_to_celsius(temp):\n",
    "    return ((temp - 32) * (5/9))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"data/img/python-function.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fahr_to_celsius(32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('freezing point of water:', fahr_to_celsius(32), 'C')\n",
    "print('boiling point of water:', fahr_to_celsius(212), 'C')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def celsius_to_kelvin(temp_c):\n",
    "    return temp_c + 273.15\n",
    "\n",
    "print('freezing point of water in Kelvin:', celsius_to_kelvin(0.))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fahr_to_kelvin(temp_f):\n",
    "    temp_c = fahr_to_celsius(temp_f)\n",
    "    temp_k = celsius_to_kelvin(temp_c)\n",
    "    return temp_k\n",
    "\n",
    "print('boiling point of water in Kelvin:', fahr_to_kelvin(212.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: write a function to print every letter in a given word."
   ]
  },
  {
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}