print2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Print med formatering\n",
    "\n",
    "## Metoden .format()\n",
    "\n",
    "\n",
    "Att skriva ut med formatering kan inledningsvis delas upp i 2 delar. En del som är statisk och en del som är flexibel.\n",
    "\n",
    "Idén är att ange en sträng (fix) med platshållare för sådant som ska kunna varieras. Ett typiskt exempel är: \"Bredden är {} m, längden är {} m och djupet är {} m. Priset: {} kr\".\n",
    "Därefter anger man det som ska in i parenteserna {} med hjälp av en listliknande uppräkning: (2,4,1.5,234)!\n",
    "\n",
    "Sedan måste man ha ett system för detta. Systemet är att man först anger strängen och sedan det som ska in i parenteserna: sträng.format(). Kommandot får formen:\n",
    "\n",
    "\"Bredden är {} m, längden är {} m och djupet är {} m. Priset: {} kr\".format(2,4,1.5,234)\n",
    "\n",
    "Vilket ger utskriften: Bredden är 2 m, längden är 4 m och djupet är 1,5 m. Priset: 234 kr.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Vi skriver koden och en utskrift:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bredden är 2 m, längden är 4 m och djupet är 1.5 m. Priset: 234 kr\n"
     ]
    }
   ],
   "source": [
    "x = \"Bredden är {} m, längden är {} m och djupet är {} m. Priset: {} kr\".format(2,4,1.5,234)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Man kan vänta med format till printsatsen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bredden är 2 m, längden är 4 m och djupet är 1.5 m. Priset: 234 kr\n"
     ]
    }
   ],
   "source": [
    "x = \"Bredden är {} m, längden är {} m och djupet är {} m. Priset: {} kr\"\n",
    "\n",
    "print(x.format(2,4,1.5,234))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi ser på lite olika exempel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jag har en och du har två\n"
     ]
    }
   ],
   "source": [
    "print('Jag har {} och du har {}'.format('en', 'två'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jag såg 1 pelikan idag, i går såg jag 2\n"
     ]
    }
   ],
   "source": [
    "print('Jag såg {} pelikan idag, i går såg jag {}'.format(1, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`{}` kan dirigera vilket av elementen i listan som ska skrivas ut var. I `.format('en', 'två')` kan `en` adresseras, inte helt oväntat, med index 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jag har två och du har en\n"
     ]
    }
   ],
   "source": [
    "print('Jag har {1} och du har {0}'.format('en', 'två'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fyra minus två är två\n"
     ]
    }
   ],
   "source": [
    "print(\"{3} minus {1} är {1}\".format(\"ett\",\"två\",\"tre\",\"fyra\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ofta säger man att {} anger var variabler ska skrivas ut."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11 minus 3 är 8\n"
     ]
    }
   ],
   "source": [
    "x = 11\n",
    "y = 3\n",
    "z = x - y\n",
    "\n",
    "txt = \"{0} minus {1} är {2}\"\n",
    "\n",
    "print(txt.format(x,y,z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se nedan. Följande kanske något omständliga sätt att skriva är vanligt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test\n",
      "test\n"
     ]
    }
   ],
   "source": [
    "print(\"{}\".format(\"test\"))  # Omständligt\n",
    "print(\"test\")  # Så skrev vi i början"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Höger- respektive vänsterjustering. \n",
    "\n",
    "Vi tittar nu på hur utskriften kan justeras till höger eller vänster på utskriftsraden. Vi kommer att använda det mer omständliga sättet att skriva.\n",
    "\n",
    "### Justering av strängar\n",
    "\n",
    "Vi börjar med strängar. Det fungerar annorlunda för tal. Kommandona för styrning av utskriften finns i de `{}` vi använder för att tala om var i en sträng variabler ska skrivas ut.\n",
    "\n",
    "För att skriva justerat till höger använder vi symbolen `>` som pekar åt höger."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123456789*\n",
      "__rest\n"
     ]
    }
   ],
   "source": [
    "print('123456789*')  # För att positionerna ska synas\n",
    "\n",
    "print('{:_>6}'.format('rest'))  # Understreck _ används för att fylla ut tomma positioner"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vi har 6 positioner till 'rest' och i dessa 6 positioner skrivs 'rest' till höger'. 'rest' har t i position 6. Ordets slut är högerjusterat till position 6."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Varför står det kolon i {}? Jo det beror på att man kan ange variabler. I exemplet nedan ska variabeln som heter x skrivas ut. Vi vet dock inte vad den ska vara förrän vi kommer till print-satsen med format och där kan vi ange vilket värde variabeln x ska ha, i detta fall strängen 'rest'.\n",
    "'ut' tar 2 positioner och sedan tar rest 6 positioner och skrivs högerjusterat. Se nedan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12345678901234567890\n",
      "ut  rest\n",
      "ut  rest\n",
      "ut  rest och gå   5\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print('12345678901234567890')  # För att positionerna ska synas\n",
    "\n",
    "txt = \"ut{x:>6}\"\n",
    "print(txt.format(x='rest'))\n",
    "\n",
    "# Är samma som (men mindre flexibelt)\n",
    "txt2 = \"ut{:>6}\"\n",
    "print(txt2.format('rest'))\n",
    "\n",
    "# Ett exempel till...\n",
    "txt = \"ut{x:>6} och gå {y:>3}\"\n",
    "print(txt.format(x='rest', y=5))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Så om det står inget till vänster om kolon innanför parentesen `{:>6}` så betyder det att det finns bara en sak som ska skrivas och den står i `format()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strängar justeras till vänster med hjälp av symbolen `<` (som är förinställt)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123456789*\n",
      "rest______\n",
      "rest____\n",
      "rest      \n",
      "123456789*123\n",
      "Hej!rest____A\n"
     ]
    }
   ],
   "source": [
    "print('123456789*') \n",
    "print('{:_<10}'.format('rest'))\n",
    "print('{:_<8}'.format('rest'))\n",
    "\n",
    "print('{:10}'.format('rest')) # < är förinställt, så det behöver egentligen inte anges\n",
    "\n",
    "\n",
    "print('123456789*123')\n",
    "print('Hej!{:_<8}A'.format('rest'))  \n",
    "# Först 'Hej!' (4 positioner) sedan 8 positioner till 'rest', sedan 'A'\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Justering av tal\n",
    "\n",
    "#### Heltal\n",
    "\n",
    "Vanliga sättet att formatera heltal är att skriva till höger (förinställt vänster för strängar men höger för tal). Symbolen `d` talar om för python att vi arbetar med heltal i basen 10 (decimal integer). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123456789*\n",
      "42\n",
      "  42\n",
      "__42\n",
      "----\n",
      "\n",
      "        42\n",
      "        42\n",
      "----\n",
      "\n",
      "123456789*\n",
      "42__\n",
      "42__hej\n",
      "42________\n",
      "42________hej\n"
     ]
    }
   ],
   "source": [
    "print('123456789*') \n",
    "\n",
    "print('{:d}'.format(42))  # syns inget intressant\n",
    "print('{:4d}'.format(42))\n",
    "print('{:_>4d}'.format(42))  # samma som föregående, > förinställt\n",
    "print(\"----\\n\")\n",
    "print('{:10d}'.format(42))\n",
    "print('{:10}'.format(42))  # även d kan tas bort\n",
    "print(\"----\\n\")\n",
    "\n",
    "# Och så vänsterjusterat\n",
    "print('123456789*') \n",
    "\n",
    "print('{:_<4}'.format(42))  # vänster\n",
    "print('{:_<4}hej'.format(42))  # vänster 42 tar 4 positioner, därpå följer hej\n",
    "print('{:_<10d}'.format(42))  # vänster\n",
    "print('{:_<10d}hej'.format(42))  # vänster 42 tar 10 positioner, därpå följer hej\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ett exempel på utskrift i annan bas.\n",
    "\n",
    "`x` står för hexadecimal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2A\n"
     ]
    }
   ],
   "source": [
    "print('{:X}'.format(42))  # vänster"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$10 \\cdot 16^0+2 \\cdot 16^1$ ty A står för 10 i hexadecimala systemet (B för 11 osv...F för 15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Flyttal\n",
    "\n",
    "Det är vid formatering av flyttal som det börjar hända saker. f står för fixed point notation, dvs ett givet antal decimaler. Förinställt på 6 decimaler."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Talet pi är cirka 3.141593\n"
     ]
    }
   ],
   "source": [
    "print('Talet pi är cirka {:f}'.format(3.141592653589793))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se nedan. 6 positioner med 2 efter decimaltecknet. Det är väl denna typ man bör kunna så\n",
    "att man automatiskt styr framförallt antalet decimaler.\n",
    "6 positioner är just 6 positioner inte 6 siffror. Decimaltecknet upptar en position.\n",
    "0 framför tvingar fram nollor, testa själv genom att ta bort 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Talet pi med 2 decimaler är 003.14\n"
     ]
    }
   ],
   "source": [
    "print('Talet pi med 2 decimaler är {:06.2f}'.format(3.141592653589793))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Och om vi bara vill ange antalet decimaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.1416\n"
     ]
    }
   ],
   "source": [
    "print('{:.4f}'.format(3.141592653589793))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Heltalsexempel med 0 framför."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0042\n",
      "  42\n"
     ]
    }
   ],
   "source": [
    "print('{:04d}'.format(42))\n",
    "print('{:4d}'.format(42))  # samma position men inga nollor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Följande direkta användning av listor är också möjlig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23 42\n"
     ]
    }
   ],
   "source": [
    "data = [4, 8, 15, 16, 23, 42]\n",
    "print('{d[4]} {d[5]}'.format(d=data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Man behöver se många exempel. Det sägs ofta att den teoretiska definitionen av formateringen är svår att läsa så vi använder endast exempel, vill man verkligen göra något avancerat får man sätta sig ner med det."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "På vilken tid springer du 100 m? 23\n",
      "23.000000\n",
      "1 Det var långsamt, jag springer på 22.000000\n",
      "2 Det var långsamt, jag springer på      22.0\n",
      "3 Det var långsamt, jag springer på 22.0\n",
      "4 Det var långsamt, jag springer på 22.00\n",
      "5 Det var långsamt, jag springer på 22.00, förr sprang jag på 21.00\n"
     ]
    }
   ],
   "source": [
    "b = input(\"På vilken tid springer du 100 m? \")\n",
    "a = int(b)\n",
    "\n",
    "# Flyttal\n",
    "print(\"{:f}\".format(a))\n",
    "\n",
    "#Text också, förinställt på 6 decimaler\n",
    "print(\"1 Det var långsamt, jag springer på {:f}\".format(a-1))\n",
    "\n",
    "#Minst 9 positioner, en decimal\n",
    "print(\"2 Det var långsamt, jag springer på {:9.1f}\".format(a-1))\n",
    "\n",
    "# 1 decimal\n",
    "print(\"3 Det var långsamt, jag springer på {:.1f}\".format(a-1))\n",
    "\n",
    "\n",
    "# 2 decimaler\n",
    "print(\"4 Det var långsamt, jag springer på {:.2f}\".format(a-1))\n",
    "\n",
    "print(\"5 Det var långsamt, jag springer på {:.2f}, förr sprang jag på {:.2f}\".format(a-1,a-2))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fler blandade exempel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123456789*\n",
      "   12\n",
      "1234\n",
      "  12.235\n",
      "   12.235\n",
      "    12.235\n"
     ]
    }
   ],
   "source": [
    "print(\"123456789*\")\n",
    "# heltal med minimum bredd på 5 positioner, skriven till höger\n",
    "print(\"{:5d}\".format(12))\n",
    "\n",
    "# bredd, 2, som är mindre än talet\n",
    "print(\"{:2d}\".format(1234))\n",
    "\n",
    "# 8 positioner, 3 decmaler\n",
    "print(\"{:8.3f}\".format(12.2346))\n",
    "\n",
    "# 9 positioner, 3 decimaler\n",
    "print(\"{:9.3f}\".format(12.2346))\n",
    "\n",
    "# 10 positioner, 3 decimaler\n",
    "print(\"{:10.3f}\".format(12.2346))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### För stora tal har vi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123456789*\n",
      "0003.142e+07\n",
      "   3.142e+07\n",
      "      3.142e+07\n",
      "3.142e+07      \n",
      "3.1416e+07     \n"
     ]
    }
   ],
   "source": [
    "print(\"123456789*\")\n",
    "print('{:012.3e}'.format(31415926.53589793))  # Inledande nollor\n",
    "print('{:12.3e}'.format(31415926.53589793))\n",
    "print('{:15.3e}'.format(31415926.53589793))\n",
    "print('{:<15.3e}'.format(31415926.53589793))\n",
    "print('{:<15.4e}'.format(31415926.53589793))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Går också bra med E.\n",
    "\n",
    "Observera att det verkligen rör sig om positioner, inte siffror. Kommatecken, + och e tar var och en 1 position."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Avrundning\n",
    "\n",
    "I detta sammanhang tar vi också upp avrundning. Avrundning fungerar som i matematiken med det vanliga undantaget att tal i bas 10 som inte kan representeras exakt i bas 2 kan ge överraskningar. Principiellt avrundas mittemellan tal till jämn siffra 2,35 blir 2,4; 2,45 blir 2,4. Men man måste se upp eftersom talens representation i bas 2 är det som gäller.\n",
    "\n",
    "Kommandot är `round(x, n)` där x anger talet som ska avrundas och n anger antalet decimaler. n är villkorligt och kan utelämnas och är förinställt på 0. Formellt skrivs det som `round(x[,n])`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(round(2.346))  # Förinställt 0 antal decimaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.35\n"
     ]
    }
   ],
   "source": [
    "print(round(2.346,2))  # Som vi förväntar oss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.35\n",
      "2.34500000000000019539925233402755111455917358398437500\n",
      "2.33\n",
      "2.33499999999999996447286321199499070644378662109375000\n",
      "2.33499999999999996447286321199499070644378662109375000\n"
     ]
    }
   ],
   "source": [
    "print(round(2.345,2))  # Avrundas upp, men principen säger 2.34\n",
    "print(\"{:.53f}\".format(2.345))  # Förklaringen: talet är lagrat binärt och är då större än 2,345\n",
    "\n",
    "print(round(2.335,2))  # Avrundas ner, principen säger 2.34\n",
    "print(\"{:.53f}\".format(2.335))  # Förklaringen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.88\n",
      "3.87500000000000000000000000000000000000000000000000000\n"
     ]
    }
   ],
   "source": [
    "print(round(3.875,2))  # Principen säger upp, talet är exakt representerbart i basen 2\n",
    "print(format(3.875, '.53f'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sammanfattning\n",
    "\n",
    "Kommandona reserverar positioner så att inga andra utskrifter kan hamna i de positioner som reserverats.\n",
    "\n",
    "Kommandostrukturer att ta med sig (typexempel):\n",
    "\n",
    "\n",
    "1. print(\"Bredden är {} m, längden är {} m och djupet är {} m. Priset: {} kr\".format(2,4,1.5,234)) \n",
    "   Ange en sträng för utskriften med {} som platshållare. Innehållet står i .format().\n",
    "\n",
    "2. Text. Automatiskt vänsterjusterat: <. För högerjusterat skriv: print('{:>6}'.format('rest'))\n",
    "\n",
    "3. Tal. Förinställt höger >.\n",
    "\n",
    "   3.1 Heltal: print('{:>4d}'.format(42))\n",
    "\n",
    "   3.2 Flyttal: print(\"{:9.3f}\".format(12.2346))\n",
    "\n",
    "4. Avrundning: print(round(2.346,2))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uppgifter \n",
    "\n",
    "\n",
    "**Uppgift 1**\n",
    "\n",
    "Skriv ett program som läser in heltalskoefficienter för en andragradsekvation och sedan skriver ut ekvationen snyggt tex. 3x^2+4x-2=0\n",
    "\n",
    "[Lösningsförslag](./uppg/print2Uppgift1.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Uppgift 2**\n",
    "\n",
    "\n",
    "Skriv ett program som skriver ut följande tabell.\n",
    "```\n",
    "1234567890ABCDE\n",
    "Oslo        223\n",
    "Stockholm   145\n",
    "Malmö       452\n",
    "Ystad       553\n",
    "Luleå       112\n",
    "Östersund   612\n",
    "```\n",
    "Tabellen ska ha 10 positioner för orten (1,2...0)  vänsterjusterat och 5 positioner för talen högerjusterat (A...E). Lämpligen en lista för orterna och en lista för talen.\n",
    "\n",
    "\n",
    "[Lösningsförslag](./uppg/print2Uppgift2.ipynb)"
   ]
  }
 ],
 "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"
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}