Semaine 1 - Introduction au MOOC et aux outils Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e7369b39",
   "metadata": {},
   "source": [
    "# Semaine 1 - Introduction au MOOC et aux outils Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2a1088c",
   "metadata": {},
   "source": [
    "## 1 Organisation du MOOC"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e26cdbd",
   "metadata": {},
   "source": [
    "### Vidéo de présentation\n",
    "\n",
    "Proposé par UCA : Université Côte d'Azur\n",
    "\n",
    "Python 3.6\n",
    "\n",
    "Tronc commun de 6 semaines :\n",
    "- les types de base\n",
    "- les fonctions\n",
    "- les structures de contrôle\n",
    "- les modules\n",
    "- les espaces de nommage\n",
    "- la programmation objet\n",
    "\n",
    "Objectifs :\n",
    "- écrire du code propre\n",
    "- lire du code\n",
    "- bien utiliser les librairies\n",
    "\n",
    "Organisation :\n",
    "- vidéos\n",
    "- compléments, notebooks jupyter\n",
    "- quiz\n",
    "- exercices auto-évalués\n",
    "- forum \n",
    "\n",
    "3 niveaux de difficultés\n",
    "\n",
    "Traits marquants de Python :\n",
    "- langage très lisible\n",
    "- tout est objet\n",
    "- liaison lexicale\n",
    "- typage dynamique\n",
    "- itérations\n",
    "- espaces de nommages\n",
    "\n",
    "Modules optionnels :\n",
    "- data science : numpy, matplotlib, pandas\n",
    "- programmation asynchrone : paradigme de coroutines, librairie asyncio\n",
    "- sujets avancés : attributs, décorateurs, métaclasses\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ebbb95c",
   "metadata": {},
   "source": [
    "## 2 Pourquoi Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "839bb620",
   "metadata": {},
   "source": [
    "syntaxe articulée sur la présentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bde3b518",
   "metadata": {},
   "outputs": [],
   "source": [
    "### le zen de Python\n",
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97bafafe",
   "metadata": {},
   "source": [
    "## 3 Interpréteur et IDLE"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca51754c",
   "metadata": {},
   "source": [
    "Lancer IDLE\n",
    "\n",
    "Vérifier que la version est au moins 3.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ba8f61e",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import math\n",
    "dir(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77d0d368",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import math\n",
    "help(math.ceil)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bdc7a523",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "python -V"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "567ce268",
   "metadata": {},
   "source": [
    "## 4 Les notebooks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e005414b",
   "metadata": {},
   "outputs": [],
   "source": [
    "a=2\n",
    "b=3\n",
    "print(\"a =\", a, \"et b =\", b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71bf2dfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ou encore, équivalente mais avec un f-string\n",
    "print(f\"a = {a} et b = {b}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac33899e",
   "metadata": {},
   "source": [
    "### La suite de Fibonacci - Niveau basique"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db933e56",
   "metadata": {},
   "source": [
    "Le but de ce programme est de calculer la suite de Fibonacci, qui est définie comme ceci :\n",
    "\n",
    "𝑢0=0\n",
    " \n",
    "𝑢1=1\n",
    " \n",
    "∀𝑛>=2,𝑢𝑛=𝑢𝑛−1+𝑢𝑛−2\n",
    " \n",
    "Ce qui donne pour les premières valeurs :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "148e8276",
   "metadata": {},
   "source": [
    "On commence par définir la fonction fibonacci comme il suit. Naturellement vous n'avez pas encore tout le bagage pour lire ce code, ne vous inquiétez pas, nous allons vous expliquer tout ça dans les prochaines semaines. Le but est uniquement de vous montrer un fonctionnement de l'interpréteur Python et de IDLE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee0e3f8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    \"retourne le nombre de fibonacci pour l'entier n\"\n",
    "    # pour les deux petites valeurs de n, on peut retourner n\n",
    "    if n <= 1:\n",
    "        return n\n",
    "    # sinon on initialise f2 pour n-2 et f1 pour n-1\n",
    "    f2, f1 = 0, 1\n",
    "    # et on itère n-1 fois pour additionner\n",
    "    for i in range(2, n + 1):\n",
    "        f2, f1 = f1, f1 + f2\n",
    "#        print(i, f2, f1)\n",
    "    # le résultat est dans f1\n",
    "    return f1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d13607ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "entier = int(input(\"Entrer un entier \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5430dfa3",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"fibonacci({entier}) = {fibonacci(entier)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88512184",
   "metadata": {},
   "source": [
    "### Dessiner un carré - niveau intermédiaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7bef4f34",
   "metadata": {},
   "outputs": [],
   "source": [
    "# on a besoin du module turtle\n",
    "import turtle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8979611e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(length):\n",
    "    \"have the turtle draw a square of side <length>\"\n",
    "    for sibde in range(4):\n",
    "        turtle.forward(length)\n",
    "        turtle.left(90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d12d4eed",
   "metadata": {},
   "outputs": [],
   "source": [
    "turtle.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d783f01",
   "metadata": {},
   "outputs": [],
   "source": [
    "square(200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f62edcb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "turtle.exitonclick()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "857d5ead",
   "metadata": {},
   "source": [
    "## 5 Notions de variables, d'objet et typage dynamique"
   ]
  },
  {
   "cell_type": "raw",
   "id": "de771290",
   "metadata": {},
   "source": [
    "# mots clés interdits : \t \t \t \n",
    "False\tawait\telse\timport\tpass\n",
    "None\tbreak\texcept\tin\traise\n",
    "True\tclass\tfinally\tis\treturn\n",
    "and\tcontinue\tfor\tlambda\ttry\n",
    "as\tdef\tfrom\tnonlocal\twhile\n",
    "assert\tdel\tglobal\tnot\twith\n",
    "async\telif\tif\tor\tyield"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f6ed9e59",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6fd53171",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type('spam')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d69378f",
   "metadata": {},
   "source": [
    "Une autre fonction prédéfinie, voisine de `type` mais plus utile dans la pratique, est la fonction `isinstance` qui permet de savoir si un objet est d'un type donné. Par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a8c397a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(23, int)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b24e8537",
   "metadata": {},
   "source": [
    "Python = langage de bas niveau\n",
    "\n",
    "Pour toutes ces raisons, avec un langage de plus haut niveau comme Python, le programmeur est libéré de cet aspect de la programmation (la libération de mémoire.\n",
    "\n",
    "Pour anticiper un peu sur le cours des semaines suivantes, voici ce que vous pouvez garder en tête s'agissant de la gestion mémoire en Python :\n",
    "\n",
    "vous créez vos objets au fur et à mesure de vos besoins ;\n",
    "\n",
    "vous n'avez pas besoin de les libérer explicitement, le \"Garbage Collector\" de Python va s'en charger pour recycler la mémoire lorsque c'est possible ;\n",
    "\n",
    "Python a tendance à être assez gourmand en mémoire, comparé à un langage de bas niveau, car tout est objet et chaque objet est assorti de méta-informations qui occupent une place non négligeable. Par exemple, chaque objet possède au minimum :\n",
    "\n",
    "une référence vers son type - c'est le prix du typage dynamique ;\n",
    "un compteur de références - le nombre d'autres valeurs (variables ou objets) qui pointent vers l'objet, cette information est notamment utilisée, précisément, par le Garbage Collector pour déterminer si la mémoire utilisée par un objet peut être libérée ou non.\n",
    "un certain nombre de types prédéfinis et non mutables sont implémentés en Python comme des singletons, c'est-à-dire qu'un seul objet est créé et partagé, c'est le cas par exemple pour les petits entiers et les chaînes de caractères, on en reparlera ;\n",
    "\n",
    "lorsqu'on implémente une classe, il est possible de lui conférer cette caractéristique de singleton, de manière à optimiser la mémoire nécessaire pour exécuter un programme."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b159021",
   "metadata": {},
   "source": [
    "## 5.1  Typages statique et dynamique\n",
    "\n",
    "### 5.1.1  Complément - niveau intermédiaire\n",
    "\n",
    "Parmi les langages typés, on distingue les langages à typage statique et ceux à typage dynamique. Ce notebook tente d'éclaircir ces notions pour ceux qui n'y sont pas familiers.\n",
    "\n",
    "#### 5.1.1.1  Typage statique\n",
    "À une extrémité du spectre, on trouve les langages compilés, dits à typage statique, comme par exemple C ou C++.\n",
    "\n",
    "En C on écrira, par exemple, une version simpliste de la fonction factoriel comme ceci :\n",
    "\n",
    "int factoriel(int n) {\n",
    "    int result = 1;\n",
    "    for (int loop = 1; loop <= n; loop++)\n",
    "        result *= loop;\n",
    "    return result;\n",
    "}\n",
    "Comme vous pouvez le voir - ou le deviner - toutes les variables utilisées ici (comme par exemple n, result et loop) sont typées :\n",
    "\n",
    "on doit appeler factoriel avec un argument n qui doit être un entier (int est le nom du type entier) ;\n",
    "les variables internes result et loop sont de type entier ;\n",
    "factoriel retourne une valeur de type entier.\n",
    "Ces informations de type ont essentiellement trois fonctions :\n",
    "\n",
    "- en premier lieu, elles sont nécessaires au compilateur. En C si le programmeur ne précisait pas que result est de type entier, le compilateur n'aurait pas suffisamment d'éléments pour générer le code assembleur correspondant ;\n",
    "- en contrepartie, le programmeur a un contrôle très fin de l'usage qu'il fait de la mémoire et du matériel. Il peut choisir d'utiliser un entier sur 32 ou 64 bits, signé ou pas, ou construire avec struct et union un arrangement de ses données ;\n",
    "- enfin, et surtout, ces informations de type permettent de faire un contrôle a priori de la validité du programme, par exemple, si à un autre endroit dans le code on trouve :\n",
    "#include <stdio.h>\n",
    "\n",
    "int main(int argc, char *argv[]) {\n",
    "    /* le premier argument de la ligne de commande est argv[1] */\n",
    "    char *input = argv[1];\n",
    "    /* calculer son factoriel et afficher le résultat */\n",
    "    printf(\"Factoriel (%s) = %d\\n\", input, factoriel(input));\n",
    "    /*                                               ^^^^^\n",
    "\n",
    "     * ici on appelle factoriel avec une entrée de type 'chaîne de caractères' */\n",
    "}\n",
    "alors le compilateur va remarquer qu'on essaie d'appeler factoriel avec comme argument input qui, pour faire simple, est une chaîne de caractères et comme factoriel s'attend à recevoir un entier, ce programme n'a aucune chance de compiler.\n",
    "\n",
    "On parle alors de typage statique, en ce sens que chaque variable a exactement un type qui est défini par le programmeur une bonne fois pour toutes.\n",
    "\n",
    "C'est ce qu'on appelle le contrôle de type, ou type-checking en anglais. Si on ignore le point sur le contrôle fin de la mémoire, qui n'est pas crucial à notre sujet, ce modèle de contrôle de type présente :\n",
    "\n",
    "l'inconvénient de demander davantage au programmeur (je fais abstraction, à ce stade et pour simplifier, de langages à inférence de types comme ML et Haskell) ;\n",
    "et l'avantage de permettre un contrôle étendu, et surtout précoce (avant même de l'exécuter), de la bonne correction du programme.\n",
    "Cela étant dit, le typage statique en C n'empêche pas le programmeur débutant d'essayer d'écrire dans la mémoire à partir d'un pointeur NULL - et le programme de s'interrompre brutalement. Il faut être conscient des limites du typage statique.\n",
    "\n",
    "#### 5.1.1.2  Typage dynamique\n",
    "À l'autre bout du spectre, on trouve des langages comme, eh bien, Python.\n",
    "\n",
    "Pour comprendre cette notion de typage dynamique, regardons la fonction suivante somme.\n",
    "\n",
    "def somme(*largs):\n",
    "    \"retourne la somme de tous ses arguments\"\n",
    "    if not largs:\n",
    "        return 0\n",
    "    result = largs[0]\n",
    "    for i in range(1, len(largs)):\n",
    "        result += largs[i]\n",
    "    return result\n",
    "Naturellement, vous n'êtes pas à ce stade en mesure de comprendre le fonctionnement intime de la fonction. Mais vous pouvez tout de même l'utiliser :\n",
    "\n",
    "somme(12, 14, 300)\n",
    "liste1 = ['a', 'b', 'c']\n",
    "liste2 = [0, 20, 30]\n",
    "liste3 = ['spam', 'eggs']\n",
    "somme(liste1, liste2, liste3)\n",
    "Vous pouvez donc constater que somme peut fonctionner avec des objets de types différents: on peut lui passer des nombres, ou lui passer des listes. En fait, telle qu'elle est écrite, elle va fonctionner s'il est possible de faire + entre ses arguments. Ainsi, par exemple, on pourrait même faire :\n",
    "\n",
    "Python sait faire + entre deux chaînes de caractères\n",
    "somme('abc', 'def')\n",
    "Mais par contre on ne pourrait pas faire\n",
    "somme(12, [1, 2, 3])\n",
    "\n",
    "Il est utile de remarquer que le typage de Python, qui existe bel et bien comme on le verra, est qualifié de dynamique parce que le type est attaché à un objet et non à la variable qui le référence. On aura bien entendu l'occasion d'approfondir tout ça dans le cours.\n",
    "\n",
    "En Python, on fait souvent référence au typage sous l'appellation duck typing, de manière imagée :\n",
    "\n",
    "If it looks like a duck and quacks like a duck, it's a duck.\n",
    "\n",
    "On voit qu'on se trouve dans une situation très différente de celle du programmeur C/C++, en ce sens que :\n",
    "- à l'écriture du programme, il n'y aucun des surcoûts qu'on trouve avec C ou C++ en matière de définition de type ;\n",
    "- aucun contrôle de type n'est effectué a priori par le langage au moment de la définition de la fonction somme ;\n",
    "- par contre au moment de l'exécution, s'il s'avère qu'on tente de faire une somme entre deux types qui ne peuvent pas être additionnés, comme ci-dessus avec un entier et une liste, le programme ne pourra pas se dérouler correctement.\n",
    "\n",
    "Il y a deux points de vue vis-à-vis de la question du typage.\n",
    "\n",
    "Les gens habitués au typage statique se plaignent du typage dynamique en disant qu'on peut écrire des programmes faux et qu'on s'en rend compte trop tard - à l'exécution.\n",
    "\n",
    "À l'inverse les gens habitués au typage dynamique font valoir que le typage statique est très partiel, par exemple, en C si on essaie d'écrire dans un pointeur NULL, le système d'exploitation ne le permet pas et le programme sort tout aussi brutalement.\n",
    "\n",
    "Bref, selon le point de vue, le typage dynamique est vécu comme un inconvénient (pas assez de bonnes propriétés détectées par le langage) ou comme un avantage (pas besoin de passer du temps à déclarer le type des variables, ni à faire des conversions pour satisfaire le compilateur).\n",
    "\n",
    "Vous remarquerez cependant à l'usage, qu'en matière de vitesse de développement, les inconvénients du typage dynamique sont très largement compensés par ses avantages.\n",
    "\n",
    "#### 5.1.1.3  Type hints\n",
    "Signalons enfin que depuis python-3.5, il est possible d'ajouter des annotations de type, pour expliciter les suppositions qui sont faites par le programmeur pour le bon fonctionnement du code.\n",
    "\n",
    "Nous aurons là encore l'occasion de détailler ce point dans le cours, signalons simplement que ces annotations sont totalement optionnelles, et que même lorsqu'elles sont présentes elles ne sont pas utilisées à l'exécution par l'interpréteur. L'idée est plutôt de permettre à des outils externes, comme par exemple mypy, d'effectuer des contrôles plus poussés concernant la correction du programme."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc1e14d3",
   "metadata": {},
   "source": [
    "## 6 Les types numériques"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f6fb703b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1\n",
    "i = 1\n",
    "type(i)\n",
    "1 + 3\n",
    "1 * 5\n",
    "i = i + 5\n",
    "print(i)\n",
    "i = 393213216546546546546546546546565654654654231546654645654654\n",
    "#les entiers sont illimités)\n",
    "i * i\n",
    "i ** 5\n",
    "f = 4.3\n",
    "c = 4 + 5j\n",
    "c\n",
    "i + f\n",
    "i + f + c\n",
    "int(4.3)\n",
    "float(4)\n",
    "complex(4.0)\n",
    "1 + 4\n",
    "1 - 4\n",
    "3 * 5\n",
    "3 / 6\n",
    "3 // 6\n",
    "3 % 6\n",
    "abs(-4)\n",
    "True\n",
    "False\n",
    "1 < 2\n",
    "1 > 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7ada9771",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-1+0j)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# calculer un quotient\n",
    "48 // 5\n",
    "# modulo (le reste de la division par)\n",
    "48 % 5\n",
    "# puissance\n",
    "2 ** 10\n",
    "# multiplication de deux nombres complexes\n",
    "(2 + 3j) * 2.5j\n",
    "1j * 1.j\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1338a5f3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23456789012345"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tres_grand_nombre = 23_456_789_012_345\n",
    "tres_grand_nombre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "119618a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n"
     ]
    }
   ],
   "source": [
    "deux_cents = 0b11001000\n",
    "print(deux_cents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "44bc424c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n"
     ]
    }
   ],
   "source": [
    "deux_cents = 0o310\n",
    "print(deux_cents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "2bdfbd27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n"
     ]
    }
   ],
   "source": [
    "deux_cents = 0xc8\n",
    "print(deux_cents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "80f475ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "65536"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "21a31e67",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (2673862527.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[14], line 1\u001b[1;36m\u001b[0m\n\u001b[1;33m    2 && 16\u001b[0m\n\u001b[1;37m       ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "2 && 16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "cedbd2ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " (3 + 3) // 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "adb20ae7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3+2j)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " 3 + 2 * 1j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "0403655f",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'j' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[29], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;241m3\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m*\u001b[39m \u001b[43mj\u001b[49m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'j' is not defined"
     ]
    }
   ],
   "source": [
    "3 + 2 * j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "242b6035",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}