Bases de Python¶

Introduction¶

Python est un langage de programmation interprété : cela signifie que le logiciel python va lire les instructions et les exécuter ligne par ligne. Si une ligne contient une erreur, on ne le saura que quand cette ligne est exécutée (sauf pour les erreurs de syntaxe).

Dans la plupart des logiciels qui servent à programmer en python (qu'on appelle IDE ou environnement de développement intégré), il y a deux manières d'exécuter du code :

Soit dans une console qui permet d'exécuter une ligne à la fois, pratique pour faire des tests rapidement, en général marquée par les symboles ">>>" en début de ligne. Si la ligne de code renvoit une valeur, elle est affichée.
Soit en exécutant tout un fichier, ce qu'on fait la plupart du temps. La valeur des calculs n'est pas affichée sauf si on utilise des fonctions pour le faire (par exemple print).

Dans les notebooks comme celui-ci, le code est exécuté par cellule et la valeur de la dernière ligne de code est affichée.

In [2]:

Copied!

3
12
10
3
12
10

Out[2]:

Les opérateurs de calcul¶

On peut faire des calculs en python, les opérateurs sont les suivants :

+ : addition sur les nombres, concaténation (= coller) des chaînes de caractères
* : multiplication
a**b : a puissance b
a/b : a divisé par b, le résultat est un nombre décimal (flottant)
a//b : le quotient dans la division de a par b (résultat arrondi à l'entier inférieur)
a%b : le reste de la division de a par b. utile pour déterminer si un nombre est divisible par un autre, dans ce cas le reste vaut 0.

Les types¶

En python les valeurs ont des types. Les types de base sont :

les nombres entiers (int pour integer)
les nombres "à virgule" (float pour nombres à virgule flottante)
les chaînes de caractères (str pour string), qu'on écrit entre guillemets doubles : "Hello World!" ou simples: 'Hello World!'
les booléens (bool) qui valent True ou False (vrai ou faux)

La fonction type() renvoie le type de la valeur qu'on lui donne :

In [2]:

Copied!

type(3)
type(3)

Out[2]:

<class 'int'>

In [3]:

Copied!

type(3.14)
type(3.14)

Out[3]:

<class 'float'>

In [4]:

Copied!

type("hello")
type("hello")

Out[4]:

<class 'str'>

In [5]:

Copied!

type(True)
type(True)

Out[5]:

<class 'bool'>

On verra plus tard avec la programmation orientée objet pourquoi on a le mot-clé "class" devant le nom du type.

Les types permettent de détecter certaines erreurs, par exemple si on essaye d'additionner un entier et une chaîne de caractères :

In [6]:

Copied!

3 + "bonjour"
3 + "bonjour"

Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'

Les variables¶

Les variables sont utilisées partout en programmation : elles permettent de stocker des valeurs dans la mémoire de l'ordinateur, pour les réutiliser ensuite.

On peut choisir les noms de variables qu'on veut, à condition qu'ils n'aient pas d'espace ou de tiret (on utilise à la place le tiret bas _), et qu'ils commencent par une lettre.

Pour assigner une valeur à une variable, on écrit son nom, puis le signe =, et à droite une expression qui sera calculée. La valeur obtenue sera stockée dans la variable de gauche.

In [7]:

Copied!

mon_prénom = "Marie"
variable42 = 12
x = variable42 + 1
mon_prénom = "Marie"
variable42 = 12
x = variable42 + 1

Attention, le signe = n'a pas la même signification qu'en maths, il signifie : calcule la valeur à droite, et mets-la dans la variable de gauche.

Ainsi a = b (on met la valeur de b dans a) et b = a (on met la valeur de a dans b) ne font pas la même chose.

x = x + 1 n'a pas de sens en maths (c'est une équation qui n'a pas de solution), mais en python cela signifie qu'on augmente la valeur de la variable x de 1.

Les tests¶

Les opérateurs booléens permettent de faire des tests donc le résultat vaut True ou False :

a == b teste si a et b sont égaux
a < b, a <= b, a > b, a >= b teste les inégalités strictes ou pas

Les mots-clés if, else et elif permettent d'exécuter un bloc d'instructions seulement si une condition est vraie ou fausse :

Important : Comme tous les autres blocs en python, il ne faut pas oublier les deux points ":" à la fin de la ligne qui créé le bloc, et de décaler à droite avec la touche TAB toutes les lignes qui font partie du bloc.

In [8]:

Copied!

a = 3
if a < 5:
    print("a est plus petit que 5")
a = 3
if a < 5:
    print("a est plus petit que 5")

a est plus petit que 5

elif permet de créer un bloc avec une nouvelle condition si la condition du if était fausse, et else créé un bloc si aucune des conditions des if et elif n'étaient vraies. Les deux sont optionnels, et on peut mettre plusieurs elif à la suite.

In [9]:

Copied!





message = "bonjour"
if len(message) < 4:
    print("moins de 4 caractères")
elif len(message) == 4:
    print("4 caractères")
else:
    print("plus de 4 caractères")
message = "bonjour"
if len(message) < 4:
    print("moins de 4 caractères")
elif len(message) == 4:
    print("4 caractères")
else:
    print("plus de 4 caractères")

plus de 4 caractères

Les boucles¶

En programmation on veut souvent faire des choses répétitives. La boucle for permet de créer un bloc de code qui se répète plusieurs fois :

In [10]:

Copied!

for i in range(3):
    print("hello")
for i in range(3):
    print("hello")

hello
hello
hello

La variable i qu'on a mis dans la boucle (on peut choisir un autre nom) va compter les tours en commençant à 0. Attention, le nombre mis dans range() est le nombre de répétitions et comme on commence à 0 on s'arrête donc un nombre en dessous :

In [11]:

Copied!

for i in range(4):
    print(i)
for i in range(4):
    print(i)

La boucle while créé un bloc qui s'exécute tant que la condition mise après le while vaut True. Cette condition est réévaluée à chaque itération de la boucle. Attention, si la condition est toujours vraie la boucle ne va jamais s'arrêter, c'est une boucle infinie (et selon le logiciel qu'on utilise pour coder, ça peut le faire planter).

