En tête general

(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/

Pour exécuter une saisie Python, sélectionner la cellule et valider avec SHIFT+Entrée.

SYNTAXES ÉLÉMENTAIRES EN LANGAGE PYTHON

Cette fiche récapitule les principales syntaxes élémentaires utilisées au lycée.
Les zones Python sont modifiables et exécutables (sélectionner la cellule et valider avec SHIFT+Entrée pour exécuter).

1. Les principaux types de variables

Syntaxe Python Description
int a=-3 $\quad$ b=7 Nombres entiers
float a=2/7 $\quad$ b=7.0 $\quad$ c=3.3 Nombres flottants
(représentation des nombres décimaux)
str text='Hello prof' Chaînes de caractères (string)
bool 2+3==5 $\quad$ 2.7>=5.5 Booléens (valeur True(=1) ou False(=0))
list L1=[2,5,7] $\quad$ L2=['salut',3.8,8] Listes d'éléments
NB: Les éléments de la liste peuvent être de tous types
  • 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( ).
  • Conversion de type : On peut effectuer une conversion de type avec les instructions int( ) ; float( ) ; str( ) ; …
    À 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.
    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.

$\quad\quad$Ci-dessous quelques exemples modifiables de syntaxes. Pour exécuter une cellule, sélectionner la cellule puis SHIFT+Entrée.

In [1]:
a = 3                   # Création d'une variable nommée a de valeur 3

a                       # Affichage du contenu de la variable a
Out[1]:
3
In [2]:
type(a)                 # Affichage du type de la variable a
Out[2]:
int
In [3]:
text = 'Hello prof'     # Création d'une variable nommée text de valeur 'Hello prof'

text                    # Affichage du contenu de la variable text
Out[3]:
'Hello prof'
In [4]:
type(text)              # Affichage du type de la variable text
Out[4]:
str

2. Les instructions élémentaires

Syntaxe Python Description
Affectation a = 7 Affectation de la valeur 7 à la variable a
Opérations
élémentaires
a+b $\quad$ a-b $\quad$ a*b $\quad$ a**b
a/b $\quad$ a//b $\quad$ a%b
Somme, différence, produit, puissance,
quotient décimal, quotient et reste de la division euclidienne.
Tests a == b $\quad$ a != b
a < b $\quad$ a <= b $\quad$ a > b $\quad$ a >= b
Test d'égalité, de non égalité, de comparaisons.
Renvoie un booléen (True ou False)
NB: On peut combiner avec or, and, not
Instruction
conditionnelle
if condition:
$\quad$ |instructions_V
else:
$\quad$ |instructions_F
Réalisation des instructions_V si la condition est True, et réalisation des instructions_F si la condition est False.
NB1: else est facultatif
NB2: dans une série d'instructions conditionnelles imbriquées, "else if" se condense en "elif".
  • 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.
  • 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'.
  • 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 :
    valeur_V if Test else valeur_F vaut valeur_V si le Test vaut True et vaut valeur_F sinon.

$\quad\quad$Ci-dessous quelques exemples modifiables de syntaxes. Pour exécuter une cellule, sélectionner la cellule puis SHIFT+Entrée.

In [5]:
a = 7 ; b = 3                # Affectation des valeurs 3 et 7 aux variables respectivement nommées a et b
In [6]:
a+b                          # Calcul de la somme de a et b
Out[6]:
10
In [7]:
a**b                         # Calcul de a puissance b
Out[7]:
343
In [8]:
a == b                       # Test d'égalité de a et b
Out[8]:
False
In [9]:
'sa'+'lut'                   # Concaténation de deux chaînes de caractères
Out[9]:
'salut'
In [10]:
if a<=b:                     # exemple d'instruction conditionnelle avec la condition a<=b
    print("a<=b")            # Cette instruction est exécutée si a<=b est True
else:
    print("a>b")             # Cette instruction est exéctuée si a<=b est False
a>b
In [11]:
"a<=b" if a<=b else "a>b"    # Exemple de bloc conditionnel
Out[11]:
'a>b'

3. La structure fonctionnelle

Syntaxe Python Description
Définition
d'une fonction
def f(x):
$\quad$
|instructions à réaliser
$\quad$ return resultat
Définition d'une fonction recevant un/des argument(s) x,... et renvoyant resultat.
(arguments et résultat de tous types possibles)
Appel à une
fonction
f(x) Renvoie la valeur de l'image de x par la fonction f.
  • 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 exemple def milieu(xA,yA,xB,yB):. On peut fixer une valeur par défaut à un argument : def f(x=0):.
  • 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 l’exécution de la fonction. Ainsi, pour renvoyer plusieurs informations, il faut les associer (par exemple en les séparant par des virgules).
  • 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).

