TYPE et CONVERSIONS DE VARIABLES LISTES : Ce sont des tableaux.

Types courants : Entier (int) Réel (float) Texte (str) Booléen (bool)
MEMENTO Déclaration :
Liste = ["a","b","c"] Crée une liste de textes (type string car entre guillemets)
Déclaration de variables :
T = "Bonjour" Assigne à la variable texte (string) T le texte « Bonjour »
PYTHON 3 Liste = [2,4,8] Crée une liste d’entiers (type int car pas de guillemets)
Version 2.00 - O. Chaumette
N = 2 Assigne à la variable entière (int) N la valeur 2 Liste = [] Crée une liste vide
Lycée JP SARTRE – 69500 BRON
Conversion de variables : Liste2D = [[1,2,3],[4,5,6]] Crée une liste d’entiers à 2 dimensions (ici 2 lignes et 3 colonnes)
T = str(N) transforme un entier (int) ou réel (float) N en texte (string) Accès aux éléments de la liste :
N = int(T) ou N = float(T) transforme un texte T (string) en entier (int) ou réel (float) Liste[index] Renvoie l’élément situé à l’emplacement index (qui commence à 0)
Liste[index1:index2] Renvoie les éléments entre index1 et index2
ENTREES et SORTIES : demander une valeur à l’utilisateur et afficher à l’écran.
Liste[index1:] Renvoie les éléments à partir d’index1 jusqu’à la fin
Entrée au clavier : Liste[:index2] Renvoie les éléments du début jusqu’à index2
Un_Texte = input("question") Pose « question » à l’utilisateur. Réponse dans la variable « texte » : Un_Texte
Liste[-1] Renvoie le dernier élément (si -2 : l’avant dernier etc…)
Un_Entier = int(input("question")) Réponse dans la variable « entière » : un_entier
Liste2D[n°_ligne][n°_col] Renvoie l’élément situé à n°_ligne (en commençant à 0) et n°_col (début 0)
Sortie écran : Manipulation de listes :
print("Texte",variable) écrit sur l’écran Texte suivi du contenu de Variable séparés par un espace len(Liste) Renvoie la longueur (= nbre d’éléments) de la liste. C’est un entier.
print("Bonjour"+texte) écrit sur l’écran Bonjour suivi du contenu de texte. Réservé aux textes Liste.append(Elément) Ajoute Elément à la fin de la liste
print("Bonjour"+str(Nombre)) écrit sur l’écran Bonjour suivi de Nombre transformé en texte Liste.remove(Elément) Enlève la 1ère occurrence de Elément
print("Bonjour", end=’ ’) écrit Bonjour suivi d’un espace sans retour à la ligne (le prochain print sera collé) Liste [pos] = "a" met ‘a’ à la position pos (début=0) (en écrasant l’élt qui s’y trouve)
print("Bonjour", end=’,’) écrit Bonjour suivi d’une virgule sans retour à la ligne (le prochain print sera collé)
Liste.insert(pos,Elément) Insère Elément à la position pos (sans écraser. Cela décale les autres)
print("Bonjour\nle\nmonde") écrit Bonjour suivi d’un saut de ligne (\n) puis le puis saut de ligne puis monde
Liste.index(Elément) Renvoie l’emplacement de Elément dans la liste (1ère position = index 0).
print("%.2e"%N) Ecrit le réel (ou entier) N en écriture scientifique avec 2 décimales (donc 3 chiffres significatifs)
Liste.count(Elément) Renvoie le nombre de fois qu’Elément est présent dans la liste
TESTS et CONDITIONS : Elément in Liste Renvoie si Elément est présent dans la liste (True/False). Utile dans un if :
Exemple : if Lettre in Mot (si Lettre est présent dans Mot)
Test simple:
if Condition: bien penser aux « : »! Parcourir une liste :
Instructions si « Condition » est vraie bien penser à l’indentation !!!
for Element in Liste: Element prend successivement le contenu de chaque élément de la liste

