Python : le mode console - les variables - les types de données

Python en mode console (ou interactif)

Si vous ne savez plus comment activer la console Python, retournez au chapitre précédent.

Utiliser Python en guise de calculatrice

Familiarisons-nous avec les opérateurs de calcul Python.

Tapez ces commandes ci-dessous dans la console interactive. >>> 3+5*4 23 >>> 10/3 3.3333333333333335 >>> 10//3 3 >>> 10%3 1 >>> 10**5 100000 >>>sqrt(25) Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'sqrt' is not defined >>>exit()

Commentaires

Analysons :
• 3+5*4 donne 23 c’est à dire (5*4) +3 ; il y a donc respect de l’ordre de priorité des opérateurs : les multiplications et divisions sont effectuées avant les additions et soustractions.
• 10/3 : division normale de 10 par 3
• 10//3 : division entière de 10 par 3 ; donne 3
• 10%3 : reste de la division entière ; donne 1
• 10**5 : 10 élevé à la puissance 5 ; donne donc 100 000
• sqrt(25) : racine carrée de 25. Message d’erreur et pas de résultat. C’est normal la fonction sqrt() fait partie du module math. Or celui n’est pas chargé ("importé" dans le jargon Python).
• exit() : commande pour fermer la console. J'aurais pu cliquer sur le bouton "X" de la fenêtre.

Si vous avez un doute concernant l'ordre de priorité des opérateurs, n'hésitez pas à employer des parenthèses. Les calculs entre parenthèses se font en priorité par rapport aux autres. >>> 12 *(4+6) 120 >>> 12*4+6 54

Grâce à ce petit exemple, vous voyez que les multiplications sont faites avant les additions sauf si on utilise des parenthèses (voir première instruction).

Les opérateurs arithmétiques

Récapitulons !

Tous les langages ne proposent un opérateur qui retourne le quotient de la division euclidienne ... JavaScript.

Les variables

Utiliser des lettres dans les formules

Vous pouvez faire de l’algèbre c’est à dire utiliser des lettres dans vos formules à condition des les avoir déclarées et initialisées. Un informaticien dit qu'il manipule des variables.
Commandes à saisir dans la console interactive : >>> a = 10 >>> b= 15 >>> c= 10.5 >>> a+c 20.5 >>> b-c 4.5 >>> a**2 100 >>> a==b # a égal à b ? False >>> b>c True >>> a!=b True

Commentaires

J’ai créé trois variables a,b et c et j’ai affecté à chaque variable un nombre entier ou un flottant (nombre décimal).
Je vous montre ensuite que l’on peut effectuer toutes les opérations sur des variables.
On peut aussi faire des comparaisons entre variables en utilisant les opérateurs de comparaison.
Chaque comparaison retourne un booléen : True si la comparaison est vraie et False si la comparaison est fausse.
Une commande peut être accompagnée d’un commentaire. Le commentaire est précédé du symbole #.

Les commentaires sont facultatifs en mode commandes mais deviennnent indispensables dans le cadre d'un programme.

Nommer des variables

Le premier caractère qui désigne une variable doit être une lettre minuscule (a-z), une lettre majuscule (A-Z) ou un tiret de soulignement. Pour les autres caractères, on autorise en plus les chiffres ( 0-9 ).
Python est sensible à la casse , c'est-à-dire qu'il fait la différence entre minuscules et majuscules. Ainsi Age et age sont deux variables différentes !

On ne peut pas employer un mot réservé pour désigner une variable.
Liste des mots réservés ci-dessous :

Exemple de variable mal nommée : >>> and = 10 SyntaxError: invalid syntax

Il est interdit de nommer une variable "and" qui est un mot réservé du langage Python.

Donc rien ne vous interdit à priori de nommer une variable "print, round, input, range, ... " puisqu'il ne s'agit pas de mots réservés. Mais ce serait très maladroit pour la lisibilité de votre code d'employer comme nom de variable un nom de fonction native.

Pour nommer des variables, je vous conseille d'utiliser des mots français sans lettres accentuées tels "compteur, points, cumuls, resultat, ..."
S'il s'agit de mots composés, utilisez un trait de soulignement entre les mots OU coller les mots avec une majuscule en début de chaque mot. Ce type de notation est appelée "camelCase". La première lettre de chaque mot mais à partir du deuxième mot.

Exemples de variables : prix_ht, taux_tva, prix_ttc OU en "camelCase" : prixHt, tauxTva, prixTtc
Évitez de mélanger les deux techniques de nommage dans un même programme.

Les opérateurs de comparaisons

Surtout ne confondez pas le symbole = qui est l'opérateur d'affectation avec == qui est un opérateur de comparaison.
a = 5 : affectation de 5 à la variable a
a ==5 : comparer le contenu de a à 5 ; ce test retourne true/false

Les opérateurs de comparaison :
• < strictement inférieur
• > strictement supérieur
• <= inférieur ou égal
• >= supérieur ou égal
• == égal
• != différent