$\quad\quad$Ci-dessous quelques exemples modifiables de syntaxes. Pour exécuter une cellule, sélectionner la cellule puis SHIFT+Entrée.

In [12]:
# Exemple élémentaire

def f(x):                                      # Définition de la fonction
    "fonction qui calcule le carré de x"       # Description de la fonction
    return x**2                                # Renvoi de la valeur
In [13]:
f(3)                                           # Appel à la fonction                             
Out[13]:
9
In [14]:
# Exemple de fonction à plusieurs arguments et renvoyant plusieurs valeurs

def somme_vecteurs(x1,y1,x2,y2):
    """
    fonction qui renvoie la somme de deux vecteurs u1(x1,y1) et u2(x2,y2)
    """
    x = x1+x2   
    y = y1+y2
    return x,y   

# NB : on peut aussi écrire return x1+x2,y1+y2 
# pour éviter les variables intermédiaires x et y   
In [15]:
somme_vecteurs(2,5,3,-7)                       # Appel à la fonction  
Out[15]:
(5, -2)

4. Les boucles

Syntaxe Python Description
Boucle bornée
«Pour»
for k in range(n):
$\quad$ |instructions à réaliser
Boucle effectuée pour k prenant les valeurs entières de 0 inclus à n exclu
(0≤k
Boucle non bornée
«Tant que»
while condition :
$\quad$ |instructions à réaliser
Boucle effectuée tant que la condition (de type bool) est vérifiée.
NB : Pour créer une condition, voir Tests (Rappel : Il faut éviter les tests d’égalité sur les float)
  • Options du range :
    • range(n1,n2) permet de générer les entiers k tels que n1≤k
    • range(n1,n2,p) permet de générer les entiers k tels que n1≤k
  • 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'.

$\quad\quad$Ci-dessous quelques exemples modifiables de syntaxes. Pour exécuter une cellule, sélectionner la cellule puis SHIFT+Entrée.

In [16]:
for k in range(5):       # exemple d'utilisation du range
    print(k)             # range(5) génère les entiers à partir de 0 avec un pas de 1 et inférieurs strictement à 5
0
1
2
3
4
In [17]:
for k in range(4,12,3):  # exemple d'utilisation du range
    print(k)             # range(4,12,3) génère les entiers à partir de 4 avec un pas de 3 et inférieurs strictement à 12
4
7
10
In [18]:
for mot in ['rouge','vert','bleu']: # exemple de parcours d'une liste
    print(mot)
rouge
vert
bleu
In [19]:
for lettre in 'python': # exemple de parcours d'une chaîne de caractères
    print(lettre)
p
y
t
h
o
n
In [20]:
a = 10

while a>0.1: # exemple d'utilisation d'une boucle while
    print(a)
    a=a/2
10
5.0
2.5
1.25
0.625
0.3125
0.15625

5. Gestion des listes

Syntaxe Python Description
Création L=[]
L=[2,-7,5,6.3]
Création d’une liste vide
Création d’une liste contenant 4 éléments
Longueur len(L) Fonction renvoyant le nombre d’éléments de la liste L.
NB : len = length
Accès à une valeur L[k]
L[k]=v
Donne accès à la valeur de rang k de la liste L
Affecte la valeur v au terme de rang k de la liste L
Atention : Les rangs sont indexés à partir de 0 donc la valeur de rang k est la k+1 ème valeur de la liste.
Test v in L Renvoie un booléen indiquant si la valeur v est dans la liste L.
Ajout et suppression
d'éléments
L.append(v)
L.remove(v)
L.pop(k)
append : Place la valeur v à la fin de la liste L (ajout d’un élément).
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.
Création d'une liste par extensions successives et par compréhension L=[]
for k in range(11):
$\quad$ L.append(k**2)

est équivalent à

L=[k**2 for k in range(11)]
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) et son équivalent en syntaxe rapide, par compréhension.
Création d'une liste par extensions successives et par compréhension, avec condition L=[]
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]
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.
  • 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.
  • 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 ».
  • Gestion des tuples :
  • Syntaxe Python Description
    Création t = (2,-3,1) ou t = 2,-3,1 Création d'un 3-uplet contenant les 3 valeurs 2; -3 et 1.
    Accès à une valeur t[k]
    a,b,c = t
    Donne accès à la valeur de rang k du tuple t
    Stocke dans a,b,c les valeurs du tuple t

