code-advanced.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(code-advanced)=\n",
    "# Coding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "This chapter covers more programming, building on {ref}`code-basics`. Some of it will come in useful as you do more in code.\n",
    "\n",
    "This chapter has benefitted from the online book [*Research Software Engineering with Python*](https://merely-useful.github.io/py-rse/), the [official Python documentation](https://www.python.org/), the excellent [30 days of Python](https://github.com/Asabeneh/30-Days-Of-Python), and the [Hitchhiker's Guide to Python](https://docs.python-guide.org/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running on empty\n",
    "\n",
    "Being able to create empty containers is sometimes useful. The commands to create empty lists, tuples, dictionaries, and sets are `lst = []`, `tup=()`, `dic={}`, and `st = set()` respectively.\n",
    "\n",
    "```{admonition} Exercise\n",
    "What is the type of an empty list?\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Casting variables\n",
    "\n",
    "Sometimes we need to explicitly cast a value from one type to another. We can do this using functions like `str()`, `int()`, and `float()`. If you try these, Python will do its best to interpret the input and convert it to the output type you'd like and, if they can't, the code will throw a great big error.\n",
    "\n",
    "Here's an example of casting a `float` as an `int`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "orig_number = 4.39898498\n",
    "type(orig_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we cast it to an int:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mod_number = int(orig_number)\n",
    "mod_number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which looks like it became an integer, but we can double check that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(mod_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples and (im)mutability\n",
    "\n",
    "A tuple is an object that is defined by parentheses and entries that are separated by commas, for example `(15, 20, 32)`. (They are of type `tuple`.) As such, they have a lot in common with lists-but there's a big and important difference.\n",
    "\n",
    "Tuples are immutable, while lists are mutable. This means that, once defined, we can always modify a list using slicing and indexing, e.g. to change the first entry of a list called `listy` we would use `listy[0] = 5`. But trying to do this with a tuple will result in an error.\n",
    "\n",
    "*Immutable* objects, such as tuples, can't have their elements changed, appended, extended, or removed. Lists can do all of these things. Tuples aren't the only immutable objects in Python; strings are immutable too.\n",
    "\n",
    "You may wonder why both are needed given lists seem to provide a superset of functionality: sometimes in coding, lack of flexibility is a *good* thing because it restricts the number of ways a process can go awry. I dare say there are other reasons too, but you don't need to worry about them and using lists is a good default most of the time.\n",
    "\n",
    "````{admonition} Exercise\n",
    "Are the entries in dictionaries mutable or immutable? To help you answer this, a simple dictionary can be defined as\n",
    "\n",
    "```python\n",
    "my_dict = {\"a\": 1, \"b\": 2}\n",
    "```\n",
    "\n",
    "and the values are accessed by `dictionary[key]`, eg `my_dict[\"a\"]` for this example.\n",
    "````"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## While loops\n",
    "\n",
    "`while` loops continue to execute code until their conditional expression evaluates to `False`. (Of course, if it evaluates to `True` forever, your code will just continue to execute...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 10\n",
    "while n > 0:\n",
    "    print(n)\n",
    "    n -= 1\n",
    "\n",
    "print(\"execution complete\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NB: in case you're wondering what `-=` does, it's a compound assignment that sets the left-hand side equal to the left-hand side minus the right-hand side.\n",
    "\n",
    "You can use the keyword `break` to break out of a while loop, for example if it's reached a certain number of iterations without converging.\n",
    "\n",
    "```{admonition} Exercise\n",
    "Making use of `import string` and then `string.ascii_lowercase` to get the characters in the alphabet, write a while loop that iterates backwards through the alphabet (starting at \"z\") before printing \"execution complete\".\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets\n",
    "\n",
    "A set in coding is a collection of unordered and unindexed distinct elements (in analogy to the mathematical definition of a set). To define a set, the two commands are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "st = {}\n",
    "# or\n",
    "st = set()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These aren't very interesting though! Here's a set with some values in:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "people_set = {\"Robinson\", \"Fawcett\", \"Ostrom\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What can we do with it? We can check its length using `len(people_set)` and we can ask whether a particular entry is contained within it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Ostrom\" in people_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add multiple items or another set using `.update()` or `.union()`, or a single item using:\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "people_set.add(\"Martineau\")\n",
    "people_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can remove entries with `.remove(entry_name)` or, to remove only the last entry `.pop()`. You can easily convert between lists and sets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(people_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The real benefits of sets are that they support set operations, though. The most important are `intersection()`,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "st1 = {\"item1\", \"item2\", \"item3\", \"item4\"}\n",
    "st2 = {\"item3\", \"item2\"}\n",
    "st1.intersection(st2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`difference()`,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "st1 = {\"item1\", \"item2\", \"item3\", \"item4\"}\n",
    "st2 = {\"item2\", \"item3\"}\n",
    "st1.difference(st2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and `symmetric_difference()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "st1 = {\"item1\", \"item2\", \"item3\", \"item4\"}\n",
    "st2 = {\"item2\", \"item3\"}\n",
    "st2.symmetric_difference(st1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Truthy and falsy values\n",
    "\n",
    "Python objects can be used in expressions that will return a boolean value, such as when a list, `listy`, is used with `if listy`. Built-in Python objects that are empty are usually evaluated as `False`, and are said to be 'Falsy'. In contrast, when these built-in objects are not empty, they evaluate as `True` and are said to be 'truthy'.\n",
    "\n",
    "(If you are building your own classes, you can define this behaviour for them through the `__bool__` dunder method.)\n",
    "\n",
    "Let's see some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bool_check_var(input_variable):\n",
    "    if not (input_variable):\n",
    "        print(\"Falsy\")\n",
    "    else:\n",
    "        print(\"Truthy\")\n",
    "\n",
    "\n",
    "listy = []\n",
    "other_listy = [1, 2, 3]\n",
    "\n",
    "\n",
    "bool_check_var(listy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool_check_var(other_listy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method we defined doesn't just operate on lists; it'll work for many various other truthy and falsy objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool_check_var(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool_check_var([0, 0, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that zero was falsy, its the nothing of a float, but a list of three zeros is not an empty list, so it evaluates as truthy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool_check_var({})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool_check_var(None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Knowing what is truthy or falsy is useful in practice; imagine you'd like to default to a specific behaviour if a list called `list_vals` doesn't have any values in. You now know you can do it simply with `if list_vals`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambda functions\n",
    "\n",
    "Lambda functions are a very old idea in programming, and are part of the functional programming paradigm. Coding languages tend to be more object-oriented or functional, with the object-oriented approach originating with Alan Turing's \"Turing Machines\" and the functional approach with Alonso Church's \"lambda calculus\". These two approaches are mathematically equivalent and, on a more practical note, high-level programming languages often mix both. As examples, Haskell is strongly a functional language, statistics language R leans toward being more functional, Python is slightly more object oriented, and powerhouse languages like Fortran and C are object-oriented. However, despite being less functional than some languages, Python does have lambda functions, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1243e4e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "plus_one = lambda x: x + 1\n",
    "plus_one(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "517815ae",
   "metadata": {},
   "source": [
    "For a one-liner function that has a name it's actually better practice here to use `def plus_one(x): return x + 1`, so you shouldn't see this form of lambda function too much in the wild. However, you are likely to see lambda functions being used with dataframes and other objects. For example, if you had a dataframe with a column of string called 'strings' that you want to change to “Title Case” and replace one phrase with another, you could use lambda functions to do that (there are better ways of doing this but this is useful as a simple example):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b48977c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df = pd.DataFrame(\n",
    "    data=[[\"hello my blah is Ada\"], [\"hElLo mY blah IS Adam\"]],\n",
    "    columns=[\"strings\"],\n",
    "    dtype=\"string\",\n",
    ")\n",
    "df[\"strings\"].apply(lambda x: x.title().replace(\"Blah\", \"Name\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a8a27ab",
   "metadata": {},
   "source": [
    "More complex lambda functions can be constructed, eg `lambda x, y, z: x + y + z`. One of the best use cases of lambdas is when you *don't* want to go to the trouble of declaring a function. For example, let's say you want to compose a series of functions and you want to specify those functions in a list, one after the other. Using functions alone, you'd have to define a new function for each operation. With lambdas, it would look like this (again, there are easier ways to do this operation, but we'll use simple functions to demonstrate the principle):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "404c29ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 1\n",
    "for func in [lambda x: x + 1, lambda x: x * 2, lambda x: x**2]:\n",
    "    number = func(number)\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdb2c40d",
   "metadata": {},
   "source": [
    "Note that people often use `x` by convention, but there's nothing to stop you writing `lambda horses: horses**2` (apart from the looks your co-authors will give you).\n",
    "\n",
    "```{admonition} Exercise\n",
    "Write a lambda function that takes the square root of an input number.\n",
    "```\n",
    "\n",
    "If you want to learn more about lambda functions, check out these [short video tutorials](https://calmcode.io/lambda/introduction.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Splat and splatty-splat\n",
    "\n",
    "You read those right, yes. These are also known as \"unpacking operators\" for iterables that are fed into functions as arguments (in the form of a tuple) and keyword arguments (in the form of a dictionary) respectively. Splat is `*` and splatty-splat is `**`. Because they unpack, they allow us to efficiency send packages of arguments or keyword arguments into functions without labouriously writing out every single argument.\n",
    "\n",
    "Because function arguments are always tuples, the use of `*` must be accompanied by a tuple. Because function keywords are always dictionaries of key, value pairs, the use of `**` must always be accompanied by a dictionary.\n",
    "\n",
    "Let's take a look at splat, which unpacks tuples into function arguments. If we have a function that takes two arguments we can send variables to it in different ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89a10ac8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "\n",
    "print(add(5, 10))\n",
    "\n",
    "func_args = (6, 11)\n",
    "\n",
    "print(add(*func_args))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4ff21e6",
   "metadata": {},
   "source": [
    "The splat operator, `*`, unpacks the variable `func_args` into two different function arguments.\n",
    "\n",
    "Perhaps surprisingly, we can use the splat operator *in the definition of a function*. For example, sum_elements below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ef584b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_elements(*elements):\n",
    "    return sum(*elements)\n",
    "\n",
    "\n",
    "nums = (1, 2, 3)\n",
    "\n",
    "print(sum_elements(nums))\n",
    "\n",
    "more_nums = (1, 2, 3, 4, 5)\n",
    "\n",
    "print(sum_elements(more_nums))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1bcb685",
   "metadata": {},
   "source": [
    "```{admonition} Exercise\n",
    "Write a function multiply that multiplies two input numbers, `a` and `b`, together and returns the answer. Send the argument `(10, 12)` to it using the splat operator.\n",
    "```\n",
    "\n",
    "Splatty-splat, `**`, unpacks dictionaries into keyword arguments (aka kwargs):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bcd875f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def function_with_kwargs(a, x=0, y=0, z=0):\n",
    "    return a + x + y + z\n",
    "\n",
    "\n",
    "print(function_with_kwargs(5))\n",
    "\n",
    "kwargs = {\"x\": 3, \"y\": 4, \"z\": 5}\n",
    "\n",
    "print(function_with_kwargs(5, **kwargs))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e83f29df",
   "metadata": {},
   "source": [
    "```{admonition} Exercise\n",
    "Using a dictionary and splatty-splat with the `function_with_kwargs` function, find the sum of 9, 6, 13, and 2.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29d972f4",
   "metadata": {},
   "source": [
    "## Time\n",
    "\n",
    "Let's do a quick dive into how to deal with dates and times. This is only going to scratch the surface, but should give a sense of what's possible. For more, see the {ref}`time-intro` chapter.\n",
    "\n",
    "The built-in library that deals with datetimes is called `datetime`. Let's import it and ask it to give us a very precise account of the datetime (when the code is executed):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ac0f26f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "now = datetime.now()\n",
    "print(now)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ba035ad",
   "metadata": {},
   "source": [
    "You can pick out bits of the datetime that you need:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f665624d",
   "metadata": {},
   "outputs": [],
   "source": [
    "day = now.day\n",
    "month = now.month\n",
    "year = now.year\n",
    "hour = now.hour\n",
    "minute = now.minute\n",
    "print(f\"{year}/{month}/{day}, {hour}:{minute}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af5c69b2",
   "metadata": {},
   "source": [
    "```{admonition} Exercise\n",
    "Using an f-string, add seconds to the date and time string above.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "066b21c2",
   "metadata": {},
   "source": [
    "To add or subtract time to a datetime, use `timedelta()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55a71293",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import timedelta\n",
    "\n",
    "new_time = now + timedelta(days=365, hours=5)\n",
    "print(new_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64b0600a",
   "metadata": {},
   "source": [
    "To take the difference of two dates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6f54bf0",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date\n",
    "\n",
    "year_selection = 2030\n",
    "new_year = date(year=year_selection, month=1, day=1)\n",
    "time_till_ny = new_year - date.today()\n",
    "print(f\"{time_till_ny.days} days until New Year {year_selection}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that date and datetime are two different types of objects-a datetime includes information on the date and time, whereas a date does not."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0f10f43",
   "metadata": {},
   "source": [
    "## Miscellaneous Fun\n",
    "\n",
    "Here are some other bits of basic coding that might be useful. They really show why Python is such a delightful language.\n",
    "\n",
    "You can use unicode characters for variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "096cdd78",
   "metadata": {},
   "outputs": [],
   "source": [
    "α = 15\n",
    "β = 30\n",
    "\n",
    "print(α / β)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "327290b4",
   "metadata": {},
   "source": [
    "You can swap variables in a single assignment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25ef5cd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = \"This is a string\"\n",
    "\n",
    "a, b = b, a\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a312e666",
   "metadata": {},
   "source": [
    "**itertools** offers counting, repeating, cycling, chaining, and slicing. Here's a cycling example that uses the `next` keyword to get the next iteraction:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77ec6b57",
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import cycle\n",
    "\n",
    "lorrys = [\"red lorry\", \"yellow lorry\"]\n",
    "lorry_iter = cycle(lorrys)\n",
    "\n",
    "print(next(lorry_iter))\n",
    "print(next(lorry_iter))\n",
    "print(next(lorry_iter))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a332e98",
   "metadata": {},
   "source": [
    "**itertools** also offers products, combinations, combinations with replacement, and permutations. Here are the combinations of 'abc' of length 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71f00648",
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import combinations\n",
    "\n",
    "print(list(combinations(\"abc\", 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e261358e",
   "metadata": {},
   "source": [
    "Find out what the date is! (Can pass a timezone as an argument.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e23ff29",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date\n",
    "\n",
    "print(date.today())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8311a0b7",
   "metadata": {},
   "source": [
    "Because functions are just objects, you can iterate over them just like any other object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58f95d73",
   "metadata": {},
   "outputs": [],
   "source": [
    "functions = [str.isdigit, str.islower, str.isupper]\n",
    "\n",
    "raw_str = \"asdfaa3fa\"\n",
    "\n",
    "for str_func in functions:\n",
    "    print(f\"Function name: {str_func.__name__}, value is:\")\n",
    "    print(str_func(raw_str))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65cf7e34",
   "metadata": {},
   "source": [
    "Functions can be defined recursively. For instance, the Fibonacci sequence is defined such that $ a_n = a_{n-1} + a_{n-2} $ for $ n>1 $."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64f8a599",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    if n < 0:\n",
    "        print(\"Please enter n>0\")\n",
    "        return 0\n",
    "    elif n <= 1:\n",
    "        return n\n",
    "    else:\n",
    "        return fibonacci(n - 1) + fibonacci(n - 2)\n",
    "\n",
    "\n",
    "[fibonacci(i) for i in range(10)]"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "codeforecon",
   "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}