Il existe aussi les opérateurs "in" et "not in" : voir plus loin dans ce chapitre.

La fonction type()

En Python les variables ne sont pas typées. La fonction type retourne le type du contenu. >>> a = 5 >>> type(a) <class 'int'> >>> a= True >>> type(a) <class 'bool'> >>> a= "bonjour" >>> type(a) <class 'str'> >>> a=10/3 >>> type(a) <class 'float'> >>> a= 10.5 >>> type(a) <class 'float'> >>> a = 10,5 >>> type(a) <class 'tuple'> >>> a ="True" >>> type(a) <class 'str'> >>> a=true NameError: name 'true' is not defined >>>

La variable a est successivement de type int,bool, str, float, tuple, str.

Pour créer une variable de type "bool" il faut affecter True ou False avec la première lettre en majuscule et surtout pas de guillemets .

Par erreur, j’ai affecté à la variable a la valeur 10,5 (et non pas 10.5). À la question "quel est le type de cette variable ? ", la console répond : class ‘tuple’... Je reviendrais plus tard sur ce type de donnée.

Autres tests : >>> b="125" >>> type(b) <class 'str'> >>> a ='125' >>> type(a) <class 'str'> >>> c=125 >>> type(c) <class 'int'> >>> chaineML ="""chaine sur ... deux lignes""" >>> type(chaineML) <class 'str'> >>> instant ="aujourd'hui" >>> type(instant) <class 'str'> >>> instant2 ='aujourd\'hui' >>> instant2 "aujourd'hui" >>>

Un suite de chiffres délimitée par des guillemets (simples ou doubles) est une chaine (et non pas une valeur numérique).

La variable c est de type 'int'(contient un entier) alors que les variables a & b sont de type 'str' (chaines composées ici de caractères numériques).
chaineML contient une chaine multilignes. Une chaine multilignes (un paragraphe, par exemple) doit être délimitée par trois guillemets (simples ou doubles)
Pour créer la chaine instant2 délimitée par des guillemets simples, l'apostrophe a du être échappée. Pour éviter l'échappement j'aurais pu écrire : instant2 ="aujourdh'hui" donc employer de guillemets doubles pour délimiter la chaine.

A propos de l'opérateur +

L'opérateur + n'a pas le même sens selon qu'on manipule des nombres ou des chaines.
Séquence de commandes : >>> a=12 >>> b=24 >>> c="12" >>> d='24' >>> a+b 36 >>> c+d '1224' >>> a+d ... TypeError: unsupported operand type(s) for +: 'int' and 'str' >>>

L'opérateur + utilisé avec des "strings" provoque la concaténation (chaines mises bout à bout).
On ne peut pas utiliser directement l'opérateur + entre un nombre et une chaine alors qu'en JavaScript c'est possible : conversion automatique .

Création et manipulation d'une chaine

Instructions à tester : >>> voyelles ="aeiouy" >>> len(voyelles) 6 >>> type(voyelles) <class 'str'> >>> print(voyelles) aeiouy >>> print('voyelles') voyelles

J'affecte une chaine à une variable nommée "voyelles".

j'applique ensuite à cette variable, quatre fonctions :
• len(voyelles) : retourne la longueur de la chaine (son nombre de caractères)
• type(voyelles) : indique le type de donnée contenue dans la variable
• La commande print(voyelles) affichage du contenu de la variable voyelles
• alors que print('voyelles') : affichage de la chaine "voyelles".

Aller plus loin avec la fonction print()

La fonction print() peut être argumentée avec une expression complexe. >>> a = 9 >>> print("le carré de ", a, " est ", a**2) le carré de 9 est 81

Dans une seule commande j'affiche :
• la chaine "le carré de "
• le contenu de la variable a
• la chaine " est "
• le résultat de la formule a**2

N'oubliez pas des espaces autour du mot " est " sinon tout sera collé et donc illisible.
N'oubliez pas non plus les virgules pour que tout s'affiche sur la même ligne.

Manipulation de chaines

Pour le moment vous savez afficher la longueur et le type d'une chaine.
On peut appliquer à une chaine de nombreuses fonctions génériques mais aussi des méthodes spécifiques aux objets STR et aussi utiliser certains opérateurs.

Commandes à tester dans la console

Une chaine de caractères est stockée dans une variable nommée texte. Puis je manipule cette variable chaine avec différentes commandes :

• len(texte) : retourne la longueur de la chaine (nombre de signes : espaces, points et caractères)
• list(texte) : affiche la chaine sous forme d'une liste à raison d'un élément par caractère
• type(texte) : retourne le type de la variable 'texte'
• "M" in texte : retourne True puisque M majuscule fait partie de la chaine. J’ai donc introduit un nouvel opérateur de comparaison.
• texte[0] : retourne le premier caractère de la chaine ; je signale que le premier caractère d’une chaine a la position zéro (et non pas 1)
  Attention l'indice doit être entouré par des crochets (et non pas des parenthèses) !