In [12]:

Copied!





a = 3
while a > 0:
    print(a)
    a = a - 1
print("boum")
a = 3
while a > 0:
    print(a)
    a = a - 1
print("boum")

3
2
1
boum

Les fonctions¶

Les fonctions permettent de donner un nom à un morceau de code, pour le réutiliser quand on veut en l'appelant. Cela permet de ne pas recopier le même code plusieurs fois. On les créé dans un bloc avec le mot clé def.

In [3]:

Copied!





def ligne_deco():
    for i in range(20):
        print("#",end="")
    print()
def ligne_deco():
    for i in range(20):
        print("#",end="")
    print()

Cette cellule n'affiche rien car on n'a pas encore appelé (=utilisé) la fonction.

In [4]:

Copied!

ligne_deco()
print("Bonjour")
ligne_deco()
ligne_deco()
print("Bonjour")
ligne_deco()

####################
Bonjour
####################

Les fonctions peuvent prendre des paramètres qui permettent de donner des valeurs à une fonction pour qu'elle ne fasse pas à chaque fois la même chose, elle est ainsi plus polyvalente.

Les paramètres sont :

nommés entre parenthèses à la définition de la fonction, avec le nom qu'on veut.
puis peuvent être utilisé dans le code de la fonction grâce à ce nom, comme une variable normale. On ne peut pas savoir à l'avance la valeur qu'il y aura dans cette variable quand on écrit le code de la fonction.
enfin quand on appelle la fonction, on donne entre parenthèse les valeurs qu'on veut pour les paramètres pour cette exécution de la fonction. On peut en donner des différents à chaque fois.

