1_Basics of Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# This is a notebook for session 1: Introduction to Python\n",
    "\n",
    "We recommended you to read [A Whirlwind Tour of Python](https://www.oreilly.com/programming/free/files/a-whirlwind-tour-of-python.pdf) up to the end. The examples are also a good opportunity to take your shiny new Python installation for a test-drive, so feel free to play around with them. Alternatively, you can go through the [Jupyter notebooks](https://github.com/jakevdp/WhirlwindTourOfPython) associated with the book available on GitHub.\n",
    "\n",
    "This Notebook is an abstract version of Python basics for those, who would like to freshen up their Pyhton skills or use it as a quick reference to some ferquently-used syntaxes.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your first code in Python: You are going to print a text with a single line of code.\n",
    "\n",
    "#### Print is a very useful syntax.\n",
    "#### Notice: Python is Case sensitive, so print is different from Print."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (\"I am excited to learn Python within this course.\")\n",
    "print (\"hooray!!!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a variable called x with a value of 2\n",
    "x = 2\n",
    "\n",
    "# print x variable\n",
    "print (x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can move values across different variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# our new variable var_a holds a number\n",
    "\n",
    "var_a = 1\n",
    "print (\"var_a is\", var_a)\n",
    "\n",
    "b = var_a\n",
    "print (\"b is\",b)\n",
    "\n",
    "#what is stored in b?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# m is an interger variable\n",
    "m = 2\n",
    "print (m , \"is integer\")\n",
    "\n",
    "# n is a float variable\n",
    "n = 2.3\n",
    "print (n , \"is float\")\n",
    "\n",
    "# t is a string variable\n",
    "t = \"Pythooon\"\n",
    "print (t , \"is string\")\n",
    "\n",
    "# b is a boolean variable\n",
    "b = 2 > 3\n",
    "print (b , \"is boolean\")\n",
    "\n",
    "# a_list is a list\n",
    "a_list = [1, 2, 3, 'a', 'b', 'c']\n",
    "print (a_list, \"is a list\")\n",
    "\n",
    "# b_tuple is a list\n",
    "b_tuple = (1, 2, 3, 'a', 'b', 'c')\n",
    "print (b_tuple, \"is a tuple\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (\"The first item in a_list is\", a_list[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Do not use ``keywords`` of Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import keyword\n",
    "keyword.kwlist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: Write a code to calculate area of a rectangle!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#define two variables for the two sides of rectangle \n",
    "\n",
    "\n",
    "# multiple them by \"*\"\n",
    "\n",
    "\n",
    "#print the result\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "explore what you can do with strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Strings:\n",
    "a=\"Hello\"\n",
    "print (a)\n",
    "\n",
    "b=\"abcd765\"\n",
    "print (b)\n",
    "\n",
    "c=\"Hello\" + \" \" + \"Jamal\"\n",
    "print (c)\n",
    "\n",
    "d=\"Hello\" * 3 \n",
    "print (d)\n",
    "\n",
    "e=len(a)\n",
    "print (e)\n",
    "\n",
    "f=\"5\"+\"3\"\n",
    "print (f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a= \"street_cph_buffer.shp\"\n",
    "print (\"file extension is\", a[-4:])\n",
    "print (\"file name is\", a[0:-4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparison operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 < 7 # < less than"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 > 6 #> greater than"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "6 == 6  #== equal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 != 4 #!= not equal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 >= 0.5 #>= greater than or equal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 <= 0.6 #<= less than or equal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to write a Python ``function``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function(): \n",
    "    print (\"My function is great\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_two_numbers(a, b): \n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum_two_numbers(4, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: \n",
    "now write a function to calculate the area of a triangle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is ``methods``?\n",
    "\n",
    "A Python method is a function/property/behaviour that you can call on an object; it is a piece of code to execute on that object. You can add a '.' after your object and hold TAB button to see the existing methods. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mytext  = \"this is my text\"\n",
    "newtext = mytext.upper()\n",
    "captext = mytext.capitalize()\n",
    "print (newtext)\n",
    "print (captext)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control flows\n",
    "\n",
    "Control flow is the order in which individual statements, instructions, or function calls are executed or evaluated. The control flow of a Python program is regulated by conditional statements, loops, and function calls."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Conditional statements: a few examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2 #change this value and see the results\n",
    "if x >= 0:\n",
    "    print ('x is positive')\n",
    "else:\n",
    "    print ('x is negative')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x= -5\n",
    "if x>0 and x<10:\n",
    "    print (\"x is between 1..9\")\n",
    "elif x<20:\n",
    "    print (\"x is between 10..19\")\n",
    "elif x<=0:\n",
    "    print (\"x is less or equal than 0\")\n",
    "else:\n",
    "    print (\"x is greater or equal than 20\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "if x in [1,2,3]:\n",
    "    print ('x is in list')\n",
    "    if x == 1:\n",
    "        print ('x is 1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loops: a few samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "primes = [2,3,5,7] \n",
    "for prime in primes: \n",
    "    print (prime)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1,10):\n",
    "    print (i)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "count = 0 \n",
    "while count < 5: \n",
    "    print (count) \n",
    "    count = count + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0\n",
    "while 1:\n",
    "    print (x) #stops loop\n",
    "    if x == 5:\n",
    "        break\n",
    "    x += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0\n",
    "if x == 0:\n",
    "    pass       #do nothing\n",
    "else:\n",
    "    print (\"x is not zero\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0\n",
    "while 1:\n",
    "    print (\"x is\", x)\n",
    "    if x == 5:\n",
    "        break #stops loop\n",
    "    x += 1 #same as x = x+1\n",
    "#code after loop\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0\n",
    "if x == 0:\n",
    "    pass #do nothing\n",
    "    print ('x is  zero')\n",
    "\n",
    "else:\n",
    "    print ('x is not zero')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(0,100):\n",
    "    if x % 2 == 0: # % = modulos\n",
    "        print (x, ' is even')\n",
    "        continue #restart loop\n",
    "    print (x, ' is odd')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's create a list of odd and even numbers <100\n",
    "odd_list=[]\n",
    "even_list=[]\n",
    "\n",
    "for x in range(0,100):\n",
    "    if x % 2 == 0: # % = modulos\n",
    "        even_list.append(x)\n",
    "        continue #restart loop\n",
    "    odd_list.append(x)\n",
    "print (\"list of odd numbers\", odd_list)\n",
    "print (\"================================================\")\n",
    "print (\"list of even numbers\", even_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops: an example of guessing a random number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random \n",
    "\n",
    "no_attempts = 0\n",
    "#target_num = 28\n",
    "\n",
    "target_num=random.randrange(0, 100)\n",
    "\n",
    "while True:\n",
    "    no_attempts += 1\n",
    "    num_input = input(\"Enter a valid number between 0 and 100: \")\n",
    "    num = int(num_input)\n",
    "    \n",
    "    if num < target_num:\n",
    "        print(\"your guess is smaller than the target number\")\n",
    "        continue\n",
    "    elif num > target_num:\n",
    "        print(\"your guess is greater than the target number\")\n",
    "        continue\n",
    "    else:\n",
    "        print(\"Right answer :-)\")\n",
    "        print(\"Attempts needed: \" + str(no_attempts))\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## how to import and use Python modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import square root function from module math\n",
    "\n",
    "import math\n",
    "math.sqrt(4)\n",
    "\n",
    "import math as m\n",
    "m.sqrt(4)\n",
    "\n",
    "from math import sqrt\n",
    "sqrt(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing of strings, lists, tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# slicing of a string\n",
    "txt = \"Hello World\"\n",
    "\n",
    "txt[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "txt[0:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "txt[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# slicing of a list\n",
    "aList = [1, 2, 4, \"txt\"]\n",
    "\n",
    "aList[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aList[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aList[-2:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use length of a list in a loop\n",
    "for i in range(0,len(aList)):\n",
    "    print (aList[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples: using for printing\n",
    "\n",
    "Tuples are used to store multiple items in a single variable.\n",
    "A tuple is a collection which is ordered and unchangeable. Tuples are written with round brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num =10\n",
    "nam = \"Jim\"\n",
    "height = 1.782\n",
    "\n",
    "print (\"Jim's height is %.2f\" % (height))\n",
    "\n",
    "print (\"After %i measurement the height of %s is %.3f\" % (num, nam, height))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries \n",
    "\n",
    "Dictionaries are used to store data values in key:value pairs. A dictionary is a collection which is ordered, changeable and do not allow duplicates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "population = {\"Denmark\": 5760694, \n",
    "              \"Austria\": 8460390, \n",
    "              \"Norway\": 5342696}\n",
    "\n",
    "popDK = population[\"Denmark\"]\n",
    "print (\"Population of Denmark: %i\" % (popDK))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "staffID = {9917023: \"Jamal Jokar\", \n",
    "           10012673: \"Carsten Kessler\", \n",
    "           6639933: \"Lise Schrøder\"}\n",
    "\n",
    "staf = 10012673\n",
    "print (\"Staff ID %i is assigned to %s.\" % (staf, staffID[staf]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iterating over dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "population = {\"Denmark\": 5760694, \n",
    "              \"Austria\": 8460390, \n",
    "              \"Norway\": 5342696}\n",
    "\n",
    "for k, v in population.items():\n",
    "    print (k, \"has a population of\", v)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Delete one of the key-values in a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del population[\"Austria\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "population"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add element to dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "population[\"Sweden\"] = 9514406\n",
    "\n",
    "#Element in dictionary\n",
    "if (\"Sweden\" in population) == True:\n",
    "    print (\"Sweden is in the dictionary\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays\n",
    "\n",
    "Numpy is the mother library for dealing with arrays. Check [this](https://numpy.org) out!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import *\n",
    "a = array ([1, 5, 10])\n",
    "b = a * 2\n",
    "print (b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## File handling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "check your current working directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Siwtch to another directory – **choose one that actually exists on your computer!**\n",
    "\n",
    "Windows users, [take a look here](https://www.pitt.edu/~naraehan/python3/file_path_cwd.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "let's create a text file and write a line into it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fh = open(\"hello.txt\", \"w\") # W is for Writing a file and R for reading an existing file\n",
    "lines_of_text = [\"Hello\"] # , \"welcome to AAU\", \"we hope you enjoy the python course\"\n",
    "fh.writelines(lines_of_text)\n",
    "fh.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "let's write more lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fh = open(\"hello.txt\", \"w\")\n",
    "lines_of_text = [\"Hello!\\n\",  \"welcome to AAU\\n\", \"we hope you enjoy the python course\\n\"] \n",
    "fh.writelines(lines_of_text)\n",
    "fh.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "let's read the lines "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fh = open(\"hello.txt\",\"r\")\n",
    "print (fh.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fh = open(\"hello.txt\",\"r\")\n",
    "\n",
    "for line in fh.readlines():\n",
    "    print (line)\n",
    "fh.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Files and directories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, sys\n",
    "\n",
    "path = \"/Users/jamal/Downloads\" # again, change this to a folder on your computer!\n",
    "\n",
    "alldirs =[]\n",
    "dirs = os.listdir(path)\n",
    "# here we identify file extention\n",
    "fileext = \"txt\" \n",
    "\n",
    "# This would print all the files and directories\n",
    "for file in dirs:\n",
    "    if file.endswith(fileext):\n",
    "        alldirs.append(file)\n",
    "        print (file)\n",
    "        print (alldirs)\n",
    " \n",
    "print (\"%i files found.\" % (len(alldirs)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Error handing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exceptions allow you to prevent the program from crashing even when an error occurs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    int(\"Test\")\n",
    "except Exception as err:\n",
    "    print((\"Error occured: \", err))\n",
    "    exit() #stop script"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    try:\n",
    "        x = int(input(\"Please enter a number: \"))\n",
    "        break\n",
    "    except ValueError:\n",
    "        print(\"Oops!  That was no valid number.  Try again...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    outfile = open(\"x:/tmp/output.txt\", \"w\")\n",
    "    outfile.write(\"any output to file\\n\")\n",
    "    outfile.close()\n",
    "    print (\"File successfully written.\")\n",
    "\n",
    "except Exception as err:\n",
    "    print((\"Could not write file: \", err))\n",
    "    exit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## working with time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "print (time.time())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "start = time.time()\n",
    "for i in range(1,1000000):\n",
    "    pass\n",
    "end = time.time()\n",
    "\n",
    "runtime = end - start\n",
    "print (\"Process took %.3f sec.\" % (runtime))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "localtime = time.localtime(time.time())\n",
    "print (\"Year: \", localtime.tm_year)\n",
    "print (\"Month: \", localtime.tm_mon)\n",
    "print (\"Day: \", localtime.tm_mday)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}