• texte.index(‘M’) : retourne la position du premier caractère M
• texte.count(".") : affiche le nombre de points dans la chaine
• texte.index(‘.’) : affiche la position du premier point dans la chaine ; recherche dans la chaine à partir de la gauche
• texte.index(';') : retourne un message d'erreur car le caractère ";" n'existe pas dans la chaine.

Syntaxe

Observez que dans les instructions nous avons deux syntaxes différentes :
• len(texte), type(texte), list(texte), print(texte), etc.
• texte.index(), texte.count(), etc.

Dans un premier cas il s'agit de fonctions génériques (peuvent s'appliquer à tous les types de données). Il faut donc écrire la commmande sous la forme fonction(nomObjet)
Dans le deuxième cas il s'agit de méthodes de la classe "str" c'est à dire des fonctions spécifiques aux objets STR. Il faut alors écrire la commande sous la forme chaine.méthode() ; on parle de notation pointée

Construire de nouvelles chaines

Si vous souhaitez des textes homogènes (tout en minuscules ou tout en majuscules) il faut créer de nouvelles variables de type string comme ci-dessous : >>>texte ="Bonjour. Mon. Cher. Ami" >>> texte_minus = texte.lower() >>> texte_minus 'bonjour. mon. cher. ami' >>> texte_majus = texte.upper() >>> texte_majus 'BONJOUR. MON. CHER. AMI' >>> chaine ="ave cesar, ceux qui vont mourir te salue" >>> chaine_cryptee = chaine.replace('a','1').replace('e','2') >>> chaine_cryptee '1v2 c2s1r, c2ux qui vont mourir t2 s1lu2'

Dans la variable "text_minus" toutes les lettres sont en minuscules.
Dans la variable "texte_majus" toutes les lettres sont en majuscules.

Je teste ensuite la méthode replace().
Attention cette méthode ne modifie pas le contenu de la chaine d'origine mais celui de la variable de destination.
Vous constatez que dans "chaine_cryptee" les lettres "a" & "e" ont été remplacées par des chiffres. C'est donc l'amorce d'un cryptage ...
Syntaxe de la méthode : nouvelle_chaine = chaine.replace('old', 'new'). On peut chainer plusieurs fois replace() dans la même commande !

Les opérateurs "in" et "not in"

Comme in, l'opérateur not in tient compte de la casse.

Extraction d'une partie de chaine

Pour extraire une sous-chaine d'une chaine nous allons pratiquer le "slicing" (tranchage) ! >>> chaine ="ave cesar" >>> chaine[0] 'a' >>> chaine[1] 'v' >>> chaine[2:] 'e cesar' >>> chaine[:2] 'av' >>> chaine[2:6] 'e ce' >>>

L'expression entre crochets peut laisser dubatatif ...

Quelques exemples de slicing :
• [0] : extraire le caractère d'indice zéro
• [2:] : extraire à partir de la position 2 jusqu'au bout
• :[:2] : extraire du début jusqu'à la position 2 exclue
• [2:6] : extraire de 2 jusqu'à 6 exclu

Le petit tableau ci-dessous va vous aider ; il indique pour chaque caractère de la chaine son indice (ou position): caractère A V E C E S A R indice 0 1 2 3 4 5 6 7 8

Astuce : quand vous voyez ":" comprenez "jusqu'à".

Concaténer des chaines

Je crée deux chaines contenant respectivement les voyelles et les consonnes de l'alphabet latin.
A partir de ces deux chaines j'en crée une troisième qui est la concaténation des deux premières.
A partir de la nouvelle chaine je peux, avec la fonction générique list(), créer une liste. Chaque lettre de la chaine d'origine devient un élément de la liste.

Transformer une chaine de mots en une liste de mots

Si une chaine comprend différents groupes de lettres séparés par des espaces, il est facile de produire une liste de ces différents mots. >>> texte ="uN deuX Trois Quatre Cinq" >>> liste_chaine = texte.lower().split() >>> liste_chaine ['un', 'deux', 'trois', 'quatre', 'cinq']

Avec la méthode split() c'est chaque mot de la chaine qui dévient un élément d'une liste.
Notez que j'ai chainé la méthode split() avec la méthode lower().
La méthode split() crée une liste de mots à partir d'une chaine. Vous pouvez spécifier le séparateur. Le séparateur par défaut est un espace.

Si dans une chaine les mots sont séparés par un autre symbole que espace il faut alors spécifier dans la méthode split() le séparateur. >>> texte2 ="un-deux-trois-quatre" >>> liste_mots = texte2.split('-') >>> liste_mots ['un', 'deux', 'trois', 'quatre']

Je viens de vous montrer à maintes fois, comment créer des listes à partir de chaines. La notion de liste qui est fondamentale en python, va être approfondie dans le chapitre suivant.