code/Python-Overview.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0cd0ea69",
   "metadata": {},
   "source": [
    "Python is a popular programming language for processing text data. It is also relatively easy to learn to do some basic text analysis in Python ([\"We chose Python because it has a shallow learning curve, its syntax and semantics are transparent, and it has good string-handling functionality.\"](https://www.nltk.org/book/ch00.html)). It is free and available on all the major operating systems, with a lot of support ecosystem. So, I will use Python in this course, and this \"Notebook\" illustrates some basic functionalities of Python. Check out https://www.python.org/about/gettingstarted/ for how to install Python. \n",
    "\n",
    "There are many ways of writing python code and running it on your computer. Some people write the code from their terminal, in a plain text format. Some use Integrated Development Environments (e.g., PyCharm, Spyder, Atom). More recently, people are using interactive environments called \"Notebook\" (e.g., Jupyter, Google Colab) etc. This is a Jupyter Notebook.\n",
    "\n",
    "The goal of this notebook is to introduce some basic Python concepts. \n",
    "\n",
    "Readings: Chapters 1--10 in [Python for Everybody book](https://www.py4e.com/html3/) \n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2339f27",
   "metadata": {},
   "source": [
    "# Variables\n",
    "\n",
    "(Chapter 1-2 in py4e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d92904d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# These two lines below tell us what version of Python are we using. Sometimes, this is important to know. \n",
    "import sys\n",
    "print(sys.version)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ddd13a78",
   "metadata": {},
   "outputs": [],
   "source": [
    "#print() is a useful first function to know. \n",
    "print(\"Hello!\")\n",
    "print(\"\\\"Hello!\\\"\")\n",
    "\n",
    "print(2+3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e030a93",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python can also \"remember\" a bit.\n",
    "x=2\n",
    "print(x)\n",
    "y=x*3\n",
    "print(y)\n",
    "\n",
    "\"\"\"\n",
    "In these 4 lines, x and y are \"variables\" and we are assigning some values to them. print is a \"function\". \n",
    "x=2 is a statement which assigns the value 2 to x. print() is also a statement. \n",
    "A statement is a unit of code that is executed. \n",
    "\n",
    "* is an operator. \n",
    "\n",
    "triple quotes are for multi-line comments. \n",
    "# is for single line comment. \n",
    "\"\"\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae3ff188",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Type of a variable can be known using the built in \"type\" function.\n",
    "\n",
    "x = \"123\"\n",
    "print(type(x))\n",
    "x = 1\n",
    "print(type(x))\n",
    "print(type(3.2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "325811de",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "When you type a large integer, you might be tempted to use commas between groups of three digits, \n",
    "as in 1,000,000. This is not an integer in Python, but it won't throw an error either:\n",
    "\"\"\"\n",
    "print(1,000,000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dca91c04",
   "metadata": {},
   "source": [
    "I am using x and y, but you can have any names for your variables, as long as you follow Python's naming rules.\n",
    "- They can contain both letters and numbers, but they cannot start with a number.  \n",
    "- Don't use one of [python's 35 \"keywords\"](https://www.w3schools.com/python/python_ref_keywords.asp) as your variable names.\n",
    "- Variables need to be defined first, before they can be used. \n",
    "\n",
    "Try running the lines below, and see what errors you get. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb8304b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "76trombones = 'big parade'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2099d77e",
   "metadata": {},
   "outputs": [],
   "source": [
    "more@ = 1000000\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0000c1d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class = 'Advanced Theoretical Zymurgy'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bc9c582",
   "metadata": {},
   "outputs": [],
   "source": [
    "principal = 327.68\n",
    "interest = principle * rate"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e4f259d",
   "metadata": {},
   "source": [
    "# Operators, Conditions and Loops\n",
    "\n",
    "(Chapter 3 and 5 in Py4E)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbcb4332",
   "metadata": {},
   "outputs": [],
   "source": [
    "# the Boolean operator == compares two operands and produces True if they are equal and False otherwise\n",
    "5 == 5\n",
    "\"And\" == \"and\"\n",
    "\n",
    "x=3\n",
    "y=2\n",
    "print(x >= y)\n",
    "\n",
    "#note: you cannot compare two variables of different types like this. \n",
    "z=\"a\"\n",
    "print(x >=z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8e390aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Logical operators:\n",
    "\n",
    "a=3\n",
    "b=4\n",
    "c=5\n",
    "print(a>b and b>c)\n",
    "print(a<b and b<c)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c7a342c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conditions:\n",
    "if x > 0 :\n",
    "    print('x is positive')\n",
    "    print(x)\n",
    "else:\n",
    "    print('x is not positive')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8245ce00",
   "metadata": {},
   "source": [
    "Where did this x come from? I did not declare it in this block. But it was declared earlier in this notebook. \n",
    "You can clear outputs of previous cells. If you clear it all, and run the above cell again, you will get an error, \n",
    "because there won't be a variable x."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6db12f3c",
   "metadata": {},
   "source": [
    "Note the indentation. That is Python's way of grouping the code (some other languages use parantheses etc.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe669acc",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = -12\n",
    "if x > 0 :\n",
    "    print('x is positive')\n",
    "    print(x)\n",
    "else:\n",
    "    print('x is not positive')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c93c465",
   "metadata": {},
   "source": [
    "You can write chained conditionals (if, elif, else) or nested conditionals (a conditional inside another conditional) too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19e03421",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Catching errors and acting on them.\n",
    "while True: #While is a keyword used to implement a loop.\n",
    "    inp = input('Enter Fahrenheit Temperature:')\n",
    "    #this takes input from the user. \n",
    "    try:\n",
    "        if inp == \"exit\":\n",
    "            print(\"Exiting this loop\")\n",
    "            break #Breaks out of the loop if we enter \"exit\"\n",
    "        fahr = float(inp)\n",
    "        cel = (fahr - 32.0) * 5.0 / 9.0\n",
    "        print(cel)\n",
    "    except:\n",
    "        print('Not a valid number. Please enter a valid number')\n",
    "\n",
    "# Code slightly edited from: http://www.py4e.com/code3/fahren2.py"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c31abdc5",
   "metadata": {},
   "source": [
    "Loops are used to iterate through a piece of code (e.g., process a list of numbers or strings, enumerate a large list of items etc).  You can use a \"for\" loop or a \"while\" loop in Python. You can \"break\" out of a loop, or \"continue\". You can also easily fall into an infinite loop that never stops, if you make an error in programming your loop.\n",
    "\n",
    "Read [Chapter 5 in Py4e](https://www.py4e.com/html3/05-iterations) to get a good picture of what loops are and how to implement them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93d833b5",
   "metadata": {},
   "source": [
    "### Programming Exercise\n",
    "\n",
    "Do the exercises 1--3 in Chapter 3 and 1--2 in Chapter 5 of Py4E for practice."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d45bc9c7",
   "metadata": {},
   "source": [
    "# Functions\n",
    "\n",
    "Chapter 4 in Py4E\n",
    "\n",
    "We repeated the same chunk of code twice in the two blocks that illustrated conditionals. Such repetitive code can be made into a \"Function\" for reuse. Stuff like \"print\" and \"type\" that we saw so far are built-in Python functions (there are several of them, and there are many more pre-implemented ones which we can install as libraries, import into our code and use)\n",
    "\n",
    "functions are defined using the def keyword.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "809e194b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Here is a small function which takes a value and prints whether it is a positive or negative integer. \n",
    "def isPositive(x):\n",
    "    if type(x) == int:\n",
    "        if x > 0 :\n",
    "            print('x is positive')\n",
    "        else:\n",
    "            print('x is not positive')\n",
    "    else:\n",
    "        print(\"x is not an integer. So, there is no positive or negative.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1fe53ec8",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 24\n",
    "isPositive(x)\n",
    "x = \"a\"\n",
    "isPositive(x)\n",
    "x = -2\n",
    "isPositive(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3eea4086",
   "metadata": {},
   "source": [
    "Functions can sometimes \"return\" something instead of just printing outputs, which can be put to use for something else later. For example, consider the built-in function len. It returns an integer - length of the variable it takes as an input \"argument\". The following snippet illustrates how it works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e889e2b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"trial\"\n",
    "print(len(x))\n",
    "y = len(x)\n",
    "print(y > 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5452941f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now, let me change the \"isPositive\" function to \"return\" something.\n",
    "#Here is a small function which takes a value and prints whether it is a positive or negative integer. \n",
    "def isPositive(x):\n",
    "    if type(x) == int:\n",
    "        if x > 0 :\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "    else:\n",
    "        print(\"x is not an integer. So, there is no positive or negative.\")\n",
    "        return None  #None is used to define a Null value in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ceba9259",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "if isPositive(x):\n",
    "    print(\"We will see this message\")\n",
    "else:\n",
    "    print(\"We won't see this message as long as we don't change x\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6580b97",
   "metadata": {},
   "source": [
    "## Exercise:\n",
    "\n",
    "Read the Chapter 4 in Py4E and do the exercises in the end. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20967f53",
   "metadata": {},
   "source": [
    "# Reading and Writing text in python\n",
    "\n",
    "Chapter 7 in Py4E\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ef5276e",
   "metadata": {},
   "source": [
    "When we want to read or write existing files (e.g., on your hard drive), we first must open it. Opening the file communicates with your operating system, which knows where the data for each file is stored. When you open a file, you are asking the operating system to find the file by name and make sure the file exists. In this example, we open the file mbox.txt, which should be stored in the same folder that you are in when you start Python. You can download this file from www.py4e.com/code3/mbox.txt\n",
    "\n",
    "Once you download the file and store it in the same folder as this Notebook, run the following code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74b9ca6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "fhand = open('mbox.txt')\n",
    "print(fhand)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b631667",
   "metadata": {},
   "source": [
    "If the open is successful, the operating system returns us a file handle. The file handle is not the actual data contained in the file, but instead it is a “handle” that we can use to read the data. You are given a handle if the requested file exists and you have the proper permissions to read the file.\n",
    "\n",
    "Now, let us print the first 10 lines of the file. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f91889c",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,10):\n",
    "    print(fhand.readline())\n",
    "fhand.close() #closes the file we opened. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc44f0a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "fhand = open('mbox.txt')\n",
    "entire_contents = fhand.read()\n",
    "print(len(entire_contents)) #prints length in number of characters.\n",
    "fhand.close()\n",
    "\n",
    "fhand = open('mbox.txt')\n",
    "entire_contents = fhand.readlines()\n",
    "print(len(entire_contents)) #prints length in number of lines.\n",
    "fhand.close()\n",
    "\n",
    "#Why did I open the file twice here?? \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "284960a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Writing into files.\n",
    "\n",
    "fhand = open(\"temp.txt\", \"w\")\n",
    "\n",
    "for i in range(0,10):\n",
    "    fhand.write(\"a line\")\n",
    "    fhand.write(\"\\n\")\n",
    "\n",
    "fhand.close()\n",
    "\n",
    "#Now, you will see a file temp.txt in this folder on your hard disk, with \"a line\" printed 10 times. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "718cf82b",
   "metadata": {},
   "source": [
    "These are just a few basic file operations. Encoding of the text file can play an important role while handling text with accents, other scripts etc.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "475a104d",
   "metadata": {},
   "source": [
    "# Python's data structures: Strings, Lists, Dictionaries, Tuples\n",
    "\n",
    "Chapters 6, 8, 9, 10 in Py4E"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83853355",
   "metadata": {},
   "source": [
    "## Strings\n",
    "\n",
    "A string is a sequence of characters. You can access the characters one at a time with the bracket operator, by its index (starts at 0, not at 1, as you may have noticed earlier). We can traverse the string with a loop, \"slice\" a string, use some built-in string functions to do other operations on it, compare two strings etc.\n",
    "\n",
    "Here are some examples. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "843a1ac0",
   "metadata": {},
   "outputs": [],
   "source": [
    "mystr = \"banana\"\n",
    "\n",
    "#accesses characters by index:\n",
    "print(mystr[0])\n",
    "print(mystr[1])\n",
    "print(mystr[-1]) #not an error. See what happens\n",
    "print(mystr[12]) #error, because string isn't that long.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a564faca",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#length of the string\n",
    "print(len(mystr))\n",
    "\n",
    "#prints all characters in the string one by one\n",
    "for character in mystr:\n",
    "    print(character)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e332007a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#slicing a string:\n",
    "s = 'Monty Python'\n",
    "print(s[0:5])\n",
    "print(s[6:12])\n",
    "\n",
    "#If you omit the first index (before the colon), the slice starts at the beginning of the string. \n",
    "#If you omit the second index, the slice goes to the end of the string:\n",
    "print(s[:4])\n",
    "print(s[7:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40ad8687",
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"in\" operator\n",
    "\"on\" in s #checks if the substring \"on\" appears in s (\"Monty Python\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33fe29e5",
   "metadata": {},
   "source": [
    "There are a lot of pre-implemented string methods (i.e., functions that are tied to specific objects like strings).\n",
    "Some examples are in the [Python documentation](https://docs.python.org/3/library/stdtypes.html#string-methods). Here are a few:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4003aff5",
   "metadata": {},
   "outputs": [],
   "source": [
    "mystr = \"This is a string with some spaces, commas, and a full stop.\"\n",
    "print(mystr.upper())\n",
    "print(mystr.find(\"is\"))\n",
    "print(mystr.startswith(\"This\"))\n",
    "print(mystr.endswith(\"This\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd962c56",
   "metadata": {},
   "source": [
    "There are a lot more. string is a useful data structure while working with NLP, for obvious reasons. Check out Chapter 6 in Py4E for a more detailed introduction, and try doing those exercies."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55a76bb9",
   "metadata": {},
   "source": [
    "## Lists in Python\n",
    "\n",
    "Chapter 8 in Py4E\n",
    "\n",
    "Like a string, a list is a sequence of values. In a string, the values are characters; in a list, they can be any type. The values in list are called elements or sometimes items.\n",
    "\n",
    "There are several ways to create a new list; the simplest is to enclose the elements in square brackets []:\n",
    "\n",
    "We can use a loop to traverse a list, we can change elements in a list, and we can use a list within a list. We can concatenate two lists, append an item to a list, extend a list, slice it, and do a lot more! \n",
    "\n",
    "Lists are another very useful data structure while dealing with textual data. A string can also be made into a list of characters. \n",
    "\n",
    "Here are a few examples of using a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f41b34cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "mystr = \"This is a string with some spaces, commas, and a full stop.\"\n",
    "mylist = mystr.split(\" \") #splitting the string into a list, by space character\n",
    "\n",
    "print(len(mylist))\n",
    "print(mylist[2:6])\n",
    "\n",
    "for i in range(0, len(mylist)):\n",
    "    print(mylist[i])\n",
    "    \n",
    "for i in mylist:\n",
    "    print(i)\n",
    "    \n",
    "mylist.append(\"adding this\")\n",
    "print(mylist)\n",
    "\n",
    "mylist.append([\"adding\", \"this\"])\n",
    "print(mylist)\n",
    "\n",
    "mylist.extend([\"adding\", \"this\"])\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a29cc027",
   "metadata": {},
   "outputs": [],
   "source": [
    "alist = [1,2,3]\n",
    "blist = [\"a\",\"b\",\"c\"]\n",
    "print(alist+blist)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18908365",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(blist*3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "501b8160",
   "metadata": {},
   "outputs": [],
   "source": [
    "mystr = \"This is an example\"\n",
    "mylist = mystr.split(\" \")\n",
    "mystr2 = \" \".join(mylist)\n",
    "print(mystr)\n",
    "print(mylist)\n",
    "print(mystr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f28edaa4",
   "metadata": {},
   "source": [
    "There is ofcourse, a lot more than what I quickly introduced. Read Chapter 7 in Py4E and do the exercises. We can have some discussion early next week on these."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb586dcc",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "\n",
    "You can think of a dictionary as a mapping between a set of indices (which are called keys) and a set of values. Each key maps to a value. The association of a key and a value is called a key-value pair or sometimes an item.\n",
    "\n",
    "As an example, we’ll build a dictionary that maps users with their email addresses.\n",
    "\n",
    "The function dict creates a new dictionary with no items. Because dict is the name of a built-in function, you should avoid using it as a variable name.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ab2848c",
   "metadata": {},
   "outputs": [],
   "source": [
    "emailmap = dict()\n",
    "print(emailmap)\n",
    "\n",
    "emailmap[\"user1\"] = \"user1@email.com\"\n",
    "emailmap[\"user2\"] = \"user2@email.com\"\n",
    "print(emailmap)\n",
    "\n",
    "emailmap.update({\"user3\":\"user3@gmail.com\", \"user4\":\"user4@gmail.com\"})\n",
    "print(emailmap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75baa06f",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(emailmap[\"user1\"])\n",
    "print(emailmap[\"user5\"]) #throws an error as there is no user5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c99aeda4",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(emailmap.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e93d4199",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(emailmap.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acc54e62",
   "metadata": {},
   "source": [
    "You can use dictionaries, for example, to count frequency of words in a file (or a bunch of files). You can combine them with other python data structures and their methods, other python functions etc, to build pretty sophisticated programs already! I won't discuss further, but take a look at Chapters 9 and 10 in Py4E to get a fuller picture and try the exercises!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa8730a7",
   "metadata": {},
   "source": [
    "# Concluding remarks:\n",
    "\n",
    "This is a really quick overview of the basics of Python programming. My goal is just to introduce the basic syntax, and the different building blocks of python code. With this, you will already be able to read some of the simpler python programs. In the next part of today's lecture, we will look into installing NLTK, one of the well known text processing libraries, and see how we can use it to do some preliminary corpus analysis. \n",
    "\n",
    "Note: My Python tutorial notes from 2020 are also uploaded with this notebook. "
   ]
  }
 ],
 "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}