python/builtin-advanced-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Click [here](https://medium.com/@morihosseini/mastering-advanced-python-built-ins-302541f844fb) to access the associated Medium article."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. `zip`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 1: Basic Pairing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Alice', 85), ('Bob', 92), ('Charlie', 78)]\n"
     ]
    }
   ],
   "source": [
    "names = [\"Alice\", \"Bob\", \"Charlie\"]\n",
    "scores = [85, 92, 78]\n",
    "\n",
    "# Pair names with scores\n",
    "paired = zip(names, scores)\n",
    "\n",
    "print(list(paired))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 2: Transposing Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Alice', 'Bob', 'Charlie')\n",
      "(85, 92, 78)\n"
     ]
    }
   ],
   "source": [
    "data = [('Alice', 85), ('Bob', 92), ('Charlie', 78)]\n",
    "\n",
    "# Unzip the data into two separate lists\n",
    "names, scores = zip(*data)\n",
    "\n",
    "print(names)\n",
    "print(scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 3: Handling Iterables of Uneven Length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 'x'), (2, 'y')]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [\"x\", \"y\"]\n",
    "\n",
    "# Combine uneven lists\n",
    "print(list(zip(a, b)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 'x'), (2, 'y'), (3, 'z')]\n"
     ]
    }
   ],
   "source": [
    "from itertools import zip_longest\n",
    "\n",
    "print(list(zip_longest(a, b, fillvalue=\"z\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 4: Iterating Over Multiple Lists Simultaneously"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 Apples\n",
      "3 Bananas\n",
      "5 Cherries\n"
     ]
    }
   ],
   "source": [
    "quantities = [2, 3, 5]\n",
    "items = [\"Apples\", \"Bananas\", \"Cherries\"]\n",
    "\n",
    "for item, quantity in zip(items, quantities):\n",
    "    print(f\"{quantity} {item}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 5: Advanced Use Case - Creating Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Alice', 'age': 30, 'city': 'New York'}\n"
     ]
    }
   ],
   "source": [
    "keys = [\"name\", \"age\", \"city\"]\n",
    "values = [\"Alice\", 30, \"New York\"]\n",
    "\n",
    "data = dict(zip(keys, values))\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 6: Transposing a Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 4, 7), (2, 5, 8), (3, 6, 9)]\n"
     ]
    }
   ],
   "source": [
    "matrix = [\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6],\n",
    "    [7, 8, 9]\n",
    "]\n",
    "\n",
    "transposed = list(zip(*matrix))\n",
    "print(transposed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Combine with List Comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alice: 85', 'Bob: 92', 'Charlie: 78']\n"
     ]
    }
   ],
   "source": [
    "# Combine and format strings dynamically\n",
    "names = [\"Alice\", \"Bob\", \"Charlie\"]\n",
    "scores = [85, 92, 78]\n",
    "formatted = [f\"{name}: {score}\" for name, score in zip(names, scores)]\n",
    "\n",
    "print(formatted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. `enumerate`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 1: Basic Usage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: Apple\n",
      "1: Banana\n",
      "2: Cherry\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"Apple\", \"Banana\", \"Cherry\"]\n",
    "\n",
    "# Enumerate the list\n",
    "for index, fruit in enumerate(fruits):\n",
    "    print(f\"{index}: {fruit}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 2: Customizing the Starting Index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1: Apple\n",
      "2: Banana\n",
      "3: Cherry\n"
     ]
    }
   ],
   "source": [
    "for index, fruit in enumerate(fruits, start=1):\n",
    "    print(f\"{index}: {fruit}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 3: Enumerating Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Character at index 0: P\n",
      "Character at index 1: y\n",
      "Character at index 2: t\n",
      "Character at index 3: h\n",
      "Character at index 4: o\n",
      "Character at index 5: n\n"
     ]
    }
   ],
   "source": [
    "word = \"Python\"\n",
    "\n",
    "for index, char in enumerate(word):\n",
    "    print(f\"Character at index {index}: {char}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 4: Building Dictionaries with Indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 'Apple', 1: 'Banana', 2: 'Cherry'}\n"
     ]
    }
   ],
   "source": [
    "fruit_dict = {index: fruit for index, fruit in enumerate(fruits)}\n",
    "print(fruit_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 5: Enumerating with Multiple Iterables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: Apple - 10\n",
      "1: Banana - 5\n",
      "2: Cherry - 8\n"
     ]
    }
   ],
   "source": [
    "quantities = [10, 5, 8]\n",
    "\n",
    "for index, (fruit, quantity) in enumerate(zip(fruits, quantities)):\n",
    "    print(f\"{index}: {fruit} - {quantity}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 6: Enumerating with Conditionals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Even index 0: Apple\n",
      "Even index 2: Cherry\n"
     ]
    }
   ],
   "source": [
    "# Identify and process even-indexed fruits\n",
    "for index, fruit in enumerate(fruits):\n",
    "    if index % 2 == 0:\n",
    "        print(f\"Even index {index}: {fruit}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nest for Multidimensional Structures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix[0][0] = 1\n",
      "Matrix[0][1] = 2\n",
      "Matrix[0][2] = 3\n",
      "Matrix[1][0] = 4\n",
      "Matrix[1][1] = 5\n",
      "Matrix[1][2] = 6\n",
      "Matrix[2][0] = 7\n",
      "Matrix[2][1] = 8\n",
      "Matrix[2][2] = 9\n"
     ]
    }
   ],
   "source": [
    "matrix = [\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6],\n",
    "    [7, 8, 9]\n",
    "]\n",
    "\n",
    "for row_idx, row in enumerate(matrix):\n",
    "    for col_idx, value in enumerate(row):\n",
    "        print(f\"Matrix[{row_idx}][{col_idx}] = {value}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. `partial`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 1: Fixing Arguments for Reusability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "from functools import partial\n",
    "\n",
    "# Partially apply the int function to work with base 2\n",
    "binary_to_int = partial(int, base=2)\n",
    "\n",
    "# Now you can easily convert binary strings to integers\n",
    "print(binary_to_int(\"1010\"))\n",
    "print(binary_to_int(\"1111\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 2: Preconfigured Callbacks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Alice!\n",
      "Goodbye, Bob!\n"
     ]
    }
   ],
   "source": [
    "from functools import partial\n",
    "\n",
    "def greet(greeting, name):\n",
    "    print(f\"{greeting}, {name}!\")\n",
    "\n",
    "# Create a partial function for a fixed greeting\n",
    "say_hello = partial(greet, \"Hello\")\n",
    "say_goodbye = partial(greet, \"Goodbye\")\n",
    "\n",
    "say_hello(\"Alice\")\n",
    "say_goodbye(\"Bob\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 3: Simplifying Repeated Calculations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.0\n",
      "9.0\n"
     ]
    }
   ],
   "source": [
    "from functools import partial\n",
    "from math import pow\n",
    "\n",
    "# Create a function to calculate square and cube\n",
    "square = partial(pow, 2)\n",
    "cube = partial(pow, 3)\n",
    "\n",
    "print(square(4))\n",
    "print(cube(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 4: Combining with Higher-Order Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 40]\n"
     ]
    }
   ],
   "source": [
    "from functools import partial\n",
    "\n",
    "def multiply(x, y):\n",
    "    return x * y\n",
    "\n",
    "# Create a partial function to always multiply by 10\n",
    "multiply_by_10 = partial(multiply, 10)\n",
    "\n",
    "# Use it in map\n",
    "numbers = [1, 2, 3, 4]\n",
    "result = map(multiply_by_10, numbers)\n",
    "print(list(result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 5: Partial with Default Keyword Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ordering a medium pizza with thin crust and toppings: pepperoni, mushrooms.\n",
      "Ordering a large pizza with stuffed crust and toppings: cheese, ham.\n"
     ]
    }
   ],
   "source": [
    "from functools import partial\n",
    "\n",
    "def order_pizza(size, crust, toppings=[]):\n",
    "    print(f\"Ordering a {size} pizza with {crust} crust and toppings: {', '.join(toppings)}.\")\n",
    "\n",
    "# Create partial functions for specific pizza preferences\n",
    "thin_crust = partial(order_pizza, crust=\"thin\")\n",
    "large_pizza = partial(order_pizza, size=\"large\")\n",
    "\n",
    "thin_crust(size=\"medium\", toppings=[\"pepperoni\", \"mushrooms\"])\n",
    "\n",
    "large_pizza(crust=\"stuffed\", toppings=[\"cheese\", \"ham\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. `all` and `any`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 1: Validating Conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All passwords meet the length requirement.\n"
     ]
    }
   ],
   "source": [
    "passwords = [\"secure123\", \"adminpass\", \"myp@ssword\"]\n",
    "\n",
    "# Check if all passwords are at least 8 characters long\n",
    "if all(len(p) >= 8 for p in passwords):\n",
    "    print(\"All passwords meet the length requirement.\")\n",
    "else:\n",
    "    print(\"Some passwords are too short.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 2: Checking for Any Matches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No passwords contain spaces.\n"
     ]
    }
   ],
   "source": [
    "# Check if any password contains a space\n",
    "if any(\" \" in p for p in passwords):\n",
    "    print(\"Some passwords contain spaces.\")\n",
    "else:\n",
    "    print(\"No passwords contain spaces.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 3: Combining `all` and `any`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Some users have no subscriptions.\n"
     ]
    }
   ],
   "source": [
    "users = [\n",
    "    {\"name\": \"Alice\", \"subscriptions\": [\"Premium\"]},\n",
    "    {\"name\": \"Bob\", \"subscriptions\": [\"Free\"]},\n",
    "    {\"name\": \"Charlie\", \"subscriptions\": []},\n",
    "]\n",
    "\n",
    "# Check if all users have at least one subscription\n",
    "if all(any(sub for sub in user[\"subscriptions\"]) for user in users):\n",
    "    print(\"All users have at least one subscription.\")\n",
    "else:\n",
    "    print(\"Some users have no subscriptions.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 4: Using Empty Iterables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(all([]))\n",
    "print(any([]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Combine with Generators for Efficiency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "# Check large datasets efficiently\n",
    "large_dataset = (x % 2 == 0 for x in range(1_000_000))\n",
    "print(all(large_dataset))  # Stops at the first odd number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. `filter()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 1: Filtering Even Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6]\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5, 6]\n",
    "\n",
    "# Use filter to extract even numbers\n",
    "evens = filter(lambda x: x % 2 == 0, numbers)\n",
    "print(list(evens))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 2: Filtering Strings Based on Length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'banana']\n"
     ]
    }
   ],
   "source": [
    "words = [\"apple\", \"kiwi\", \"banana\", \"pear\"]\n",
    "\n",
    "# Filter words with more than 4 letters\n",
    "long_words = filter(lambda x: len(x) > 4, words)\n",
    "print(list(long_words))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 3: Removing Falsy Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'hello', [1, 2]]\n"
     ]
    }
   ],
   "source": [
    "data = [0, 1, \"\", \"hello\", None, [], [1, 2], False]\n",
    "\n",
    "# Filter out falsy values\n",
    "filtered_data = filter(None, data)\n",
    "print(list(filtered_data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 4: Combining `filter` with Named Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 10]\n"
     ]
    }
   ],
   "source": [
    "# Define a filter function\n",
    "def is_positive(number):\n",
    "    return number > 0\n",
    "\n",
    "numbers = [-10, -5, 0, 5, 10]\n",
    "\n",
    "# Use filter with a named function\n",
    "positives = filter(is_positive, numbers)\n",
    "print(list(positives))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 5: Filtering with Complex Conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'name': 'Alice', 'age': 25}, {'name': 'Charlie', 'age': 30}]\n"
     ]
    }
   ],
   "source": [
    "people = [\n",
    "    {\"name\": \"Alice\", \"age\": 25},\n",
    "    {\"name\": \"Bob\", \"age\": 15},\n",
    "    {\"name\": \"Charlie\", \"age\": 30}\n",
    "]\n",
    "\n",
    "# Filter people older than 18\n",
    "adults = filter(lambda person: person[\"age\"] > 18, people)\n",
    "print(list(adults))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 6: Using `filter` with Generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# Generator for numbers\n",
    "numbers = (x for x in range(1, 1000000))\n",
    "\n",
    "# Filter even numbers from a large range\n",
    "evens = filter(lambda x: x % 2 == 0, numbers)\n",
    "\n",
    "# Print the first 5 results\n",
    "print([next(evens) for _ in range(5)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 7: Filtering and Chaining with `map`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 16, 36]\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5, 6]\n",
    "\n",
    "# Square only the even numbers\n",
    "squared_evens = map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, numbers))\n",
    "print(list(squared_evens))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Debugging `filter`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'hello']\n"
     ]
    }
   ],
   "source": [
    "data = [0, 1, \"\", \"hello\", None, []]\n",
    "print(list(filter(None, data)))  # Inspect results directly"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv3.13",
   "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.13.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}