\n", "\n", "\n", "\n", "Cette fiche récapitule les principales syntaxes élémentaires utilisées au lycée.SYNTAXES ÉLÉMENTAIRES EN LANGAGE PYTHON
\n", "\n", "
\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "1. Les principaux types de variables
\n", "
\n", "\n", "\n", "\n", "
\n", "\n", " \n", "\n", " \n", " Syntaxe Python \n", "\n", " Description \n", "\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "int \n", "\n", " a=-3 $\\quad$ b=7 \n", "\n", " Nombres entiers \n", "\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "float \n", "\n", " a=2/7 $\\quad$ b=7.0 $\\quad$ c=3.3 \n", "\n", " Nombres flottants \n", "
(représentation des nombres décimaux)\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "str \n", "\n", " text='Hello prof' \n", "\n", " Chaînes de caractères (string) \n", "\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "bool \n", "\n", " 2+3==5 $\\quad$ 2.7>=5.5 \n", "\n", " Booléens (valeur True(=1) ou False(=0)) \n", "\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "list \n", "\n", " L1=[2,5,7] $\\quad$ L2=['salut',3.8,8] \n", "\n", " Listes d'éléments \n", "
NB: Les éléments de la liste peuvent être de tous types
\n", "\n", "\n", "\n", "$\\quad\\quad$Ci-dessous quelques exemples modifiables de syntaxes. Pour exécuter une cellule, sélectionner la cellule puis SHIFT+Entrée.\n", "" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = 3 # Création d'une variable nommée a de valeur 3\n", "\n", "a # Affichage du contenu de la variable a" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "int" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(a) # Affichage du type de la variable a" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Hello prof'" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "text = 'Hello prof' # Création d'une variable nommée text de valeur 'Hello prof'\n", "\n", "text # Affichage du contenu de la variable text" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "str" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(text) # Affichage du type de la variable text" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "
\n", "- Typage : Python est un langage typé, mais l'utilisateur n'a pas à déclarer le type d'élément qu'il définit et utilise, l'interpréteur Python attribue lui-même le type adéquat. On peut vérifier le type d'un élément avec l'instruction type( ).
\n", "- Conversion de type : On peut effectuer une conversion de type avec les instructions int( ) ; float( ) ; str( ) ; …
\n", "
\n", "À savoir : Une saisie du type a=3 génère par défaut un int, mais une saisie a=3.0 génère par défaut un float.
\n", "L’instruction input() génère automatiquement un élément de type str et il peut donc être nécessaire de convertir le type. En général, on n’utilisera pas l’instruction input() (ni print()), préférant la définition de fonctions, éventuellement appelées en console.
\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "2. Les instructions élémentaires
\n", "
\n", "\n", "\n", "\n", "
\n", "\n", " \n", "\n", " \n", " Syntaxe Python \n", "\n", " Description \n", "\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "Affectation \n", "\n", " a = 7 \n", "\n", " Affectation de la valeur 7 à la variable a \n", "\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "Opérations \n", "
élémentaires\n", " a+b $\\quad$ a-b $\\quad$ a*b $\\quad$ a**b \n", "
a/b $\\quad$ a//b $\\quad$ a%b\n", " Somme, différence, produit, puissance, \n", "
quotient décimal, quotient et reste de la division euclidienne.\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "Tests \n", "\n", " a == b $\\quad$ a != b \n", "
a < b $\\quad$ a <= b $\\quad$ a > b $\\quad$ a >= b\n", " Test d'égalité, de non égalité, de comparaisons. \n", "
Renvoie un booléen (True ou False)
NB: On peut combiner avec or, and, not\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "Instruction \n", "
conditionnelle\n", " if condition: \n", "
$\\quad$ |instructions_V
else:
$\\quad$ |instructions_F\n", " Réalisation des instructions_V si la condition est True, et réalisation des instructions_F si la condition est False. \n", "
NB1: else est facultatif
NB2: dans une série d'instructions conditionnelles imbriquées, \"else if\" se condense en \"elif\".
\n", "\n", "\n", "\n", "\n", "$\\quad\\quad$Ci-dessous quelques exemples modifiables de syntaxes. Pour exécuter une cellule, sélectionner la cellule puis SHIFT+Entrée.\n", "" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "a = 7 ; b = 3 # Affectation des valeurs 3 et 7 aux variables respectivement nommées a et b" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "10" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a+b # Calcul de la somme de a et b" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "343" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a**b # Calcul de a puissance b" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a == b # Test d'égalité de a et b" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'salut'" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "'sa'+'lut' # Concaténation de deux chaînes de caractères" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a>b\n" ] } ], "source": [ "if a<=b: # exemple d'instruction conditionnelle avec la condition a<=b\n", " print(\"a<=b\") # Cette instruction est exécutée si a<=b est True\n", "else:\n", " print(\"a>b\") # Cette instruction est exéctuée si a<=b est False" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'a>b'" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"a<=b\" if a<=b else \"a>b\" # Exemple de bloc conditionnel" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "
\n", "- Tests sur flottants : Le codage des nombres décimaux à l’aide du type float génère des approximations et il faut donc éviter d’effectuer des tests d’égalité sur des éléments de type float. Par exemple, 0.1+0.1+0.1==0.3 renvoie False.
\n", "- Opérations sur chaînes de caractères : L’opération 'sa'+'lut' effectue la concaténation : 'salut'. L’opération 'miam'*3 effectue une répétition : 'miammiammiam'.
\n", "- Bloc conditionnel : Une syntaxe experte permet de créer un bloc prenant une valeur en fonction de la réalisation ou non d’une condition :
\n", "
valeur_V if Test else valeur_F vaut valeur_V si le Test vaut True et vaut valeur_F sinon.
\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "3. La structure fonctionnelle
\n", "
\n", "\n", "\n", "\n", "
\n", "\n", " \n", "\n", " \n", " Syntaxe Python \n", "\n", " Description \n", "\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "Définition \n", "
d'une fonction\n", " def f(x): \n", "
$\\quad$ |instructions à réaliser
$\\quad$ return resultat\n", " Définition d'une fonction recevant un/des argument(s) x,... et renvoyant resultat. \n", "
(arguments et résultat de tous types possibles)\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "Appel à une \n", "
fonction\n", " f(x) \n", "\n", " Renvoie la valeur de l'image de x par la fonction f. \n", "
\n", "\n", "\n", "\n", "\n", "$\\quad\\quad$Ci-dessous quelques exemples modifiables de syntaxes. Pour exécuter une cellule, sélectionner la cellule puis SHIFT+Entrée.\n", "" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# Exemple élémentaire\n", "\n", "def f(x): # Définition de la fonction\n", " \"fonction qui calcule le carré de x\" # Description de la fonction\n", " return x**2 # Renvoi de la valeur" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "9" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f(3) # Appel à la fonction " ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "# Exemple de fonction à plusieurs arguments et renvoyant plusieurs valeurs\n", "\n", "def somme_vecteurs(x1,y1,x2,y2):\n", " \"\"\"\n", " fonction qui renvoie la somme de deux vecteurs u1(x1,y1) et u2(x2,y2)\n", " \"\"\"\n", " x = x1+x2 \n", " y = y1+y2\n", " return x,y \n", "\n", "# NB : on peut aussi écrire return x1+x2,y1+y2 \n", "# pour éviter les variables intermédiaires x et y " ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(5, -2)" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "somme_vecteurs(2,5,3,-7) # Appel à la fonction " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "
\n", "- Arguments d’une fonction : Une fonction peut ne pas avoir d’argument, et on écrit dans ce cas def f():, ou prendre plusieurs valeurs en arguments, par\n", "exemple def milieu(xA,yA,xB,yB):. On peut fixer une valeur par défaut à un argument : def f(x=0):.\n", "
- Instruction return : Une fonction peut ne pas renvoyer de résultat (pas de return) et on parle alors plutôt de processus. L’exécution d’un return interrompt\n", "l’exécution de la fonction. Ainsi, pour renvoyer plusieurs informations, il faut les associer (par exemple en les séparant par des virgules).
\n", "- Variables locales et globales : En général et par défaut, une fonction n’altère pas les valeurs des variables globales du programme et agit sur des copies des variables (à l’exception de certaines opérations, notamment sur les listes).
\n", "
\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "4. Les boucles
\n", "
\n", "\n", "\n", "\n", "
\n", "\n", " \n", "\n", " \n", " Syntaxe Python \n", "\n", " Description \n", "\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "Boucle bornée \n", "
\n", "«Pour»\n", " for k in range(n): \n", "
$\\quad$ |instructions à réaliser\n", " Boucle effectuée pour k prenant les valeurs entières de 0 inclus à n exclu \n", "
(0$≤$k$<$n donc n valeurs générées)\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "Boucle non bornée \n", "
\n", "«Tant que»\n", " while condition : \n", "
$\\quad$ |instructions à réaliser\n", " Boucle effectuée tant que la condition (de type bool) est vérifiée. \n", "
\n", "NB : Pour créer une condition, voir Tests (Rappel : Il faut éviter les tests d’égalité sur les float)
\n", "\n", "\n", "\n", "\n", "$\\quad\\quad$Ci-dessous quelques exemples modifiables de syntaxes. Pour exécuter une cellule, sélectionner la cellule puis SHIFT+Entrée.\n", "" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n" ] } ], "source": [ "for k in range(5): # exemple d'utilisation du range\n", " print(k) # range(5) génère les entiers à partir de 0 avec un pas de 1 et inférieurs strictement à 5" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n", "7\n", "10\n" ] } ], "source": [ "for k in range(4,12,3): # exemple d'utilisation du range\n", " print(k) # range(4,12,3) génère les entiers à partir de 4 avec un pas de 3 et inférieurs strictement à 12" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "rouge\n", "vert\n", "bleu\n" ] } ], "source": [ "for mot in ['rouge','vert','bleu']: # exemple de parcours d'une liste\n", " print(mot)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "p\n", "y\n", "t\n", "h\n", "o\n", "n\n" ] } ], "source": [ "for lettre in 'python': # exemple de parcours d'une chaîne de caractères\n", " print(lettre)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10\n", "5.0\n", "2.5\n", "1.25\n", "0.625\n", "0.3125\n", "0.15625\n" ] } ], "source": [ "a = 10\n", "\n", "while a>0.1: # exemple d'utilisation d'une boucle while\n", " print(a)\n", " a=a/2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "
\n", "- Options du range :\n", "
\n", "\n", "
\n", "- range(n1,n2) permet de générer les entiers k tels que n1≤k
\n", " - range(n1,n2,p) permet de générer les entiers k tels que n1≤k
\n", " - Compléments sur for : range est une instruction permettant de générer des int, mais on peut aussi faire itérer la boucle for sur une liste prédéfinie avec d’autres typages : for mot in ['rouge','vert','bleu'] ou for lettre in 'python'.\n", "
\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "5. Gestion des listes
\n", "
\n", "\n", "\n", "\n", "
\n", "\n", " \n", "\n", " \n", " Syntaxe Python \n", "\n", " Description \n", "\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "Création \n", "\n", " L=[] \n", "
L=[2,-7,5,6.3]\n", " Création d’une liste vide \n", "
Création d’une liste contenant 4 éléments\n", " \n", "\n", " \n", " \n", " \n", " \n", " Longueur \n", "\n", " len(L) \n", "\n", " Fonction renvoyant le nombre d’éléments de la liste L. \n", "
\n", "NB : len = length\n", " \n", "\n", " \n", " \n", " \n", " \n", " Accès à une valeur \n", "\n", " L[k] \n", "
L[k]=v\n", " Donne accès à la valeur de rang k de la liste L \n", "
Affecte la valeur v au terme de rang k de la liste L
\n", "Atention : Les rangs sont indexés à partir de 0 donc la valeur de rang k est la k+1 ème valeur de la liste.\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "Test \n", "\n", " v in L \n", "\n", " Renvoie un booléen indiquant si la valeur v est dans la liste L. \n", "\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "Ajout et suppression \n", "
d'éléments\n", " L.append(v) \n", "
L.remove(v)
L.pop(k)\n", " append : Place la valeur v à la fin de la liste L (ajout d’un élément). \n", "
remove : Supprime la première apparition de la valeur v dans la liste L.
pop : Supprime (et renvoie) la valeur de rang k de la liste L.\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "Création d'une liste par extensions successives et par compréhension \n", "\n", " L=[] \n", "
for k in range(11):
$\\quad$ L.append(k**2)
est équivalent à
L=[k**2 for k in range(11)]\n", " Création d’une liste à partir d’une liste vide, par extensions successives (ici, création de la liste des carrés des entiers de 0 à 10)\n", "et son équivalent en syntaxe rapide, par compréhension. \n", "\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "Création d'une liste par extensions successives et par compréhension, avec condition \n", "\n", " L=[] \n", "
for k in range(11):
$\\quad$ if k%2:
$\\quad\\quad\\;\\;$ L.append(k**2)
est équivalent à
L=[k**2 for k in range(11) if k%2]\n", " Création d’une liste à partir d’une liste vide, par extensions successives sous condition (ici, création de la liste des carrés des entiers k de 0 à 10 pour k impair) et son équivalent en syntaxe rapide, par compréhension avec condition.
\n", "\n", "\n", "\n", "\n", "$\\quad\\quad$Ci-dessous quelques exemples modifiables de syntaxes. Pour exécuter une cellule, sélectionner la cellule puis SHIFT+Entrée.\n", "" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[2, -7, 5, 6.3]" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L=[2,-7,5,6.3] # création d'une liste contenant 4 valeurs\n", "L # affichage de la liste" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(L) # affichage de la taille de la liste" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-7" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L[1] # affichage de l'élément de rang 1 de la liste" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[2, 4, 5, 6.3]" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L[1] = 4 # affectation d'une nouvelle valeur à l'élément de rang 1 de la liste\n", "L # affichage de la liste" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "5 in L # test de l'appartenance d'une valeur à la liste" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[2, 4, 5, 6.3, 7]" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L.append(7) # ajout d'une valeur dans la liste\n", "L # affichage de la liste" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[2, 4, 6.3, 7]" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L.remove(5) # suppression d'une valeur de la liste\n", "L # affichage de la liste" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[2, 6.3, 7]" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L.pop(1) # suppression de l'élément de rang 1 de la liste\n", "L # affichage de la liste" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#génération d'une liste par extensions successives\n", "\n", "L=[ ]\n", "for k in range(11):\n", " L.append(k**2)\n", "\n", "L # affichage de la liste " ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#génération d'une liste par compréhension\n", "\n", "L=[ k**2 for k in range(11) ]\n", "\n", "L # affichage de la liste " ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 9, 25, 49, 81]" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#génération d'une liste par extensions successives avec condition\n", "\n", "L=[ ]\n", "for k in range(11):\n", " if k%2:\n", " L.append(k**2)\n", "\n", "L # affichage de la liste " ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 9, 25, 49, 81]" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#génération d'une liste par compréhension sous condition\n", "\n", "L=[ k**2 for k in range(11) if k%2]\n", "\n", "L # affichage de la liste " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "
\n", "- Listes et tuples : La liste est un type d’objet de taille dynamique, contrairement à un élément de type tuple (équivalent d’un tableau), dont la taille est fixée. Ce type tuple peut être utile notamment pour stocker des coordonnées en dimension fixée (2 ou 3 par exemple), mais la valeur est ensuite non modifiable.
\n", "- Autres types de collections : Il existe en Python d’autres types de collections que les listes, par exemple les dictionnaires (type dict). Mais dans les programmes officiels du lycée, il est indiqué : « Afin d’éviter les confusions, on se limite aux listes dans présenter d’autres types de collections ».
\n", "- Gestion des tuples :
\n", "\n", "
\n", "\n", " \n", "\n", " \n", " Syntaxe Python \n", "\n", " Description \n", "\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "Création \n", "\n", " t = (2,-3,1) ou t = 2,-3,1 \n", "\n", " Création d'un 3-uplet contenant les 3 valeurs 2; -3 et 1. \n", "\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "Accès à une valeur \n", "\n", " t[k] \n", "
a,b,c = t\n", " Donne accès à la valeur de rang k du tuple t \n", "
Stocke dans a,b,c les valeurs du tuple t
\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "6. Utilisation de modules / Bibliothèques
\n", "
\n", "\n", "\n", "\n", "
\n", "\n", " \n", "\n", " \n", " Syntaxe Python \n", "\n", " Description \n", "\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "Module math \n", "\n", " from math import* \n", "\n", " Permet de récupérer toutes les fonctions et constantes du module math (* signifie tout) \n", "\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " avec le module math : \n", "
pi$\\quad$e
log(x)$\\quad$exp(x)
cos(x)$\\quad$sin(x)$\\quad$tan(x)
sqrt(x)\n", " $\\;$ \n", "
Valeurs approchées de $\\pi$ et de e
logarithme népérien et exponentielle de x
cosinus, sinus et tangente de x
racine carrée de x\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "Module random \n", "\n", " from random import* \n", "\n", " Permet de récupérer toutes les fonctions et constantes du module random (* signifie tout) \n", "\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " avec le module random : \n", "
random()
randint(a,b)\n", " $\\;$ \n", "
Nombre flottant aléatoire dans [0;1[
Nombre int aléatoire compris entre a et b
\n", "\n", "\n", "\n", "\n", "$\\quad\\quad$Ci-dessous quelques exemples modifiables de syntaxes. Pour exécuter une cellule, sélectionner la cellule puis SHIFT+Entrée.\n", "" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "from math import* # import du module math" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3.141592653589793" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pi # valeur approchée de pi" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2.718281828459045" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "e # valeur approchée de e (nombre d'Euler)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.6931471805599453" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "log(2) # logarithme népérien" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "7.38905609893065" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "exp(2) # exponentielle" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.4142135623730951" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sqrt(2) # racine carrée" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [], "source": [ "from random import* # import du module random" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.15537491729049413" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "random() # nombre aléatoire dans [0;1[" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "randint(1,6) # entier aléatoire compris entre 1 et 6 (1 et 6 inclus)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "*(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/*" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.5" } }, "nbformat": 4, "nbformat_minor": 2 }\n", "
\n", "- Installation d'une bibliothèque :
\n", "
Pour ajouter certaines bibliothèques à l'environnement Python, il faux exécuter une seule fois en console l'instruction pip install nom_du_module- Utilisation d’une bibliothèque :
\n", "
Il convient d’importer en début de programme les fonctions du module à l’aide de l’instruction from nom_module import* (* signifie toutes les fonctions)
\n", "NB : On peut aussi importer les fonctions du module à l’aide de l’instruction import nom_module mais les fonctions devront ensuite être appelées avec la syntaxe nom_module.nom_fonction(), moins pratique à l’usage mais évitant les ambiguités si des fonctions de deux bibliothèques portaient le même nom.- Import sélectif :
\n", "
Si on ne souhaite récupérer que certaines fonctions ou variables d'un module, on peut également utiliser une syntaxe du type from math import sqrt,pi en listant les éléments souhaités.