{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Premiers calculs en Python\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "285\n", "285\n" ] } ], "source": [ "i = 0\n", "s=0\n", "for i in range(10):\n", " i = i**2\n", " s+=i\n", "print(s)\n", "\n", "print (1+2**2+3**2+4**2+5**2+6**2+7**2+8**2+9**2)" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.2\n", "4.2\n", "\n", "\n", "\n", "\n", "\n" ] } ], "source": [ "a=1.2\n", "print a \n", "b=a+3\n", "print b\n", "c=1\n", "d=float(1)\n", "e=1.0\n", "print type(a)\n", "print type(b)\n", "print type(c)\n", "print type(d)\n", "print type(e)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Affectation : \n", "Ici, a est une variable, en interne elle a été automatiquement typée en flottant « float » parce qu’il y a un point décimal. a est l’identifiant de la variable (attention à ne pas utiliser le mots réservés comme identifiant), = est l’opérateur d’affectation.\n", "\n", "Forcer le typage d’une variable :\n", "d = float(1)\n", "Même sans point décimal, d est considéré comme float.\n", "\n", "Connaître le type d’un objet\n", "type(nom_de_variable) affiche le type interne d’une variable \n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "# Bases de Python \n", "\n", "## 1.1 Les Types simples\n", "\n", "+ les entiers sont représentés par:\n", " + le type `int` entre $-2^{31}$ et $2^{31}$,\n", " + le type `long` au-delà, en valeur exacte et uniquement limité par la mémoire disponible. Il est parfois caractérisé par le suffixe `L` à la fin de la valeur littérale;\n", "+ les réels sont représentés par le type `float`, en virgule flottante avec environ 15 chiffres (décimaux) significatifs. Les réels représentables sont ceux de valeur absolue comprise entre $10^{-300}$ et $10^{300}$ environ. Deux valeurs spéciales sont également possibles pour indiquer l'échec de la représentation: `nan` (not a number) et `inf` (infinity);\n", "+ les nombres complexes sont représentés par le type `complex`, implémenté en mémoire par deux `float`. Ils s'écrivent sous la forme `a + bj` où `a` et `b` sont les représentations **littérales** de deux `float`.\n", "+ le type booléen : `bool` peut prendre les valeurs `True` ou `False`. Attention aux majuscules, python y est sensible " ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1234567890\n", "\n", "1524157875019052100\n", "\n" ] }, { "data": { "text/plain": [ "152415787501905210000L" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Entiers\n", "print 1234567890\n", "print type(1234567890)\n", "print 1234567890 * 1234567890\n", "print type(1234567890 * 1234567890)\n", "1234567890 * 123456789000" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.5\n", "\n", "4.2e+19\n", "0.000456\n", "inf\n", "-1.11022302463e-16\n" ] } ], "source": [ "# Réels\n", "print 0.5\n", "print type(0.5)\n", "print 4.2 * 10000000000000000000\n", "print .456e-3\n", "print 1e500\n", "print 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 - 1.0" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(3+4j)\n", "\n", "5.0\n", "1j\n", "(-2+0j)\n" ] } ], "source": [ "# Complexes\n", "print 3 + 4j\n", "print type(3 + 4j)\n", "print abs(3 + 4j)\n", "print 1j # Correct\n", "#print j # Incorrect: il manque le \"1\"\n", "print 1j*2j" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n", "\n" ] } ], "source": [ "# Booléens\n", "print True\n", "print type(False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.2 Types itérables\n", "\n", "Il s'agit du regroupement de plusieurs valeurs dans les cases d'un conteneur. Par défaut, `python` en propose au moins quatre:\n", "\n", "+ le type `tuple`, séparé par des virgules et enclos par des parenthèses. \n", " Une fois un `tuple` créé, il est impossible de modifier ses éléments ou sa taille. \n", " Les éléments d'un tuple ne sont pas forcément de même type : collection d'objets hétérogènes.\n", " Accès indicé" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(2, 6, 8, 10, 15, 26)\n", "6\n", "2\n" ] }, { "ename": "TypeError", "evalue": "'tuple' object does not support item assignment", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;32mprint\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[1;32m 9\u001b[0m \u001b[0;31m#modification ?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mt1\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0;32mprint\u001b[0m \u001b[0mt1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" ] } ], "source": [ "#définition d'un tuple\n", "t1 = (2,6,8,10,15,26) \n", "print(t1)\n", "#taille du tuple \n", "print(len(t1))\n", "#accès indicé\n", "a = t1[0] \n", "print(a) \n", "#modification ? \n", "t1[2] = 3\n", "print t1" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(8, 10, 15)\n", "(2, 6, 8, 10)\n" ] } ], "source": [ "#plage d'indices \n", "b = t1[2:5] \n", "print(b)\n", "#autre plage\n", "c = t1[:4] \n", "print(c) " ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(2, 6, 8, 10, 15, 26, 7, 9, 31)\n", "(7, 9, 31, 7, 9, 31)\n", "(3, 6, 'toto', True, 34.1)\n", "((2, 3, 5), (6, 7, 9), (1, 8))\n", "8\n", "3\n" ] } ], "source": [ "#Un peu plus loin en tuples... concaténation\n", "t2 = (7,9,31)\n", "t3 = t1 + t2\n", "print(t3)\n", "\n", "#replication\n", "t4 = 2 * t2 \n", "print(t4)\n", "\n", "#tuples d'objets hétérogènes\n", "v1 = (3,6,\"toto\",True,34.1) \n", "print(v1)\n", "\n", "#tuple de tuples\n", "x = ((2,3,5),(6,7,9),(1,8))\n", "print(x)\n", "\n", "#accès indicé\n", "print(x[2][1])\n", "\n", "#accès aux tailles\n", "print(len(x))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "+ le type `list`, séparé par des virgules et enclos par des crochets. \n", " Le plus polyvalent\n", " En gros, une liste, c'est comme un tuple, mais DE TAILLE DYNAMIQUE et MODIFIABLE" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[2, 6, 8, 10, 15, 26]\n", "6\n", "2\n", "[2, 6, 3, 10, 15, 26]\n" ] } ], "source": [ "#définition d'une liste\n", "L1 = [2,6,8,10,15,26] \n", "print(L1)\n", "#taille de la tuple = 6 \n", "print(len(L1))\n", "#accès indicé = 2\n", "a = L1[0]\n", "print(a)\n", "#modification ! Possible !\n", "L1[2] = 3\n", "print(L1) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mauvaise nouvelle... une manière un peu étrange de définir les liste d'entiers de 1 à n... \n", "ATTENTION !" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n", "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n" ] } ], "source": [ "#liste de base : les entiers de 1 à n\n", "n=20\n", "l1=range(1,n)\n", "print l1\n", "l2=range(n)\n", "print l2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Les autres mécanismes associés aux tuples sont transposables (plages d'indices, objets hétérogènes, concaténation, réplication, liste de listes...) " ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[32, 69, 28, 69]\n", "[32, 69, 28, 69, 21]\n", "[32, 53, 69, 28, 69, 21]\n", "[32, 53, 69, 69, 21]\n", "53\n", "[32, 69, 69, 21]\n", "[21, 69, 69, 32]\n", "[21, 69, 69, 32, 34, 55]\n" ] } ], "source": [ "#autre liste\n", "L2 = [32,69,28,69]\n", "print(L2)\n", "#ajout\n", "L2.append(21)\n", "print(L2)\n", "#insertion à l'indice 1 \n", "L2.insert(1,53) \n", "print(L2)\n", "#suppression elt n°3\n", "del L2[3]\n", "print(L2)\n", "#accès + suppression elt n°1 \n", "a = L2.pop(1)\n", "print(a) \n", "print(L2)\n", "#inversion\n", "L2.reverse()\n", "print(L2)\n", "#étendre\n", "L2.extend([34,55])\n", "print(L2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Une bonne nouvelle : les \"List Compréhension\" \n", "C'est un objet simple (et concis) pour générer une liste à partir d'une fonction ou d'une autre liste." ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 25, 64, 144, 49]\n", "[1, 25, 64, 144, 49]\n" ] } ], "source": [ "#Exemple : Monter tous les chiffres de \"source\" au carré\n", "#Façon naïve (et longue) avec une boucle : \n", "source = [1,5,8,12,7]\n", "resultat1 = []\n", "for v in source:\n", " resultat1=resultat1+[v**2]\n", "print(resultat1)\n", "\n", "#Façon \"List Compréhension\"\n", "resultat2 = [v**2 for v in source] \n", "print(resultat2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Une mauvaise nouvelle : Une variable de type liste est en fait une référence => Problème de copies..." ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[61, 92, 17]\n", "[61, 92, 17]\n", "[61, 55, 17]\n", "[61, 55, 17]\n" ] } ], "source": [ "#L3\n", "L3 = [61,92,17]\n", "print(L3)\n", "#affectation ?\n", "L4 = L3\n", "print(L4)\n", "#modification d'une valeur \n", "L4[1] = 55\n", "#répercussions sur L4 bien sur... mais aussi sur L3 :-/\n", "print(L4) \n", "print(L3)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[61, 92, 17]\n", "[61, 92, 17]\n", "[61, 55, 17]\n", "[61, 92, 17]\n" ] } ], "source": [ "from copy import copy\n", "#L3\n", "L3 = [61,92,17]\n", "print L3\n", "#copie des valeurs (en python 3 L3.copy()) fonctionne aussi\n", "L4 = copy(L3) \n", "print(L4)\n", "L4[1] = 55\n", "print(L4) \n", "print(L3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "+ le type `str`, sans séparateur et enclos par des guillements simples ' ou doubles \". Il ne peut contenir que des caractères;\n", " \n", "+ le type `set`, séparé par des virgules et enclos pas des accolades. Chaque élément ne peut apparaitre qu'une fois. Il n'est pas possible d'accéder aux éléments directement par indexage. Il n'est pas possible de créer l'ensemble vide par la valeur littérale `{}`, à la place utiliser `set()` ou `set([])`;" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "bonjour le monde\n", "16\n", "bonjour\n" ] }, { "ename": "TypeError", "evalue": "'str' object does not support item assignment", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;32mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;31m#non modifiable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0ms1\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"B\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment" ] } ], "source": [ "#définir une chaîne\n", "s1 = \"bonjour le monde\" \n", "print(s1)\n", "#longueur\n", "long = len(s1) \n", "print(long)\n", "#accès indicé\n", "s2 = s1[:7] \n", "print(s2)\n", "#non modifiable \n", "s1[0] = \"B\" " ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "BONJOUR LE MONDE\n", "3\n", "2\n", "BANJAUR LE MANDE\n" ] } ], "source": [ "#méthodes associées \n", "S = s1.upper() \n", "print(S)\n", "#recherche d'une sous-chaîne\n", "id = S.find(\"JO\")\n", "print(id) \n", "#nb d'occurences\n", "nb = S.count(\"ON\")\n", "print(nb)\n", "#remplacement de « O » par « A » \n", "SA = S.replace(\"O\",\"A\") \n", "print(SA)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.3 Opérateurs\n", "\n", "Selon le type des opérandes, les opérateurs se comportent différemment. On sera par exemple attentif au fait que les opérateurs `//` (division euclidienne) et `/` (division) coïncident sur $\\mathbb Z\\times\\mathbb Z$ en Python2. Si l'on souhaite un résultat flottant, il faut transtyper explicitement l'un des opérandes en `float`.\n", "\n", "| Opérateur | Opération |\n", "|-|-|\n", "| `=` | Affectation de variable. On peut affecter plusieurs variables en une fois, en regroupant variables et valeurs à affecter dans des conteneurs. Par exemple: `a,b=1,2` ou encore `[x,y]=(0,0)` |\n", "| `+` | Addition, concaténation entre itérables de même type |\n", "| `*` | Multiplication, répétition d'un itérable |\n", "| `-` | Négation, opposé ou soustraction pour les valeurs numériques. Différence pour les ensembles |\n", "| `/` | Division |\n", "| `//` | Division entière |\n", "| `**` | Exposant |\n", "| `%` | Modulo |\n", "| `not` `or` `and` | Opérations booléennes |\n", "| `<` `<=` `==` `!=` `<>` `>=` `>` | Comparaison $<$ $\\leq$ $=$ $\\neq$ $\\neq$ $\\geq$ $>$ |\n", "| `in` | Présence d'une valeur dans un conteneur |\n", "| `not in` | Absence d'une valeur dans un conteneur |\n", "| `is` | Tester si une valeur est d'un type donné |\n", "| $\\vert$ `&` `^` | Opérations bits à bits sur les valeurs numériques. Union, intersection ou différence symétrique pour les ensembles |\n", "\n", "Python propose aussi des opérateurs combinés avec une affectation, dits *in situ*. En voici quelques-uns.\n", "\n", "| Opérateur | Opération |\n", "|-|-|\n", "| `x += y` | `x = x + y` |\n", "| `x *= y` | `x = x * y` |\n", "| `x -= y` | `x = x - y` |\n", "| `x /= y` | `x = x / y` |\n", "| `x //= y` | `x = x // y` |\n", "| `x **= y` | `x = x ** y` |\n", "| `x %= y` | `x = x % y` |\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "# Divisions\n", "print 2 / 3\n", "print 2 / 3.\n", "print 2 / float(3)\n", "print 1.5 // 0.6" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "# Conteneurs\n", "print [1, 2] + [3, 4, 5]\n", "print \"bla\" * 5\n", "print {1, 2, 3} - {2, 3, 4}\n", "print {1, 2, 3} | {2, 3, 4}" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n", "False\n", "True\n", "False\n" ] } ], "source": [ "# Comparaison\n", "print [\"abc\", \"def\"] > [\"abc\", \"dee\"]\n", "print [] > [1]\n", "print 2 in (1, 2, 3)\n", "print 1.0 is float" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 2 Structures de contrôle\n", "\n", "La structure syntaxique en Python est déterminée par les niveaux d'indentation du code.\n", "\n", "Les blocs de code relatifs à une structure de contrôle (boucle ou branchement conditionnel) sont introduits par le symbole `:` à la fin de la ligne qui précède et doivent être indentés d'un niveau supplémentaire par rapport au niveau parent. Le retour au niveau d'indentation précédent signale au compilateur la fin du bloc.\n", "\n", "\n", "En principe, on indente de quatre espaces supplémentaires à chaque niveau. Ceux-ci peuvent être obtenus facilement grâce à la touche de tabulation.\n", "\n", "## 2.1 Branchements conditionnels\n", "\n", "La syntaxe générale est\n", "\n", "```python\n", "if condition1:\n", " instructions\n", "elif condition2:\n", " instructions\n", "elif condition3:\n", " instructions\n", "else:\n", " instructions\n", "```\n", "\n" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a est negatif\n" ] } ], "source": [ "a = -5\n", "\n", "if a < 0:\n", " print 'a est negatif'\n", "elif a>0:\n", " print 'a est positif'\n", "else:\n", " print 'a est nul'\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2.2 Boucles for (itération)\n", "\n", "La syntaxe générale d'une boucle for est \n", "\n", "```python\n", "for variable in iterable:\n", " instructions\n", "```\n" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "2\n", "3\n", "1\n", "2\n", "3\n" ] } ], "source": [ "l = (1, 2, 3)\n", "\n", "# Première méthode pour parcourir un itérable: par parcours direct\n", "for x in l:\n", " print x\n", "\n", "# Deuxième méthode pour parcourir un itérable: par parcours indexé\n", "for k in range(len(l)):\n", " print l[k]" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "H\n", "e\n", "l\n", "l\n", "o\n" ] } ], "source": [ "for c in \"Hello\":\n", " print c" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "22\n", "210\n" ] } ], "source": [ "# Somme des éléments d'une liste de réels\n", "source=[1,2,3,6,10]\n", "somme=0\n", "for x in source:\n", " somme=somme+x\n", "print somme\n", "\n", "#Somme des entiers de 1 à n\n", "n=20\n", "somme=0\n", "for k in range(1,n+1):\n", " somme=somme+k\n", "print somme" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "156\n", "True\n" ] } ], "source": [ "# Somme des entiers pairs de 1 à n\n", "n=25\n", "s=0\n", "for k in range(1,n+1):\n", " if k%2==0:\n", " s=s+k\n", "print s\n", "\n", "# verification \n", "pairs=[k for k in range(1,n+1) if k%2==0]\n", "so=sum(pairs)\n", "print s==so " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2.3 Boucles while (itération)\n", "\n", "La syntaxe générale d'une boucle While est \n", "\n", "```python\n", "while condition:\n", " instructions\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 3 Fonctions\n", "\n", "## 3.1 Fonctions de base\n", "\n", "Comme on l'a vu, une fonction s'évalue avec des parenthèses et peut également s'affecter à une variable (dans ce cas sans parenthèses).\n", "\n", "Les fonctions peuvent prendre plusieurs paramètres, séparés par des virgules. Certains paramètres peuvent avoir des valeurs par défaut, il est alors possible de les omettre lors de l'évaluation.\n", "\n", "Pour consulter la rubrique d'aide relative à une fonction, on peut taper son nom suivi ou précédé d'un point d'interrogation. \n", "\n", "Voici une liste de quelques fonctions prédéfinies.\n", "\n", "| Fonction | Usage |\n", "|-|-|\n", "| `all(c)` ou `any(c)` | Indique si respectivement tous ou l'un des éléments du conteneur `c` convertis en booléens valent `True` |\n", "| `input(prompt = '')` | Demande à l'utilisateur d'entrer une valeur avec une invite optionnelle |\n", "| `len(c)` | Renvoie la longueur (`int`) du conteneur `c` |\n", "| `map(f, c)` | Renvoie le conteneur de même type que `c` contenant les valeurs de la fonction `f` appliquée aux éléments de `c` |\n", "| `min(c)` ou `max(c)` | Minimum et maximum d'un conteneur dont les éléments sont comparables entre eux |\n", "| `range(start = 0, stop, step = 1)` | Renvoie une liste contenant les entiers de `min` à `max` exclus par pas de longueur `step` |\n", "| `round(x, n = 0)` | Renvoie l'arrondi de la valeur numérique `x` sous flottante à (au plus) `n` chiffres décimaux après la virgule |\n", "| `sum(c)` | Renvoie la somme des éléments du conteneur `c` |\n", "| `type(x)` | Renvoie le type de `x` |" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]\n", "100\n" ] } ], "source": [ "l = range(100)\n", "print l\n", "print len(l)" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[-10, -9, -8, -7, -6, -5, -4, -3, -2, -1]\n", "-55 -10 -1\n", "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n" ] } ], "source": [ "l = range(-10, 0)\n", "print l\n", "print sum(l), min(l), max(l)\n", "print map(abs, l)" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Entrer une valeur : -3\n", "La valeur est de type : \n" ] } ], "source": [ "x = input(\"Entrer une valeur : \")\n", "print \"La valeur est de type :\", type(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.2 Fonctions de classes\n", "\n", "En réalité, la plupart des types (y compris numériques) sont représentés par Python en interne comme des classes. Une classe est un agrégat de données et de fonctions. Pour accéder à ceux-ci, on postfixe l'instance par un point suivi du nom du *champ* (donnée) ou de la *méthode* (fonction) correspondant.\n", "\n", "Par exemple, une valeur de type `complex` possède:\n", "\n", "+ des champs `real` et `imag`;\n", "+ une méthode `conjugate()`.\n" ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-3.0\n", "2.0\n" ] }, { "ename": "NameError", "evalue": "name 'real' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m3j\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32mprint\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreal\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;32mprint\u001b[0m \u001b[0mreal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0;32mprint\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconjugate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mNameError\u001b[0m: name 'real' is not defined" ] } ], "source": [ "print (5-3j).imag\n", "z = 2 + 3j\n", "print z.real\n", "print real(z)\n", "print z.conjugate()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Une méthode simple pour connaitre l'ensemble des champs et méthodes d'une classe, est de commencer à taper son nom suivi d'un point, puis d'appuyer sur la touche de tabulation.\n", "\n", "Voici une courte liste de quelques champs et méthodes utiles.\n", "\n", "| Classe | Champ ou méthode | Utilisation |\n", "|-|-|\n", "| `complex` | `imag` `real` | Parties réelles et imaginaires |\n", "| | `conjugate()` | Renvoie le conjugué |\n", "| `list` | `append(x)` | Ajoute un élément en fin de liste |\n", "| | `count(x)` | Renvoie le nombre d'occurences de `x` |\n", "| | `index(x)` | Renvoie l'index de la première occurence |\n", "| | `insert(index, x)` | Insère un élément à l'index spécifié |\n", "| | `pop(index = -1)` | Enlève un élément et renvoie sa valeur |\n", "| | `remove(x)` | Enlève la première occurence de `x` |\n", "| | `reverse()` | Inverse l'ordre des éléments |\n", "| | `sort()` | Classe la liste |\n", "| `str` | `find(substr)` | Renvoie la première occurence d'une sous-chaîne |\n", "| | `upper()` | Renvoie la chaîne obtenue en remplaçant les minuscules par des majuscules |\n", "| `set` | `add(x)` | Ajoute un élément (sauf s'il y est déjà) |\n", "| | `clear()` | Enlève tous les éléments |\n", "| | `discard(x)` | Enlève un élément (s'il y est) |\n", "| `tuple` | `count(x)` | Renvoie le nombre d'occurences de `x` |\n", "| | `index(x)` | Renvoie l'index de la première occurence |" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "print \"bonjour\".find(\"jour\")\n", "print [1, 3, 2, 5, 1, 4, 7, 1, 8, 0, 6, 1, 2].count(1)\n", "print (2+3j).conjugate()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.3 Définition de nouvelles fonctions\n", "\n", "Voici un exemple de syntaxe.\n", "\n", "```python\n", "def f(x, y=4, z=5):\n", " # instructions\n", " return valeur\n", "```\n", "\n", "Cette instruction stocke dans la variable `f` une fonction à trois variables `x`, `y` et `z`. \n", "Les variables `y` et `z` ont des valeurs par défaut. Le tableau suivant regroupe différentes manières d'appeler `f` ainsi que les valeurs prises par les paramètres `x`, `y` et `z`. \n", "\n", "| Appel | x | y | z |\n", "|-|-|-|-|\n", "| `f(1, 2, 3)` | 1 | 2 | 3 |\n", "| `f(x=1, y=2, z=3)` | 1 | 2 | 3 |\n", "| `f(1, 2)` | 1 | 2 | 5 |\n", "| `f(1)` | 1 | 4 | 5 |\n", "| `f(1, z=3)` | 1 | 4 | 3 |\n", "\n", "En principe, on doit s'assurer que les instructions composant le corps de la fonction mènent toujours à une instruction `return`, quels que soient les éventuels branchements conditionnels. Dans le cas contraire, on prend le risque que la fonction renvoie `None`. Cela dit, ce comportement peut être désiré pour certaines fonctions \"procédurales\", par exemple celles qui se contentent d'effectuer une opération d'affichage (représentation graphique ou impression) et pour lesquelles la valeur renvoyée n'a pas d'importance.\n", "\n", "La première instruction `return` rencontrée interrompt immédiatement l'exécution de la fonction. On prendra garde à ne pas confondre `print` et `return`, la première se contentant de modifier l'affichage sans renvoyer de valeur." ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "None\n" ] } ], "source": [ "def f(x):\n", " if x > 0:\n", " return x\n", "\n", "print f(1)\n", "print f(-1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il est également possible de définir des fonctions récursives." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "from numpy import log\n", "def factorial(n):\n", " if n == 0:\n", " return 1\n", " else:\n", " return n * factorial(n - 1)\n", "\n", "x=log(float(factorial(100)))\n", "print x\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 2", "language": "python", "name": "python2" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.11" } }, "nbformat": 4, "nbformat_minor": 0 }