{ "cells": [ { "cell_type": "markdown", "id": "73791c49", "metadata": {}, "source": [ "# Python Basics\n", "In this tutorial, we will cover some python basic concepts like data types, conditional statements, loops, containers, functions, and plots.\n", "\n", "This notebook has been created with the help of the following resources:\n", "\n", "1. Python [Colab Notebook](https://colab.research.google.com/github/cs231n/cs231n.github.io/blob/master/python-colab.ipynb#scrollTo=0vJLt3JRL9eR) from CS231n.\n", "2. Python Tutorial from [W3Schools](https://www.w3schools.com/python/default.asp).\n" ] }, { "cell_type": "markdown", "id": "c567ac3c", "metadata": {}, "source": [ "## Basic data types" ] }, { "cell_type": "markdown", "id": "18b2cc8c", "metadata": {}, "source": [ "### Numbers\n", "There are three numeric types in Python:\n", "\n", "* `int`\n", "* `float`\n", "* `complex`" ] }, { "cell_type": "code", "execution_count": 82, "id": "3354787d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5 \n", "2.4 \n", "(2+5j) \n" ] } ], "source": [ "# Numbers\n", "x = 5\n", "y = 2.4\n", "z = 2 + 5j\n", "print(x, type(x))\n", "print(y, type(y))\n", "print(z, type(z))" ] }, { "cell_type": "code", "execution_count": 4, "id": "16cacc39", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "25\n", "1.6666666666666667\n", "1\n", "2\n", "6\n", "12\n" ] } ], "source": [ "# Math operators\n", "# We have +, -, *, /, **, //, %\n", "\n", "print(x ** 2) # Exponentiation\n", "print(x / 3) # Division\n", "print(x // 3) # Floor Division\n", "print(x % 3) # Modulus\n", "\n", "x += 1\n", "print(x)\n", "x *= 2\n", "print(x)" ] }, { "cell_type": "markdown", "id": "8833ffaa", "metadata": {}, "source": [ "### Booleans\n", "Python implements all of the usual operators for Boolean logic, but uses English words rather than symbols (`&&`, `||`, etc.)." ] }, { "cell_type": "code", "execution_count": 5, "id": "7deaae2f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True \n", "False \n" ] } ], "source": [ "t, f = True, False\n", "print(t, type(t))\n", "print(f, type(f))" ] }, { "cell_type": "code", "execution_count": 6, "id": "b32dba98", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "False\n", "True\n", "False\n", "True\n" ] } ], "source": [ "# Logical operators\n", "\n", "print(t and f) # Logical AND\n", "print(t or f) # Logical OR\n", "print(not t) # Logical NOT\n", "print(t != f) # Logical XOR" ] }, { "cell_type": "markdown", "id": "5b04f59f", "metadata": {}, "source": [ "### Strings\n", "Strings in python are surrounded by either single quotation marks, or double quotation marks.\n", "\n", "`'hello'` is the same as `\"hello\"`." ] }, { "cell_type": "code", "execution_count": 7, "id": "1c633f98", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hello 5\n", "Hello World!\n" ] } ], "source": [ "hello = 'Hello'\n", "print(hello, type(hello), len(hello))\n", "print(hello + ' World!')" ] }, { "cell_type": "code", "execution_count": 2, "id": "9b31c9cd", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "What is your name? Ali\n", "How old are you? 29\n", "Next year Ali will be 30 year old\n", "Next year Ali will be 30 year old\n" ] } ], "source": [ "# Input data\n", "Name = input('What is your name? ')\n", "Age = int(input('How old are you? ')) # casting\n", "\n", "# String format\n", "print(f'Next year {Name} will be {Age+1} year old')\n", "print('Next year {} will be {} year old'.format(Name, Age+1))" ] }, { "cell_type": "code", "execution_count": 10, "id": "4693e040", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Happy new year!\n", "Happy new year!\n", "HAPPY NEW YEAR!\n", "happy new year!\n", "1\n", "2\n", "Happyy new year!\n", "True\n" ] } ], "source": [ "# String methods\n", "\n", "s = 'Happy new year!'\n", "print(s)\n", "print(s.capitalize())\n", "print(s.upper())\n", "print(s.lower())\n", "print(s.find('a'))\n", "print(s.count('a'))\n", "print(s.replace('Happy', 'Happyy'))\n", "print('new' in s)" ] }, { "cell_type": "markdown", "id": "d9e7496d", "metadata": {}, "source": [ "## Conditional statements" ] }, { "cell_type": "code", "execution_count": 4, "id": "e406aafc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n", "False\n", "False\n" ] } ], "source": [ "# Comparison operators\n", "# ==, !=, <, >, <=, >=\n", "\n", "print(2 < 5)\n", "print(2 > 1 > 5)\n", "print(2 >= 2 and 5 < -1)" ] }, { "cell_type": "code", "execution_count": 12, "id": "bf2d9dd8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Enter integer number a 25\n", "Enter integer number b 12\n", "a is greater than b\n" ] } ], "source": [ "a = int(input('Enter integer number a '))\n", "b = int(input('Enter integer number b '))\n", "if b > a:\n", " print(\"b is greater than a\")\n", "elif a == b:\n", " print(\"a and b are equal\")\n", "else:\n", " print(\"a is greater than b\")" ] }, { "cell_type": "markdown", "id": "b1dc4244", "metadata": {}, "source": [ "We can use short hand if ... else:" ] }, { "cell_type": "code", "execution_count": 83, "id": "dc1c85ef", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a = b\n" ] } ], "source": [ "a = 5\n", "b = 5\n", "print('b > a') if b > a else print('a = b') if a == b else print('a > b')" ] }, { "cell_type": "markdown", "id": "88c1f57e", "metadata": {}, "source": [ "## Loop" ] }, { "cell_type": "markdown", "id": "31d605ed", "metadata": {}, "source": [ "Python has two primitive loop commands:\n", "* `while` loops\n", "* `for` loops" ] }, { "cell_type": "markdown", "id": "dc1e9bf1", "metadata": {}, "source": [ "### While loop" ] }, { "cell_type": "markdown", "id": "48c8b237", "metadata": {}, "source": [ "With the while loop we can execute a set of statements as long as a condition is true." ] }, { "cell_type": "code", "execution_count": 13, "id": "709a5abc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "2\n", "3\n", "4\n", "5\n", "i is no longer less than 6\n" ] } ], "source": [ "i = 1\n", "while i < 6:\n", " print(i)\n", " i += 1\n", "else:\n", " print(\"i is no longer less than 6\")" ] }, { "cell_type": "markdown", "id": "376cd364", "metadata": {}, "source": [ "With the `break` statement we can stop the loop even if the while condition is true.\n", "\n", "With the `continue` statement we can stop the current iteration, and continue with the next:" ] }, { "cell_type": "code", "execution_count": 17, "id": "ab5b4705", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "2\n", "3\n", "4\n", "5\n" ] } ], "source": [ "i = 1\n", "while True:\n", " print(i)\n", " if i == 5:\n", " break\n", " i += 1" ] }, { "cell_type": "markdown", "id": "03b14012", "metadata": {}, "source": [ "### For loop" ] }, { "cell_type": "markdown", "id": "c6735607", "metadata": {}, "source": [ "A for loop is used for iterating over a sequence (that is either a list, a tuple, a dictionary, a set, or a string).\n", "\n", "The `break` and `continue` works here as before." ] }, { "cell_type": "code", "execution_count": 18, "id": "c0a4b67d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "str1\n", "2\n", "48.4\n", "(7+1j)\n", "True\n" ] } ], "source": [ "l = ['str1', 2, 48.4, 7+1j, True, 2]\n", "for i in l:\n", " print(i)\n", " if type(i) == bool:\n", " break" ] }, { "cell_type": "markdown", "id": "7b232b6d", "metadata": {}, "source": [ "To loop through a set of code a specified number of times, we can use the `range()` function.\n", " \n", "The `range()` function returns a sequence of numbers, starting from 0 by default, and increments by 1 (by default), and ends at a specified number." ] }, { "cell_type": "code", "execution_count": 19, "id": "9e966b31", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10\n", "20\n", "30\n", "40\n", "50\n", "60\n", "70\n", "80\n", "90\n" ] } ], "source": [ "for i in range(1, 100):\n", " if i % 10 == 0:\n", " print(i)" ] }, { "cell_type": "markdown", "id": "9996a037", "metadata": {}, "source": [ "## Containers" ] }, { "cell_type": "markdown", "id": "b91dfeba", "metadata": {}, "source": [ "Python includes several built-in container types: lists, dictionaries, sets, and tuples.\n", "\n", "* **List** is a collection which is ordered and changeable. Allows duplicate members.\n", "* **Dictionary** is a collection which is ordered and changeable. No duplicate members.\n", "* **Tuple** is a collection which is ordered and unchangeable. Allows duplicate members.\n", "* **Set** is a collection which is unordered, unchangeable, and unindexed. No duplicate members." ] }, { "cell_type": "markdown", "id": "ef50c966", "metadata": {}, "source": [ "### Lists" ] }, { "cell_type": "markdown", "id": "4c953ade", "metadata": {}, "source": [ "A list is the Python equivalent of an array, but is resizeable and can contain elements of different types." ] }, { "cell_type": "code", "execution_count": 31, "id": "f212226f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['str1', 2, 48.4, (7+1j), True, 2] 6\n", "['Mohammad', 'str1', 2, 48.4, (7+1j), True, 2, 0]\n", "['str1', 2, 48.4, (7+1j), True, 2]\n" ] } ], "source": [ "l1 = ['str1', 2, 48.4, 7+1j, True, 2]\n", "print(l1, type(l1), len(l1))\n", "\n", "# List methods\n", "l1.append(0) # Add a new element to the end of the list\n", "l1.insert(0, 'Mohammad') # Add a new element at the desired index (here 0)\n", "print(l1)\n", "l1.pop() # Remove and return the last element of the list\n", "l1.pop(0) # Removes a desired element of the list\n", "print(l1)" ] }, { "cell_type": "code", "execution_count": 32, "id": "cb60e2e2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0, 1, 2, 3, 4]\n", "[1, 2, 3]\n", "[0, 1]\n", "[0, 1, 2, 3, 4]\n", "[0, 1, 2, 3, 4]\n", "[4, 3, 2, 1, 0]\n" ] } ], "source": [ "# List slicing\n", "\n", "nums = list(range(0, 5, 1))\n", "print(nums)\n", "print(nums[1:4])\n", "print(nums[:2])\n", "print(nums[:])\n", "print(nums[::1])\n", "print(nums[::-1])" ] }, { "cell_type": "markdown", "id": "290033c2", "metadata": {}, "source": [ "*Note*: In python, the indices start from **0** (unlike MATLAB that start from 1)." ] }, { "cell_type": "code", "execution_count": 33, "id": "43d7d00e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "#1: cat\n", "#2: dog\n", "#3: monkey\n" ] } ], "source": [ "# Loop over a list\n", "animals = ['cat', 'dog', 'monkey']\n", "for idx, animal in enumerate(animals):\n", " print('#{}: {}'.format(idx + 1, animal))" ] }, { "cell_type": "markdown", "id": "2f33a883", "metadata": {}, "source": [ "**List comprehension** offers a shorter syntax when you want to create a new list based on the values of an existing list:" ] }, { "cell_type": "code", "execution_count": 34, "id": "a3273d82", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0, 4, 16]\n" ] } ], "source": [ "nums = [0, 1, 2, 3, 4]\n", "even_squares = [x ** 2 for x in nums if x % 2 == 0]\n", "print(even_squares)" ] }, { "cell_type": "markdown", "id": "52cc25e6", "metadata": {}, "source": [ "### Dictionaries" ] }, { "cell_type": "markdown", "id": "3a37333c", "metadata": {}, "source": [ "A dictionary stores (key, value) pairs, similar to a `Map` in Java or an object in Javascript. You can use it like this:" ] }, { "cell_type": "code", "execution_count": 40, "id": "2149975e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'person': 2, 'cat': 4, 'spider': 8, 'fish': 0} \n", "2\n", "dict_keys(['person', 'cat', 'spider', 'fish'])\n", "dict_values([2, 4, 8, 0])\n", "dict_items([('person', 2), ('cat', 4), ('spider', 8), ('fish', 0)])\n", "N/A\n", "4\n" ] } ], "source": [ "# Dictionary\n", "d = {'person': 2,\n", " 'cat': 4,\n", " 'spider': 8}\n", "d['fish'] = 0\n", "\n", "# Dictionary methods\n", "print(d, type(d))\n", "print(d['person'])\n", "print(d.keys())\n", "print(d.values())\n", "print(d.items())\n", "print(d.get('dog', 'N/A'))\n", "print(d.get('cat', 'N/A'))" ] }, { "cell_type": "code", "execution_count": 39, "id": "5fb61cb6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "A person has 2 legs\n", "A cat has 4 legs\n", "A spider has 8 legs\n", "A fish has 0 legs\n" ] } ], "source": [ "# Dictionary loop\n", "for animal, legs in d.items():\n", " print(f'A {animal} has {legs} legs')" ] }, { "cell_type": "markdown", "id": "b8655b07", "metadata": {}, "source": [ "### Tuples" ] }, { "cell_type": "markdown", "id": "c7348d54", "metadata": {}, "source": [ "A tuple is an (immutable) ordered list of values." ] }, { "cell_type": "code", "execution_count": 41, "id": "c4bc342f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "('apple', 12, False, 2.2) 4\n" ] } ], "source": [ "t = (\"apple\", 12, False, 2.2)\n", "print(t, type(t), len(t))" ] }, { "cell_type": "code", "execution_count": 42, "id": "e8b4b06d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "apple\n", "banana\n", "cherry\n" ] } ], "source": [ "# Tuple unpacking\n", "\n", "fruits = (\"apple\", \"banana\", \"cherry\")\n", "(green, yellow, red) = fruits\n", "print(green)\n", "print(yellow)\n", "print(red)" ] }, { "cell_type": "markdown", "id": "6507489f", "metadata": {}, "source": [ "### Sets" ] }, { "cell_type": "markdown", "id": "23fdb4b0", "metadata": {}, "source": [ "A set is an unordered collection of distinct elements." ] }, { "cell_type": "code", "execution_count": 49, "id": "afe3257c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{False, 'apple', 'cherry', 'banana'} 4\n", "True\n", "{False, 2, 'banana', 'cherry'}\n" ] } ], "source": [ "# Set\n", "s = {\"apple\", \"banana\", \"cherry\", False, 0}\n", "print(s, type(s), len(s))\n", "print('apple' in s)\n", "s.remove('apple') # Remove an element from a set\n", "s.add(2) # Add an element to a set\n", "print(s)" ] }, { "cell_type": "markdown", "id": "af1f586a", "metadata": {}, "source": [ "## Functions" ] }, { "cell_type": "code", "execution_count": 72, "id": "f0bf736d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "negative\n", "zero\n", "positive\n" ] } ], "source": [ "# function\n", "def sign(x):\n", " \n", " if x > 0:\n", " return 'positive'\n", " elif x < 0:\n", " return 'negative'\n", " else:\n", " return 'zero'\n", "\n", "for x in [-1, 0, 2.5]:\n", " print(sign(x))" ] }, { "cell_type": "code", "execution_count": 73, "id": "c33c284c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 1, 2, 3, 6, 8, 10]\n" ] } ], "source": [ "def quicksort(arr):\n", " if len(arr) <= 1:\n", " return arr\n", " pivot = arr[len(arr) // 2]\n", " left = [x for x in arr if x < pivot]\n", " middle = [x for x in arr if x == pivot]\n", " right = [x for x in arr if x > pivot]\n", " return quicksort(left) + middle + quicksort(right)\n", "\n", "print(quicksort([3,6,8,10,1,2,1]))" ] }, { "cell_type": "markdown", "id": "8c932696", "metadata": {}, "source": [ "### Arbitrary Arguments (*args)\n", "If you do not know how many arguments that will be passed into your function, add a `*` before the parameter name in the function definition.\n", "\n", "This way the function will receive a *tuple* of arguments, and can access the items accordingly:" ] }, { "cell_type": "code", "execution_count": 75, "id": "1631feef", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The youngest child is Sara\n" ] } ], "source": [ "def my_function(*kids):\n", " print(\"The youngest child is \" + kids[2])\n", "\n", "my_function(\"Ali\", \"Mohammad\", \"Sara\")" ] }, { "cell_type": "markdown", "id": "a6ce6db2", "metadata": {}, "source": [ "### Keyword Arguments\n", "We can also send arguments with the key = value syntax.\n", "\n", "This way the order of the arguments does not matter." ] }, { "cell_type": "code", "execution_count": 76, "id": "04e29086", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The youngest child is Sara\n" ] } ], "source": [ "def my_function(child3, child2, child1):\n", " print(\"The youngest child is \" + child3)\n", "\n", "my_function(child1 = \"Ali\", child2 = \"Mohammad\", child3 = \"Sara\")" ] }, { "cell_type": "markdown", "id": "175c99ad", "metadata": {}, "source": [ "### Arbitrary Keyword Arguments (**kwargs)\n", "\n", "If you do not know how many keyword arguments that will be passed into your function, add two asterisk: `**` before the parameter name in the function definition.\n", "\n", "This way the function will receive a *dictionary* of arguments, and can access the items accordingly:" ] }, { "cell_type": "code", "execution_count": 77, "id": "db87d744", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "His last name is Nasiri\n" ] } ], "source": [ "def my_function(**kid):\n", " print(\"His last name is \" + kid[\"lname\"])\n", "\n", "my_function(fname = \"Ali\", lname = \"Nasiri\")" ] }, { "cell_type": "markdown", "id": "ab67d2f3", "metadata": {}, "source": [ "### Default Parameter Value\n", "The following example shows how to use a default parameter value.\n", "\n", "If we call the function without argument, it uses the default value." ] }, { "cell_type": "code", "execution_count": 78, "id": "db41bf83", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "I am from Iran\n", "I am from Brazil\n" ] } ], "source": [ "def my_function(country = \"Iran\"):\n", " print(\"I am from \" + country)\n", "\n", "my_function()\n", "my_function(\"Brazil\")" ] }, { "cell_type": "markdown", "id": "e3ab56f4", "metadata": {}, "source": [ "## Classes\n", "Python is an object oriented programming language. Almost everything in Python is an object, with its properties and methods.\n", "\n", "A Class is like an object constructor, or a \"blueprint\" for creating objects.\n", "\n", "All classes have a function called \\_\\_init\\_\\_(), which is always executed when the class is being initiated." ] }, { "cell_type": "code", "execution_count": 84, "id": "7d37c275", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Mohammad\n", "Hello, Mohammad!\n", "HELLO, MOHAMMAD!\n" ] } ], "source": [ "# Class\n", "class Greeter:\n", "\n", " # Constructor\n", " def __init__(self, name):\n", " self.name = name # Create an instance variable\n", " # self.greet()\n", "\n", " # Instance method\n", " def greet(self, loud=False):\n", " if loud:\n", " print('HELLO, {}!'.format(self.name.upper()))\n", " else:\n", " print('Hello, {}!'.format(self.name))\n", "\n", "g = Greeter('Mohammad') # Construct an instance of the Greeter class\n", "print(g.name)\n", "g.greet() # Call an instance method; prints \"Hello, Mohammad!\"\n", "g.greet(loud=True) # Call an instance method; prints \"HELLO, MOHAMMAD!\"" ] }, { "cell_type": "markdown", "id": "41de8e26", "metadata": {}, "source": [ "### Inheritance\n", "Inheritance allows us to define a class that inherits all the methods and properties from another class.\n", "\n", "Parent class is the class being inherited from, also called base class.\n", "\n", "Child class is the class that inherits from another class, also called derived class.\n", "\n", "Python has a `super()` function that will make the child class inherit all the methods and properties from its parent." ] }, { "cell_type": "code", "execution_count": 86, "id": "6131a1b3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Welcome Mohammad Rasouli to the class of 1400\n" ] } ], "source": [ "class Person:\n", " \n", " def __init__(self, fname, lname):\n", " self.firstname = fname\n", " self.lastname = lname\n", " \n", " def printname(self):\n", " print(self.firstname, self.lastname)\n", "\n", "class Student(Person):\n", " \n", " def __init__(self, fname, lname, year):\n", " super().__init__(fname, lname)\n", " self.graduationyear = year\n", " \n", " def welcome(self):\n", " print(\"Welcome\", self.firstname, self.lastname, \"to the class of\", self.graduationyear)\n", "\n", "x = Student(\"Mohammad\", \"Rasouli\", 1400)\n", "x.welcome()" ] }, { "cell_type": "markdown", "id": "f2a15898", "metadata": {}, "source": [ "## Plotting" ] }, { "cell_type": "markdown", "id": "dda1fe55", "metadata": {}, "source": [ "Matplotlib is a plotting library. In this section give a brief introduction to the `matplotlib.pyplot` module, which provides a plotting system similar to that of MATLAB." ] }, { "cell_type": "code", "execution_count": 89, "id": "cb52b459", "metadata": {}, "outputs": [], "source": [ "# !pip install matplotlib\n", "# !pip install numpy" ] }, { "cell_type": "code", "execution_count": 4, "id": "a2e621fd", "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "# from matplotlib import pyplot as plt\n", "import numpy as np\n", "import random" ] }, { "cell_type": "markdown", "id": "bff0c782", "metadata": {}, "source": [ "The most important function in `matplotlib` is plot, which allows you to plot 2D data. Here is a simple example:" ] }, { "cell_type": "code", "execution_count": 54, "id": "566ddd46", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# A basic plot\n", "x_vals = [1, 2, 3, 4]\n", "y_vals = [0, 1, 2, 3]\n", "plt.plot(x_vals, y_vals, label= 'A Basic Plot')\n", "plt.xlabel('x-axis label')\n", "plt.ylabel('y-axix label')\n", "plt.legend()\n", "plt.title('A Basic Sample Plot')\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "4f4079e2", "metadata": {}, "source": [ "With just a little bit of extra work we can easily plot multiple lines at once, and add a title, legend, and axis labels:" ] }, { "cell_type": "code", "execution_count": 5, "id": "7908c8d1", "metadata": {}, "outputs": [ { "data": { "application/javascript": [ "/* Put everything inside the global mpl namespace */\n", "/* global mpl */\n", "window.mpl = {};\n", "\n", "mpl.get_websocket_type = function () {\n", " if (typeof WebSocket !== 'undefined') {\n", " return WebSocket;\n", " } else if (typeof MozWebSocket !== 'undefined') {\n", " return MozWebSocket;\n", " } else {\n", " alert(\n", " 'Your browser does not have WebSocket support. ' +\n", " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", " 'Firefox 4 and 5 are also supported but you ' +\n", " 'have to enable WebSockets in about:config.'\n", " );\n", " }\n", "};\n", "\n", "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", " this.id = figure_id;\n", "\n", " this.ws = websocket;\n", "\n", " this.supports_binary = this.ws.binaryType !== undefined;\n", "\n", " if (!this.supports_binary) {\n", " var warnings = document.getElementById('mpl-warnings');\n", " if (warnings) {\n", " warnings.style.display = 'block';\n", " warnings.textContent =\n", " 'This browser does not support binary websocket messages. ' +\n", " 'Performance may be slow.';\n", " }\n", " }\n", "\n", " this.imageObj = new Image();\n", "\n", " this.context = undefined;\n", " this.message = undefined;\n", " this.canvas = undefined;\n", " this.rubberband_canvas = undefined;\n", " this.rubberband_context = undefined;\n", " this.format_dropdown = undefined;\n", "\n", " this.image_mode = 'full';\n", "\n", " this.root = document.createElement('div');\n", " this.root.setAttribute('style', 'display: inline-block');\n", " this._root_extra_style(this.root);\n", "\n", " parent_element.appendChild(this.root);\n", "\n", " this._init_header(this);\n", " this._init_canvas(this);\n", " this._init_toolbar(this);\n", "\n", " var fig = this;\n", "\n", " this.waiting = false;\n", "\n", " this.ws.onopen = function () {\n", " fig.send_message('supports_binary', { value: fig.supports_binary });\n", " fig.send_message('send_image_mode', {});\n", " if (fig.ratio !== 1) {\n", " fig.send_message('set_device_pixel_ratio', {\n", " device_pixel_ratio: fig.ratio,\n", " });\n", " }\n", " fig.send_message('refresh', {});\n", " };\n", "\n", " this.imageObj.onload = function () {\n", " if (fig.image_mode === 'full') {\n", " // Full images could contain transparency (where diff images\n", " // almost always do), so we need to clear the canvas so that\n", " // there is no ghosting.\n", " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", " }\n", " fig.context.drawImage(fig.imageObj, 0, 0);\n", " };\n", "\n", " this.imageObj.onunload = function () {\n", " fig.ws.close();\n", " };\n", "\n", " this.ws.onmessage = this._make_on_message_function(this);\n", "\n", " this.ondownload = ondownload;\n", "};\n", "\n", "mpl.figure.prototype._init_header = function () {\n", " var titlebar = document.createElement('div');\n", " titlebar.classList =\n", " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", " var titletext = document.createElement('div');\n", " titletext.classList = 'ui-dialog-title';\n", " titletext.setAttribute(\n", " 'style',\n", " 'width: 100%; text-align: center; padding: 3px;'\n", " );\n", " titlebar.appendChild(titletext);\n", " this.root.appendChild(titlebar);\n", " this.header = titletext;\n", "};\n", "\n", "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", "\n", "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", "\n", "mpl.figure.prototype._init_canvas = function () {\n", " var fig = this;\n", "\n", " var canvas_div = (this.canvas_div = document.createElement('div'));\n", " canvas_div.setAttribute('tabindex', '0');\n", " canvas_div.setAttribute(\n", " 'style',\n", " 'border: 1px solid #ddd;' +\n", " 'box-sizing: content-box;' +\n", " 'clear: both;' +\n", " 'min-height: 1px;' +\n", " 'min-width: 1px;' +\n", " 'outline: 0;' +\n", " 'overflow: hidden;' +\n", " 'position: relative;' +\n", " 'resize: both;' +\n", " 'z-index: 2;'\n", " );\n", "\n", " function on_keyboard_event_closure(name) {\n", " return function (event) {\n", " return fig.key_event(event, name);\n", " };\n", " }\n", "\n", " canvas_div.addEventListener(\n", " 'keydown',\n", " on_keyboard_event_closure('key_press')\n", " );\n", " canvas_div.addEventListener(\n", " 'keyup',\n", " on_keyboard_event_closure('key_release')\n", " );\n", "\n", " this._canvas_extra_style(canvas_div);\n", " this.root.appendChild(canvas_div);\n", "\n", " var canvas = (this.canvas = document.createElement('canvas'));\n", " canvas.classList.add('mpl-canvas');\n", " canvas.setAttribute(\n", " 'style',\n", " 'box-sizing: content-box;' +\n", " 'pointer-events: none;' +\n", " 'position: relative;' +\n", " 'z-index: 0;'\n", " );\n", "\n", " this.context = canvas.getContext('2d');\n", "\n", " var backingStore =\n", " this.context.backingStorePixelRatio ||\n", " this.context.webkitBackingStorePixelRatio ||\n", " this.context.mozBackingStorePixelRatio ||\n", " this.context.msBackingStorePixelRatio ||\n", " this.context.oBackingStorePixelRatio ||\n", " this.context.backingStorePixelRatio ||\n", " 1;\n", "\n", " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", "\n", " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", " 'canvas'\n", " ));\n", " rubberband_canvas.setAttribute(\n", " 'style',\n", " 'box-sizing: content-box;' +\n", " 'left: 0;' +\n", " 'pointer-events: none;' +\n", " 'position: absolute;' +\n", " 'top: 0;' +\n", " 'z-index: 1;'\n", " );\n", "\n", " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", " if (this.ResizeObserver === undefined) {\n", " if (window.ResizeObserver !== undefined) {\n", " this.ResizeObserver = window.ResizeObserver;\n", " } else {\n", " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", " this.ResizeObserver = obs.ResizeObserver;\n", " }\n", " }\n", "\n", " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", " var nentries = entries.length;\n", " for (var i = 0; i < nentries; i++) {\n", " var entry = entries[i];\n", " var width, height;\n", " if (entry.contentBoxSize) {\n", " if (entry.contentBoxSize instanceof Array) {\n", " // Chrome 84 implements new version of spec.\n", " width = entry.contentBoxSize[0].inlineSize;\n", " height = entry.contentBoxSize[0].blockSize;\n", " } else {\n", " // Firefox implements old version of spec.\n", " width = entry.contentBoxSize.inlineSize;\n", " height = entry.contentBoxSize.blockSize;\n", " }\n", " } else {\n", " // Chrome <84 implements even older version of spec.\n", " width = entry.contentRect.width;\n", " height = entry.contentRect.height;\n", " }\n", "\n", " // Keep the size of the canvas and rubber band canvas in sync with\n", " // the canvas container.\n", " if (entry.devicePixelContentBoxSize) {\n", " // Chrome 84 implements new version of spec.\n", " canvas.setAttribute(\n", " 'width',\n", " entry.devicePixelContentBoxSize[0].inlineSize\n", " );\n", " canvas.setAttribute(\n", " 'height',\n", " entry.devicePixelContentBoxSize[0].blockSize\n", " );\n", " } else {\n", " canvas.setAttribute('width', width * fig.ratio);\n", " canvas.setAttribute('height', height * fig.ratio);\n", " }\n", " /* This rescales the canvas back to display pixels, so that it\n", " * appears correct on HiDPI screens. */\n", " canvas.style.width = width + 'px';\n", " canvas.style.height = height + 'px';\n", "\n", " rubberband_canvas.setAttribute('width', width);\n", " rubberband_canvas.setAttribute('height', height);\n", "\n", " // And update the size in Python. We ignore the initial 0/0 size\n", " // that occurs as the element is placed into the DOM, which should\n", " // otherwise not happen due to the minimum size styling.\n", " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", " fig.request_resize(width, height);\n", " }\n", " }\n", " });\n", " this.resizeObserverInstance.observe(canvas_div);\n", "\n", " function on_mouse_event_closure(name) {\n", " /* User Agent sniffing is bad, but WebKit is busted:\n", " * https://bugs.webkit.org/show_bug.cgi?id=144526\n", " * https://bugs.webkit.org/show_bug.cgi?id=181818\n", " * The worst that happens here is that they get an extra browser\n", " * selection when dragging, if this check fails to catch them.\n", " */\n", " var UA = navigator.userAgent;\n", " var isWebKit = /AppleWebKit/.test(UA) && !/Chrome/.test(UA);\n", " if(isWebKit) {\n", " return function (event) {\n", " /* This prevents the web browser from automatically changing to\n", " * the text insertion cursor when the button is pressed. We\n", " * want to control all of the cursor setting manually through\n", " * the 'cursor' event from matplotlib */\n", " event.preventDefault()\n", " return fig.mouse_event(event, name);\n", " };\n", " } else {\n", " return function (event) {\n", " return fig.mouse_event(event, name);\n", " };\n", " }\n", " }\n", "\n", " canvas_div.addEventListener(\n", " 'mousedown',\n", " on_mouse_event_closure('button_press')\n", " );\n", " canvas_div.addEventListener(\n", " 'mouseup',\n", " on_mouse_event_closure('button_release')\n", " );\n", " canvas_div.addEventListener(\n", " 'dblclick',\n", " on_mouse_event_closure('dblclick')\n", " );\n", " // Throttle sequential mouse events to 1 every 20ms.\n", " canvas_div.addEventListener(\n", " 'mousemove',\n", " on_mouse_event_closure('motion_notify')\n", " );\n", "\n", " canvas_div.addEventListener(\n", " 'mouseenter',\n", " on_mouse_event_closure('figure_enter')\n", " );\n", " canvas_div.addEventListener(\n", " 'mouseleave',\n", " on_mouse_event_closure('figure_leave')\n", " );\n", "\n", " canvas_div.addEventListener('wheel', function (event) {\n", " if (event.deltaY < 0) {\n", " event.step = 1;\n", " } else {\n", " event.step = -1;\n", " }\n", " on_mouse_event_closure('scroll')(event);\n", " });\n", "\n", " canvas_div.appendChild(canvas);\n", " canvas_div.appendChild(rubberband_canvas);\n", "\n", " this.rubberband_context = rubberband_canvas.getContext('2d');\n", " this.rubberband_context.strokeStyle = '#000000';\n", "\n", " this._resize_canvas = function (width, height, forward) {\n", " if (forward) {\n", " canvas_div.style.width = width + 'px';\n", " canvas_div.style.height = height + 'px';\n", " }\n", " };\n", "\n", " // Disable right mouse context menu.\n", " canvas_div.addEventListener('contextmenu', function (_e) {\n", " event.preventDefault();\n", " return false;\n", " });\n", "\n", " function set_focus() {\n", " canvas.focus();\n", " canvas_div.focus();\n", " }\n", "\n", " window.setTimeout(set_focus, 100);\n", "};\n", "\n", "mpl.figure.prototype._init_toolbar = function () {\n", " var fig = this;\n", "\n", " var toolbar = document.createElement('div');\n", " toolbar.classList = 'mpl-toolbar';\n", " this.root.appendChild(toolbar);\n", "\n", " function on_click_closure(name) {\n", " return function (_event) {\n", " return fig.toolbar_button_onclick(name);\n", " };\n", " }\n", "\n", " function on_mouseover_closure(tooltip) {\n", " return function (event) {\n", " if (!event.currentTarget.disabled) {\n", " return fig.toolbar_button_onmouseover(tooltip);\n", " }\n", " };\n", " }\n", "\n", " fig.buttons = {};\n", " var buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'mpl-button-group';\n", " for (var toolbar_ind in mpl.toolbar_items) {\n", " var name = mpl.toolbar_items[toolbar_ind][0];\n", " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", " var image = mpl.toolbar_items[toolbar_ind][2];\n", " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", "\n", " if (!name) {\n", " /* Instead of a spacer, we start a new button group. */\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", " buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'mpl-button-group';\n", " continue;\n", " }\n", "\n", " var button = (fig.buttons[name] = document.createElement('button'));\n", " button.classList = 'mpl-widget';\n", " button.setAttribute('role', 'button');\n", " button.setAttribute('aria-disabled', 'false');\n", " button.addEventListener('click', on_click_closure(method_name));\n", " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", "\n", " var icon_img = document.createElement('img');\n", " icon_img.src = '_images/' + image + '.png';\n", " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", " icon_img.alt = tooltip;\n", " button.appendChild(icon_img);\n", "\n", " buttonGroup.appendChild(button);\n", " }\n", "\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", "\n", " var fmt_picker = document.createElement('select');\n", " fmt_picker.classList = 'mpl-widget';\n", " toolbar.appendChild(fmt_picker);\n", " this.format_dropdown = fmt_picker;\n", "\n", " for (var ind in mpl.extensions) {\n", " var fmt = mpl.extensions[ind];\n", " var option = document.createElement('option');\n", " option.selected = fmt === mpl.default_extension;\n", " option.innerHTML = fmt;\n", " fmt_picker.appendChild(option);\n", " }\n", "\n", " var status_bar = document.createElement('span');\n", " status_bar.classList = 'mpl-message';\n", " toolbar.appendChild(status_bar);\n", " this.message = status_bar;\n", "};\n", "\n", "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", " // which will in turn request a refresh of the image.\n", " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", "};\n", "\n", "mpl.figure.prototype.send_message = function (type, properties) {\n", " properties['type'] = type;\n", " properties['figure_id'] = this.id;\n", " this.ws.send(JSON.stringify(properties));\n", "};\n", "\n", "mpl.figure.prototype.send_draw_message = function () {\n", " if (!this.waiting) {\n", " this.waiting = true;\n", " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", " var format_dropdown = fig.format_dropdown;\n", " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", " fig.ondownload(fig, format);\n", "};\n", "\n", "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", " var size = msg['size'];\n", " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", " fig._resize_canvas(size[0], size[1], msg['forward']);\n", " fig.send_message('refresh', {});\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", " var x0 = msg['x0'] / fig.ratio;\n", " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", " var x1 = msg['x1'] / fig.ratio;\n", " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", " x0 = Math.floor(x0) + 0.5;\n", " y0 = Math.floor(y0) + 0.5;\n", " x1 = Math.floor(x1) + 0.5;\n", " y1 = Math.floor(y1) + 0.5;\n", " var min_x = Math.min(x0, x1);\n", " var min_y = Math.min(y0, y1);\n", " var width = Math.abs(x1 - x0);\n", " var height = Math.abs(y1 - y0);\n", "\n", " fig.rubberband_context.clearRect(\n", " 0,\n", " 0,\n", " fig.canvas.width / fig.ratio,\n", " fig.canvas.height / fig.ratio\n", " );\n", "\n", " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", "};\n", "\n", "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", " // Updates the figure title.\n", " fig.header.textContent = msg['label'];\n", "};\n", "\n", "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", " fig.canvas_div.style.cursor = msg['cursor'];\n", "};\n", "\n", "mpl.figure.prototype.handle_message = function (fig, msg) {\n", " fig.message.textContent = msg['message'];\n", "};\n", "\n", "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", " // Request the server to send over a new figure.\n", " fig.send_draw_message();\n", "};\n", "\n", "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", " fig.image_mode = msg['mode'];\n", "};\n", "\n", "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", " for (var key in msg) {\n", " if (!(key in fig.buttons)) {\n", " continue;\n", " }\n", " fig.buttons[key].disabled = !msg[key];\n", " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", " if (msg['mode'] === 'PAN') {\n", " fig.buttons['Pan'].classList.add('active');\n", " fig.buttons['Zoom'].classList.remove('active');\n", " } else if (msg['mode'] === 'ZOOM') {\n", " fig.buttons['Pan'].classList.remove('active');\n", " fig.buttons['Zoom'].classList.add('active');\n", " } else {\n", " fig.buttons['Pan'].classList.remove('active');\n", " fig.buttons['Zoom'].classList.remove('active');\n", " }\n", "};\n", "\n", "mpl.figure.prototype.updated_canvas_event = function () {\n", " // Called whenever the canvas gets updated.\n", " this.send_message('ack', {});\n", "};\n", "\n", "// A function to construct a web socket function for onmessage handling.\n", "// Called in the figure constructor.\n", "mpl.figure.prototype._make_on_message_function = function (fig) {\n", " return function socket_on_message(evt) {\n", " if (evt.data instanceof Blob) {\n", " var img = evt.data;\n", " if (img.type !== 'image/png') {\n", " /* FIXME: We get \"Resource interpreted as Image but\n", " * transferred with MIME type text/plain:\" errors on\n", " * Chrome. But how to set the MIME type? It doesn't seem\n", " * to be part of the websocket stream */\n", " img.type = 'image/png';\n", " }\n", "\n", " /* Free the memory for the previous frames */\n", " if (fig.imageObj.src) {\n", " (window.URL || window.webkitURL).revokeObjectURL(\n", " fig.imageObj.src\n", " );\n", " }\n", "\n", " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", " img\n", " );\n", " fig.updated_canvas_event();\n", " fig.waiting = false;\n", " return;\n", " } else if (\n", " typeof evt.data === 'string' &&\n", " evt.data.slice(0, 21) === 'data:image/png;base64'\n", " ) {\n", " fig.imageObj.src = evt.data;\n", " fig.updated_canvas_event();\n", " fig.waiting = false;\n", " return;\n", " }\n", "\n", " var msg = JSON.parse(evt.data);\n", " var msg_type = msg['type'];\n", "\n", " // Call the \"handle_{type}\" callback, which takes\n", " // the figure and JSON message as its only arguments.\n", " try {\n", " var callback = fig['handle_' + msg_type];\n", " } catch (e) {\n", " console.log(\n", " \"No handler for the '\" + msg_type + \"' message type: \",\n", " msg\n", " );\n", " return;\n", " }\n", "\n", " if (callback) {\n", " try {\n", " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", " callback(fig, msg);\n", " } catch (e) {\n", " console.log(\n", " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", " e,\n", " e.stack,\n", " msg\n", " );\n", " }\n", " }\n", " };\n", "};\n", "\n", "function getModifiers(event) {\n", " var mods = [];\n", " if (event.ctrlKey) {\n", " mods.push('ctrl');\n", " }\n", " if (event.altKey) {\n", " mods.push('alt');\n", " }\n", " if (event.shiftKey) {\n", " mods.push('shift');\n", " }\n", " if (event.metaKey) {\n", " mods.push('meta');\n", " }\n", " return mods;\n", "}\n", "\n", "/*\n", " * return a copy of an object with only non-object keys\n", " * we need this to avoid circular references\n", " * https://stackoverflow.com/a/24161582/3208463\n", " */\n", "function simpleKeys(original) {\n", " return Object.keys(original).reduce(function (obj, key) {\n", " if (typeof original[key] !== 'object') {\n", " obj[key] = original[key];\n", " }\n", " return obj;\n", " }, {});\n", "}\n", "\n", "mpl.figure.prototype.mouse_event = function (event, name) {\n", " if (name === 'button_press') {\n", " this.canvas.focus();\n", " this.canvas_div.focus();\n", " }\n", "\n", " // from https://stackoverflow.com/q/1114465\n", " var boundingRect = this.canvas.getBoundingClientRect();\n", " var x = (event.clientX - boundingRect.left) * this.ratio;\n", " var y = (event.clientY - boundingRect.top) * this.ratio;\n", "\n", " this.send_message(name, {\n", " x: x,\n", " y: y,\n", " button: event.button,\n", " step: event.step,\n", " modifiers: getModifiers(event),\n", " guiEvent: simpleKeys(event),\n", " });\n", "\n", " return false;\n", "};\n", "\n", "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", " // Handle any extra behaviour associated with a key event\n", "};\n", "\n", "mpl.figure.prototype.key_event = function (event, name) {\n", " // Prevent repeat events\n", " if (name === 'key_press') {\n", " if (event.key === this._key) {\n", " return;\n", " } else {\n", " this._key = event.key;\n", " }\n", " }\n", " if (name === 'key_release') {\n", " this._key = null;\n", " }\n", "\n", " var value = '';\n", " if (event.ctrlKey && event.key !== 'Control') {\n", " value += 'ctrl+';\n", " }\n", " else if (event.altKey && event.key !== 'Alt') {\n", " value += 'alt+';\n", " }\n", " else if (event.shiftKey && event.key !== 'Shift') {\n", " value += 'shift+';\n", " }\n", "\n", " value += 'k' + event.key;\n", "\n", " this._key_event_extra(event, name);\n", "\n", " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", " return false;\n", "};\n", "\n", "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", " if (name === 'download') {\n", " this.handle_save(this, null);\n", " } else {\n", " this.send_message('toolbar_button', { name: name });\n", " }\n", "};\n", "\n", "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", " this.message.textContent = tooltip;\n", "};\n", "\n", "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", "// prettier-ignore\n", "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o\", \"download\"]];\n", "\n", "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\", \"webp\"];\n", "\n", "mpl.default_extension = \"png\";/* global mpl */\n", "\n", "var comm_websocket_adapter = function (comm) {\n", " // Create a \"websocket\"-like object which calls the given IPython comm\n", " // object with the appropriate methods. Currently this is a non binary\n", " // socket, so there is still some room for performance tuning.\n", " var ws = {};\n", "\n", " ws.binaryType = comm.kernel.ws.binaryType;\n", " ws.readyState = comm.kernel.ws.readyState;\n", " function updateReadyState(_event) {\n", " if (comm.kernel.ws) {\n", " ws.readyState = comm.kernel.ws.readyState;\n", " } else {\n", " ws.readyState = 3; // Closed state.\n", " }\n", " }\n", " comm.kernel.ws.addEventListener('open', updateReadyState);\n", " comm.kernel.ws.addEventListener('close', updateReadyState);\n", " comm.kernel.ws.addEventListener('error', updateReadyState);\n", "\n", " ws.close = function () {\n", " comm.close();\n", " };\n", " ws.send = function (m) {\n", " //console.log('sending', m);\n", " comm.send(m);\n", " };\n", " // Register the callback with on_msg.\n", " comm.on_msg(function (msg) {\n", " //console.log('receiving', msg['content']['data'], msg);\n", " var data = msg['content']['data'];\n", " if (data['blob'] !== undefined) {\n", " data = {\n", " data: new Blob(msg['buffers'], { type: data['blob'] }),\n", " };\n", " }\n", " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", " ws.onmessage(data);\n", " });\n", " return ws;\n", "};\n", "\n", "mpl.mpl_figure_comm = function (comm, msg) {\n", " // This is the function which gets called when the mpl process\n", " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", "\n", " var id = msg.content.data.id;\n", " // Get hold of the div created by the display call when the Comm\n", " // socket was opened in Python.\n", " var element = document.getElementById(id);\n", " var ws_proxy = comm_websocket_adapter(comm);\n", "\n", " function ondownload(figure, _format) {\n", " window.open(figure.canvas.toDataURL());\n", " }\n", "\n", " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", "\n", " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", " // web socket which is closed, not our websocket->open comm proxy.\n", " ws_proxy.onopen();\n", "\n", " fig.parent_element = element;\n", " fig.cell_info = mpl.find_output_cell(\"
\");\n", " if (!fig.cell_info) {\n", " console.error('Failed to find cell for figure', id, fig);\n", " return;\n", " }\n", " fig.cell_info[0].output_area.element.on(\n", " 'cleared',\n", " { fig: fig },\n", " fig._remove_fig_handler\n", " );\n", "};\n", "\n", "mpl.figure.prototype.handle_close = function (fig, msg) {\n", " var width = fig.canvas.width / fig.ratio;\n", " fig.cell_info[0].output_area.element.off(\n", " 'cleared',\n", " fig._remove_fig_handler\n", " );\n", " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", "\n", " // Update the output cell to use the data from the current canvas.\n", " fig.push_to_output();\n", " var dataURL = fig.canvas.toDataURL();\n", " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", " // the notebook keyboard shortcuts fail.\n", " IPython.keyboard_manager.enable();\n", " fig.parent_element.innerHTML =\n", " '';\n", " fig.close_ws(fig, msg);\n", "};\n", "\n", "mpl.figure.prototype.close_ws = function (fig, msg) {\n", " fig.send_message('closing', msg);\n", " // fig.ws.close()\n", "};\n", "\n", "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", " // Turn the data on the canvas into data in the output cell.\n", " var width = this.canvas.width / this.ratio;\n", " var dataURL = this.canvas.toDataURL();\n", " this.cell_info[1]['text/html'] =\n", " '';\n", "};\n", "\n", "mpl.figure.prototype.updated_canvas_event = function () {\n", " // Tell IPython that the notebook contents must change.\n", " IPython.notebook.set_dirty(true);\n", " this.send_message('ack', {});\n", " var fig = this;\n", " // Wait a second, then push the new image to the DOM so\n", " // that it is saved nicely (might be nice to debounce this).\n", " setTimeout(function () {\n", " fig.push_to_output();\n", " }, 1000);\n", "};\n", "\n", "mpl.figure.prototype._init_toolbar = function () {\n", " var fig = this;\n", "\n", " var toolbar = document.createElement('div');\n", " toolbar.classList = 'btn-toolbar';\n", " this.root.appendChild(toolbar);\n", "\n", " function on_click_closure(name) {\n", " return function (_event) {\n", " return fig.toolbar_button_onclick(name);\n", " };\n", " }\n", "\n", " function on_mouseover_closure(tooltip) {\n", " return function (event) {\n", " if (!event.currentTarget.disabled) {\n", " return fig.toolbar_button_onmouseover(tooltip);\n", " }\n", " };\n", " }\n", "\n", " fig.buttons = {};\n", " var buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'btn-group';\n", " var button;\n", " for (var toolbar_ind in mpl.toolbar_items) {\n", " var name = mpl.toolbar_items[toolbar_ind][0];\n", " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", " var image = mpl.toolbar_items[toolbar_ind][2];\n", " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", "\n", " if (!name) {\n", " /* Instead of a spacer, we start a new button group. */\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", " buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'btn-group';\n", " continue;\n", " }\n", "\n", " button = fig.buttons[name] = document.createElement('button');\n", " button.classList = 'btn btn-default';\n", " button.href = '#';\n", " button.title = name;\n", " button.innerHTML = '';\n", " button.addEventListener('click', on_click_closure(method_name));\n", " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", " buttonGroup.appendChild(button);\n", " }\n", "\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", "\n", " // Add the status bar.\n", " var status_bar = document.createElement('span');\n", " status_bar.classList = 'mpl-message pull-right';\n", " toolbar.appendChild(status_bar);\n", " this.message = status_bar;\n", "\n", " // Add the close button to the window.\n", " var buttongrp = document.createElement('div');\n", " buttongrp.classList = 'btn-group inline pull-right';\n", " button = document.createElement('button');\n", " button.classList = 'btn btn-mini btn-primary';\n", " button.href = '#';\n", " button.title = 'Stop Interaction';\n", " button.innerHTML = '';\n", " button.addEventListener('click', function (_evt) {\n", " fig.handle_close(fig, {});\n", " });\n", " button.addEventListener(\n", " 'mouseover',\n", " on_mouseover_closure('Stop Interaction')\n", " );\n", " buttongrp.appendChild(button);\n", " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", "};\n", "\n", "mpl.figure.prototype._remove_fig_handler = function (event) {\n", " var fig = event.data.fig;\n", " if (event.target !== this) {\n", " // Ignore bubbled events from children.\n", " return;\n", " }\n", " fig.close_ws(fig, {});\n", "};\n", "\n", "mpl.figure.prototype._root_extra_style = function (el) {\n", " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", "};\n", "\n", "mpl.figure.prototype._canvas_extra_style = function (el) {\n", " // this is important to make the div 'focusable\n", " el.setAttribute('tabindex', 0);\n", " // reach out to IPython and tell the keyboard manager to turn it's self\n", " // off when our div gets focus\n", "\n", " // location in version 3\n", " if (IPython.notebook.keyboard_manager) {\n", " IPython.notebook.keyboard_manager.register_events(el);\n", " } else {\n", " // location in version 2\n", " IPython.keyboard_manager.register_events(el);\n", " }\n", "};\n", "\n", "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", " // Check for shift+enter\n", " if (event.shiftKey && event.which === 13) {\n", " this.canvas_div.blur();\n", " // select the cell after this one\n", " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", " IPython.notebook.select(index + 1);\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", " fig.ondownload(fig, null);\n", "};\n", "\n", "mpl.find_output_cell = function (html_output) {\n", " // Return the cell and output element which can be found *uniquely* in the notebook.\n", " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", " // IPython event is triggered only after the cells have been serialised, which for\n", " // our purposes (turning an active figure into a static one), is too late.\n", " var cells = IPython.notebook.get_cells();\n", " var ncells = cells.length;\n", " for (var i = 0; i < ncells; i++) {\n", " var cell = cells[i];\n", " if (cell.cell_type === 'code') {\n", " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", " var data = cell.output_area.outputs[j];\n", " if (data.data) {\n", " // IPython >= 3 moved mimebundle to data attribute of output\n", " data = data.data;\n", " }\n", " if (data['text/html'] === html_output) {\n", " return [cell, data, j];\n", " }\n", " }\n", " }\n", " }\n", "};\n", "\n", "// Register the function which deals with the matplotlib target/channel.\n", "// The kernel may be null if the page has been refreshed.\n", "if (IPython.notebook.kernel !== null) {\n", " IPython.notebook.kernel.comm_manager.register_target(\n", " 'matplotlib',\n", " mpl.mpl_figure_comm\n", " );\n", "}\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# magic command\n", "%matplotlib notebook \n", "\n", "x_values = np.arange(0, 2*np.pi, 0.05)\n", "y_sin = np.sin(x_values)\n", "y_cos = np.cos(x_values)\n", "\n", "# plt.figure(figsize= (5, 5), facecolor= 'w', edgecolor= 'k')\n", "plt.plot(x_values, y_sin, x_values, y_cos)\n", "plt.xlabel('x-axis label')\n", "plt.ylabel('y-axix label')\n", "plt.title('Sine and Cosine Plot')\n", "plt.legend(['sin(x)', 'cos(x)'])\n", "plt.axis([0, 2*np.pi, -1.5, 1.5])\n", "plt.grid(True)\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "64b15037", "metadata": {}, "source": [ "We can also control line properties:" ] }, { "cell_type": "code", "execution_count": 65, "id": "8d062a53", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "(x1, y1) = ([1, 2, 3, 4], random.sample(range(0, 5), 4))\n", "(x2, y2) = ([1, 2, 3, 4], random.sample(range(0, 5), 4))\n", "(x3, y3) = ([1, 2, 3, 4], random.sample(range(0, 5), 4))\n", "\n", "#plt.figure(figsize= (5, 6))\n", "line1 = plt.plot(x1, y1)\n", "line2 = plt.plot(x2, y2)\n", "line3 = plt.plot(x3, y3)\n", "\n", "plt.setp(line1, color= 'r', linewidth= 1.5, linestyle= '--')\n", "plt.setp(line2, color= 'b', linewidth= 1.5, marker= 'x')\n", "plt.setp(line3, color= 'g', linewidth= 1.5, marker= 'D')\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "49ee2230", "metadata": {}, "source": [ "We can plot different things in the same figure using the subplot function." ] }, { "cell_type": "code", "execution_count": 67, "id": "1a59ba77", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Subplot\n", "plt.subplot(2, 1, 1)\n", "plt.plot(x1, y1, color= 'b')\n", "plt.subplot(2, 1, 2)\n", "plt.plot(x2, y2, color= 'r')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 69, "id": "982f2617", "metadata": { "scrolled": false }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Bar plot\n", "\n", "x = [\"A\", \"B\", \"C\", \"D\", \"E\"]\n", "y = [5, 3, 1, 4, 7]\n", "\n", "plt.bar(x,y)\n", "plt.show()" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.5" } }, "nbformat": 4, "nbformat_minor": 5 }