$\quad\quad$Ci-dessous quelques exemples modifiables de syntaxes. Pour exécuter une cellule, sélectionner la cellule puis SHIFT+Entrée.

In [21]:
L=[2,-7,5,6.3]             # création d'une liste contenant 4 valeurs
L                          # affichage de la liste
Out[21]:
[2, -7, 5, 6.3]
In [22]:
len(L)                     # affichage de la taille de la liste
Out[22]:
4
In [23]:
L[1]                       # affichage de l'élément de rang 1 de la liste
Out[23]:
-7
In [24]:
L[1] = 4                   # affectation d'une nouvelle valeur à l'élément de rang 1 de la liste
L                          # affichage de la liste
Out[24]:
[2, 4, 5, 6.3]
In [25]:
5 in L                     # test de l'appartenance d'une valeur à la liste
Out[25]:
True
In [26]:
L.append(7)                # ajout d'une valeur dans la liste
L                          # affichage de la liste
Out[26]:
[2, 4, 5, 6.3, 7]
In [27]:
L.remove(5)                # suppression d'une valeur de la liste
L                          # affichage de la liste
Out[27]:
[2, 4, 6.3, 7]
In [28]:
L.pop(1)                   # suppression de l'élément de rang 1 de la liste
L                          # affichage de la liste
Out[28]:
[2, 6.3, 7]
In [29]:
#génération d'une liste par extensions successives

L=[ ]
for k in range(11):
    L.append(k**2)

L                          # affichage de la liste        
Out[29]:
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
In [30]:
#génération d'une liste par compréhension

L=[ k**2 for k in range(11) ]

L                          # affichage de la liste   
Out[30]:
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
In [31]:
#génération d'une liste par extensions successives avec condition

L=[ ]
for k in range(11):
    if k%2:
        L.append(k**2)

L                          # affichage de la liste    
Out[31]:
[1, 9, 25, 49, 81]
In [32]:
#génération d'une liste par compréhension sous condition

L=[ k**2 for k in range(11) if k%2]

L                          # affichage de la liste 
Out[32]:
[1, 9, 25, 49, 81]

6. Utilisation de modules / Bibliothèques

Syntaxe Python Description
Module math from math import* Permet de récupérer toutes les fonctions et constantes du module math (* signifie tout)
avec le module math :
pi$\quad$e
log(x)$\quad$exp(x)
cos(x)$\quad$sin(x)$\quad$tan(x)
sqrt(x)
$\;$
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
Module random from random import* Permet de récupérer toutes les fonctions et constantes du module random (* signifie tout)
avec le module random :
random()
randint(a,b)
$\;$
Nombre flottant aléatoire dans [0;1[
Nombre int aléatoire compris entre a et b
  • Installation d'une bibliothèque :
    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 :
    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)
    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.

$\quad\quad$Ci-dessous quelques exemples modifiables de syntaxes. Pour exécuter une cellule, sélectionner la cellule puis SHIFT+Entrée.

In [33]:
from math import*           # import du module math
In [34]:
pi                          # valeur approchée de pi
Out[34]:
3.141592653589793
In [35]:
e                           # valeur approchée de e (nombre d'Euler)
Out[35]:
2.718281828459045
In [36]:
log(2)                      # logarithme népérien
Out[36]:
0.6931471805599453
In [37]:
exp(2)                      # exponentielle
Out[37]:
7.38905609893065
In [38]:
sqrt(2)                     # racine carrée
Out[38]:
1.4142135623730951
In [39]:
from random import*         # import du module random
In [40]:
random()                    # nombre aléatoire dans [0;1[
Out[40]:
0.15537491729049413
In [41]:
randint(1,6)                # entier aléatoire compris entre 1 et 6 (1 et 6 inclus)
Out[41]:
3

(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/