Test avec SINON (else): ASTUCE : Afficher les éléments d’une liste les uns à la suite des autres (séparés par un espace):
if Condition: T = ""
Instructions si « Condition » est vraie bien penser à l’indentation et aux « : » for Element in Liste:
else: T = T +" "+ Element remplacer ici Element par str(Element) si la liste contient des entiers
Instructions si « Condition » est fausse print (T)
Test avec SINON SI (else if): CHAINES (ou TEXTES): Ce sont des listes de caractères donc ont les mêmes fonctions + des fonctions suppl. :
If Condition1:
Instructions si « Condition1 » est vraie bien penser à l’indentation et aux « : »
Mise en forme :
Texte = "Bonjour \nSalut" Saute une ligne après le \n
elif Condition2:
Instructions si « Condition2 » est vraie Texte = "Bonjour \"Salut\"" Saute des guillemets à la place de \"
else: Manipulations fréquentes de chaines :
Instructions si « Condition1 et 2 » sont fausses Texte.lower() Met le texte en minuscule
Test avec conditions multiples: Texte.upper() Met le texte en majuscule
if Condition1 and/or Condition2: and: condition 1 ET 2 respectées Texte.split() Renvoie une liste contenant les mots du texte (s’ils st séparés par « espace »)
Instructions or: condition 1 OU 2 respectées Texte.split(Caractère) Renvoie une liste contenant les mots du texte (s’ils st séparés par Caractère)
Texte.find(Mot) Renvoie le + petit index de Mot dans Mon_Texte (ou -1 si pas trouvé)
Opérateurs dans les conditions: ATTENTION le signe = est réservé à l’affectation de variables Texte.replace(MotOld,MotNew) Remplace MotOld par MotNew dans Mon_Texte
== :égal != :différent not : contraire de la condition
> (ou <):supérieur (ou inférieur) >= (ou <=):sup (ou inf) ou égal Texte [:n] Renvoie les n premiers caractères en partant de la gauche
Texte [Len(Mon_Texte)- n:] Renvoie les n premiers caractères en partant de la droite
On peut utiliser un intervalle : exple : if 2<x<3:Instructions
Texte [n1:n2] Renvoie les caractères entre les rangs n1 et n2
Variable Booléenne
Texte.startswith(Mot) Renvoie True si Mon_Texte commence par Mot
Mon_Booleen = (A==B) la variable Mon_Booleen prendra la valeur True si A égal B, False sinon.
Texte.endswith(Mot) Renvoie True si Mon_Texte finit par Mot
INCREMENTATION d’une variable : Changer sa valeur en fonction de sa valeur initiale. Utilisation des codes ASCII (des caractères d’un texte) :
Var += 1 incrémente la variable de 1 : cela remplace Var = Var +1.(Cas gral : Var+=Valeur) Caractere = chr(Code_Ascii) Renvoie le caractère (type str) dont le code ascii est Code_Ascii
Cela marche aussi avec une chaine (Chaine += Texte revient à écrire Chaine = Chaine + Texte) Code_ASCII = ord(Caractère) Renvoie le code ascii de Caractère.
Il existe aussi : Var -= Valeur (pour soustraire Valeur à Var), Var *= Valeur (pour multiplier Var par Valeur) Codes ASCII utiles : "A":65 "Z":90 "a":97 "z":122 "0":48 "9":57 espace :32

Mémento Python 3.x par O. Chaumette – Lycée JP Sartre – 69500 BRON – version 2.00 – page 1 Mémento Python 3.x par O. Chaumette – Lycée JP Sartre – 69500 BRON – version 2.00 – page 2
BOUCLES : FONCTIONS : Ce sont des parties de programme que l’on peut appeler régulièrement selon les besoins.
Boucle FOR générale: Dans le cas où on connaît le nombre de répétitions Définition d’une fonction SANS return (=procédure) : c’est un morceau de programme qu’on peut appeler
for Variable in Ensemble de valeurs: Variable va prendre toutes les valeurs de « ensemble de valeurs » def Ma_fonction():
Instructions bien penser à l’indentation !!! Liste d’instructions Attention à l’indentation

Boucle FOR avec des nombres: Appel de la fonction:

