{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Python, NumPy and MatplotLib" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Python is a high-level, dynamically typed programming language used extensively in Digital technologies. It is used from rapid prototyping to industrial-grade enterprise applications. Below we will learn about the basics of the language. In this classroom, we will use Python version 3 as Python version 2 is now discontinued. Lets look at this video to get the basic understanding for of Python" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "scrolled": false }, "outputs": [ { "data": { "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from IPython.display import YouTubeVideo\n", "YouTubeVideo('28-oixCfK9c', width=860, height=460)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Basic Data Types" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Like other programming languages, python also provides basic data structures like [integers, floats](https://docs.python.org/3.5/library/stdtypes.html#numeric-types-int-float-complex), [booleans](https://docs.python.org/3.5/library/stdtypes.html#boolean-operations-and-or-not), and [strings](https://docs.python.org/3.5/library/stdtypes.html#string-methods). Integers and floats work same as in other languages, but don't have unary ++ or -- operator. Booleans use 'True' and 'False' to denote the bool type, these variables can be evaluated using [and, or, not](https://docs.python.org/3.5/library/stdtypes.html#boolean-operations-and-or-not). [Strings](https://docs.python.org/3.5/library/stdtypes.html#string-methods) in python provide a lot of functionality as we see in the below examples." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#initailizing variable\n", "\n", "num = 5\n", "num_f = 6.5\n", "\n", "print(num)\n", "print(type(num))\n", "print(num_f)\n", "print(type(num_f))\n", "\n", "# Operations\n", "\n", "print(num+2)\n", "print(num-2)\n", "print(num+num_f)\n", "print (num/2)\n", "print (num*2)\n", "print (num**2)\n", "\n", "# Shortcuts\n", "\n", "num += 3\n", "print (num)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Booleans\n", "\n", "t, f = True, False\n", "\n", "print (type(t))\n", "\n", "print (t or f)\n", "\n", "print (t and f)\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Strings\n", "\n", "d = ' digital '\n", "t = 'technology'\n", "\n", "# String concatenation\n", "print (d+' '+t)\n", "\n", "# String Methods\n", "\n", "print ('{0} {1}'.format(d,t))\n", "print (d.capitalize())\n", "print (d.upper())\n", "print (d.replace('d','g'))\n", "print (d.strip())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Data Containers" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Apart from the basic data types, python provides [containers](https://docs.python.org/3.5/tutorial/datastructures.html#data-structures) to use and manipulate the basic data types with ease. These containers are built in the core of the language and don't need explicit libraries to work with. Python also supports a concept of iteration over containers using [generators](https://docs.python.org/3.5/library/stdtypes.html#generator-types). Let's discuss each of these topics in detail. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Lists" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Lists](https://docs.python.org/3.5/tutorial/datastructures.html#more-on-lists) in python is an ordered, mutable collection of objects. You can think of [lists](https://docs.python.org/3.5/tutorial/datastructures.html#more-on-lists) as an array with additional functionalities. These additional functionalities include list slicing, resizing, looping and list comprehensions. Lists are created using square brackets, i.e. []. Let's explore more about Lists in the cell below. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Lists\n", "\n", "pt = [3, 6, 9]\n", "\n", "print (type(pt))\n", "\n", "print (pt, pt[2])\n", "\n", "pt[2] = 'digital'\n", "\n", "print (pt)\n", "\n", "pt.append('Technologies')\n", "print (pt)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# List Slicing\n", "\n", "pt = list(range(7))\n", "\n", "print (pt)\n", "\n", "print(pt[2:5])\n", "\n", "print(pt[-1])\n", "\n", "print (pt [:4])\n", "\n", "print (pt[3:])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# List loops\n", "\n", "pt = list (range(7))\n", "\n", "print (pt)\n", "\n", "for value in pt:\n", " print (value**2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#List comprehension\n", "pt = list (range(7))\n", "\n", "sqrt = [x**2 for x in pt ]\n", "\n", "print(sqrt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Dictionary" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Dictionaries](https://docs.python.org/3.5/tutorial/datastructures.html#dictionaries) in python is a unordered set of key-value pairs. It is indexed by keys, which can be any immutable type. You can think of [dictionaries](https://docs.python.org/3.5/tutorial/datastructures.html#dictionaries) as an “associative array”. Dictionaries are created using braces, i.e. {}. Similar to list, it provides additional functionalities include dictionary slicing, resizing, looping and dict comprehensions. Let's explore more about Dictionaries in the cell below. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Dictionaries\n", "\n", "val = {'sky':'blue','grass':'green','flower':'red'}\n", "\n", "print (val)\n", "\n", "print(val['sky'])\n", "\n", "for k, v in val.items():\n", " print ('{0} is {1}'.format(k,v))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Sets" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A [set](https://docs.python.org/3.5/library/stdtypes.html#set) is an unordered unique collection of objects. Unlike lists or tuples, a set cannot have multiple occurrences of the same element. You can create a set using set() command. Let's explore more about sets in the cell below. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Sets\n", "\n", "vehicle = {'car','truck','bikes'}\n", "\n", "print(vehicle)\n", "\n", "vehicle.add('scooter')\n", "\n", "print(vehicle)\n", "\n", "vehicle.remove('car')\n", "\n", "print(vehicle)\n", "\n", "for i in vehicle:\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Tuples" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Tuples](https://docs.python.org/3.5/tutorial/datastructures.html#tuples-and-sequences) are similar to lists but are not mutable. Tuples are faster and smaller than a list. One key feature of a tuple is that unlike lists, it can be used as a key in dictionaries and as elements of sets. A tuple can be created with an () or with the tuple() builtin function. Let's explore more about sets in the cell below." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Tuples\n", "\n", "t = (1,3)\n", "\n", "print (type(t))\n", "\n", "for i in t:\n", " print (i)\n", " \n", "# Dict comprehension with tuples\n", "\n", "dt = {(x,x**2): x for x in range(10)}\n", "\n", "print (dt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Functions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Functions](https://docs.python.org/3.5/tutorial/controlflow.html#defining-functions) help abstract the functionality into a module. Functions make the program more organized, modular and manageable as it grows in size. Functions in python are created using def Keyword. Let's explore functions in the cell below." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def mult(a, b):\n", " return(a*b)\n", "\n", "def add(a,b):\n", " return(a+b)\n", "\n", "print (mult(2,4))\n", "print (add(3,5))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Classes" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Like in other Object-oriented languages, [classes](https://docs.python.org/3.5/tutorial/classes.html) in python provide a mechanism of encapsulating variables and functions and serve as a blueprint for the objects. In python, a class is created by the keyword class. Let's explore classes in the cell below." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Classes\n", "\n", "class hello:\n", " \n", " def __init__(self, name):\n", " self.name = name\n", " \n", " def greet(self):\n", " print (\"Hello {0} to the class\".format(self.name))\n", " \n", "h = hello('learner')\n", "\n", "h.greet()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### NumPy" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "image/jpeg": "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\n", "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from IPython.display import YouTubeVideo\n", "YouTubeVideo('cZGGtxUTNIg', width=860, height=460)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Arrays\n", "Arrays and matrices are used in processing data in scientific, and statistical programming used in machine learning, computer vision and other digital technologies. [NumPy]((https://numpy.org/devdocs/user/quickstart.html)) provides a high-performance multidimensional array object and tools for working with these arrays. NumPy library will be very useful in our next tutorials on linear algebra." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Numpy\n", "\n", "import numpy as np\n", "\n", "mt1 = np.array([2,3,4])\n", "\n", "print (mt1)\n", "print (mt1.shape)\n", "\n", "# Other ways\n", "\n", "mt2 = np.zeros((2,2))\n", "print (mt2)\n", "\n", "mt3 = np.ones((2,2))\n", "print (mt3)\n", "\n", "mt4 = np.full((2,2),8)\n", "print (mt4)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Array Maths" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "arr1 = np.full((2,2), 4)\n", "arr2 = np.full((2,2), 3)\n", "\n", "print(np.add(arr1, arr2))\n", "\n", "print(np.subtract(arr1,arr2))\n", "\n", "print(np.multiply(arr1,arr2))\n", "\n", "print(np.divide(arr1,arr2))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Indexing and Slicing" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "arr = np.array(([1,2,3],[4,5,6],[7,8,9]))\n", "\n", "row_1 = arr[1,:]\n", "row_2 = arr[1:2,:]\n", "\n", "print (row_1, row_1.shape)\n", "print (row_2, row_2.shape)\n", "\n", "\n", "col_1 = arr[:,1]\n", "col_2 = arr[:,1:2]\n", "\n", "print (col_1, col_1.shape)\n", "print (col_2, col_2.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Matplotlib\n", "[Matplotlib\n", "](https://matplotlib.org/) is a python library for creating static, animated, and interactive visualizations in Python. Matplotlib is very useful in visualization of data in the digital world. Below we will explore matplotlib plot function, which allows you to plot 2D data." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "year = [2011,2012,2013,2014,2015,2016]\n", "\n", "goog = [10,14,15,16,18,33]\n", "\n", "appl = [5,6,8,10,17,21]\n", "\n", "plt.plot(year,goog,\n", " year,appl)\n", "\n", "plt.xlabel(\"Year\")\n", "\n", "plt.ylabel(\"Shares\")\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Subplot\n", "\n", "On the same plot, we can use subplot to plot different functions. We can use add_subplot to create multiple plots in the same figure. In add_subplot \"111\" means \"1x1 grid, first subplot\" and \"334\" means \"3x3 grid, 4th subplot\"." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "fig = plt.figure(1, figsize=(15,4))\n", "\n", "chart1 = fig.add_subplot(122)\n", "chart2 = fig.add_subplot(121)\n", "\n", "chart1.plot(year, appl)\n", "\n", "chart2.plot(year,goog)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercices - Python, Numpy and Matplotlib" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "1. Create a function housingData() in such a way that it should accept area and cost and display both, and if the area or cost is missing in function call it should show area as 1000 and cost as 4000." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def housingData():\n", " \"\"\"\n", " Accept area and cost\n", " \"\"\"\n", " \n", "housingData()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "2. Create a NumPy 2D matrix for area and cost for atleast eight houses. Calculate the total cost and area of the 8 houses. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def housingData():\n", " \"\"\"\n", " Accept area and cost\n", " \"\"\"\n", " \n", " \n", "def calculateTotalArea():\n", " \"\"\"\n", " Calculate total area and cost\n", " \"\"\"\n", " \n", " \n", "housingData()\n", "calculateTotalArea()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "3. Plot the above 2D array on a graph." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def housingData():\n", " \"\"\"\n", " Accept area and cost\n", " \"\"\"\n", " \n", " \n", "def calculateTotalArea():\n", " \"\"\"\n", " Calculate total area and cost\n", " \"\"\"\n", " \n", " \n", "def plotData():\n", " \"\"\"\n", " Plot the data for the 2D Values\n", " \"\"\"\n", " \n", "housingData()\n", "calculateTotalArea()\n", "plotData()" ] } ], "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.4" } }, "nbformat": 4, "nbformat_minor": 4 }