Quand on appelle une fonction, il faut savoir le nombre de paramètres dont elle a besoin: si on en donne trop ou pas assez, on aura une erreur.

In [15]:

Copied!





def rectangle(lignes, colonnes):
    for i in range(lignes):
        for j in range(colonnes):
            print("#",end="")
        print()

rectangle(3,10) # on choisit 3 comme valeur pour lignes et 10 pour colonnes
print()
rectangle(5,2)
def rectangle(lignes, colonnes):
    for i in range(lignes):
        for j in range(colonnes):
            print("#",end="")
        print()

rectangle(3,10) # on choisit 3 comme valeur pour lignes et 10 pour colonnes
print()
rectangle(5,2)

##########
##########
##########

##
##
##
##
##

Les listes¶

une liste en python est un tableau qui permet de stocker plusieurs valeurs.

In [6]:

Copied!

L = [10,20,30,40]
semaine = ["lundi","mardi","mercredi","jeudi","vendredi","samedi","dimanche"]
L = [10,20,30,40]
semaine = ["lundi","mardi","mercredi","jeudi","vendredi","samedi","dimanche"]

On peut accéder à un élément de la liste en donnant sa position entre crochets (le premier élément est en position 0):

In [17]:

Copied!

semaine[1]
semaine[1]

Out[17]:

'mardi'