for Compteur in range(Nombre): Compteur varie de 0 à Nombre-1 Ma_fonction() à placer dans le prg principal : Exécute le code de « Ma_Fonction »
for Compteur in range(début,fin): Compteur varie de début à fin-1
for Compteur in range(début,fin,pas): Compteur varie de début à fin-1 par sauts de pas Définition d’une fonction AVEC return:
def Ma_fonction():
for Compteur in range(fin,début,-1): Compteur varie de fin à début+1 (donc à l’envers) Liste d’instructions qui crée une «Variable_Résultat »
return Variable_Résultat
Boucle FOR avec des listes/chaines:
for Variable in Liste: Variable prend la valeur de chaque élément de la liste Liste Appel de la fonction :
Variable = Ma_fonction() met dans Variable le résultat des instructions de Ma_fonction
Boucle WHILE (tant que) : Dans le cas où on ne connaît pas le nombre de répétitions
while Condition: bien penser aux « : » et à l’indentation
Définition d’une fonction avec des ARGUMENTS (ou paramètres):
Instructions tant que « Condition » est vraie
def Ma_fonction(paramètre1, paramètre2,…):
Modifier la variable intervenant dans la condition sinon la boucle serait infinie !
Liste d’instructions qui crée une «Variable_Résultat »
Sortie « artificielle » de boucle : en utilisant paramètre1, paramètre2
break arrête la boucle return Variable_Résultat
Appel de la fonction AVEC paramètres :
OPERATEURS et FONCTIONS MATHÉMATIQUES:
Variable = Ma_fonction(p1,p2…) met dans Variable le résultat des instructions de Ma_fonction
Division: (ayant utilisé les paramètres p1, p2 etc…)
Nbre1// Nbre2 Renvoie la partie entière de la division de Nbre1 par Nbre2
Nbre1%Nbre2 Renvoie le reste de la division de Nbre1 par Nbre2 Utilisation d’une variable du programme principal dans une fonction :
divmod(Nbre1, Nbre2) Renvoie un tuple (Résultat Division entière,Reste) Les Variables d’une fonction et celles du programme principal sont indépendantes. Si on peut utiliser une variable du
programme principal dans une fonction, il faut ajouter dans la fonction :
Fonctions: global Nom_de_la_Variable_du_prg_Principal
round(x) arrondit un "réel" x vers l'entier le plus proche
round(x, n) arrondit un "réel" à la décimale n. n négatif permet un arrondi à la dizaine, centaine... près.
** marque l'exposant et a la priorité sur +, -, *, / FICHIERS : LECTURE/ECRITURE simple de textes
pow(x,y) renvoie x à la puissance y, équivaut à x ** y Création/ouverture d’un fichier « Nom_de_Fichier.ext » :
max(x, y) renvoie la plus grande des deux valeurs Mon_fichier = open(‘Nom_de_Fichier.ext’,’w’) ouverture en écriture (efface l’existant si déjà présent)
min(x, y) renvoie la plus petite des deux valeurs Mon_fichier = open(‘Nom_de_Fichier.ext’,’a’) ouverture en modification (pour ajouter des données)
abs() renvoie la valeur absolue d'un nombre (sans le signe)
Mon_fichier = open(‘Nom_de_Fichier.ext’,’r’) ouverture en lecture
MODULE MATH : en complément des fonctions précédente. Pour les réels.
Déclaration : Fermeture d’un fichier : OBLIGATOIRE s’il a été ouvert !!
import math Mon_fichier.close()
Fonctions : Ecriture de données dans « Mon_Fichier » : il faut que « Mon_fichier » ait été ouvert (en écriture ou modif)
math.pi retourne une approximation de la constante pi: 3.1415926535897931
math.degrees() et radians() transforment en degrés ou en radians
Mon_fichier.write(Texte) Ecrit « Texte » à la suite du fichier ; sans saut de ligne !
math.cos(),.sin(),.tan() fonctions trigonométriques usuels Pour ajouter une saut de ligne : Texte doit être : ’\n’
math.acos(),.asin(),.atan() fonctions trigonométriques inverses Pour ajouter une tabulation : Texte doit être : ’\t’
math.exp() exponentielle
math.log() et math.log10() logarithme népérien et décimal
math.sqrt() renvoie la racine carrée
Lecture de données dans « Mon_Fichier » : il faut que « Mon_fichier » ait été ouvert (en lecture)
Variable = Mon_fichier.read() Met dans « Variable » tout le contenu du fichier
MODULE RANDOM : hazard Variable = Mon_fichier.read(N) Met dans « Variable » les N caractères du fichier
(à partir de la position atteinte dans le fichier)
Déclaration : Variable = Mon_fichier.readline() Met dans « Variable » une ligne du fichier
import random (à partir de la position atteinte dans le fichier)
Fonctions : Liste = Mon_fichier.readlines() Met toutes les lignes du fichier dans une liste.
random.choice(Ma_Liste) choisit un élément de la liste Ma_Liste
random.sample(Ma_Liste,n) renvoie une liste de n éléments choisis dans Ma_Liste Changement du dossier dans lequel on lit/écrit le fichier :
random.shuffle(Ma_Liste) mélange les éléments de Ma_Liste import os
random.randrange(borne1,borne2) renvoie un entier au hasard entre borne1 (incluse) et borne2 (exclue) os.chrdir(Dossier_Voulu) Dossier_Voulu peut être absolu: “C:/Mon/Dossier” ou relatif: “/Mon/Dossier”

Mémento Python 3.x par O. Chaumette – Lycée JP Sartre – 69500 BRON – version 2.00 – page 3 Mémento Python 3.x par O. Chaumette – Lycée JP Sartre – 69500 BRON – version 2.00 – page 4