{ "cells": [ { "cell_type": "markdown", "id": "4ce57a62", "metadata": {}, "source": [ "## Syntaxe de base\n", "\n", "Cette section résume en quelques lignes les éléments essentiels et la syntaxe du langage python." ] }, { "cell_type": "code", "execution_count": 29, "id": "3210bf8c", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
run previous cell, wait for 2 seconds
\n", "" ], "text/plain": [ "" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\n", "# Afficher la table des matières\n", "\n", "from jyquickhelper import add_notebook_menu\n", "add_notebook_menu()" ] }, { "cell_type": "markdown", "id": "006d262a", "metadata": {}, "source": [ "Connaitre la version installée :" ] }, { "cell_type": "code", "execution_count": 30, "id": "27cde259", "metadata": { "ExecuteTime": { "end_time": "2021-08-29T17:27:48.012042Z", "start_time": "2021-08-29T17:27:48.005899Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3.8.8 (default, Apr 13 2021, 12:59:45) \n", "[Clang 10.0.0 ]\n" ] } ], "source": [ "import sys\n", "print (sys.version)" ] }, { "cell_type": "markdown", "id": "d78d88b0", "metadata": {}, "source": [ "Avec la version 3.x, le langage a introduit quelques changements importants qui seront précisés. Il est préférable de choisir la version 3.5 plutôt que 2.7. Outre le fait qu'elle contient les dernières évolutions, elle est beaucoup plus cohérente en ce qui concerne les chaînes de caractères." ] }, { "cell_type": "markdown", "id": "ecc0ce8a", "metadata": { "ExecuteTime": { "end_time": "2021-08-29T17:27:48.479178Z", "start_time": "2021-08-29T17:27:48.464515Z" } }, "source": [ "Quelques précisions sur le langage :\n", "\n", "- **Commentaires :** Les commentaires dans un programme commencent par le symbole **#** et vont jusqu’à la fin de la ligne.\n", "\n", "- Généralement une instruction par ligne, sans marqueur à la fin. Si plusieurs instructions par ligne, les séparer par **;**\n", "\n", "- Contraintes de nommage : Les noms de variable (fonction, classe...) doivent respecter des règles syntaxiques : ils peuvent contenir des lettres, chiffres, des underscore (_) mais doivent commencer par une lettre\n", "\n", "- L’indentation est primordiale.\n", "\n", "- On commence à compter à 0.\n", " \n", "- L’instruction **print** permet d’afficher n’importe quelle information. **print** est une fonction, tout ce qui doit être affiché doit l’être entre parenthèses.\n", "\n", "- L’instruction **help** affiche l’aide associée à une variable, une fonction, une classe, une méthode, un module. Pour une fonction, une classe, une méthode du programme, cette aide correspond à une chaîne de caractères encadrée par trois \". Ce message d’aide peut s’étaler sur plusieurs lignes." ] }, { "cell_type": "markdown", "id": "d1ceb331", "metadata": {}, "source": [ "### Valeurs, Variables et Affectations" ] }, { "cell_type": "markdown", "id": "2b216ebb", "metadata": { "ExecuteTime": { "end_time": "2021-08-29T17:27:48.255682Z", "start_time": "2021-08-29T17:27:48.240474Z" } }, "source": [ "#### Les variables" ] }, { "cell_type": "markdown", "id": "0ac7c28e", "metadata": {}, "source": [ "Une variable permet de stocker des données pour les réutiliser plus tard.\n", "\n", "a=< valeur >\n", "\n", "Le type de **** détermine le type de la variable **a**. Si une variable porte déjà le même nom, son contenu est écrasé (perdu aussi)." ] }, { "cell_type": "code", "execution_count": 31, "id": "17909703", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Affectation d'une valeur à une variable\n", "a = 1\n", "a" ] }, { "cell_type": "markdown", "id": "3879adae", "metadata": {}, "source": [ "Une affectation crée une liaison entre un nom et une donnée." ] }, { "cell_type": "markdown", "id": "f07db816", "metadata": {}, "source": [ "##### Contraintes de nommage\n", "\n", "Les noms de variable (de fonction, de classe...) doivent respecter des règles syntaxiques :\n", " - peuvent contenir des lettres, chiffres, des underscore (_) mais doivent commencer par une lettre\n", " - Par convention les noms de variables sont en minuscule, et les noms de classe commencent par une majuscule.\n", " - la casse est importante (ma_variable ≠ Ma_VaRiAbLE)\n", " - certains noms *mots-clés* sont réservés par le langage. Ces mots-clés sont :\n", "\n", " and, as, assert, break, class, continue, def, del, elif, else, except, \n", " exec, finally, for, from, global, if, import, in, is, lambda, not, or,\n", " pass, print, raise, return, try, while, with, yield\n", "\n", "Note: faites attention au mot-clé **lambda**, qui pourrait facilement être une variable dans un programme scientifique. Mais étant un mot-clé, il ne peut pas être utilisé comme un nom de variable." ] }, { "cell_type": "markdown", "id": "45964339", "metadata": {}, "source": [ "#### Affectations\n" ] }, { "cell_type": "markdown", "id": "57814fc7", "metadata": {}, "source": [ "##### Affectation simple\n", "\n", "\n", "L'opérateur d'affectation en Python est effectuée par **=**. Python est un langage de typage dynamique, donc vous n'avez pas besoin de spécifier le type d'une variable lors de sa création.\n", "\n", "L'affectation d'une valeur à une nouvelle variable crée la variable.\n", "De manière générale nom_variable = valeur." ] }, { "cell_type": "code", "execution_count": 32, "id": "931f02b2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(2, 3)" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Affectations simples\n", "a = 2\n", "b = 3\n", "a, b" ] }, { "cell_type": "markdown", "id": "ceaa872a", "metadata": {}, "source": [ "##### Expressions\n", "\n", "Une expression combine des variables et des littéraux par l’intermédiaire d’opérateurs et de fonctions.\n", " \n", "Python évalue les expressions : il applique les opérateurs et les fonctions afin de déterminer leur valeur résultat." ] }, { "cell_type": "code", "execution_count": 33, "id": "2bcfc9cb", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1, 2, 3, 4)" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(1, 2) + (3, 4)" ] }, { "cell_type": "code", "execution_count": 34, "id": "6cbd35af", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "28" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c=5 ; max(a, b) + 5*c" ] }, { "cell_type": "markdown", "id": "5e9cf8c5", "metadata": {}, "source": [ "#### Types de données simples" ] }, { "cell_type": "markdown", "id": "94d498eb", "metadata": {}, "source": [ "Chaque donnée en Python est un objet dont :\n", " - le type caractérise la nature de l’objet, ses opérations, cf. `type()`, `dir()`\n", " - l’identité caractérise l’objet (e.g. une adresse mémoire), `id()`\n", " - la valeur est le contenu des données" ] }, { "cell_type": "code", "execution_count": 35, "id": "55e0119d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4611181488" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a=\"Bonjour\"\n", "id(a)" ] }, { "cell_type": "code", "execution_count": 36, "id": "b91bfbd3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "str" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(a)" ] }, { "cell_type": "code", "execution_count": 37, "id": "5ada7921", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['__add__',\n", " '__class__',\n", " '__contains__',\n", " '__delattr__',\n", " '__dir__',\n", " '__doc__',\n", " '__eq__',\n", " '__format__',\n", " '__ge__',\n", " '__getattribute__',\n", " '__getitem__',\n", " '__getnewargs__',\n", " '__gt__',\n", " '__hash__',\n", " '__init__',\n", " '__init_subclass__',\n", " '__iter__',\n", " '__le__',\n", " '__len__',\n", " '__lt__',\n", " '__mod__',\n", " '__mul__',\n", " '__ne__',\n", " '__new__',\n", " '__reduce__',\n", " '__reduce_ex__',\n", " '__repr__',\n", " '__rmod__',\n", " '__rmul__',\n", " '__setattr__',\n", " '__sizeof__',\n", " '__str__',\n", " '__subclasshook__',\n", " 'capitalize',\n", " 'casefold',\n", " 'center',\n", " 'count',\n", " 'encode',\n", " 'endswith',\n", " 'expandtabs',\n", " 'find',\n", " 'format',\n", " 'format_map',\n", " 'index',\n", " 'isalnum',\n", " 'isalpha',\n", " 'isascii',\n", " 'isdecimal',\n", " 'isdigit',\n", " 'isidentifier',\n", " 'islower',\n", " 'isnumeric',\n", " 'isprintable',\n", " 'isspace',\n", " 'istitle',\n", " 'isupper',\n", " 'join',\n", " 'ljust',\n", " 'lower',\n", " 'lstrip',\n", " 'maketrans',\n", " 'partition',\n", " 'replace',\n", " 'rfind',\n", " 'rindex',\n", " 'rjust',\n", " 'rpartition',\n", " 'rsplit',\n", " 'rstrip',\n", " 'split',\n", " 'splitlines',\n", " 'startswith',\n", " 'strip',\n", " 'swapcase',\n", " 'title',\n", " 'translate',\n", " 'upper',\n", " 'zfill']" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dir(a)" ] }, { "cell_type": "code", "execution_count": 38, "id": "0f66c3f3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on built-in function upper:\n", "\n", "upper() method of builtins.str instance\n", " Return a copy of the string converted to uppercase.\n", "\n" ] } ], "source": [ "help(a.upper)" ] }, { "cell_type": "markdown", "id": "71d55a93", "metadata": {}, "source": [ "##### Types fondamentaux" ] }, { "cell_type": "code", "execution_count": 39, "id": "3af95074", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "int" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# entier (integers)\n", "a = 1\n", "type(a)" ] }, { "cell_type": "code", "execution_count": 40, "id": "5674fcf5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "float" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# réel (float)\n", "a = 1.0\n", "type(a)" ] }, { "cell_type": "code", "execution_count": 41, "id": "23c7f978", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "bool" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Booléen (boolean)\n", "b1 = True\n", "b2 = False\n", "type(b2)" ] }, { "cell_type": "code", "execution_count": 42, "id": "930d285f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "complex" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Nombres complexes: notez que l'utilisation de `j` permet de spécifier la partie imaginaire \n", "a = 1.0 - 1.0j\n", "type(a)" ] }, { "cell_type": "code", "execution_count": 43, "id": "d4556cab", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(1-1j)\n", "1.0 -1.0\n" ] } ], "source": [ "print(a)\n", "print(a.real, a.imag)" ] }, { "cell_type": "markdown", "id": "1d1a0b8b", "metadata": {}, "source": [ "Vous pouvez également tester si les variables sont de certains types :" ] }, { "cell_type": "code", "execution_count": 44, "id": "b3fa9f07", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(a) is float" ] }, { "cell_type": "markdown", "id": "3c3478fc", "metadata": {}, "source": [ "##### Typage dynamique\n", "\n", "Une variable possède un type associé, bien qu'il ne soit pas explicitement spécifiée. Le type est dérivé de la valeur qui lui a été attribuée.\n", "L’instruction type(a) retourne le type de la variable a." ] }, { "cell_type": "code", "execution_count": 45, "id": "fa6b4a4e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "int" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = 4\n", "type(a)" ] }, { "cell_type": "markdown", "id": "698035e7", "metadata": {}, "source": [ "Si vous attribuez une nouvelle valeur à une variable, son type peut changer." ] }, { "cell_type": "code", "execution_count": 46, "id": "60622998", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tuple" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = (3, 8)\n", "type(a)" ] }, { "cell_type": "markdown", "id": "8f1f50f6", "metadata": {}, "source": [ "##### Typage fort" ] }, { "cell_type": "code", "execution_count": 47, "id": "4745e098", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "15.5" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a=12.5\n", "3+a" ] }, { "cell_type": "code", "execution_count": 48, "id": "a2e25a1c", "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "can only concatenate str (not \"float\") to str", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m/var/folders/2b/cj2pm60x61s5qlxpmr7g7km00000gn/T/ipykernel_5800/4172067606.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m\"La valeur de a = \"\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"float\") to str" ] } ], "source": [ "\"La valeur de a = \"+a" ] }, { "cell_type": "markdown", "id": "8ef6a255", "metadata": {}, "source": [ "Le **typage fort** signifie que les conversions implicites de types sont formellement interdites.\n", "\n", "Les **seules conversions implicites** de types sont entre types numériques : **int → float → complex**.\n", "\n", "Pour toutes les autres conversions, il faut utiliser explicitement des fonctions de conversion." ] }, { "cell_type": "code", "execution_count": 49, "id": "3299afb8", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'La valeur de de = 12.5'" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"La valeur de de = \"+str(a)" ] }, { "cell_type": "markdown", "id": "d45dc921", "metadata": {}, "source": [ "### Opérateurs et opérateurs de comparaisons\n", "\n", "La plupart des opérateurs et des opérateurs de comparaisons en Python fonctionnent comme on peut s'y attendre:\n", "\n", " - Opérateurs arithmétiques +, -, *, /, // (division entière), '**' puissance" ] }, { "cell_type": "code", "execution_count": 50, "id": "7b5eca34", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(3, -1, 2, 0.5)" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "1 + 2, 1 - 2, 1 * 2, 1 / 2" ] }, { "cell_type": "code", "execution_count": 51, "id": "fb4270be", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(3.0, -1.0, 2.0, 0.5)" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "1.0 + 2.0, 1.0 - 2.0, 1.0 * 2.0, 1.0 / 2.0" ] }, { "cell_type": "code", "execution_count": 52, "id": "5379a48b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.0" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Division entière des nombres réels\n", "3.0 // 2.0" ] }, { "cell_type": "markdown", "id": "8dbfdc54", "metadata": {}, "source": [ "**Remarque :** L'opérateur **/** effectue toujours une division en virgule flottante dans Python 3.x. Cela n'est pas vrai dans Python 2.x, où le résultat de / est toujours un entier si les opérandes sont des entiers. Pour être plus précis, 1/2 = 0.5 (float) dans Python 3.x et 1/2 = 0 (int) dans Python 2.x (mais 1.0 / 2 = 0.5 dans Python 2.x)." ] }, { "cell_type": "markdown", "id": "e67f2925", "metadata": {}, "source": [ " - Les opérateurs booléens sont : and, not, or." ] }, { "cell_type": "code", "execution_count": 53, "id": "0f547fb6", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(False, False, True)" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "True and False, not True, True or False" ] }, { "cell_type": "markdown", "id": "1f4217db", "metadata": {}, "source": [ " - Les opérateurs de comparaison : >, <, >= (supérieur ou égal), <= (inférieur ou égal), == égalité, is identiques." ] }, { "cell_type": "code", "execution_count": 54, "id": "9e5f2342", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(True, True)" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "2 > 1, 3<=6" ] }, { "cell_type": "code", "execution_count": 55, "id": "20f2fcd1", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# égalité\n", "[1,2] == [1,2]" ] }, { "cell_type": "code", "execution_count": 56, "id": "5c522209", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Objets identiques?\n", "l1 = l2 = [1,2]\n", "\n", "l1 is l2" ] } ], "metadata": { "celltoolbar": "Tags", "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.8.8" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false } }, "nbformat": 4, "nbformat_minor": 5 }