Différences

Ci-dessous, les différences entre deux révisions de la page.

--- python:bases:variables [2021/07/19 11:23] – phil
+++ python:bases:variables [2022/09/25 10:33] (Version actuelle) – [Plus loin ...] phil
@@ Ligne 1: / Ligne 1: @@
+[[python:bases:controle|{{ :suivant.png?nolink&30|Les instructions de contrôle}}]] {{ :retour.png?nolink&30|}} [[:python:accueilpython|{{ :iconemaison.jpg?nolink&30|Sommaire Python et microPython}}]]
+===== Python - Variables, constantes, types numériques et entrées / sorties dans la console =====
+[Mise à jour le : 16/8/2022]
+  * **Sources**
+    *  **Documentation** sur Python.org : <html><a href="https://docs.python.org/fr/3.6/reference/index.html" target="_blank">référence du langage</a>, <a href="https://docs.python.org/fr/3/reference/lexical_analysis.html#keywords" target="_blank">analyse lexicale</a>,  <a href="https://docs.python.org/fr/3.5/library/functions.html" target="_blank">fonctions natives</a></html> (built-in)
+  * **Lectures connexes**
+    * **Real Python**
+      * <html><a href="https://realpython.com/python-data-types/" target="_blank">Basic Data Types in Python</a></html>
+      * <html><a href="https://realpython.com/python-or-operator/" target="_blank">How to Use the Python or Operator</a></html>
+      * <html><a href="https://realpython.com/python-sort/" target="_blank">How to Use sorted() and sort() in Python</a></html>
+    * **Developpez.com** - <html><a href="https://python.developpez.com/cours/TutoSwinnen/?page=page_9#L7.2" target="_blank">Variables locales et globales</a></html>
+  * **Mots-clés** : programme, donnée, mémoire, variable, déclarer, initialiser
+<callout type="warning" icon="true">Les mots ci-dessous sont dits "réservés". Ils ne peuvent pas être utilisés comme nom de variable. Les mots __soulignés__ sont une nouveauté de Python 3. Les mots en **gras** sont utilisés dans cette page.</callout>
+|  and        |  continue   |  finally     |  is            |  raise     |
+|   as        |  def        |  for         |  lambda        |  return    |
+|  assert     |  del        |  from        |  **__None__**  |  __True__  |
+|  __async__  |  elif       |  **global**  |  __nonlocal__  |  try       |
+|  __await__  |  else       |  if          |  not           |  while     |
+|  break      |  except     |  import      |  or            |  with      |
+|  class      |  __False__  |  in          |  pass          |  yield     |
+  * <html><a href="https://docs.python.org/fr/3.5/library/functions.html" target="_blank">Fonctions natives</a></html>** (built-in)**((Fonctions toujours disponibles.)) utilisées dans les exemples : **type**(), **isinstance**(), **float**(), **print**().
+----
+==== 1. Les variables ====
+{{ :micropython:affect-var5.png?nolink&120|}}
+Pendant l'exécution d'un **programme**, les **données** qu'il manipule sont stockées en **mémoire**. Les **variables** permettent de manipuler ces données sans se préoccuper de leur position. Pour cela, il suffit de leur donner un nom (les **déclarer**).
+=== 1.1 Nommage des variables ===
+  * Une variable doit respecter quelques règles de syntaxe :
+    - Le nom d'une variable ne peut être composé que de **lettres**, de **chiffres** et de "**_**".
+    - Le nom d'une variable ne peut pas commencer par un chiffre.
+    - Python est **sensible à la casse** (position =/= Position)
+    - L'**usage** veut que l'on se limite à des caractères minuscules (<html><a href="https://wprock.fr/blog/conventions-nommage-programmation/" target="_blank">underscore case </a></html>) !
+=== 1.2 Déclaration et initialisation ===
+<callout icon="fa fa-hand-stop-o" color="red" title="ATTENTION">En Python, la simple **déclaration** d'une variable ne suffit pas à la créer. Après avoir choisi son nom, il est nécessaire de lui **affecter** une **valeur initiale** (**initialisation**). En Python l'**affectation** s'effectue avec le symbole "**=**".</callout>
+<code python  exvar1.py>
+position_x = 10 # variable de type entier nommée selon la convention inderscore case
+pi = 1.14159 # variable de type réel
+hello = "Hello world !" # variable de type chaîne de caractère
+position_x, pi, hello = 10,1.14159,"Hello world !" # C'est possible !
+</code>
+=== 1.3 Le type des variables ===
+  * **Source** : <html><a href="https://docs.python.org/fr/3.7/library/stdtypes.html#built-in-types" target="_blank">Types natifs</a></html>
+Le **type d'une variable** identifie la **nature de son contenu** : nombre entier, nombre décimal, texte, etc.. Ces différents types d'information peuvent être placés dans une variable.
+<callout type="primary" icon="true">En Python, il n'est pas nécessaire de préciser le type d'une variable. Python est dit **typé //dynamiquement//**. </callout>
+  * On dispose de quatre **types numériques** en Python :
+    * Les entiers (**int**)
+    * Les décimaux (**float**)
+    * Les nombres complexes (**complex**)
+    * Les booléens (**bool**) sous ensemble des entiers
+<callout type="primary" icon="true">Les **entiers** sont donnés **sans perte de précision**.</callout>
+  * **Connaître le type d'une variable** : pour cela, on utilise les fonctions natives //**type()**// et //**isinstance()**//.
+<code python exvar2a.py>
+nom_variable = 15
+type(nom_variable) # renvoie <class 'int'> dans la console
+isinstance(15,int) # renvoie true
+type(4+5j) # renvoie <class 'complex'>
+</code>
+  * **Convertir le type d'une variable**
+    * Convertir une **chaîne de caractères** en un entier avec la fonction **//int()//**<code python exvar2b.py>
+annee = "2019" # renvoie la chaîne de caractères '2019' dans la console
+annee = int(annee) # renvoie le nombre 2019 dans la console
+</code>
+    * Convertir un **entier** en une chaîne de caractères avec la fonction **//str()//**<code python exvar2c.py>
+annee = 2019 # renvoie le nombre 2019 dans la console
+annee = str(annee) # renvoie la chaîne de caractères '2019'
+</code>
+    * **float()** : permet la transformation en flottant.
+    * **long()**  : transforme une valeur en long.
+=== 1.4 Copie de variables ===
+Le contenu d'une variable //var1// peut être placé dans une variable //var2//.
+<code python exvar3.py>
+var2 = var1
+</code>
+=== 1.5 Permutation ===
+Python propose un moyen simple pour permuter deux variables (échanger leur valeur).
+<code python exvar4.py>
+a = 5
+b = 32
+a,b = b,a # résultat a = 32, b = 5
+</code>
+=== 1.6 Opérations arithmétiques et logiques ===
+  * **Source** : <html><a href="https://python-reference.readthedocs.io/en/latest/docs/operators/index.html#bitwise-operators" target="_blank">Opérateurs</a></html>
+  * ** Opérations arithmétiques**
+^ addition ^ soustraction ^ multiplication ^ division euclidienne ^ division  entière ^ reste division  ^ puissance ^
+|  **+**    |   **-**     |    ** * **     |     **/**            |       **/ /**    |      ** % **    |  ** * * **  |
+  * //Exemple sur des entiers//
+<code python exvar5a.py>
+var1 = 5
+var2 = 1
+var3 = var1 + var2 # résultat var3 = 6
+</code>
+  * //Exemple sur des flottants//
+<code python - exvar5b.py>
+var1 = 5.2
+var2 = 1.4
+var3 = var1 + var2 # résultat var3 = 6.6
+</code>
+  * **Opérations booléennes**
+^ conjonction (ET) ^ Disjonction  (OU) ^ Négation (NON) ^
+|  and             |    or             |        not     |
+<callout type="warning" icon="true">Les variables booléennes prennent les valeurs **True** et **False** ou **1** et **0**.</callout>
+//Exemples//
+<code python exvar6a.py>
+bool1, bool2 = True, False
+bool3, bool4 = 1, 0
+bool5 = bool1 and bool2 # résultat : bool5 = False
+bool5 = bool1 or bool2  # résultat : bool6 = True
+bool7 = not(bool1)      # résultat : bool7 = False
+bool8 = bool3 & bool4   # résultat : bool8 = 0
+</code>
+  * **Opérations au niveau bit**
+^    ET   ^    OU    ^    NON   ^ OU EXCLUSIF ^ Décalage à gauche ^ Décalage à droite^
+|  **&**  |  **|**   |  **~**   |  **^**      |        **<<**     |      ** >>**     |
+<callout type="warning" icon="true">Les opérateurs de niveau bit s'appliquent sur chacun des **bits** d'un mot. \\ Exemple si A = a<sub>1</sub>a<sub>0</sub> et B = b<sub>1</sub>b<sub>0</sub> alors C = A & B => C = c<sub>1</sub>c<sub>0</sub> tel que c<sub>1</sub> = a<sub>1</sub>&b<sub>1</sub> et c<sub>0</sub>=a<sub>0</sub>&b<sub>0</sub></callout>
+//Exemples//
+<code python exvar6b.py>
+# 0b précise que le nombre qui suit est exprimé en binaire
+var1 = 0b01010101    # résultat var1 = 85 en base 10
+var2 = 0b10101010    # résultat var2 = 170 en base 10
+var3 = var1 & var2   # résultat var3 = 0 en base 10, bin(var3) = 0b00000000
+var4 = var1 | var2   # résultat var4 = 255 en base 10, bin(var4) = 0b11111111
+var5 = ~var1         # résultat var5 = -86 en base 10 car l'ordinateur calcule en complément à 2
+                     # or 2**n + complément à 2 de x = x ici = = 8 donc 256-86 = 170 = 0b10101010 = var2
+var6 = var1 ^ bool2  # résultat bin(var6) = 0b11111111
+var7 = var1 << 1     # résultat var7 = 170 (décalage à gauche de 1 => multiplication entière par 2)
+var8 = var2 >> 1     # résultat var8 = 85 (décalage à droite de 1 => division entière par 2)
+</code>
+  * **Base 2, 10, 16**
+Par défaut, les nombres entiers saisis ou affichés sont en base 10.
+<callout type="primary" icon="true">Pour manipuler des séquences de bits, de longueur arbitraire on utilise **0b** devant la valeur binaire ou **0x** devant la valeur hexadécimale.La fonction **bin**(**n**) renvoie la valeur de n en binaire. La fonction **hex**(**n**) renvoie la valeur de n en hexadécimale. Ces fonctions renvoient des chaînes de caractères.</callout>
+//Exemples//
+<code python exvar6c.py>
+bin(43)         # renvoie '0b101011'
+bin(0xf4)       #         '0b11110100'
+hex(43)         #         '0x2b'
+hex(0b11110100) #         '0xf4'
+</code>
+=== 1.7 Variable sans valeur ===
+<callout type="primary" icon="trie">On peut réinitialiser une variable en l'affectant d'une valeur **vide** avec le mot **//None//**.</callout>
+=== 1.8 Portée des variables ===
+La **portée** d'une variable est la portion de code source où elle est accessible.
+<callout type="warning" icon="true">Pour connaître la portée d'une variable on utilise la règle **LEGB** : \\ **L**ocalement (variable déclarée dans une fonction) \\ **E**nglobante (variable déclarée dans une fonction qui contient la fonction où elle est appelée) \\ **G**lobalement (variable déclarée globalement) \\ **B**uiltins (est une variable Built-in)</callout>
+  * **Espace local**
+<callout icon="fa fa-hand-stop-o" color="red" title="ATTENTION">Les variables définies dans un corps de fonction ou passées en paramètres sont seulement accessibles dans le corps de la fonction.</callout>
+//Exemple//
+<code python *.py>
+# Espace local au programme
+valext = 5 # variable connue dans et hors de la fonction
+def func(valint): # ici valint <- valext, valint : variable connue seulement dans la fonction
+    # Espace local à la fonction func
+    valint = valint * 2
+    # valext est connue de func bien que sa déclaration soit à l'extérieure
+    print("Dans la fonction func, valext = ", valext)
+    # REMARQUES
+    # valint = valext * 2 est possible, mais déconseillé par les bonnes pratiques de programmation
+    # valext = valext * 2 est INTERDIT, car on ne peut pas modifier une variable extérieure à l'espace local
+    print("Dans la fonction func, valint * 2 = ", valint," car valint <- valext lors de l'appel")
+    return valint
+print("Avant l'appel de func, valext = ", valext)
+valext = func(valext) # valext est connue de func bien que sa déclaration soit à l'extérieure
+print("Après l'appel de func et l'opération valext = func(valext), valext = ", valext)
+print(valint) # valint n'est pas connue à l'extérieure de func
+</code>
+//Résultat attendu// \\
+Avant l'appel de func, valext =  5 \\
+Dans la fonction func, valext = 5 \\
+Dans la fonction func, valint * 2 =  10 \\
+Après l'appel de func et l'opération valext = func(valext), valext =  10  car valint <- valext lors de l'appel \\
+**Une exception s'est produite : NameError** \\
+**name 'valint' is not defined** \\
+<callout icon="fa fa-hand-stop-o" color="red" title="ATTENTION">Une fonction ne peut pas modifier la valeur d'une variable extérieure à son espace local par une affectation.</callout>
+  * **Variable globale**
+<callout icon="fa fa-hand-stop-o" color="red" title="ATTENTION">Pour modifier une variable extérieure à une fonction, on la qualifie de **globale**.</callout>
+//Exemple//
+<code python *.py>
+# Espace local au programme
+valext = 5 # variable connue dans et hors de la fonction
+def func(): # ici valint <- valext, valint : variable connue seulement dans la fonction
+    # Espace local à la fonction func
+    global valext # A éviter sauf cas particulier
+    return valext * 2
+print("Après l'appel de func, valext = ", func())
+</code>
+==== 2. Entrée / sortie dans la console ====
+Il est fréquent qu'un utilisateur ait besoin de saisir des informations lors de l'exécution d'un programme. Les fonctions **print()** et **input()** permettent d'interragir avec l'utilisateur dans la console.
+=== 2.1 Afficher le contenu des variables  ===
+On affiche le contenu d'une ou plusieurs variables dans console avec la fonction **//print()//**.
+//Exemple//
+<code python exvar7.py>
+nom = "Dupont"
+age = 35
+print("Je suis", nom, "et j'ai", age, "ans.") # Retourne : Je suis Dupont et j'ai 35 ans. dans la console
+</code>
+<callout type="primary" icon="true">Par défaut l'instruction **print** provoque un retour à la ligne après l'affichage. On peut changer ce comportement en fournissant une autre chaîne de caractère à accoler à l'affichage comme ci-dessus ou même rien.</callout>
+// Exemple //
+<code python *.py>
+print("Ce texte s'affiche", end=" ") # Retourne : Ce texte s'affiche sur une seule ligne.
+print("sur une seule ligne.", end=" ")
+</code>
+----
+=== 2.2 Saisir une donnée utilisateur ===
+On entre une donnée utilisateur dans la console avec la fonction **//input()//**.
+<code python exvar8.py>
+nom = input("Quel est votre nom ?")
+print("Bonjour",nom)
+</code>
+----
+==== 3. Constantes ====
+{{ :python:bases:realpython.png?nolink|}}
+  * **Real Python** : <html><a href="https://realpython.com/python-constants/" target=_blank">Python Constants: Improve Your Code's Maintainability</a></html>
+==== Résumé ====
+  * Les variables **conservent les données** du programme lors de son exécution. Leur contenu peut changer. Il faut éviter de mettre des espaces et des accents dans les noms de variable.
+  * Pour affecter une valeur à une variable, on utilise la syntaxe: //nomVariable **=** valeur//.
+  * Il existe différents types de variables : **entier**, **réel**, **chaîne de caractères**, etc.
+  * Les variables **locales**, définies avant l'appel d'une fonction, sont accessibles en lecture seule depuis l'appel de la fonction. Une variable locale définie dans une fonction est supprimée après l'exécution de la fonction.
+  * Les variables **globales** se définissent à l'aide du mot-clé //**globale**// suivi du nom de la variable préalablement créée. Elles peuvent être modifiées dans le corps d'une fonction.
+  * Pour afficher une donnée dans la console, on utilise la fonction **print()**.
+  * Pour entrer une donnée utilisateur dans la console, on utilise la fonction **input()**.
+----
+{{ :python:bases:realpython.png?nolink|}}
+==== Quiz ====
+  * <html><a href="https://realpython.com/quizzes/python-variables/" target="_blank">Python Variables Quiz</a></html>
+  * <html><a href="https://realpython.com/quizzes/python-data-types/" target="_blank">Basic Data Types in Python Quiz</a></html>
+  * <html><a href="https://realpython.com/quizzes/python-rounding/" target="_blank">Rounding Numbers in Python Quiz</a></html>
+==== Plus loin ... ====
+  * <html><a href="https://realpython.com/python-numbers/" target="_blank">Numbers in Python</a></html>
+  * <html><a href="https://realpython.com/python-boolean/#the-in-operator" target="_blank">Python Booleans: Optimize Your Code With Truth Values</a></html>
+  * <html><a href="https://realpython.com/python-namespaces-scope/" target="_blank">Namespaces and Scope in Python</a></html>