Python Fundamentals.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Fundamentals\n",
    "\n",
    "This notebook is a tutorial on Python fundamentals and covers how to work with lists, dictionaries, functions, strings and for loops. Some useful links are included below:\n",
    "\n",
    "https://www.python.org/about/gettingstarted/\n",
    "\n",
    "https://www.w3schools.com/python/python_intro.asp\n",
    "\n",
    "https://pythonprogramming.net\n",
    "\n",
    "https://pythonprogramming.net/python-fundamental-tutorials/\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "t11 = 3 <= 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Jupyter Notebooks\n",
    "This file is a Jupyter Notebook. It runs Python in the web browser. The code is divided into cells. A cell can be executed (also known as running the cell) by typing *shift+enter*. To write text in a cell we can change the cell from *code* to *markdown* in teh toolbar at the top of the notebook. For more about workign with markdonw language to style the cells in the notebook see the links below:\n",
    "\n",
    "https://www.markdownguide.org/\n",
    "\n",
    "https://www.markdownguide.org/extended-syntax/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing packages\n",
    "\n",
    "Python packages provide bits of code written by other people that can be reused in our code. To use packages we install them by typing:\n",
    "```\n",
    "pip install some_package \n",
    "```\n",
    "at the command line. To import a package we type:\n",
    "```\n",
    "import some_package\n",
    "```\n",
    "in our jupyter notebook or python script."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assignment and operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assignment\n",
    "Assignment in python refers to the setting of variables to certain values so that those values can be retrieved later. It is done using the equals sign. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "apple\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "fruit = 'apple'\n",
    "print(x)\n",
    "print(fruit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operators\n",
    "\n",
    "Operations in Python include subtraction, addition, multiplication, and division and also tests to see if things are equal to each other or not or greater than or smaller than, such operations return True or False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x1 = 12\n",
      "x2 = -2\n",
      "x3 = 21\n",
      "x4 = 21\n",
      "x5 = 19683\n",
      "x6 = True\n",
      "x7 = False\n",
      "x8 = False\n",
      "x9 = True\n",
      "x10 = True\n",
      "x11 = False\n"
     ]
    }
   ],
   "source": [
    "# addition\n",
    "x1 = 5 + 7\n",
    "# subtraction\n",
    "x2 = 5 - 7\n",
    "# multiplication\n",
    "x3 = 3 * 7\n",
    "# division\n",
    "x4 = 3 * 7\n",
    "# exponentiation (raising to a power)\n",
    "x5 =3 ** 9\n",
    "# is equal to \n",
    "x6 = 5 == 5\n",
    "x7 = 5 == 4\n",
    "# is not equal to\n",
    "x8 = 5 != 5\n",
    "x9 = 5 != 4\n",
    "# is greater than\n",
    "x10 = 7 > 3\n",
    "x11 = 3 > 7\n",
    "\n",
    "print('x1 =',x1)\n",
    "print('x2 =',x2)\n",
    "print('x3 =',x3)\n",
    "print('x4 =',x4)\n",
    "print('x5 =',x5)\n",
    "print('x6 =',x6)\n",
    "print('x7 =',x7)\n",
    "print('x8 =',x8)\n",
    "print('x9 =',x9)\n",
    "print('x10 =',x10)\n",
    "print('x11 =',x11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If, else and elif\n",
    "\n",
    "If, else and elif (else if) are statements that determine whether a block of code should be executed or not. If the condition in the statement is True then the code will be run and otherwise it wont."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat\n",
      "Tom\n"
     ]
    }
   ],
   "source": [
    "x = 2\n",
    "animal = ''\n",
    "person = ''\n",
    "\n",
    "if x > 1:\n",
    "    animal = 'cat'\n",
    "else:\n",
    "    animal = 'dog'\n",
    "    \n",
    "if x == 3:\n",
    "    person = 'Jack'\n",
    "elif x == 1:\n",
    "    person = 'Jill'\n",
    "elif x == 2:\n",
    "    person = 'Tom'\n",
    "else:\n",
    "    person = 'Ellie'\n",
    "    \n",
    "print(animal)\n",
    "print(person)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python data types\n",
    "\n",
    "Data types are different categories for stroign information and include strings, integers, floats, lists, dictioanries and more. To see what type an object is in python we can call the type function on that object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'list'>\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "x1 = 'my string'\n",
    "x2 = 3\n",
    "x3 = 4.678\n",
    "x4 = [1,3,4]\n",
    "x5 = {'a': 1}\n",
    "\n",
    "print(type(x1))\n",
    "print(type(x2))\n",
    "print(type(x3))\n",
    "print(type(x4))\n",
    "print(type(x5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integers and Floats\n",
    "\n",
    "Integers and floats are both numeric data types. Integers are rounded whole numbers and floats have a decimal place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "my_int_1 = 3\n",
    "my_int_2 = 4\n",
    "my_float_1 = 3.4567\n",
    "my_float_2 = 7.2567\n",
    "print(type(my_int_1))\n",
    "print(type(my_int_2))\n",
    "print(type(my_float_1))\n",
    "print(type(my_float_2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings\n",
    "\n",
    "Strings are enclosed between apostrophes or quotation marks and are useful for storing names and text but numbers can also be stored in string format, in fact any collection of charteres can be written as a string. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "donald duck\n",
      "34\n",
      "jkjlkj890893786387*()*(&&~~#)\n"
     ]
    }
   ],
   "source": [
    "my_string_1 = 'a'\n",
    "my_string_2 = \"donald duck\"\n",
    "my_string_3 = '34'\n",
    "my_string_4 = 'jkjlkj890893786387*()*(&&~~#)'\n",
    "\n",
    "print(my_string_1)\n",
    "print(my_string_2)\n",
    "print(my_string_3)\n",
    "print(my_string_4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "\n",
    "Lists are an ordered collection of items separated by commas and enclosed in square brackets. They can store a variety of different data types inside including numbers, strings, other lists and more. Each item in a list can be retrieved using the items index. Indexing in Python lists starts at 0 and goes up to N-1 for a list of length N. Items can be assigned to positions in lists in several ways, either by typing out the full list explicitly, by assigning a particular item to a particular position using the index, or by appending to the end of the list to grow the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "k\n",
      "[2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "my_first_list = [1,3,5,6,7,3,7,8]\n",
    "my_second_list = ['a','f', 'g', 'k']\n",
    "my_third_list = [1,'a',3, [2,3,4], 7.2, 8.9, 'l']\n",
    "\n",
    "print(my_first_list[0])\n",
    "print(my_second_list[3])\n",
    "print(my_third_list[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 3, 5, 9, 4, 10]\n"
     ]
    }
   ],
   "source": [
    "list_1 = [1,3,5,6,4]\n",
    "list_1[0] = 7\n",
    "list_1[3] = 9\n",
    "list_1.append(10)\n",
    "\n",
    "print(list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "\n",
    "Dictionaries are an unordered collection of key value pairs separated by commas and enclosed in curly brackets. They can store a variety of different data types inside including numbers, strings, lists, other dictionaries and more. Each value in a dcitionary can be retrieved using the corresponding key which is usually a string. Key value pairs are separated by colons so an example dictionary may look like:\n",
    "```\n",
    "{\n",
    "    my_key_1: my_val_1,\n",
    "    my_key_2: my_val_2,\n",
    "    my_key_3: my_val_3\n",
    "}\n",
    "```\n",
    "Values can be assigned to keys in a dictionary either by typing out the dictionary explicitly or by assigning the specific value to a specific key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "ok\n"
     ]
    }
   ],
   "source": [
    "my_first_dictionary = {\n",
    "    'a': 0,\n",
    "    'b': 1,\n",
    "    'c': 2,\n",
    "    'd': 3\n",
    "}\n",
    "my_second_dictionary = {\n",
    "    'apple': 'gross',\n",
    "    'banana': 'ok',\n",
    "    'orange': 'nice',\n",
    "    'pear': 'weird'\n",
    "}\n",
    "\n",
    "\n",
    "print(my_first_dictionary['c'])\n",
    "print(my_second_dictionary['banana'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'fruit': 'apple', 'bread': 'brown', 'milk': 'semi-skimmed'}\n"
     ]
    }
   ],
   "source": [
    "dict_1 = {\n",
    "    'fruit': 'apple'\n",
    "}\n",
    "dict_1['bread'] = 'brown'\n",
    "dict_1['milk'] = 'semi-skimmed'\n",
    "print(dict_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "Functions are bits of code that take some inputs, do somethign with them, and then maybe but not always return some outputs. They are very useful and important as they can help us avoid writing the smae bit of code over and over again. Functions are declared in Python using the *def* command, followed by the function name and arguments, followed by the body of the function which is indented by four spaces (or a tab), and finally they may close with a *return* statement though this is not always required. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "18\n",
      "6\n",
      "8\n",
      "15\n",
      "720\n"
     ]
    }
   ],
   "source": [
    "def my_add_one_function(x):\n",
    "    a = x + 1\n",
    "    return a\n",
    "\n",
    "def my_times_by_three_function(x):\n",
    "    d = x * 3\n",
    "    return d\n",
    "\n",
    "def multiply_a_and_b(a, b):\n",
    "    result = a * b\n",
    "    return result\n",
    "\n",
    "def my_more_complicated_function(x):\n",
    "    x1 = x + 3 \n",
    "    x2 = x1 * 7 + 2\n",
    "    x3 = x1 * x2\n",
    "    return x3\n",
    "\n",
    "print(my_add_one_function(1))\n",
    "print(my_add_one_function(2))\n",
    "print(my_times_by_three_function(6))\n",
    "print(my_times_by_three_function(2))\n",
    "print(multiply_a_and_b(2, 4))\n",
    "print(multiply_a_and_b(3, 5))\n",
    "print(my_more_complicated_function(7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For loops\n",
    "\n",
    "For loops are used to loop over (also known as iterate) items in some collection, e.g., a list. Each item from the list is passed into the body of the for loop and manipulated in some way and perhaps stored in another object e.g., another list. A for loop is genrally of the form:\n",
    "```\n",
    "for item in list_of_items:\n",
    "    do_something_with_item(item)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "my_items_1 = [2,4,5,6,7]\n",
    "my_items_2 = []\n",
    "for item in my_items_1:\n",
    "    x = item + 1\n",
    "    my_items_2.append(x)\n",
    "    \n",
    "print(my_items_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "my_animals = ['cat', 'dog', 'dog', 'cat', 'rat', 'cat', 'cat']\n",
    "cats = 0\n",
    "rats = 0\n",
    "dogs = 0\n",
    "for animal in my_animals:\n",
    "    if animal == 'cat':\n",
    "        cats += 1\n",
    "    if animal == 'dog':\n",
    "        dogs += 1\n",
    "    if animal == 'rat':\n",
    "        rats += 1\n",
    "print(cats)\n",
    "print(dogs)\n",
    "print(rats)"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}