From b16bcf6e864f62c116b0254c5893ae92b1645a5d Mon Sep 17 00:00:00 2001 From: Amar Date: Fri, 29 Sep 2023 19:21:50 +0530 Subject: [PATCH] session 1 raw --- session-1/Main/Flow Control.ipynb | 330 +++ session-1/Main/Function.ipynb | 494 +++++ session-1/Main/List.ipynb | 566 +++++ session-1/Main/Operators.ipynb | 293 +++ session-1/Main/Practice.ipynb | 189 ++ .../Main/Pre introduction to Python.ipynb | 282 +++ session-1/Main/Tuple, Set, Dictionary.ipynb | 514 +++++ session-1/Practice.ipynb | 189 ++ session-1/Sessio-1-Basic-Data-viz-Main.ipynb | 1253 +++++++++++ session-1/beginner_intro.py | 290 +++ session-1/{python_101.ipynb => v1.ipynb} | 41 +- session-1/v2.ipynb | 1387 ++++++++++++ session-1/v3.ipynb | 1908 +++++++++++++++++ 13 files changed, 7715 insertions(+), 21 deletions(-) create mode 100644 session-1/Main/Flow Control.ipynb create mode 100644 session-1/Main/Function.ipynb create mode 100644 session-1/Main/List.ipynb create mode 100644 session-1/Main/Operators.ipynb create mode 100644 session-1/Main/Practice.ipynb create mode 100644 session-1/Main/Pre introduction to Python.ipynb create mode 100644 session-1/Main/Tuple, Set, Dictionary.ipynb create mode 100644 session-1/Practice.ipynb create mode 100644 session-1/Sessio-1-Basic-Data-viz-Main.ipynb create mode 100644 session-1/beginner_intro.py rename session-1/{python_101.ipynb => v1.ipynb} (97%) create mode 100644 session-1/v2.ipynb create mode 100644 session-1/v3.ipynb diff --git a/session-1/Main/Flow Control.ipynb b/session-1/Main/Flow Control.ipynb new file mode 100644 index 0000000..971d20b --- /dev/null +++ b/session-1/Main/Flow Control.ipynb @@ -0,0 +1,330 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Flow Control: If, for loop, while loop" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## If, else, elif" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Basic if statement\n", + "x = 0\n", + "y = 5\n", + "\n", + "if x < y: \n", + " print('yes')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# use of membership operator for if statement\n", + "if 'ele' in 'Electrical': \n", + " print('yes')\n", + "\n", + "\n", + "if 'item1' in ['item1', 'item2', 'item3']: \n", + " print('item1 is present')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "num = input(\"Enter a number: \") # Taking input from user\n", + "\n", + "#print(type(num)) # The type of input is always string\n", + "\n", + "print(\"Entered number is \" + str(num))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Python program to check if the input number is odd or even.\n", + "# A number is even if division by 2 give a remainder of 0.\n", + "# If remainder is 1, it is odd number.\n", + "\n", + "num = input(\"Enter a number: \")\n", + "\n", + "\n", + "# Fill the blank inside the if statement\n", + "# You will require typecasting and Modulo operator\n", + "\n", + "if ():\n", + " print(\"{0} is Even\".format(num))\n", + "else:\n", + " print(\"{0} is Odd\".format(num))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# use of elif\n", + "# A better way of writing this same code is shown later.\n", + "\n", + "name = 'IIT Bombay'\n", + "\n", + "\n", + "if name == 'IIT Bombay':\n", + " print('Founded in 1958')\n", + " \n", + "elif name == 'IIT Kharagpur':\n", + " print('Founded in 1950')\n", + " \n", + "elif name == 'IIT Kanpur':\n", + " print('Founded in 1959')\n", + " \n", + "elif name == 'IIT Delhi':\n", + " print('Founded in 1961')\n", + " \n", + "elif name == 'IIT Madras':\n", + " print('Founded in 1959')\n", + " \n", + "elif name == 'IIT Guwahati':\n", + " print('Founded in 1994')\n", + " \n", + "else:\n", + " print(\"I don't know when it was founded\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Special:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "raining = True\n", + "print(\"Let's go to the\", 'beach' if not raining else 'library')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "age = 21\n", + "status = 'minor' if age < 27 else 'adult'\n", + "status" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x = 40\n", + "y = 50\n", + "increment = (1 + x) if x > y else (1 + y)\n", + "increment" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Program to check if the input year is a leap year or not.\n", + "# Fill up the blank to make the program work.\n", + "# You may add more if else statements if you need.\n", + "\n", + "year = int(input(\"Enter a year: \"))\n", + "\n", + "if (year % 4) == 0:\n", + " if():\n", + " pass\n", + " else:\n", + " pass\n", + "else:\n", + " print(\"{0} is not a leap year\".format(year))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Loops - For loop" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "numbers = [1, 2, 3, 40, 50, 6, 7, 80, 9]\n", + "\n", + "# variable to store the sum\n", + "add = 0\n", + "\n", + "# iterate over the list\n", + "for num in numbers:\n", + " add += num # add = add + num\n", + "\n", + "print(\"The sum is\", add)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can generate a sequence of numbers using range( ) function. range(50) will generate numbers from 0 to 49 (50 numbers). We can also define the start, stop and step size as range(start,stop,step size). step size defaults to 1 if not provided." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(list(range(0,10)))\n", + "\n", + "print(list(range(5,10)))\n", + "\n", + "print(list(range(0,10,2)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "numbers = [1, 2, 3, 40, 50, 6, 7, 80, 9]\n", + "\n", + "# variable to store the sum\n", + "add = 0\n", + "\n", + "# iterate over the list\n", + "for i in range(len(numbers)):\n", + " add += numbers[i] # add = add + num\n", + "\n", + "print(\"The sum is\", add)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A for loop can have an **else** block as well. The else part is executed if the items in the sequence used in for loop exhausts." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "digits = [0, 1, 5]\n", + "\n", + "for i in digits:\n", + " print(i)\n", + "else:\n", + " print(\"No items left.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Python program to check if the input number is prime or not\n", + "\n", + "num = 79\n", + "\n", + "if num > 1:\n", + " pass\n", + "\n", + "# Write a for loop to check if a number is prime\n", + "\n", + "else:\n", + " print(num,\"is not a prime number\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## While loop" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "counter = 0\n", + "\n", + "while counter < 3:\n", + " print(\"Inside loop\")\n", + " counter = counter + 1\n", + "else:\n", + " print(\"Inside else\")" + ] + }, + { + "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.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/session-1/Main/Function.ipynb b/session-1/Main/Function.ipynb new file mode 100644 index 0000000..a277eaa --- /dev/null +++ b/session-1/Main/Function.ipynb @@ -0,0 +1,494 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Functions\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Structure of a Python function\n", + "def function_name(parameters):\n", + " \"\"\"docstring\"\"\"\n", + " # statements\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Basic function syntax\n", + "def square(num):\n", + " \"\"\"This function prints square of a value\"\"\"\n", + " print(\"Square of\", num, \"is\", num**2)\n", + " \n", + "square(5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def power(num, exp):\n", + " ''' docstring'''\n", + " print(num**exp)\n", + " \n", + "power(5,3)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def power(num, exp):\n", + " ''' docstring'''\n", + " return(num**exp)\n", + "\n", + "myvar = power(5,3)\n", + "print(myvar)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def power(num, exp = 2):\n", + " ''' docstring'''\n", + " return(num**exp)\n", + "\n", + "myvar1 = power(5,3)\n", + "myvar2 = power(5)\n", + "print(myvar)\n", + "print(myvar2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def swap(num1, num2):\n", + " '''Swaps the values'''\n", + " return num2, num1\n", + "\n", + "x = 10\n", + "y = 20\n", + "\n", + "x, y = swap(x, y)\n", + "print(\"x is \", x)\n", + "print(\"y is \", y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def my_func():\n", + " x = 10\n", + " print(\"Value inside function:\",x)\n", + "\n", + "x = 20\n", + "my_func()\n", + "print(\"Value outside function:\",x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Program make a simple calculator that can add, subtract, multiply and divide using functions\n", + "\n", + "# This function adds two numbers \n", + "def add(x, y):\n", + " pass\n", + "\n", + "# This function subtracts two numbers \n", + "def subtract(x, y):\n", + " pass\n", + "\n", + "# This function multiplies two numbers\n", + "# add code for multiply\n", + " \n", + "\n", + "# This function divides two numbers\n", + "# add code for divide\n", + "\n", + "print(\"Select operation.\")\n", + "print(\"1.Add\")\n", + "print(\"2.Subtract\")\n", + "print(\"3.Multiply\")\n", + "print(\"4.Divide\")\n", + "\n", + "# Take input from the user \n", + "choice = input(\"Enter choice(1/2/3/4):\")\n", + "\n", + "num1 = int(input(\"Enter first number: \"))\n", + "num2 = int(input(\"Enter second number: \"))\n", + "\n", + "if choice == '1':\n", + " print(num1,\"+\",num2,\"=\", add(num1,num2))\n", + "\n", + "elif choice == '2':\n", + " print(num1,\"-\",num2,\"=\", subtract(num1,num2))\n", + "\n", + "elif choice == '3':\n", + " print(num1,\"*\",num2,\"=\", multiply(num1,num2))\n", + "\n", + "elif choice == '4':\n", + " print(num1,\"/\",num2,\"=\", divide(num1,num2))\n", + "else:\n", + " print(\"Invalid input\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def greet(*names):\n", + " \"\"\"This function greets all\n", + " the person in the names tuple.\"\"\"\n", + "\n", + " # names is a tuple with arguments\n", + " for name in names:\n", + " print(\"Hello\",name)\n", + "\n", + "greet(\"Monica\",\"Luke\",\"Steve\",\"John\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Skipping Scope of Variables**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lambda Functions\n", + "In Python, **lambda** function is an **anonymous function that is defined without a name.**\n", + "While normal functions are defined using the def keyword, in these functions are defined using the lambda keyword. We use lambda functions when we require a nameless function for a short period of time." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# lambda functions\n", + "\n", + "square = lambda x: x ** 2\n", + "\n", + "print(square(5))\n", + "\n", + "# works almost the same way as\n", + "# \n", + "# def double(x):\n", + "# return x * 2\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sum = lambda x, y, z: x**2 + y**2 + z**2\n", + "\n", + "print(sum(1,2,3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Built in Functions\n", + "check out https://docs.python.org/3/library/functions.html" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have already seen some of the built in functions without realising that those are functions: " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**type( ), print( ), input( ), range( ), int( ), float( ), str( ), complex( ), list( ), set( ), tuple( ), dict( ), len( ), format( )**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will look into some new built in functions: **abs( ), round( ), filter( ), map( ), min( ), max( ), sum( ), sorted( ), zip( )** " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#abs\n", + "x = -10\n", + "y = -0.3\n", + "z = 4+3j\n", + "\n", + "print(\"abs(x) is \", abs(x))\n", + "print(\"abs(y) is \", abs(y))\n", + "print(\"abs(z) is \", abs(z))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# filter()\n", + "# The filter() function in Python takes in a function and a list as arguments.\n", + "# The function is called with all the items in the list and a new list is returned which contains \n", + "# items for which the function evaluats to True.\n", + "\n", + "#print the vowels only\n", + "# list of alphabets\n", + "alphabets = ['i', 'i', 't', 'b', 'o', 'm', 'b', 'a', 'y']\n", + "\n", + "def Vowels(alphabet):\n", + " vowels = ['a', 'e', 'i', 'o', 'u']\n", + "\n", + " if(alphabet in vowels):\n", + " return True\n", + " else:\n", + " return False\n", + "\n", + "filteredVowels = filter(Vowels, alphabets)\n", + "\n", + "print('The vowels are:')\n", + "for vowel in filteredVowels:\n", + " print(vowel)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# filter()\n", + "# Program to filter out only the odd items from a list\n", + "\n", + "my_list = [1, 2, 3, 5, 4, 6, 8, 11, 3, 12, 16, 19, 21, 22, 24]\n", + "\n", + "new_list = list((filter(lambda x: (x%2 == 1) , my_list)))\n", + "\n", + "print(new_list)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# map()\n", + "\n", + "# Program to double each item in a list \n", + "\n", + "my_list = [1, 2, 3, 5, 4, 6, 8, 11, 3, 12, 16, 19, 21, 22, 24]\n", + "\n", + "new_list = list(map(lambda x: x * 2 , my_list))\n", + "\n", + "\n", + "print(new_list)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# map()\n", + "list_ = []\n", + "for i in range(4):\n", + " list_.append(input())\n", + "print(list_)\n", + "\n", + "new_list = list(map(int, list_))\n", + "print(\"new list after map is \", new_list)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# using max() and min()\n", + "num = [21, 23, 32, 8, 5, 10, 6]\n", + "print('Maximum is:', max(num))\n", + "print('Minimum is:', min(num))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# max()\n", + "num = [15, 300, 2700, 821]\n", + "num1 = [12, 2]\n", + "num2 = [34, 567,454]\n", + "\n", + "# using max(iterable, *iterables, key)\n", + "print('Maximum is:', max(num, num1, num2, key=len))\n", + "print('Minimum is:', min(num, num1, num2, key=len))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#sum\n", + "numbers = [2.5, 3, 4, -5]\n", + "\n", + "numbersSum = sum(numbers)\n", + "print(numbersSum)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#sorted\n", + "\n", + "# vowels list\n", + "pyList = [4, 3, 6, 7, 9, 12, 3]\n", + "print(sorted(pyList))\n", + "\n", + "# string \n", + "pyString = 'Python'\n", + "print(sorted(pyString))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pySet = {'e', 'a', 'u', 'o', 'i'}\n", + "print(sorted(pySet, reverse=True))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# take second element for sort\n", + "def takeSecond(elem):\n", + " return elem[1]\n", + "\n", + "\n", + "list_ = [(2, 2), (3, 4), (4, 1), (1, 3)]\n", + "\n", + "# sort list with key\n", + "sortedList = sorted(random, key=takeSecond)\n", + "\n", + "# print list\n", + "print('Sorted list:', sortedList)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#zip\n", + "numbersList = [1, 2, 3]\n", + "strList = ['one', 'two']\n", + "numbersTuple = ('ONE', 'TWO', 'THREE', 'FOUR')\n", + "\n", + "result = zip(numbersList, numbersTuple)\n", + "\n", + "# Converting to set\n", + "resultSet = set(result)\n", + "print(resultSet)\n", + "\n", + "result = zip(numbersList, strList, numbersTuple)\n", + "\n", + "# Converting to set\n", + "resultSet = set(result)\n", + "print(resultSet)" + ] + }, + { + "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.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/session-1/Main/List.ipynb b/session-1/Main/List.ipynb new file mode 100644 index 0000000..8819bdc --- /dev/null +++ b/session-1/Main/List.ipynb @@ -0,0 +1,566 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Lists\n", + "\n", + "\n", + "In Python, a list is created by placing all the elements inside a square bracket [ ], separated by commas. It can have any number of items and they may be of different types (integer, float, string etc.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Creating List\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# empty list\n", + "my_list = []\n", + "\n", + "# list of integers\n", + "my_list = [1, 2, 3]\n", + "\n", + "# list with different datatypes\n", + "my_list = [1, \"Hello world\", 4.09]\n", + "\n", + "my_list = [0]*4\n", + "\n", + "print(my_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## List index\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# nested list\n", + "my_list = [\"This is a nested list\", [1, 2, 3], ['this is the first item of third element of my_list']]\n", + "\n", + "# first element of my_list\n", + "print(my_list[0])\n", + "\n", + "# second element of my_list\n", + "print(my_list[1])\n", + "\n", + "\n", + "print(my_list[1][2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Negative indexing\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_list = ['I','I','T','B','O','M','B','A','Y']\n", + "\n", + "\n", + "print(my_list[-1])\n", + "\n", + "print(my_list[-5])\n", + "\n", + "#print(my_list[-len(my_list)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## List slicing\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_list = ['I','I','T','B','O','M','B','A','Y']\n", + "# elements 3rd to 5th\n", + "print(my_list[2:5])\n", + "\n", + "# elements beginning to 4th\n", + "print(my_list[:-5])\n", + "\n", + "# elements 6th to end\n", + "print(my_list[5:])\n", + "\n", + "# elements beginning to end\n", + "print(my_list[:])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(my_list[0:9])\n", + "\n", + "# every 2nd element is taken\n", + "print(my_list[0:9:2])\n", + "\n", + "# every 2nd element is taken\n", + "print(my_list[::2])\n", + "\n", + "#nice little trick to reverse a list\n", + "print(my_list[::-1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Python List methods\n", + "\n", + "| Method | Description |\n", + "|---|:---|\n", + "|append()| Add an element to the end of the list|\n", + "|extend() | Add all elements of a list to the another list|\n", + "|insert() | Insert an item at the defined index|\n", + "|remove()| Removes an item from the list|\n", + "|pop() | Removes and returns an element at the given index|\n", + "|clear()| Removes all items from the list|\n", + "|index() | Returns the index of the first matched item|\n", + "|count()| Returns the count of number of items passed as an argument|\n", + "|sort() | Sort items in a list in ascending order|\n", + "|reverse()| Reverse the order of items in the list|\n", + "|copy() | Returns a shallow copy of the list|" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "# change the element in the 0th position\n", + "my_list[0] = 10\n", + "print(my_list)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_list.append(10)\n", + "print(my_list)\n", + "\n", + "my_list.extend([11, 12, 13])\n", + "print(my_list)\n", + "\n", + "# will throw error if the item is not in the list\n", + "my_list.remove(2)\n", + "print(my_list)\n", + "\n", + "my_list.sort()\n", + "print(my_list)\n", + "\n", + "my_list.reverse()\n", + "print(my_list)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## List Comprehension: Elegant way to create new List\n", + "List comprehension is an elegant and concise way to create new list from an existing list in Python." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pow2 = [x**2 for x in range(10)]\n", + "\n", + "print(pow2)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# similar program\n", + "pow2 = []\n", + "for x in range(10):\n", + " pow2.append(x**2)\n", + "\n", + "print(pow2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pow2 = [x**2 for x in range(10) if x > 5]\n", + "\n", + "pow2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "odd = [x for x in range(20) if x % 2 == 1]\n", + "odd\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "[x+y for x in ['Python ','C '] for y in ['Language','Programming']]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Matrix multiplication - Normal way and Pythonic approach\n", + "\n", + "#### requires: List, List comprehension, functions, zip( ), " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 3x3 matrix\n", + "matrix_A = [[12,7,3],\n", + " [4 ,5,6],\n", + " [7 ,8,9]]\n", + "\n", + "# 3x4 matrix\n", + "matrix_B = [[5,8,1,2],\n", + " [6,7,3,0],\n", + " [4,5,9,1]]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Program to multiply two matrices the non pythonic way\n", + "\n", + "def multiply_matrices(X, Y):\n", + " '''This function multiplies two matrices.'''\n", + " \n", + " result = [[0,0,0,0],\n", + " [0,0,0,0],\n", + " [0,0,0,0]]\n", + " \n", + " # iterate through rows of X\n", + " for i in range(len(X)):\n", + " # iterate through columns of Y\n", + " for j in range(len(Y[0])):\n", + " # iterate through rows of Y\n", + " for k in range(len(Y)):\n", + " result[i][j] += X[i][k] * Y[k][j]\n", + " \n", + " return result\n", + "\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "result = multiply_matrices(matrix_A, matrix_B)\n", + "for r in result:\n", + " print(r)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Lets make the code more generalized. results matrices should take the dimension automatically**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# dimension of result = (rows of matrix A) x (columns of matrix B) \n", + "result = [[0]*len(matrix_B[0]) for i in range(3)]\n", + "print(result)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def multiply_matrices(X, Y):\n", + " '''This function multiplies two matrices.'''\n", + " \n", + " result = [[0]*len(Y[0]) for i in range(len(Y))] ## genraized result matrix\n", + " \n", + " for i in range(len(X)):\n", + " for j in range(len(Y[0])):\n", + " for k in range(len(Y)):\n", + " result[i][j] += X[i][k] * Y[k][j]\n", + " return result\n", + "\n", + "result = multiply_matrices(matrix_A, matrix_B)\n", + "for r in result:\n", + " print(r)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# use of zip function\n", + "list_a = [1, 2, 3, 4, 5]\n", + "list_b = [10, 20, 30, 40, 50]\n", + "\n", + "list(zip(list_a, list_b))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "[a*b for a,b in zip(list_a, list_b)]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "list_a = [1, 2, 3, 4, 5]\n", + "sum(list_a)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sum([a*b for a,b in zip(list_a, list_b)])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "list(zip(matrix_B[0], matrix_B[1], matrix_B[2]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#written in a consize manner\n", + "\n", + "list(zip(*matrix_B))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Pythonic way\n", + "\n", + "def multiply_matrices(X, Y):\n", + " result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]\n", + " return result\n", + "\n", + "result = multiply_matrices(matrix_A, matrix_B)\n", + "for r in result:\n", + " print(r)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Lets make the code better.\n", + "# fill the if statements such that it checks if the matrix multiplication can be done\n", + "\n", + "def multiply_matrices(X, Y):\n", + " if():\n", + " pass\n", + " else:\n", + " print(\"Dimensions don't match\")\n", + " return [False]\n", + " result = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]\n", + " return result\n", + "\n", + "result = multiply_matrices(matrix_A, matrix_B)\n", + "for r in result:\n", + " print(r)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Transpose of a Matrix\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Non pythonic way\n", + "\n", + "# Program to transpose a matrix using nested loop\n", + "\n", + "X = [[12,7],\n", + " [4 ,5],\n", + " [3 ,8]]\n", + "\n", + "result = [[0,0,0],\n", + " [0,0,0]]\n", + "\n", + "# iterate through rows\n", + "for i in range(len(X)):\n", + " # iterate through columns\n", + " for j in range(len(X[0])):\n", + " result[j][i] = X[i][j]\n", + "\n", + "for r in result:\n", + " print(r)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Using List comprehension\n", + "\n", + "X = [[12,7],\n", + " [4 ,5],\n", + " [3 ,8]]\n", + "\n", + "result = [[X[j][i] for j in range(len(X))] for i in range(len(X[0]))]\n", + "\n", + "for r in result:\n", + " print(r)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Transpose Using zip\n", + "\n", + "X = [[12,7],\n", + " [4 ,5],\n", + " [3 ,8]]\n", + "\n", + "result = list(zip(*X)) # these are tuples inside a list\n", + "print(result)" + ] + }, + { + "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.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/session-1/Main/Operators.ipynb b/session-1/Main/Operators.ipynb new file mode 100644 index 0000000..5f37315 --- /dev/null +++ b/session-1/Main/Operators.ipynb @@ -0,0 +1,293 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Operators in Python\n", + " Operators in Python are special symbols that carry out arithmetic or logical computation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Arithmetic operators" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Arithmetic operators are used to perform mathematical operations.\n", + "\n", + "| Operator | Operation |\n", + "|--------| :-------|\n", + "|+\t| Add two operands |\n", + "| -\t| Subtract right operand from the left|\n", + "|* |\tMultiply two operands|\n", + "| / |\tDivision operator|\n", + "|% |\tModulus opeartor|\t\n", + "|// |\tFloor division |\n", + "|** |\tExponent - left operand raised to the power of right|" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x = 10\n", + "y = 3\n", + "\n", + "\n", + "print('x + y =',x+y)\n", + "\n", + "print('x - y =',x-y)\n", + "\n", + "print('x * y =',x*y)\n", + "\n", + "print('x / y =',x/y)\n", + "\n", + "print('x % y =',x%y)\n", + "\n", + "# Extra info: divmod(num1, num2) gives a tuple with (quotient, remainder)\n", + "# print(divmod(x,y))\n", + "\n", + "#something new and useful\n", + "print('x // y =',x//y)\n", + "\n", + "print('x ** y =',x**y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparison operators\n", + "Comparison operators are used to compare values. It either returns **True** or **False**.\n", + "\n", + "| Opeartor | Meaning |\n", + "| ------| -------|\n", + "|>|\tGreater than |\n", + "|<\t|Less than | \n", + "|==\t|Equal to |\n", + "|!=\t|Not equal to |\n", + "|>=\t|Greater than or equal to |\n", + "|<=\t|Less than or equal to \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x = 10\n", + "y = 3\n", + "\n", + "\n", + "print('x > y is',x>y)\n", + "\n", + "print('x < y is',x= y is',x>=y)\n", + "\n", + "print('x <= y is',x<=y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x = 2\n", + "\n", + "print('1 < x < 3 is', 1 < x < 3)\n", + "\n", + "print('10 < x < 20 is', 10 < x < 20)\n", + "\n", + "print('3 > x <= 2 is', 3 > x <= 2)\n", + "\n", + "print('2 == x < 4 is', 2 == x < 4)\n", + "\n", + "print('2 == x > 4 is', 2 == x > 4)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Logical Operator\n", + "| Operator | Meaning |\n", + "|-------| -------|\n", + "|and\t|True if both the operands are true\t|\n", + "|or\t|True if either of the operands is true\t|\n", + "|not |\tcomplements the operand|" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x = True # x = 1\n", + "y = False # y = 0\n", + "\n", + "\n", + "print('x and y is',x and y)\n", + "\n", + "print('x or y is',x or y)\n", + "\n", + "print('not x is',not x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Bitwise operator\n", + "Bitwise operators operate bit by bit, hence the name.\n", + "\n", + "In the table below: Let x = 10 (0000 1010 in binary) and y = 4 (0000 0100 in binary)\n", + "\n", + "|Operator|\tMeaning|\tExample|\n", + "|--------|----------|---------|\n", + "|&\t|Bitwise AND|\tx& y = 0 (0000 0000)|\n", + "||\t|Bitwise OR\t|x \\| y = 14 (0000 1110)|\n", + "|~\t|Bitwise NOT|\t~x = -11 (1111 0101)|\n", + "|^\t|Bitwise XOR|\tx ^ y = 14 (0000 1110)|\n", + "|>>\t|Bitwise right shift|\tx>> 2 = 2 (0000 0010)|\n", + "|<<\t|Bitwise left shift\t|x<< 2 = 40 (0010 1000)|" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Assignment operators\n", + "|Operator|\tExample\t|Equivatent to|\n", + "|------|------|------|\n", + "|=\t|x = 5\t|x = 5|\n", + "|+=\t|x += 5\t|x = x + 5|\n", + "|-=\t|x -= 5\t|x =x - 5|\n", + "|*=\t|x *= 5\t|x = x * 5|\n", + "|/=\t|x /= 5\t|x = x / 5|\n", + "|%=\t|x %= 5\t|x = x % 5|\n", + "|//=|\tx //= 5\t|x = x // 5|\n", + "|**=|\tx **= 5\t|x = x ** 5|\n", + "|&=\t|x &= 5\t|x = x & 5|\n", + "|\\|=\t|x \\|= 5 | \tx = x \\| 5|\n", + "|^=\t|x ^= 5\t|x = x ^ 5|\n", + "|>>=|\tx >>= 5\t|x = x >> 5|\n", + "|<<=|\tx <<= 5|\tx = x << 5|" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Special operators: Identity operators and Membership Operator" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Membership operators: **in** and **not in**,\n", + "Identity operators: **is** and **is not** \n", + "\n", + "**is** and **is not** are the identity operators in Python. They are used to check if two values (or variables) are located on the same part of the memory. Two variables that are equal does not imply that they are identical." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Membership Operator\n", + "\n", + "# True if the operands are identical (refer to the same object)\n", + "\n", + "x1 = 5\n", + "y1 = 5\n", + "\n", + "\n", + "a1 = 'Mumbai'\n", + "a2 = 'Mumbai'\n", + "\n", + "list1 = [1,2,3]\n", + "list2 = [1,2,3]\n", + "\n", + "# print(id(x1), id(y1))\n", + "print(x1 is y1)\n", + "\n", + "\n", + "print(a2 is a1)\n", + "\n", + "# print(id(list1), id(list2))\n", + "print(list1 is list2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Membership Operator\n", + "\n", + "city = 'Bombay'\n", + "list1 = [1, 2, 3, 4]\n", + "\n", + "\n", + "print('H' not in city)\n", + "\n", + "print('Bom' in city)\n", + "\n", + "print(1 in list1)\n", + "\n", + "print([1, 2] in list1)\n", + "\n", + "print('ay' in list1)\n" + ] + }, + { + "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.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/session-1/Main/Practice.ipynb b/session-1/Main/Practice.ipynb new file mode 100644 index 0000000..52bd4e4 --- /dev/null +++ b/session-1/Main/Practice.ipynb @@ -0,0 +1,189 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Problem 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a=int(input(\"Enter the first number: \"))\n", + "b=int(input(\"Enter the second number: \"))\n", + "\n", + "#quotient\n", + "#remainder\n", + "\n", + "print(\"Quotient is:\",quotient)\n", + "print(\"Remainder is:\",remainder)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Problem 2: Find the average\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "n=int(input(\"Enter the number of elements to be inserted: \"))\n", + "a=[]\n", + "\n", + "# Take inputs one by one and save them in a list\n", + "# how can you use list comprehension here?\n", + "\n", + " \n", + " \n", + "avg=sum(a)/n\n", + "print(\"Average of elements in the list\",avg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Problem 3: Find all the divisors" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "n=int(input(\"Enter an integer:\"))\n", + "\n", + "##" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Problem 4: Find factorial of a number\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "num = int(input(\"Enter a number: \"))\n", + "\n", + "factorial = 1\n", + "\n", + "# check if the number is negative, positive or zero\n", + "if num < 0:\n", + " print(\"Sorry, factorial does not exist for negative numbers\")\n", + "elif num == 0:\n", + " print(\"The factorial of 0 is 1\")\n", + "else:\n", + " pass\n", + "\n", + "\n", + "# Can we write a better code with functions?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Problem 5: Display Fibonacci Sequence Using Recursion\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def recur_fibo(n):\n", + " \"\"\"Recursive function to\n", + " print Fibonacci sequence\"\"\"\n", + " pass\n", + "\n", + "\n", + "nterms = 10\n", + "\n", + "\n", + "if nterms <= 0:\n", + " print(\"Plese enter a positive integer\")\n", + "else:\n", + " print(\"Fibonacci sequence:\")\n", + " for i in range(nterms):\n", + " print(recur_fibo(i))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "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.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/session-1/Main/Pre introduction to Python.ipynb b/session-1/Main/Pre introduction to Python.ipynb new file mode 100644 index 0000000..6c019c7 --- /dev/null +++ b/session-1/Main/Pre introduction to Python.ipynb @@ -0,0 +1,282 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Pre-introduction to Python\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### This notebook is for getting your system ready for Python and get a glimse of what is coming. Just get a hang of the notebook interface and run some simple scripts written below. Feel free to edit the codes and play around.\n", + "All the codes written here are in Python 3.5, so if you have version > 3.5 things should work fine. To check if the python in your system is running fine run the following line of code. (note: press Shift + Enter to run the code)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Press Shift + Enter\n", + "# You should see a line \"Welcome to the world of Python\"\n", + "print(\"Welcome to the world of Python\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# To check what version of python you are running\n", + "import sys\n", + "sys.version" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So if the above two snippets are running and your python version > 3.5, you are good to go! \n", + "Now let us see some basic syntax in python programming language.\n", + "### Statement:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instructions that a Python interpreter can execute are called statements. Like an assignment operator." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = 1 + 2 + 3\n", + "print(a)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# this will give you an error\n", + "a = 1 + 2 \\\n", + " + 3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# to fix that use '\\' or parenthesis like '()'\n", + "a = 1 + 2 \\\n", + " + 3\n", + "b = (1 + 2 \n", + " + 3)\n", + "print(a)\n", + "print(b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Indentation:\n", + "Unlike other programming languages Python does not use braces { } to define a block of code. Python uses indentation. Many people use tabs for indentation but generally four whitespaces are preferred over tabs. By default indentation is done in notebook when you press enter." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "a = 6\n", + "if a == 6:\n", + " print('Hello')\n", + "else:\n", + " print('oops')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comments:\n", + "In Python, we use the hash (#) symbol to start writing a comment." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# This is a comment. This won't run.\n", + "var = 6\n", + "print(var)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# This is a multi line\n", + "# comment. But there is a better \n", + "# way.\n", + "\n", + "\"\"\"Triple quotes can be used\n", + "as multi-line comment just like this\"\"\"\n", + "print(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Variables:\n", + "In Python, variables do not need declaration to reserve memory space. As you might have already seen in the earlier examples the variable declaration happens automatically when we assign a value to a variable. Python is a type inferred language, it can automatically infer if a variable is a int or float or a string. Let us see an example:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "num_1 = 5\n", + "num_2 = 6.0\n", + "num_3 = 5 + 5j\n", + "item = \"Python\"\n", + "\n", + "print(type(num_1))\n", + "print(type(num_2))\n", + "print(type(num_3))\n", + "print(type(item))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Major Data Types in Python are Numbers, List, Tuple, Strings, Set, Dictionary. We will only see how Lists work for now. Rest would be discussed in the workshop." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### List: \n", + "It is an ordered sequence of items. It is one of the most used datatype in Python and is very flexible. It is like an array in C/C++ but here all the items in a list do not need to be of the same type.\n", + "Declaring a list is pretty straight forward." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "first_list = [0, 1, 1, 2, 3, 5, 8]\n", + "type(first_list)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Gives the first item of a list.\n", + "first_list[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Gives the length of a list\n", + "len(first_list)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "second_list = [0, 1.2, 'it works fine']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "second_list[2]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us end this here with an easter egg:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import this" + ] + }, + { + "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.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/session-1/Main/Tuple, Set, Dictionary.ipynb b/session-1/Main/Tuple, Set, Dictionary.ipynb new file mode 100644 index 0000000..da008e4 --- /dev/null +++ b/session-1/Main/Tuple, Set, Dictionary.ipynb @@ -0,0 +1,514 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dictionary\n", + "Python dictionary is an unordered collection of items. A dictionary has a key: value pair.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# empty dictionary\n", + "my_dict = {}\n", + "\n", + "# dictionary with integer keys\n", + "my_dict = {1: 'Apple', 2: 'Samsung', 3: 'Mi', 2: 'One plus'}\n", + "\n", + "# dictionary with mixed keys\n", + "my_dict = {'name': 'random', 1: [2, 4, 3]}\n", + "\n", + "# using dict()\n", + "my_dict = dict({1: 'Apple', 2: 'Samsung', 3: 'Mi', 2: 'One plus'})\n", + "\n", + "# from sequence having each item as a pair\n", + "my_dict = dict([(1,'Apple'), (2,'Samsung')])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_dict" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_dict = {'name':'IIT Bombay', 'year': 1958}\n", + "\n", + "\n", + "print(my_dict['name'])\n", + "\n", + "\n", + "print(my_dict.get('year'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Trying to access keys which doesn't exist throws error\n", + "#my_dict.get('address')\n", + "my_dict['city']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_dict = {'name':'IIT Bombay', 'year': 1958}\n", + "\n", + "# update value\n", + "my_dict['name'] = 'IIT Bombay, Powai'\n", + "\n", + "print(my_dict)\n", + "\n", + "# add item\n", + "my_dict['city'] = 'Mumbai' \n", + "\n", + "\n", + "print(my_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "squares = {x: x*x for x in range(6)}\n", + "\n", + "# Output: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}\n", + "print(squares)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "squares = {}\n", + "for x in range(6):\n", + " squares[x] = x*x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "| Method | Descriptions |\n", + "|--------|:---------|\n", + "|clear() |\tRemoves all the elements from the dictionary |\n", + "|copy()\t| Returns a copy of the dictionary |\n", + "|fromkeys() |\tReturns a dictionary with the specified keys and values |\n", + "|get()\t| Returns the value of the specified key |\n", + "|items() |\tReturns a list containing the a tuple for each key value pair |\n", + "|keys() |\tReturns a list contianing the dictionary's keys |\n", + "|pop() |\tRemoves the element with the specified key |\n", + "|popitem() |\tRemoves the last inserted key-value pair |\n", + "|update() |\tUpdates the dictionary with the specified key-value pairs|\n", + "|values() |\tReturns a list of all the values in the dictionary|" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "name = 'IIT Bombay'\n", + "if name == 'IIT Bombay':\n", + " print('Founded in 1958')\n", + " \n", + "elif name == 'IIT Kharagpur':\n", + " print('Founded in 1950')\n", + " \n", + "elif name == 'IIT Kanpur':\n", + " print('Founded in 1959')\n", + " \n", + "elif name == 'IIT Delhi':\n", + " print('Founded in 1961')\n", + " \n", + "elif name == 'IIT Madras':\n", + " print('Founded in 1959')\n", + " \n", + "elif name == 'IIT Guwahati':\n", + " print('Founded in 1994')\n", + " \n", + "else:\n", + " print(\"I don't know when it was founded\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "year = {'IIT Bombay': 'Founded in 1958',\n", + " 'IIT Kharagpur': 'Founded in 1950',\n", + " 'IIT Kanpur': 'Founded in 1959',\n", + " 'IIT Delhi': 'Founded in 1961',\n", + " 'IIT Madras': 'Founded in 1959',\n", + " 'IIT Guwahati': 'Founded in 1994'}\n", + "\n", + "print(year.get('IIT Kharagpur', \"I don't know when it was founded\"))\n", + "print(year.get('IIT Roorkee', \"I don't know when it was founded\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tuple\n", + "In Python, a tuple is similar to a list. The difference between the two is that we cannot change the elements of a tuple once it is assigned whereas in a list, elements can be changed." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# empty tuple\n", + "\n", + "my_tuple = ()\n", + "print(my_tuple)\n", + "\n", + "# tuple having integers\n", + "\n", + "my_tuple = (1, 2, 3)\n", + "print(my_tuple)\n", + "\n", + "# tuple with mixed datatypes\n", + "\n", + "my_tuple = (1, \"Hello\", 3.4)\n", + "print(my_tuple)\n", + "\n", + "\n", + "# tuple can be created without parentheses\n", + "# also called tuple packing\n", + "\n", + "my_tuple = 3, 4.6, \"string\"\n", + "print(my_tuple)\n", + "\n", + "# tuple unpacking is also possible\n", + "\n", + "a, b, c = my_tuple\n", + "print(a)\n", + "print(b)\n", + "print(c)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# only parentheses is not enough\n", + "\n", + "my_tuple = (\"Mumbai\")\n", + "print(type(my_tuple))\n", + "\n", + "# need a comma at the end\n", + "\n", + "my_tuple = (\"Mumbai\",) \n", + "print(type(my_tuple))\n", + "\n", + "# parentheses is optional\n", + "\n", + "my_tuple = \"Mumbai\",\n", + "print(type(my_tuple))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_tuple = ('Hello', 2, 3, [6, 5])\n", + "\n", + "\n", + "#my_tuple[1] = 9\n", + "\n", + "# but item of mutable element can be changed\n", + "\n", + "my_tuple[3][0] = 9\n", + "print(my_tuple)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Concatenation\n", + "\n", + "print((1, 2, 3) + (4, 5, 6))\n", + "\n", + "# Repeat\n", + "\n", + "print((\"Tuples are great\",) * 3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_tuple = ('i','i','t','b','o','m','b','a','y')\n", + "\n", + "# Count\n", + "\n", + "print(my_tuple.count('b'))\n", + "\n", + "# Index\n", + "print(my_tuple.index('i'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Set\n", + "A set is an unordered collection of items. Every element is unique (no duplicates) and must be immutable (which cannot be changed)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# set of integers\n", + "my_set = {1, 2, 3}\n", + "print(my_set)\n", + "\n", + "# set of mixed datatypes\n", + "my_set = {1.0, \"string\", (1, 2, 3)}\n", + "print(my_set)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# initialize a with {}\n", + "a = {}\n", + "\n", + "# check data type of a\n", + "print(type(a))\n", + "\n", + "# initialize a with set()\n", + "a = set()\n", + "\n", + "# check data type of a\n", + "print(type(a))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# initialize my_set\n", + "my_set = {1,3}\n", + "print(my_set)\n", + "\n", + "\n", + "#my_set[0]\n", + "\n", + "# add an element\n", + "my_set.add(2)\n", + "print(my_set)\n", + "\n", + "# add multiple elements\n", + "\n", + "my_set.update([2,3,4])\n", + "print(my_set)\n", + "\n", + "# add list and set\n", + "\n", + "my_set.update([4,5,9], {1,6,8})\n", + "print(my_set)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Some interesting things about Strings\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "str = 'Python Workshop'\n", + "print('str = ', str)\n", + "\n", + "#first character\n", + "print('str[0] = ', str[0])\n", + "\n", + "#last character\n", + "print('str[-1] = ', str[-1])\n", + "\n", + "#slicing 2nd to 5th character\n", + "print('str[1:5] = ', str[1:5])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "str[3]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "str[3] = 'a'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "str1 = 'Hello'\n", + "str2 ='World!'\n", + "\n", + "# using +\n", + "print('str1 + str2 = ', str1 + str2)\n", + "\n", + "# using *\n", + "print('str1 * 3 =', str1 * 3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"IITBombay\".lower()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"IITBombay\".upper()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"Python Workshop\".split()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"Python-Workshop-2018\".split('-')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_list = ['Python', 'Workshop']\n", + "' '.join(my_list)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"Python Workshop\".find(\"Wo\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"Python Workshop\".replace(\"W\",\"w\")" + ] + }, + { + "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.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/session-1/Practice.ipynb b/session-1/Practice.ipynb new file mode 100644 index 0000000..52bd4e4 --- /dev/null +++ b/session-1/Practice.ipynb @@ -0,0 +1,189 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Problem 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a=int(input(\"Enter the first number: \"))\n", + "b=int(input(\"Enter the second number: \"))\n", + "\n", + "#quotient\n", + "#remainder\n", + "\n", + "print(\"Quotient is:\",quotient)\n", + "print(\"Remainder is:\",remainder)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Problem 2: Find the average\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "n=int(input(\"Enter the number of elements to be inserted: \"))\n", + "a=[]\n", + "\n", + "# Take inputs one by one and save them in a list\n", + "# how can you use list comprehension here?\n", + "\n", + " \n", + " \n", + "avg=sum(a)/n\n", + "print(\"Average of elements in the list\",avg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Problem 3: Find all the divisors" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "n=int(input(\"Enter an integer:\"))\n", + "\n", + "##" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Problem 4: Find factorial of a number\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "num = int(input(\"Enter a number: \"))\n", + "\n", + "factorial = 1\n", + "\n", + "# check if the number is negative, positive or zero\n", + "if num < 0:\n", + " print(\"Sorry, factorial does not exist for negative numbers\")\n", + "elif num == 0:\n", + " print(\"The factorial of 0 is 1\")\n", + "else:\n", + " pass\n", + "\n", + "\n", + "# Can we write a better code with functions?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Problem 5: Display Fibonacci Sequence Using Recursion\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def recur_fibo(n):\n", + " \"\"\"Recursive function to\n", + " print Fibonacci sequence\"\"\"\n", + " pass\n", + "\n", + "\n", + "nterms = 10\n", + "\n", + "\n", + "if nterms <= 0:\n", + " print(\"Plese enter a positive integer\")\n", + "else:\n", + " print(\"Fibonacci sequence:\")\n", + " for i in range(nterms):\n", + " print(recur_fibo(i))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "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.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/session-1/Sessio-1-Basic-Data-viz-Main.ipynb b/session-1/Sessio-1-Basic-Data-viz-Main.ipynb new file mode 100644 index 0000000..1ed5dc2 --- /dev/null +++ b/session-1/Sessio-1-Basic-Data-viz-Main.ipynb @@ -0,0 +1,1253 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nPython list indexing\\nNumPy basic syntax\\nmatplotlib introduction\\n'" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "Python list indexing\n", + "NumPy basic syntax\n", + "matplotlib introduction\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [], + "source": [ + "my_list = [1, 2, 3, 4]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4]\n" + ] + } + ], + "source": [ + "print(my_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_list[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "ename": "IndexError", + "evalue": "list index out of range", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmy_list\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m: list index out of range" + ], + "output_type": "error" + } + ], + "source": [ + "my_list[4]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(my_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n2\n3\n4\n" + ] + } + ], + "source": [ + "for i in my_list:\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 5, 5]\n" + ] + } + ], + "source": [ + "my_list.append(5)\n", + "print(my_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "my_list.insert(0, -1)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-1, 1, 2, 3, 4]\n" + ] + } + ], + "source": [ + "print(my_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "del my_list[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-1, 1, 3, 4]\n" + ] + } + ], + "source": [ + "print(my_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "my_list.remove(4)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-1, 1]\n" + ] + } + ], + "source": [ + "print(my_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "my_list = [2, 6, 3, 2, 7, 5, 4, 7, 6, 4]" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [], + "source": [ + "my_list.sort(reverse=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[7, 7, 6, 6, 5, 4, 4, 3, 2, 2]" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_list" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[6, 6, 5, 4]" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_list[2:6]" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[7, 7, 6, 6, 5]" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_list[:5]" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[4, 4, 3, 2, 2]" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_list[5:]" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_list[-2]" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[3, 2, 2]" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_list[-3:]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "module 'numpy' has no attribute 'float256'", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat16\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat64\u001b[0m \u001b[0;31m# Standard python float\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat256\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m: module 'numpy' has no attribute 'float256'" + ], + "output_type": "error" + } + ], + "source": [ + "# Starting Numpy\n", + "import numpy as np\n", + "\n", + "np.int8\n", + "np.int16\n", + "np.int32 # Standard python integer\n", + "np.int64\n", + "\n", + "np.float16\n", + "np.float64 # Standard python float\n", + "np.float256" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "x = np.linspace(0, 10, 40)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0. , 0.25641026, 0.51282051, 0.76923077,\n 1.02564103, 1.28205128, 1.53846154, 1.79487179,\n 2.05128205, 2.30769231, 2.56410256, 2.82051282,\n 3.07692308, 3.33333333, 3.58974359, 3.84615385,\n 4.1025641 , 4.35897436, 4.61538462, 4.87179487,\n 5.12820513, 5.38461538, 5.64102564, 5.8974359 ,\n 6.15384615, 6.41025641, 6.66666667, 6.92307692,\n 7.17948718, 7.43589744, 7.69230769, 7.94871795,\n 8.20512821, 8.46153846, 8.71794872, 8.97435897,\n 9.23076923, 9.48717949, 9.74358974, 10. ])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(40,)" + ] + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "sinx = np.sin(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 123, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAD8CAYAAABzTgP2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x, sinx)" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0. , 0.25641026, 0.51282051, 0.76923077,\n 1.02564103, 1.28205128, 1.53846154, 1.79487179,\n 2.05128205, 2.30769231],\n [ 2.56410256, 2.82051282, 3.07692308, 3.33333333,\n 3.58974359, 3.84615385, 4.1025641 , 4.35897436,\n 4.61538462, 4.87179487],\n [ 5.12820513, 5.38461538, 5.64102564, 5.8974359 ,\n 6.15384615, 6.41025641, 6.66666667, 6.92307692,\n 7.17948718, 7.43589744],\n [ 7.69230769, 7.94871795, 8.20512821, 8.46153846,\n 8.71794872, 8.97435897, 9.23076923, 9.48717949,\n 9.74358974, 10. ]])" + ] + }, + "execution_count": 120, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x.reshape(4, 10)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "cosx = np.cos(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 129, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAD8CAYAAABzTgP2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nbB4HBjMzm8eBwczM5vn/n41TkUyIiO4AAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x, sinx, 'o')\n", + "plt.plot(x, cosx, 'x')" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [], + "source": [ + "y = sinx * cosx\n", + "z = cosx ** 2 - sinx ** 2" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 133, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAD8CAYAAABzTgP2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x, y)\n", + "plt.plot(x, z)\n", + "plt.legend(['sin(x) cos(x)', 'cos(x)^2 - sin(x)^2'])\n", + "# http://matplotlib.org/users/legend_guide.html" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.79265269738691579" + ] + }, + "execution_count": 134, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.dot(sinx, cosx)" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": {}, + "outputs": [], + "source": [ + "random_list = np.random.random((5, 4))" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.10160215, 0.19638517, 0.18114557, 0.44743895],\n [ 0.22978511, 0.28151483, 0.15760194, 0.8515004 ],\n [ 0.14102359, 0.40204428, 0.33531824, 0.887159 ],\n [ 0.99371695, 0.63259281, 0.93574292, 0.40019842],\n [ 0.50737189, 0.69522328, 0.74474918, 0.07566387]])" + ] + }, + "execution_count": 140, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "random_list" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.28151482594821708" + ] + }, + "execution_count": 143, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "random_list[1, 1]" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "metadata": {}, + "outputs": [], + "source": [ + "a = np.array([[1, 2, 3, 4], [5, 6, 7, 8]], dtype=np.float64)" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1., 2., 3., 4.],\n [ 5., 6., 7., 8.]])" + ] + }, + "execution_count": 150, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n(2, 4)\n8\n" + ] + } + ], + "source": [ + "print(a.ndim)\n", + "print(a.shape)\n", + "print(a.size)" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0.58687902 0.15109334 0.59085781 1.65976747]\n [ 0.33607006 -0.11234594 0.75864456 -0.48617888]\n [-1.54559726 1.89337696 0.27475704 -2.21918716]\n [-1.13116517 -0.41494606 0.93628712 0.82470554]]\n" + ] + } + ], + "source": [ + "print(np.random.standard_normal((4, 4)))" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": {}, + "outputs": [], + "source": [ + "a = np.random.standard_normal((2, 3))\n", + "b = np.random.standard_normal((2, 3))" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.11610972, 0.59962024, 2.35640598],\n [-0.10938713, 0.25340579, 0.22537108],\n [ 0.2898026 , -0.73885257, 0.6479818 ],\n [ 1.40726154, 0.13462496, -0.77445899]])" + ] + }, + "execution_count": 167, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.vstack([a, b])" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.11610972, 0.59962024, 2.35640598, 0.2898026 , -0.73885257,\n 0.6479818 ],\n [-0.10938713, 0.25340579, 0.22537108, 1.40726154, 0.13462496,\n -0.77445899]])" + ] + }, + "execution_count": 170, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.hstack([a, b])" + ] + }, + { + "cell_type": "code", + "execution_count": 172, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.11610972, -0.10938713],\n [ 0.59962024, 0.25340579],\n [ 2.35640598, 0.22537108]])" + ] + }, + "execution_count": 172, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a.T" + ] + }, + { + "cell_type": "code", + "execution_count": 173, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.11610972, -0.10938713],\n [ 0.59962024, 0.25340579],\n [ 2.35640598, 0.22537108]])" + ] + }, + "execution_count": 173, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a.transpose()" + ] + }, + { + "cell_type": "code", + "execution_count": 174, + "metadata": {}, + "outputs": [], + "source": [ + "np.save('array.npy', a)" + ] + }, + { + "cell_type": "code", + "execution_count": 175, + "metadata": {}, + "outputs": [], + "source": [ + "loaded_array = np.load('array.npy')" + ] + }, + { + "cell_type": "code", + "execution_count": 177, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.11610972, 0.59962024, 2.35640598],\n [-0.10938713, 0.25340579, 0.22537108]])" + ] + }, + "execution_count": 177, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loaded_array" + ] + }, + { + "cell_type": "code", + "execution_count": 189, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0.86605881 0.34328046 0.30613523 0.32191526]\n [ 0.39613612 0.66678478 0.38061782 0.57401435]\n [ 0.97763981 0.51574922 0.39385415 0.32439499]\n [ 0.13135189 0.78272864 0.78130271 0.44735846]\n [ 0.08804111 0.31719408 0.07886734 0.96297163]]\n" + ] + } + ], + "source": [ + "a = np.random.random((5, 4))\n", + "print(a)" + ] + }, + { + "cell_type": "code", + "execution_count": 191, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.97763981, 0.51574922, 0.39385415, 0.32439499],\n [ 0.13135189, 0.78272864, 0.78130271, 0.44735846]])" + ] + }, + "execution_count": 191, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[2:4]" + ] + }, + { + "cell_type": "code", + "execution_count": 195, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0.39385415, 0.78130271])" + ] + }, + "execution_count": 195, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[2:4, 2]" + ] + }, + { + "cell_type": "code", + "execution_count": 198, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.324394985845\n0.324394985845\n" + ] + } + ], + "source": [ + "print(a[2, 3])\n", + "print(a[2][3])" + ] + }, + { + "cell_type": "code", + "execution_count": 200, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.51574922, 0.39385415],\n [ 0.78272864, 0.78130271]])" + ] + }, + "execution_count": 200, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[2:4, 1:3]" + ] + }, + { + "cell_type": "code", + "execution_count": 201, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.97763981, 0.51574922, 0.39385415, 0.32439499],\n [ 0.13135189, 0.78272864, 0.78130271, 0.44735846]])" + ] + }, + "execution_count": 201, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[2:4, :]" + ] + }, + { + "cell_type": "code", + "execution_count": 204, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.97763981, 0.51574922, 0.39385415, 0.32439499],\n [ 0.13135189, 0.78272864, 0.78130271, 0.44735846]])" + ] + }, + "execution_count": 204, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[2:4]" + ] + }, + { + "cell_type": "code", + "execution_count": 207, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.86605881, 0.34328046, 0.30613523, 0.32191526],\n [ 0.39613612, 0.66678478, 0.38061782, 0.57401435],\n [ 0.97763981, 0.51574922, 0.39385415, 0.32439499],\n [ 0.13135189, 0.78272864, 0.78130271, 0.44735846],\n [ 0.08804111, 0.31719408, 0.07886734, 0.96297163]])" + ] + }, + "execution_count": 207, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[:, ::2]\n", + "# step size(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 208, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ True, False, False, False],\n [False, True, False, True],\n [ True, True, False, False],\n [False, True, True, False],\n [False, False, False, True]], dtype=bool)" + ] + }, + "execution_count": 208, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a > 0.5" + ] + }, + { + "cell_type": "code", + "execution_count": 209, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0.86605881, 0.66678478, 0.57401435, 0.97763981, 0.51574922,\n 0.78272864, 0.78130271, 0.96297163])" + ] + }, + "execution_count": 209, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[a > 0.5]" + ] + }, + { + "cell_type": "code", + "execution_count": 220, + "metadata": {}, + "outputs": [], + "source": [ + "import seaborn as sns\n", + "sns.set_style('dark')" + ] + }, + { + "cell_type": "code", + "execution_count": 222, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 222, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeEAAAFJCAYAAACsBZWNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(np.random.random(100), 'r')" + ] + }, + { + "cell_type": "code", + "execution_count": 225, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 225, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe0AAAFJCAYAAAC2OXUDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nVOJ/+mESkc9I1EAAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x, sinx, 'o')\n", + "plt.plot(x, cosx, 'g')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD8CAYAAAB+UHOxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n/j8P6Ar+pykLAAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.ylim(cosx.min() * 1.5, cosx.max() * 1.5)\n", + "plt.xlim(x.min() - 2, x.max() * 1.5)\n", + "plt.plot(x, cosx, label='cos(x)')\n", + "plt.legend(loc='upper left', frameon=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD8CAYAAAB+UHOxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAIIgCAnK/wdNlGvrPwcDcAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "t = np.arange(0.0, 5.0, 0.01)\n", + "s = np.cos(2 * np.pi * t)\n", + "line, = plt.plot(t, s, lw=2)\n", + "\n", + "plt.annotate('local max', xy=(2, 1),\n", + " xytext=(3, 1.5),\n", + " arrowprops=dict(facecolor='white', shrink=0.05),\n", + " )\n", + "\n", + "plt.ylim(-2, 2)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVMAAAENCAYAAACyz4bzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n/w+39UzDsrNf3QAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, polar=True)\n", + "r = np.arange(0, 1, 0.001)\n", + "theta = 2 * 2 * np.pi * r\n", + "line, = ax.plot(theta, r,\n", + " color='#ee8d18', lw=7)\n", + "\n", + "ind = 800\n", + "thisr, thistheta = r[ind], theta[ind]\n", + "ax.plot([thistheta], [thisr], 'o')\n", + "ax.annotate('a polar annotation',\n", + " xy=(thistheta, thisr), # theta, radius\n", + " xytext=(0.05, 0.05), # fraction, fraction\n", + " textcoords='figure fraction',\n", + " arrowprops=dict(facecolor='red', shrink=0.05),\n", + " horizontalalignment='left',\n", + " verticalalignment='bottom',\n", + " )\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2.0 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/session-1/beginner_intro.py b/session-1/beginner_intro.py new file mode 100644 index 0000000..daad7fd --- /dev/null +++ b/session-1/beginner_intro.py @@ -0,0 +1,290 @@ +''' +INTRO TO PYTHON + +Beginner Notes +''' + + + +# this is a comment +# the program will ignore comments +# they are for developer use + +# variables +name = "Ivan" +age = 19 + +print(name, "is", age, "years old.") + +# suppose a year passes +age = 20 +print(name, "is", age, "years old.") + + +# arithmatic + +x = 5 +y = 3 + +add = x + y +sub = x - y +mul = x * y +div = x / y +exp = x ** y + +# modulus gets the remainder +mod = x % y + + +# increment x by y +# x = x + y +x += y + +# decrement x by y +# x = x - y +x -= y + +# This also works for other operators +x *= y +x /= y + + +# if statements + +condition1 = True +condition2 = False + +if condition1: + print("Condition1 is True") +elif condition2: + print("Condition1 is False, but Condition2 is True") +else: + print("Both Condition1 and Condition2 are False") + + + +x = 5 +y = 9 + +x += 5 + +if x < y: + print("x < y") +elif y > x: + print("x > y") +else: + print("x == y") + + + +# thats my note for myself +# for p in itertools.permutations('ABCD'): + + +# loops! :) + +i = 1 +while i < 10: + print(i) + i += 1 + +for i in range(0,10): + print(i) + +sample_list = ['this', 'is', 'a', 'list', ':)'] +for item in sample_list: + print(item) + + +# recursion +def recursive_loop(number): + if(number > 0): + print(number) + return recursive_loop(number - 1) + else: + print(number) + return + +recursive_loop(5) + + +# iterables + +# iterables are a collection of items +# that can be iterated over +# usually in a loop + +sample_list = ['i', 'am','stressed', 'for', 'my', 'cosc', 328, 'midterm'] +print(sample_list) + +print("You can access elements by index") +print("Remember python indexes from zero to follow industry standards") +print("Element 6:", sample_list[6]) + +print("You can also access elements in reverse with the '-' character") +print("Note this does not start from zero") +print("Element -2", sample_list[-2]) + +# changing the data in a list + +sample_list[6] = 320 +print("The new class is COSC", sample_list[6]) + +# adding to a lust + +sample_list.append("and final") +print(sample_list) + +# append vs extend + +list_1 = ['cat', 'dog', 'log'] +list_2 = ['frog', 'bog'] + +list_1.append(list_2) +print("Append:") +print(list_1) +print(list_1[3]) + + +list_1 = ['cat', 'dog', 'log'] +list_2 = ['frog', 'bog'] + +list_1.extend(list_2) +print("Extend:") +print(list_1) +print(list_1[3]) + +sample_tuple = ('cosc', 328, 'should', 'stay', 'an', 'immutable', 'unit') +print(sample_tuple) +print("Element 4:", sample_tuple[3]) + +try: + # this will raise an exception + sample_tuple[1] = 320 +except Exception as e: + print(e) + + + +sample_set = {'a', 'duplicate', 'in', 'a', 'set', 'is', 'deleted'} +print(sample_set) + +try: + # this will raise an exception + print(sample_set[1]) +except Exception as e: + print(e) + +# dictionaries + +my_dict = {1:'one', 2:'two', 3:'three', 4:'four'} +print(my_dict) +print("my_dict[1]:", my_dict[1]) + +my_dict["five"]=5 +print(my_dict) +print(my_dict["five"]) + + +# list comprehension + +some_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] +negative_evens = [-i for i in some_list if i % 2 == 0] + +# the equivalent code without list comprehension + +negative_evens = [] +for i in some_list: + if i % 2 == 0: + negative_evens.append(-i) + + +# Functions + + +def example_fucntion(parameter1, parameter2): + ''' i am a comment explaining what the function does ''' + variable = parameter1 + 10 + + output = 0 + if variable > parameter2: + for i in range(0, parameter2): + output += (variable - i) + else: + output = parameter2 + + return output + +def function_in_fuction(): + # you can have a function in a function + print('a=4, b=9, c=-10, d=9') + sum = add_all(4,9,-10,9) + print('the sum of a, b, c, d is', sum) + + +def add_all(a, b, c, d=0): + # if d is not given into the function, + # the value of d is zero by default + return a + b + c + d + +print("Passed in:") +print(add_all(1,2,3,4)) +# passed in: 10 + +print("\nNot Passed in:") +print(add_all(1,2,3)) +# not passed in 6 + + + + + + +# Object Oriented Programming + + +class Robot: + ''' + This is a Robot + ''' + # this is a constructor + def __init__(self, metal_type, ai=True): + # this is how you declare an attribute (self.attribute) + self.metal_type = metal_type + self.ai=ai + + def do_robot_thing(self): + # i am a function + # you have to use self to access object methods + self.spin() + + def spin(self): + print("wee!!") + + +class SpecialRobot(Robot): + ''' + This is a Robot that has been extended to have a special item + the (Robot) denotes that this class extends Robot + ''' + def __init__(self, metal_type, ai=True, special_item='love and affection'): + super(Robot) + self.special_item = special_item + + def use_special_item(self): + return self.special_item + + def change_special_item(self): + new_item = input('What is the Robot\'s new item?') + print("Changing Robot's item to", new_item) + self.special_item = new_item + + +# instanciating +robot_1 = Robot("aluminum") +robot_1.do_robot_thing() + +robot_2 = SpecialRobot("tin", True, "bat") +robot_2.do_robot_thing() +robot_2.change_special_item() + diff --git a/session-1/python_101.ipynb b/session-1/v1.ipynb similarity index 97% rename from session-1/python_101.ipynb rename to session-1/v1.ipynb index 8773e4a..2457b0c 100644 --- a/session-1/python_101.ipynb +++ b/session-1/v1.ipynb @@ -111,7 +111,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -120,7 +120,7 @@ "True" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -315,19 +315,18 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 8, "metadata": {}, "outputs": [ { - "ename": "NameError", - "evalue": "name 'hello' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mhello\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mNameError\u001b[0m: name 'hello' is not defined" - ] + "data": { + "text/plain": [ + "'hello'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -343,7 +342,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -352,7 +351,7 @@ "12" ] }, - "execution_count": 14, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -372,7 +371,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -388,7 +387,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -397,7 +396,7 @@ "int" ] }, - "execution_count": 16, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -1530,7 +1529,7 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -1556,7 +1555,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -1565,7 +1564,7 @@ "12" ] }, - "execution_count": 59, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -2095,7 +2094,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.11.3" } }, "nbformat": 4, diff --git a/session-1/v2.ipynb b/session-1/v2.ipynb new file mode 100644 index 0000000..6b8fea4 --- /dev/null +++ b/session-1/v2.ipynb @@ -0,0 +1,1387 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Intro to Python\n", + "In this notebook, we will introduce basic Python programming to get a beginner up and running (and more).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Variables, Types, and more" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello\n" + ] + } + ], + "source": [ + "new_string = 'Hello'\n", + "print(new_string)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World!\n", + "Hello World!\n" + ] + } + ], + "source": [ + "# Concatentation\n", + "newer_string = 'World!'\n", + "another_string = new_string + ' ' + newer_string\n", + "print(another_string)\n", + "print(new_string, newer_string)" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result: Here is how to substitute into a string\n" + ] + } + ], + "source": [ + "# Substitution, by index\n", + "sentence = 'Here is how to {0} into a {1}'\n", + "action = 'substitute'\n", + "thing = 'string'\n", + "print('Result:', sentence.format(action, thing))" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result: Keyword substitute for strings\n" + ] + } + ], + "source": [ + "# Substitution, by keyword\n", + "sentence = 'Keyword {_action} for {_thing}s'\n", + "print('Result:', sentence.format(_action=action, _thing=thing))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 2 10\n", + "13\n", + "0.05\n" + ] + } + ], + "source": [ + "# Variables\n", + "a, b = 1, 2\n", + "c = 10\n", + "print(a, b, c)\n", + "print(a + b + c)\n", + "print(a / b / c) \n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.5\n", + "3.0\n" + ] + } + ], + "source": [ + "# Increment, etc\n", + "a += 1\n", + "print(a / b)\n", + "b -= 1\n", + "print(a / b)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "# Types\n", + "print(type(a))\n", + "print(type(b))\n", + "print(type(a/b))\n", + "print(type(True))\n", + "print(type(None))\n", + "print(type(lambda x: x+x))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lists and Tuples" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "cars = ['bmw', 'ford', 'skoda']\n", + "print(len(cars))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bmw\n", + "ford\n" + ] + } + ], + "source": [ + "# Get elements by index\n", + "print(cars[0])\n", + "print(cars[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['bmw', 'ford', 'skoda', 'kia']\n" + ] + } + ], + "source": [ + "# Add to a list\n", + "cars.append('kia')\n", + "print(cars)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'kia'" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get last element\n", + "cars[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['bmw', 'ford', 'skoda', 'kia']\n", + "['ford', 'skoda']\n", + "['ford', 'skoda', 'kia']\n", + "['bmw', 'ford', 'skoda']\n" + ] + } + ], + "source": [ + "# List Slices\n", + "print(cars[:])\n", + "print(cars[1:3])\n", + "print(cars[1:]) # note, includes index 1\n", + "print(cars[:3]) # note, does not include index 3" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n" + ] + } + ], + "source": [ + "# Copy a list, versus reference a list\n", + "ref_cars = cars\n", + "copy_cars = cars[:]\n", + "print(ref_cars is cars) # two variables pointing to the same object\n", + "print(copy_cars is cars) # two different instances" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "# Mix types in lists\n", + "stuff = [1, 0.5, 'Hello', True]\n", + "for s in stuff:\n", + " print(type(s))" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sizes:\n", + "3\n", + "5\n", + "5\n", + "6\n", + "\n", + "Types:\n", + "\n", + "\n", + "\n", + "\n", + "Elements:\n", + "[11, 12, 13, 14, 15]\n", + "11\n", + "22\n", + "36\n" + ] + } + ], + "source": [ + "# Multi dimensional lists\n", + "d1 = [11,12,13,14,15]\n", + "d2 = [21,22,23,24,25]\n", + "d3 = [31,32,33,34,35,36]\n", + "d = [d1,d2,d3]\n", + "\n", + "print('Sizes:')\n", + "print(len(d))\n", + "print(len(d[0]))\n", + "print(len(d[1]))\n", + "print(len(d[2]))\n", + "\n", + "print('\\nTypes:')\n", + "print(type(d))\n", + "print(type(d[0]))\n", + "print(type(d[0][0]))\n", + "\n", + "print('\\nElements:')\n", + "print(d[0])\n", + "print(d[0][0])\n", + "print(d[1][1])\n", + "print(d[-1][-1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dictionaries" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'boats': ['campion', 'seadoo'], 'cars': ['bmw', 'ford', 'skoda', 'kia'], 'trucks': ['toyota', 'gmc'], 'flying cars': None}\n", + "\n" + ] + } + ], + "source": [ + "vehicles = {\n", + " 'cars': cars,\n", + " 'trucks': ['toyota', 'gmc'],\n", + " 'boats': ['campion', 'seadoo'],\n", + " 'flying cars': None\n", + "}\n", + "print(vehicles) # note, dicts are not ordered\n", + "print(type(vehicles))" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['campion', 'seadoo']\n", + "['campion', 'seadoo']\n" + ] + } + ], + "source": [ + "# Get values from keys\n", + "print(vehicles['boats'])\n", + "# or\n", + "print(vehicles.get('boats'))" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'boats': ['campion', 'seadoo'], 'cars': ['bmw', 'ford', 'skoda', 'kia'], 'trucks': ['toyota', 'gmc'], 'flying cars': 'Coming soon...'}\n" + ] + } + ], + "source": [ + "# Assign to existing key\n", + "vehicles['flying cars'] = 'Coming soon...'\n", + "print(vehicles)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'boats': ['campion', 'seadoo'], 'planes': ['boeing', 'airbus'], 'cars': ['bmw', 'ford', 'skoda', 'kia'], 'trucks': ['toyota', 'gmc'], 'flying cars': 'Coming soon...'}\n" + ] + } + ], + "source": [ + "# Add new key:value pairs\n", + "vehicles['planes'] = ['boeing', 'airbus']\n", + "print(vehicles)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['boats', 'planes', 'cars', 'trucks', 'flying cars'])\n" + ] + } + ], + "source": [ + "# Get all keys of the dictionary\n", + "print(vehicles.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_values([['campion', 'seadoo'], ['boeing', 'airbus'], ['bmw', 'ford', 'skoda', 'kia'], ['toyota', 'gmc'], 'Coming soon...'])\n" + ] + } + ], + "source": [ + "# Get all values of the dictionary\n", + "print(vehicles.values())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conditional Tests" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n", + "True\n" + ] + } + ], + "source": [ + "x = 1\n", + "y = 2\n", + "\n", + "# Equals\n", + "print(x == y)\n", + "print(x + 1 == y)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n" + ] + } + ], + "source": [ + "# Not Equal\n", + "print(x != y)\n", + "print(x + 1 != y)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n", + "True\n", + "True\n" + ] + } + ], + "source": [ + "# Greater than\n", + "print(x > y)\n", + "print(x + 2 > y)\n", + "print(x + 1 >= y) # or equal to" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n", + "True\n" + ] + } + ], + "source": [ + "# Less than\n", + "print(x < y)\n", + "print(x + 2 < y)\n", + "print(x + 1 <= y) # or equal to" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "True\n" + ] + } + ], + "source": [ + "# Logical Operators\n", + "print(x <= 1 and y > 1)\n", + "print(x == 2 or y == 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n" + ] + } + ], + "source": [ + "# Common String conditions\n", + "claim = 'Python is the best!'\n", + "\n", + "print(claim == 'Python is the best!')\n", + "print(claim == 'python is the best!')" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n", + "True\n", + "False\n" + ] + } + ], + "source": [ + "# Starts or Ends with\n", + "print(claim.startswith('Py'))\n", + "print(claim.startswith('py'))\n", + "print(claim.endswith('best!'))\n", + "print(claim.endswith('Best!'))" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "False\n", + "True\n" + ] + } + ], + "source": [ + "# Contains\n", + "print('Python' in claim)\n", + "print('isthe' in claim)\n", + "print('is the' in claim)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n", + "True\n", + "True\n" + ] + } + ], + "source": [ + "# Not conditions\n", + "print(not True)\n", + "print(not claim.startswith('Nope'))\n", + "print('wrong' not in claim)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## If/Else statements" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['bmw', 'ford', 'skoda', 'kia']\n" + ] + } + ], + "source": [ + "if len(cars) > 0:\n", + " print(cars)" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No cars\n" + ] + } + ], + "source": [ + "if len(cars) > 4:\n", + " print(cars)\n", + "else:\n", + " print('No cars')" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cool!\n", + "No Opinion.\n", + "Cool!\n", + "Meh...\n" + ] + } + ], + "source": [ + "# Chain Conditions\n", + "for car in cars:\n", + " if car == 'bmw' or car == 'skoda':\n", + " print('Cool!')\n", + " elif car == 'kia':\n", + " print('Meh...')\n", + " else:\n", + " print('No Opinion.')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loops" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bmw\n", + "ford\n", + "skoda\n", + "kia\n" + ] + } + ], + "source": [ + "# For Loop\n", + "for car in cars: # iterates through cars\n", + " print(car)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "4\n", + "3\n", + "2\n", + "1\n" + ] + } + ], + "source": [ + "# While Loop\n", + "counter = 5\n", + "while counter > 0:\n", + " print(counter)\n", + " counter -= 1" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Key boats has a value of ['campion', 'seadoo']\n", + "Key planes has a value of ['boeing', 'airbus']\n", + "Key cars has a value of ['bmw', 'ford', 'skoda', 'kia']\n", + "Key trucks has a value of ['toyota', 'gmc']\n", + "Key flying cars has a value of Coming soon...\n" + ] + } + ], + "source": [ + "# Example with dictionary\n", + "for key, value in vehicles.items():\n", + " print('Key {0} has a value of {1}'.format(key, value))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "# Basic with positional arguments\n", + "def myfunc(x, y):\n", + " return x + y\n", + "\n", + "print(myfunc(1, 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n", + "0.5\n", + "2.0\n" + ] + } + ], + "source": [ + "# Using keyword args\n", + "def myfunc2(x=None, y=None):\n", + " if x and y:\n", + " return x / y\n", + " else:\n", + " return None\n", + "\n", + "print(myfunc2())\n", + "print(myfunc2(1, 2)) # positional\n", + "print(myfunc2(y=1, x=2)) # keyword" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kwargs: {}\n", + "None\n", + "Kwargs: {'x': 1, 'y': 1}\n", + "2\n", + "Kwargs: {'z': 1, 'w': 1}\n", + "None\n" + ] + } + ], + "source": [ + "# Using only keyword args\n", + "def myfunc3(**kwargs):\n", + " print('Kwargs:', kwargs)\n", + " if 'x' in kwargs.keys() and 'y' in kwargs.keys():\n", + " return kwargs.get('x') + kwargs.get('y')\n", + " else:\n", + " return None\n", + "\n", + "print(myfunc3())\n", + "print(myfunc3(x=1, y=1))\n", + "print(myfunc3(z=1, w=1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Importing" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "darwin\n" + ] + } + ], + "source": [ + "# import a library\n", + "import sys\n", + "print(sys.platform)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Seconds from epoch: 1488308232.22233\n" + ] + } + ], + "source": [ + "# import a module/function/class of a library\n", + "from time import time\n", + "print('Seconds from epoch:', time())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Working with Files" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Current Working Directory /Users/michaelconnor/Documents/SparkGeo/projects/python_gdal_workshop\n" + ] + } + ], + "source": [ + "# The os library is used for most filesystem interactions, regardless of OS.\n", + "import os\n", + "cur_dir = os.getcwd()\n", + "print('Current Working Directory', cur_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['.DS_Store', '.git', '.gitignore', '.ipynb_checkpoints', 'cheat sheets', 'images', 'Install_Anaconda.md', 'Intro to Python.ipynb', 'ls8', 'README.md', 'utils']\n" + ] + } + ], + "source": [ + "# List contents of the directory\n", + "contents = os.listdir(cur_dir)\n", + "print(contents)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Is file: .DS_Store\n", + "Is dir: .git\n", + "Is file: .gitignore\n", + "Is dir: .ipynb_checkpoints\n", + "Is dir: cheat sheets\n", + "Is dir: images\n", + "Is file: Install_Anaconda.md\n", + "Is file: Intro to Python.ipynb\n", + "Is dir: ls8\n", + "Is file: README.md\n", + "Is dir: utils\n" + ] + } + ], + "source": [ + "# Check if the element is a file or directory\n", + "for content in contents:\n", + " if os.path.isfile(content):\n", + " print('Is file:', content)\n", + " elif os.path.isdir(content):\n", + " print('Is dir:', content)\n", + " else:\n", + " print('Unknown')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/Users/michaelconnor/Documents/SparkGeo/projects/python_gdal_workshop/README.md\n" + ] + } + ], + "source": [ + "# Get the full path to a file, must be relative or absolute path\n", + "full_path = os.path.realpath('README.md')\n", + "print(full_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "# Check if the file exists\n", + "print(os.path.exists(full_path))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# Python Workshop\n", + "\n", + "This repo contains materials for an entry level Python remote sensing workshop. Topics covered include:\n", + "\n", + "\n", + "\n", + "* Setup Anaconda and install GDAL\n", + "\n", + "* Introduce basic Python programming skills\n", + "\n" + ] + } + ], + "source": [ + "# Open a file for reading\n", + "myfile = open(full_path, 'r')\n", + "for i in range(5):\n", + " print(myfile.readline())\n", + "myfile.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/Users/michaelconnor/Documents/SparkGeo/projects/python_gdal_workshop\n" + ] + } + ], + "source": [ + "# Get the directory from a path\n", + "cur_dir = os.path.dirname(full_path)\n", + "print(cur_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/Users/michaelconnor/Documents/SparkGeo/projects/python_gdal_workshop/myfile.txt\n" + ] + } + ], + "source": [ + "# Create a new path to a file\n", + "new_file = os.path.join(cur_dir, 'myfile.txt')\n", + "print(new_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Current contents: ['.DS_Store', '.git', '.gitignore', '.ipynb_checkpoints', 'cheat sheets', 'images', 'Install_Anaconda.md', 'Intro to Python.ipynb', 'ls8', 'myfile.txt', 'README.md', 'utils'] \n", + "\n", + "File Contents:\n", + "\n", + "Here is my new file.Cool right?\n", + " Oops, forgot to add a new line.\n", + "\n", + "Current contents: ['.DS_Store', '.git', '.gitignore', '.ipynb_checkpoints', 'cheat sheets', 'images', 'Install_Anaconda.md', 'Intro to Python.ipynb', 'ls8', 'README.md', 'utils'] \n", + "\n" + ] + } + ], + "source": [ + "# Open a new file for writing\n", + "myfile = open(new_file, 'w')\n", + "myfile.write('Here is my new file.')\n", + "myfile.write('Cool right?')\n", + "myfile.write('\\n Oops, forgot to add a new line.')\n", + "myfile.close()\n", + "\n", + "output_contents = lambda src_dir: print('\\nCurrent contents:', os.listdir(src_dir), '\\n')\n", + "\n", + "output_contents(cur_dir)\n", + "\n", + "# Alternate way of opening->reading_closing a file\n", + "with open(new_file, 'r') as fr:\n", + " print('File Contents:\\n')\n", + " print(fr.read())\n", + "\n", + "# Delete (remove) the file\n", + "os.remove(new_file)\n", + "\n", + "output_contents(cur_dir)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Not covered" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This tutorial has intentionally not covered things like Classes, Exceptions, or any other topics that are not necessary for the workshop. This is intended to keep things simple yet provide enough tools to work efficiently in Python." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Next Steps" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is meant as a crash course, not comprehensive by any means. If you are looking for more in depth Python training or tutorials, there are many resources online. Lot's of websites provide great programming language training, including Python. It is also recommended to buy a reference type Python book. There are many avaiable, including ones for geospatial work, for example: \n", + "- [Python Geospatial Development](https://www.packtpub.com/application-development/python-geospatial-development-third-edition)\n", + "- [Learning Geospatial Analysis with Python](https://www.packtpub.com/application-development/learning-geospatial-analysis-python)\n", + "These books vary in learning level, and focus. The specific book is left to the user to find depending on their needs. \n", + "\n", + "Lastly, there is no programmer that does not depend on the internet for help with the most basic syntax to the most complicated algorithms. Don't waste too much time reading a book when a quick search on the internet will find what you need in under a second. Popular website for these types of answer is Stackoverflow or any of it's divisions.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python [default]", + "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.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/session-1/v3.ipynb b/session-1/v3.ipynb new file mode 100644 index 0000000..ed6dbe6 --- /dev/null +++ b/session-1/v3.ipynb @@ -0,0 +1,1908 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is an introduction to Python workshop run by the Quantitative Sciences Course Union (QSCU) at the University of British Columbia, Okanagan Campus.\n", + "\n", + "The Intro to Python Workshop is run by Ivan Carvallho and Kathryn Lecha" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# A Beginner's Introduction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comments\n", + "\n", + "Comments are sections of code ignored by the computer and instead saved for developers to read. They are very important when maintaining long chunks of code that many developers will see.\n", + "\n", + "Documentation is a very important aspect of programming." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.050038Z", + "start_time": "2020-01-29T00:17:02.045474Z" + } + }, + "outputs": [], + "source": [ + "# this is a comment\n", + "# the program will ignore comments\n", + "# they are for developer use" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simple Data Manipulation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Variables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Variables are used to store data. This is useful for both large amounts of data and data that has the possibility of changing.\n", + "\n", + "In practice, even if the data is not expected to change, it is saved as a variable, partially for readability.\n", + "\n", + "Variables should always be given descriptive names that follow the form:\n", + "word1_word2_etc" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.063047Z", + "start_time": "2020-01-29T00:17:02.056338Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ivan is 19 years old.\n" + ] + } + ], + "source": [ + "name = \"Ivan\"\n", + "age = 19\n", + "\n", + "print(name, \"is\", age, \"years old.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.073375Z", + "start_time": "2020-01-29T00:17:02.067259Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ivan is 20 years old.\n" + ] + } + ], + "source": [ + "# suppose a year passes\n", + "age = 20\n", + "print(name, \"is\", age, \"years old.\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Arithmatic Operators\n", + "Python has all of the standard arithmetic operators for mathematical operations." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.091864Z", + "start_time": "2020-01-29T00:17:02.080713Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Math with 5 and 3\n", + "Addition: 8\n", + "Subtraction: 2\n", + "Multiplication: 15\n", + "Division: 1.6666666666666667\n", + "Exponentional (x^y): 125\n", + "Modulus: 2\n" + ] + } + ], + "source": [ + "x = 5\n", + "y = 3\n", + "print(\"Math with 5 and 3\")\n", + "\n", + "add = x + y\n", + "print(\"Addition:\", add)\n", + "\n", + "sub = x - y\n", + "print(\"Subtraction:\", sub)\n", + "\n", + "mul = x * y\n", + "print(\"Multiplication:\", mul)\n", + "\n", + "div = x / y\n", + "print(\"Division:\", div)\n", + "\n", + "exp = x ** y\n", + "print(\"Exponentional (x^y):\", exp)\n", + "\n", + "# modulus gets the remainder of x / y\n", + "mod = x % y\n", + "print(\"Modulus:\", mod)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also assign new values to variables based on mathematical operations" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.106682Z", + "start_time": "2020-01-29T00:17:02.095677Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Before incrementing: 5\n", + "After incrementing: 8 \n", + "\n", + "Before decrementing: 8\n", + "After decrementing: 5 \n", + "\n", + "Before multication: 5\n", + "After multication: 15 \n", + "\n", + "Before division: 15\n", + "After division: 5.0\n" + ] + } + ], + "source": [ + "# increment x by y\n", + "# x = x + y\n", + "print(\"Before incrementing:\", x)\n", + "x += y\n", + "print(\"After incrementing:\", x, '\\n')\n", + "\n", + "# decrement x by y\n", + "# x = x - y\n", + "print(\"Before decrementing:\", x)\n", + "x -= y\n", + "print(\"After decrementing:\", x, '\\n')\n", + "\n", + "# This also works for other operators\n", + "print(\"Before multication:\", x)\n", + "x *= y\n", + "print(\"After multication:\", x, '\\n')\n", + "\n", + "print(\"Before division:\", x)\n", + "x /= y\n", + "print(\"After division:\", x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basic Logic Operations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparisions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We use comparisons to run code that reflects dependencies based off of program and variable status. \n", + "\n", + "The most basic comparision is the the IF statement that executes one set of operations if a condition is true and another if the condition is false." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.118376Z", + "start_time": "2020-01-29T00:17:02.109430Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Condition1 is True\n" + ] + } + ], + "source": [ + "condition1 = True\n", + "condition2 = False\n", + "\n", + "if condition1:\n", + " print(\"Condition1 is True\")\n", + "elif condition2:\n", + " print(\"Condition1 is False, but Condition2 is True\")\n", + "else:\n", + " print(\"Both Condition1 and Condition2 are False\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can use if statements evaluate variable values" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.128399Z", + "start_time": "2020-01-29T00:17:02.122820Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x > y\n" + ] + } + ], + "source": [ + "x = 5\n", + "y = 9\n", + "\n", + "x += 5\n", + "\n", + "if x < y:\n", + " print(\"x < y\")\n", + "elif x > y:\n", + " print(\"x > y\")\n", + "else:\n", + " print(\"x == y\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loops" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-17T01:34:13.316192Z", + "start_time": "2020-01-17T01:34:13.295803Z" + } + }, + "source": [ + "Loops are used to keep code flexible and manageable, so there is no chunks of copy-paste code.\n", + "\n", + "There are 2 main types of loops:\n", + "while and for loops" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### While Loops" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "While loops will continue to run while a condition is true" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.140069Z", + "start_time": "2020-01-29T00:17:02.131747Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n" + ] + } + ], + "source": [ + "i = 1\n", + "while i < 10:\n", + " print(i)\n", + " i += 1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-17T01:36:56.309986Z", + "start_time": "2020-01-17T01:36:56.299066Z" + } + }, + "source": [ + "Be careful to not create an infinite loop" + ] + }, + { + "cell_type": "raw", + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-17T20:46:34.957610Z", + "start_time": "2020-01-17T20:46:34.952786Z" + } + }, + "source": [ + "while True:\n", + " print(\"DO NOT RUN ME!!!\")\n", + " print(\"i will not stop!!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### For Loops" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For loops will iterate for a fixed number of times. In many ways, it is a short way to write a while loop" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.191866Z", + "start_time": "2020-01-29T00:17:02.184203Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n" + ] + } + ], + "source": [ + "for i in range(0,10):\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Recursion" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Recursion is a higher level concept using functions that call themselves for repition. They need a base case to act as a condition to stop recursing.\n", + "The main idea is to break down problems into smaller problems in a divide-and-conquer manner.\n", + "We will learn more about functions later in this workshop." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.205254Z", + "start_time": "2020-01-29T00:17:02.197866Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "4\n", + "3\n", + "2\n", + "1\n", + "0\n" + ] + } + ], + "source": [ + "def recursive_loop(number):\n", + " if(number > 0):\n", + " print(number)\n", + " return recursive_loop(number - 1)\n", + " else:\n", + " print(number)\n", + " return\n", + "\n", + "recursive_loop(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-17T01:26:30.514311Z", + "start_time": "2020-01-17T01:26:30.500030Z" + } + }, + "source": [ + "## Iterables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Iterables are a kind of data structure that are able to be iterated over.\n", + "This means that they serve as a structure in memory that hold data that is logically related in some way. Each peice of information in the structure can be accessed one at a time." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Lists" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lists are the most basic set of data structure. Each element in a list can be accessed by it's index (where its located), or in order.\n", + "\n", + "Lists can hold any datatype" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.215854Z", + "start_time": "2020-01-29T00:17:02.210014Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['i', 'am', 'stressed', 'for', 'my', 'cosc', 328, 'midterm']\n" + ] + } + ], + "source": [ + "sample_list = ['i', 'am','stressed', 'for', 'my', 'cosc', 328, 'midterm']\n", + "print(sample_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.228326Z", + "start_time": "2020-01-29T00:17:02.221368Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "You can access elements by index\n", + "Remember python indexes from zero to follow industry standards\n", + "Element 6: 328\n" + ] + } + ], + "source": [ + "print(\"You can access elements by index\")\n", + "print(\"Remember python indexes from zero to follow industry standards\")\n", + "print(\"Element 6:\", sample_list[6])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.238506Z", + "start_time": "2020-01-29T00:17:02.230996Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "You can also access elements in reverse with the '-' character\n", + "Note this does not start from zero\n", + "Element -2 328\n" + ] + } + ], + "source": [ + "print(\"You can also access elements in reverse with the '-' character\")\n", + "print(\"Note this does not start from zero\")\n", + "print(\"Element -2\", sample_list[-2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Data in a list is mutable and can be changed." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.249924Z", + "start_time": "2020-01-29T00:17:02.242428Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The new class is COSC 320\n" + ] + } + ], + "source": [ + "# Suppose I finish the COSC 328 midterm and instead become stressed about the 320 midterm\n", + "sample_list[6] = 320\n", + "print(\"The new class is COSC\", sample_list[6])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-17T01:47:00.840381Z", + "start_time": "2020-01-17T01:47:00.833578Z" + } + }, + "source": [ + "You can add elements to a list with APPEND or EXTEND. " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.260202Z", + "start_time": "2020-01-29T00:17:02.253126Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['i', 'am', 'stressed', 'for', 'my', 'cosc', 320, 'midterm', 'and final']\n" + ] + } + ], + "source": [ + "sample_list.append(\"and final\")\n", + "print(sample_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There is a very important difference between APPEND and EXTEND.\n", + "You can have a list as an element in a list.\n", + "\n", + "APPEND will add the list as an element in the list\n", + "\n", + "EXTEND will append every element in the list to the list." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.269714Z", + "start_time": "2020-01-29T00:17:02.262526Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Append:\n", + "['cat', 'dog', 'log', ['frog', 'bog']]\n", + "['frog', 'bog']\n" + ] + } + ], + "source": [ + "list_1 = ['cat', 'dog', 'log']\n", + "list_2 = ['frog', 'bog']\n", + "\n", + "list_1.append(list_2)\n", + "print(\"Append:\")\n", + "print(list_1)\n", + "print(list_1[3])" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.282232Z", + "start_time": "2020-01-29T00:17:02.273311Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extend:\n", + "['cat', 'dog', 'log', 'frog', 'bog']\n", + "frog\n" + ] + } + ], + "source": [ + "list_1 = ['cat', 'dog', 'log']\n", + "list_2 = ['frog', 'bog']\n", + "\n", + "list_1.extend(list_2)\n", + "print(\"Extend:\")\n", + "print(list_1)\n", + "print(list_1[3])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Tuples" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A tuple is an immutable collection of indexed objects. They are used for data that will never change. One example of this is coordinates (x,y,z)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.292751Z", + "start_time": "2020-01-29T00:17:02.285320Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('cosc', 328, 'should', 'stay', 'an', 'immutable', 'unit')\n", + "Element 4: stay\n" + ] + } + ], + "source": [ + "sample_tuple = ('cosc', 328, 'should', 'stay', 'an', 'immutable', 'unit')\n", + "print(sample_tuple)\n", + "print(\"Element 4:\", sample_tuple[3])" + ] + }, + { + "cell_type": "raw", + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-17T20:46:35.218913Z", + "start_time": "2020-01-17T20:46:35.107064Z" + } + }, + "source": [ + "# this will raise an exception\n", + "sample_tuple[1] = 320" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sets" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sets are based off of mathematical sets. They are a collection of non-repeating, non-indexed objects." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.332750Z", + "start_time": "2020-01-29T00:17:02.325545Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'in', 'deleted', 'set', 'a', 'duplicate', 'is'}\n" + ] + } + ], + "source": [ + "sample_set = {'a', 'duplicate', 'in', 'a', 'set', 'is', 'deleted'}\n", + "print(sample_set)" + ] + }, + { + "cell_type": "raw", + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-17T20:46:35.225449Z", + "start_time": "2020-01-17T20:46:35.064Z" + } + }, + "source": [ + "# this will produce an error\n", + "sample_set[1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Dictionaries" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Dictionaries are unique mappings of a key to a value, so you are able to uniquely define the text. " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.464178Z", + "start_time": "2020-01-29T00:17:02.451311Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{1: 'one', 2: 'two', 3: 'three', 4: 'four'}\n", + "my_dict[1]: one\n" + ] + } + ], + "source": [ + "my_dict = {1:'one', 2:'two', 3:'three', 4:'four'}\n", + "print(my_dict)\n", + "print(\"my_dict[1]:\", my_dict[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.482179Z", + "start_time": "2020-01-29T00:17:02.475961Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n" + ] + } + ], + "source": [ + "my_dict[\"five\"]=5\n", + "print(my_dict[\"five\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Relationship between loops and Iterables" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can use loops to process the data in iterables." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.497781Z", + "start_time": "2020-01-29T00:17:02.491228Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "this\n", + "is\n", + "a\n", + "list\n", + ":)\n" + ] + } + ], + "source": [ + "sample_list = ['this', 'is', 'a', 'list', ':)']\n", + "for item in sample_list:\n", + " print(item)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### List Comprehension" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "List comprehension is a concise way to create lists with a loop and if statements" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.519778Z", + "start_time": "2020-01-29T00:17:02.511479Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, -2, -4, -6, -8, -10, -12]\n" + ] + } + ], + "source": [ + "# list comprehension\n", + "some_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n", + "negative_evens = [-i for i in some_list if i % 2 == 0]\n", + "print(negative_evens)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.536863Z", + "start_time": "2020-01-29T00:17:02.530238Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, -2, -4, -6, -8, -10, -12]\n" + ] + } + ], + "source": [ + "# the equivalent code without list comprehension\n", + "negative_evens = []\n", + "for i in some_list:\n", + " if i % 2 == 0:\n", + " negative_evens.append(-i)\n", + "print(negative_evens)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A function is a set of code made to do a set of tasks and return the result. Functions are useful when you have a chunck of code that will be run multiple times, so the chunck only has to be written once.\n", + "\n", + "It increases readability and maintainablity of code.\n", + "\n", + "Functions take in parameters, that act as variables within the function, and return the result of the function." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.546526Z", + "start_time": "2020-01-29T00:17:02.540508Z" + } + }, + "outputs": [], + "source": [ + "def example_fucntion(parameter1, parameter2):\n", + " ''' i am a comment explaining what the function does '''\n", + " variable = parameter1 + 10\n", + " \n", + " output = 0\n", + " if variable > parameter2:\n", + " for i in range(0, parameter2):\n", + " output += (variable - i)\n", + " else:\n", + " output = parameter2\n", + " \n", + " return output" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Functions can be called within functions" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.559315Z", + "start_time": "2020-01-29T00:17:02.553873Z" + } + }, + "outputs": [], + "source": [ + "def function_in_fuction():\n", + " # you can have a function in a function\n", + " print('a=4, b=9, c=-10, d=9')\n", + " sum = add_all(4,9,-10,9)\n", + " print('the sum of a, b, c, d is', sum)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Optional Parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In Python, there can be optional parameters passed in. These optional parameters will take in the value denoted in the assignment if no value is passed in to the function." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.575523Z", + "start_time": "2020-01-29T00:17:02.562394Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Passed in:\n", + "10\n", + "\n", + "Not Passed in:\n", + "6\n" + ] + } + ], + "source": [ + "def add_all(a, b, c, d=0):\n", + " # if d is not given into the function,\n", + " # the value of d is zero by default\n", + " return a + b + c + d\n", + "\n", + "print(\"Passed in:\")\n", + "print(add_all(1,2,3,4))\n", + "\n", + "print(\"\\nNot Passed in:\")\n", + "print(add_all(1,2,3))" + ] + }, + { + "cell_type": "raw", + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.675033Z", + "start_time": "2020-01-29T00:17:02.580451Z" + } + }, + "source": [ + "# note that this will only work for parameters denoted as optional\n", + "print(\"i will produce an error\")\n", + "print(add_all(1,2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# An Introduction to Advanced Techniques" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "At this point we will switch to a less directed instruction style. This portion of the Workshop was created for programmers with some experience that simply want to experience the more high level experience of Python." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Object Oriented Programming" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can say that everything in life is an object that follows some blueprint for making items. These are Objects.\n", + "\n", + "Python is an Object-Oriented language. It follows all of the OOP rules that other languages would follow." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.678075Z", + "start_time": "2020-01-29T00:17:02.565Z" + } + }, + "outputs": [], + "source": [ + "# this is an example of an Object in Python\n", + "\n", + "\n", + "class Robot:\n", + " '''\n", + " This is a Robot\n", + " '''\n", + " # this is a constructor\n", + " def __init__(self, metal_type, ai=True):\n", + " # this is how you declare an attribute (self.attribute)\n", + " self.metal_type = metal_type\n", + " self.ai=ai\n", + " \n", + " def do_robot_thing(self):\n", + " # i am a function\n", + " # you have to use self to access object methods\n", + " self.spin()\n", + " \n", + " def spin(self):\n", + " print(\"wee!!\")\n", + "\n", + "\n", + "class SpecialRobot(Robot):\n", + " '''\n", + " This is a Robot that has been extended to have a special item\n", + " the (Robot) denotes that this class extends Robot\n", + " '''\n", + " def __init__(self, metal_type, ai=True, special_item='love and affection'):\n", + " super(Robot)\n", + " self.special_item = special_item\n", + " \n", + " def use_special_item(self):\n", + " return self.special_item\n", + " \n", + " def change_special_item(self):\n", + " new_item = input('What is the Robot\\'s new item?')\n", + " print(\"Changing Robot's item to\", new_item)\n", + " self.special_item = new_item\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.680331Z", + "start_time": "2020-01-29T00:17:02.578Z" + } + }, + "outputs": [], + "source": [ + "# instanciating objects:\n", + "robot_1 = Robot(\"aluminum\")\n", + "robot_1.do_robot_thing()\n", + "\n", + "robot_2 = SpecialRobot(\"tin\", True, \"bat\")\n", + "robot_2.do_robot_thing()\n", + "robot_2.change_special_item()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Functions As Objects" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Functions in python are first class objects. This means that they can be passed as arguments to other functions, assigned to variables or even stored as elements in various data structures. The ability to perform the same operation on a list of elements is provided by a higher-order python function called map." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Installing Packages" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Installing packages in Python can be very frustrating. There are two major package management systems for python: pip and conda." + ] + }, + { + "cell_type": "raw", + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-17T23:54:52.399430Z", + "start_time": "2020-01-17T20:46:35.360410Z" + } + }, + "source": [ + "# these will both install the pandas library\n", + "! pip install pandas\n", + "! conda install pandas" + ] + }, + { + "cell_type": "raw", + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-17T23:54:58.512967Z", + "start_time": "2020-01-17T23:54:52.404248Z" + } + }, + "source": [ + "# you can check what you've installed\n", + "! pip list\n", + "! conda list" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You will need to import the library into your program in order to use it" + ] + }, + { + "cell_type": "raw", + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-18T00:00:57.595026Z", + "start_time": "2020-01-18T00:00:55.468972Z" + } + }, + "source": [ + "import pandas" + ] + }, + { + "cell_type": "raw", + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-18T00:00:57.604154Z", + "start_time": "2020-01-18T00:00:57.597751Z" + } + }, + "source": [ + "# you could also only import certain Objects and Funtions\n", + "# this follows PEP8 standards\n", + "from pandas import DataFrame" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reading From an External API" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this portion, we will try to read in information from the Financial Modeling Prep open API. This is a free API that we will try to read in some of their data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "More on Financial Modelling Prep:\n", + "Financial Modeling Prep is a new concept that informs you about stock markets information (news, currencies and stock prices)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Financial Modelling Prep offers Documentation on how to access their API here:\n", + "https://financialmodelingprep.com/developer/docs/" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:02.791196Z", + "start_time": "2020-01-29T00:17:02.783036Z" + } + }, + "outputs": [], + "source": [ + "from urllib.request import urlopen\n", + "import json\n", + "\n", + "def get_jsonparsed_data(ticker):\n", + " \"\"\"\n", + " Receive the content of ``url``, parse it as JSON and return the object.\n", + "\n", + " Parameters\n", + " ----------\n", + " url : str\n", + "\n", + " Returns\n", + " -------\n", + " dict\n", + " \"\"\"\n", + " url = get_url(ticker)\n", + " response = urlopen(url)\n", + " data = response.read().decode(\"utf-8\")\n", + " return json.loads(data)\n", + "\n", + "def get_url(ticker):\n", + " url = 'https://financialmodelingprep.com/api/financials/income-statement/' + ticker + '?datatype=json'\n", + " return url" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:03.270624Z", + "start_time": "2020-01-29T00:17:02.796012Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "JSON:\n", + "{'FB': {'Revenue': {'2014-12': '12466', '2015-12': '17928', '2016-12': '27638', '2017-12': '40653', '2018-12': '55838', 'TTM': '55838'}, 'Cost of revenue': {'2014-12': '2153', '2015-12': '2867', '2016-12': '3789', '2017-12': '5454', '2018-12': '9355', 'TTM': '9355'}, 'Gross profit': {'2014-12': '10313', '2015-12': '15061', '2016-12': '23849', '2017-12': '35199', '2018-12': '46483', 'TTM': '46483'}, 'Research and development': {'2014-12': '2666', '2015-12': '4816', '2016-12': '5919', '2017-12': '7754', '2018-12': '10273', 'TTM': '10273'}, 'Sales, General and administrative': {'2014-12': '2653', '2015-12': '4020', '2016-12': '5503', '2017-12': '7242', '2018-12': '11297', 'TTM': '11297'}, 'Total operating expenses': {'2014-12': '5319', '2015-12': '8836', '2016-12': '11422', '2017-12': '14996', '2018-12': '21570', 'TTM': '21570'}, 'Operating income': {'2014-12': '4994', '2015-12': '6225', '2016-12': '12427', '2017-12': '20203', '2018-12': '24913', 'TTM': '24913'}, 'Interest Expense': {'2014-12': '23', '2015-12': '23', '2016-12': '10', '2017-12': '6', '2018-12': '9', 'TTM': '9'}, 'Other income (expense)': {'2014-12': '-61', '2015-12': '-8', '2016-12': '101', '2017-12': '397', '2018-12': '457', 'TTM': '457'}, 'Income before taxes': {'2014-12': '4910', '2015-12': '6194', '2016-12': '12518', '2017-12': '20594', '2018-12': '25361', 'TTM': '25361'}, 'Provision for income taxes': {'2014-12': '1970', '2015-12': '2506', '2016-12': '2301', '2017-12': '4660', '2018-12': '3249', 'TTM': '3249'}, 'Net income from continuing operations': {'2014-12': '2940', '2015-12': '3688', '2016-12': '10217', '2017-12': '15934', '2018-12': '22112', 'TTM': '22112'}, 'Net income': {'2014-12': '2940', '2015-12': '3688', '2016-12': '10217', '2017-12': '15934', '2018-12': '22112', 'TTM': '22112'}, 'Preferred dividend': {'2014-12': '15', '2015-12': '19', '2016-12': '29', '2017-12': '14', '2018-12': '1', 'TTM': '1'}, 'Net income available to common shareholders': {'2014-12': '2925', '2015-12': '3669', '2016-12': '10188', '2017-12': '15920', '2018-12': '22111', 'TTM': '22111'}, 'Basic': {'2014-12': '2614', '2015-12': '2803', '2016-12': '2863', '2017-12': '2901', '2018-12': '2890', 'TTM': '2890'}, 'Diluted': {'2014-12': '2664', '2015-12': '2853', '2016-12': '2925', '2017-12': '2956', '2018-12': '2921', 'TTM': '2921'}, 'EBITDA': {'2014-12': '6176', '2015-12': '8162', '2016-12': '14870', '2017-12': '23625', '2018-12': '29685', 'TTM': '29685'}}}\n" + ] + } + ], + "source": [ + "ticker = 'FB'\n", + "\n", + "print(\"JSON:\")\n", + "data = get_jsonparsed_data(ticker)\n", + "print(data)" + ] + }, + { + "cell_type": "raw", + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-18T00:00:58.536384Z", + "start_time": "2020-01-18T00:00:58.122470Z" + } + }, + "source": [ + "from pandas import DataFrame\n", + "\n", + "def get_company_dataframe(ticker):\n", + " '''\n", + " this is just a bonus :)\n", + " '''\n", + " data = get_jsonparsed_data(ticker)\n", + " df = DataFrame(data[ticker])\n", + " return df\n", + "\n", + "\n", + "print('\\nthat\\'s hard to read... let\\'s try a dataframe:')\n", + "data = get_company_dataframe(ticker)\n", + "data.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Quality Shop of Coffee for University-Students (QSCU)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's build a small program for the following problem:\n", + "\n", + "Your friend works for the Quality Shop of Coffee for University-students (QSCU).\n", + "\n", + "The shop sells many types of drinks to customers, but does not know which one is the most popular! Can you help your friend keep track of the most sold item?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Modelling the Problem" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Necessary Elements:\n", + "- We need a table to store our data \n", + "- We need to be able to change the table to reflect sales\n", + "- We need to find the most sold item\n", + "\n", + "What we will use:\n", + "- SQLite, a small database contained in a file\n", + "- Python with API to connect to SQLite" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Conneting to a Database" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to connect to a Database we need to create a connection and then create a cursor to execute our queries" + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "import sqlite3\n", + "\n", + "self.conn = sqlite3.connect(filename)\n", + "self.cursor = self.conn.cursor()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Executing Queries" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cursor has an execute method that may return rows from the database.\n", + "Connection has a commit method to send changes to server." + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "self.cursor.execute(\n", + " \"\"\"\n", + " CREATE TABLE sales(\n", + " name text,\n", + " product_id int,\n", + " price int,\n", + " sold int\n", + " ) \n", + " \"\"\"\n", + ")\n", + "\n", + "self.cursor.execute(\"\"\"INSERT INTO sales VALUES ('Espresso', 1, 2, 0)\"\"\")\n", + "self.cursor.execute(\"\"\"INSERT INTO sales VALUES ('Macchiato', 2, 3, 0)\"\"\")\n", + "self.cursor.execute(\"\"\"INSERT INTO sales VALUES ('Regular Java', 3, 1, 0)\"\"\")\n", + "\n", + "self.conn.commit()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Completing a Program" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's use what we discussed in the workshop to make a program for the QSCU.\n", + "\n", + "Below is a sample solution:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:03.284361Z", + "start_time": "2020-01-29T00:17:03.273742Z" + } + }, + "outputs": [], + "source": [ + "import sqlite3\n", + "\n", + "\n", + "class QSCU:\n", + " \"\"\"Class representing the coffee shop, the interface to access the data.\"\"\"\n", + "\n", + " def __init__(self, filename):\n", + " \"\"\"\n", + " :param filename: the file that contains the SQLite DB.\n", + " :type filename: string\n", + " \"\"\"\n", + "\n", + " self.conn = sqlite3.connect(filename)\n", + " self.cursor = self.conn.cursor()\n", + " self.closed = False\n", + "\n", + " def setup_db(self):\n", + " \"\"\"This function initializes the database. \n", + " It creates the sales tables and inserts the coffe types that are sold.\n", + " \n", + " The database consists of 1 table:\n", + " - sales table: a table listing all the coffees, their prices and their sales\n", + " \"\"\"\n", + "\n", + " self.cursor.execute(\n", + " \"\"\"\n", + " CREATE TABLE sales(\n", + " name text,\n", + " product_id int,\n", + " price int,\n", + " sold int\n", + " ) \n", + " \"\"\"\n", + " )\n", + "\n", + " self.cursor.execute(\"\"\"INSERT INTO sales VALUES ('Espresso', 1, 2, 0)\"\"\")\n", + " self.cursor.execute(\"\"\"INSERT INTO sales VALUES ('Macchiato', 2, 3, 0)\"\"\")\n", + " self.cursor.execute(\"\"\"INSERT INTO sales VALUES ('Regular Java', 3, 1, 0)\"\"\")\n", + "\n", + " self.conn.commit()\n", + "\n", + " def sell_item(self, product_id, quantity):\n", + " \"\"\"Tells the database that a product was sold.\n", + " :param product_id: the identification of the product that was sold\n", + " :type product_id: int\n", + " :param quantity: how many items were sold\n", + " :type quantity: int\n", + " \"\"\"\n", + "\n", + " self.cursor.execute(\n", + " \"\"\"\n", + " UPDATE sales \n", + " SET sold = sold + $1\n", + " WHERE product_id = $2\n", + " \"\"\",\n", + " [quantity, product_id],\n", + " )\n", + "\n", + " self.conn.commit()\n", + "\n", + " def get_most_sold(self):\n", + " \"\"\"Retrieve the most sold item of the coffe shop.\n", + " :returns: list[(string, int)]\n", + " \"\"\"\n", + "\n", + " most_sold_row = self.cursor.execute(\n", + " \"\"\"\n", + " SELECT name, sold\n", + " FROM sales\n", + " ORDER BY sold DESC\n", + " LIMIT 1\n", + " \"\"\"\n", + " )\n", + "\n", + " return list(most_sold_row)[0]\n", + "\n", + " def close(self):\n", + " \"\"\"Close connection to database\"\"\"\n", + " self.cursor.close()\n", + " self.conn.close()\n", + " self.closed = True\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Unit Testing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Unit testing is a way to test every function in code to see if any aspect of it is broken." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### The Hello World of Unit Testing" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:03.318949Z", + "start_time": "2020-01-29T00:17:03.289822Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "test_add (__main__.TestAdd) ... ok\n", + "\n", + "----------------------------------------------------------------------\n", + "Ran 1 test in 0.001s\n", + "\n", + "OK\n" + ] + } + ], + "source": [ + "import unittest\n", + "\n", + "\n", + "def add(x, y):\n", + " return x + y\n", + "\n", + "\n", + "class TestAdd(unittest.TestCase):\n", + " def test_add(self):\n", + " self.assertEqual(add(1, 2), 3)\n", + "\n", + "\n", + "if __name__ == \"__main__\":\n", + " unittest.main(argv=[''], verbosity=2, exit=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Testing QSCU" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-29T00:17:03.355147Z", + "start_time": "2020-01-29T00:17:03.322372Z" + }, + "code_folding": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "test_add (__main__.TestAdd) ... ok\n", + "test_most_sold (__main__.TestQSCU)\n", + "Test if the get_most_sold functions returns the most sold item ... ok\n", + "test_no_sold_items (__main__.TestQSCU)\n", + "Test if the quantity of items is set to zero before any item is sold ... ok\n", + "test_sell_item (__main__.TestQSCU)\n", + "Test if the sell item function correctly updates the database ... ok\n", + "\n", + "----------------------------------------------------------------------\n", + "Ran 4 tests in 0.011s\n", + "\n", + "OK\n" + ] + } + ], + "source": [ + "# import unittest\n", + "# from qscu import QSCU\n", + "\n", + "\n", + "class TestQSCU(unittest.TestCase):\n", + " def setup_test(self):\n", + " \"\"\"Instantiate a databse in memory for the test.\"\"\"\n", + " self.shop = QSCU(\":memory:\")\n", + " self.shop.setup_db()\n", + "\n", + " def test_no_sold_items(self):\n", + " \"\"\"Test if the quantity of items is set to zero before any item is sold\"\"\"\n", + " self.setup_test()\n", + "\n", + " rows = self.shop.cursor.execute(\n", + " \"\"\"\n", + " SELECT name, sold\n", + " FROM sales\n", + " \"\"\"\n", + " )\n", + "\n", + " for name, sold in rows:\n", + " self.assertEqual(sold, 0)\n", + "\n", + " def test_sell_item(self):\n", + " \"\"\"Test if the sell item function correctly updates the database\"\"\"\n", + " self.setup_test()\n", + "\n", + " expected_result = {1: 4, 2: 5}\n", + "\n", + " self.shop.sell_item(1, 1)\n", + " self.shop.sell_item(2, 2)\n", + " self.shop.sell_item(1, 3)\n", + " self.shop.sell_item(2, 3)\n", + "\n", + " rows = self.shop.cursor.execute(\n", + " \"\"\"\n", + " SELECT product_id, sold\n", + " FROM sales\n", + " \"\"\"\n", + " )\n", + "\n", + " for product_id, sold in rows:\n", + " if product_id in expected_result:\n", + " self.assertEqual(sold, expected_result[product_id])\n", + " else:\n", + " self.assertEqual(sold, 0)\n", + "\n", + " def test_most_sold(self):\n", + " \"\"\"Test if the get_most_sold functions returns the most sold item\"\"\"\n", + " self.setup_test()\n", + "\n", + " # Case when no item has been sold: it's ok if we return any, but it must tell sold 0 times\n", + " self.assertEqual(self.shop.get_most_sold()[1], 0)\n", + "\n", + " # Another case: every item has been sold one time\n", + " self.shop.sell_item(1, 3)\n", + " self.shop.sell_item(2, 5)\n", + " self.shop.sell_item(3, 2)\n", + "\n", + " self.assertEqual(self.shop.get_most_sold(), (\"Macchiato\", 5))\n", + "\n", + " # More elaborate case: does our function work when update values again?\n", + " self.shop.sell_item(1, 5)\n", + " self.shop.sell_item(2, 2)\n", + " self.assertEqual(self.shop.get_most_sold(), (\"Espresso\", 8))\n", + "\n", + "\n", + "if __name__ == \"__main__\":\n", + " unittest.main(argv=[''], verbosity=2, exit=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's all!\n", + "Thank you for coming!\n", + "\n", + "You can find the slides at: tiny.cc/intro_python\n", + "\n", + "Please come to us if you have any questions :)" + ] + } + ], + "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.7.3" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}