Les listes sont modifiables : on peut ajouter un élément en utilisant la méthode append (une méthode est une fonction liée à une variable, on l'appelle avec le nom de la variable point le nom de la méthode)

In [18]:

Copied!

L.append(50)
L
L.append(50)
L

Out[18]:

[10, 20, 30, 40, 50]

On peut modifier une des valeurs du tableau avec une assignation, comme si c'était une variable :

In [19]:

Copied!

L[0] = 7
L
L[0] = 7
L

Out[19]:

[7, 20, 30, 40, 50]

On peut parcourir tous les éléments d'une liste avec une boucle for de deux manières.

La première est un parcours par indice avec range où on parcourt toutes les positions, pour ensuite accéder aux éléments de la liste avec les crochets. C'est toujours possible de faire cette méthode.

In [7]:

Copied!

for i in range(len(semaine)):
    print(semaine[i])
for i in range(len(semaine)):
    print(semaine[i])

lundi
mardi
mercredi
jeudi
vendredi
samedi
dimanche

La deuxième est le parcours par valeur où la variable prend directement les valeurs successives de la liste. Dans ce cas on évite d'utiliser i comme variable de boucle pour ne pas confondre et on prend un nom qui a du sens, comme jour ici puisque les valeurs sont des noms de jours.

In [9]:

Copied!

for jour in semaine:
    print(jour)
for jour in semaine:
    print(jour)

lundi
mardi
mercredi
jeudi
vendredi
samedi
dimanche

Cette méthode est plus simple à écrire et à relire, mais elle a deux limitations :

on ne peut pas modifier les valeurs de la liste car la variable jour est juste une copie de la valeur contenue dans la liste (on a le droit de la modifier, mais ça ne modifie pas la liste)
on n'a pas accès à l'indice de la valeur, ce dont on a parfois besoin. Par exemple on ne pourrait pas afficher des messages comme "mardi est le 2e jour de la semaine"

Si ces limitations posent problème, il faut utiliser le parcours par indice.

Les tuples¶

Les tuples sont un peu comme des listes, mais on les écrit avec des parenthèses au lieu de crochets (on utilise quand même les crochets pour accéder à un élément) :

In [21]:

Copied!

t = (1,2,3)
print(t[0])
t = (1,2,3)
print(t[0])

La principale différence est que les tuples ne sont pas modifiables :

In [22]:

Copied!

t[0] = 7
t[0] = 7

Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Ils sont donc utilisés quand on sait qu'on ne modifiera pas les valeurs dans le code, et surtout :

pour des tuples avec seulement quelques éléments. Par exemple si une fonction doit renvoyer une paire de valeurs, on renverra en fait un tuple à deux éléments.
comme clé dans les dictionnaire si on veut une clé composée de plusieurs valeurs, car les clés des dictionnaires n'ont pas le droit d'être modifiables.

In [10]:

Copied!

def division_euclidienne(a, b):
    return (a//b, a%b) # renvoie un tuple avec le quotient et le reste
def division_euclidienne(a, b):
    return (a//b, a%b) # renvoie un tuple avec le quotient et le reste

Les dictionnaires¶

Comme les listes, les dictionnaires permettent de stocker des éléments mais au lieu d'être dans un ordre indexé par 0,1,2... ils ne sont pas ordonnés et indexés par des clés (qui peuvent être des nombres, chaînes de caractères ou tuples mais pas des listes car les listes sont modifiables):

In [23]:

Copied!

d = { "Adam" : 12, "Anna" : 14, "Tom" : 11}
d["Adam"]
d = { "Adam" : 12, "Anna" : 14, "Tom" : 11}
d["Adam"]

Out[23]:

On peut tester si une clé est présente dans le dictionnaire avec le mot clé in

In [24]:

Copied!

print("Anna" in d)
print("Sabrina" in d)
print("Anna" in d)
print("Sabrina" in d)

True
False

On peut parcourir un dictionnaire avec for en faisant l'équivalent d'un parcours par valeur sur une liste, mais qui va sur un dictionnaire parcourir les clés du dictionnaire. Il faudra donc utiliser les crochets pour accéder aux valeurs correspondantes.

Comme il n'y a pas d'ordre dans un dictionnaire, on ne peut pas faire un parcours par indice avec range qui supposerait pouvoir accéder à l'"élément 0 du dictionnaire" ce qui n'a pas de sens.

In [25]:

Copied!

for prénom in d:
    print(prénom, "a eu la note", d[prénom])
for prénom in d:
    print(prénom, "a eu la note", d[prénom])

Adam a eu la note 12
Anna a eu la note 14
Tom a eu la note 11

Les bibliothèques ou modules¶

Pour ne pas réinventer la roue à chaque fois, on va souvent utiliser des bibliothèques, c'est à dire du code écrit par d'autres personne : Cette page liste les modules de la bibliothèque standard de python, jetez-y un oeil, mais il y en a bien d'autres.

On peut soit importer tout un module avec import puis pour utiliser les fonctions il faut les précéder du nom du module, par exemple pour utiliser le module random pour générer des nombres aléatoires :

In [26]:

Copied!

import random
print(random.randint(0,1000))
import random
print(random.randint(0,1000))

Ou bien on peut importer juste une fonction de la bibliothèque comme ceci :

In [27]:

Copied!

from random import randint
print(randint(0,1000))
from random import randint
print(randint(0,1000))

Ou si on veut importer toutes les fonctions sans avoir à réécrire le nom du module en préfixe :

(vous avez fait ça sur france-ioi avec "from robot import *", pour importer toutes les fonctions qui servaient à déplacer le robot)

In [28]:

Copied!

from random import *
from random import *

Obtenir de l'aide¶

Si on a oublié le nom d'un module, ou d'une fonction, ou comment elle s'utilise, ce n'est pas grave mais il faut être capable de retrouver ça.

On peut faire une recherche sur internet, mais dans la console python on peut aussi utiliser help() avec le nom d'un module ou d'une fonction (l'aide est en anglais):

In [29]:

Copied!

help(randint)
help(randint)

Help on method randint in module random:

randint(a, b) method of random.Random instance
    Return random integer in range [a, b], including both end points.

La fonction randint(a,b) du module random permet donc de générer un entier aléatoire entre a et b (inclus). Par exemple si on veut simuler un lancer de dé, on peut utiliser randint(1,6).

Sur internet on peut trouver la documentation détaillée du module random en français : https://docs.python.org/fr/3/library/random.html