Bases de Python

Python est un langage de programmation facile à maîtriser.

Ses avantages sont nombreux :

  • syntaxe claire et facile
  • existence de nombreuses bibliothèques
  • utilisation dans le supérieur

Afficher et lire des messages

Pour afficher du texte dans la console on utilise print()

In [1]:
print('Hello world')

Hello world

Le message à afficher est une chaîne de caractère (le format string). Elle est donc écrite entre des guillemets (simples ou doubles)

On déclare des variables avec le symbole =

In [ ]:
mon_texte = "Bonjour le Monde"
print(mon_texte)

mon_texte = "Rebonjour" + "le Monde"
print(mon_texte)

On peut demander à l'utilisateur de saisir du texte avec input()

In [ ]:
prenom = input("Comment t'appelles-tu ? ")
print("Bonjour " + prenom + " !")

La fonction input() renvoie du texte. Cela peut suprendre au début :

In [ ]:
nombre = input("Tape un nombre : ")
double = nombre * 2
print("Le 'double' du nombre saisi est", double)

Pour indiquer à Python que la valeur saisie est un nombre on doit transformer (caster en franglais) le résultat :

  • int( input() ) pour indiquer un nombre entier
  • float( input() ) pour indiquer un nombre décimal
In [ ]:
nb_entier = int( input("Tape un nombre : ") )
print(nb_entier)

nb_decimal = float( input("Tape un nombre : ") )
print(nb_decimal)

Essayer le code précédent en tapant 3 à chaque fois. Quelle est la différence entre les deux sorties ?

  1. Exercice :
    • Saisir ci-dessous le code demandant à l'utilisateur de saisir un texte puis affichant "trois fois" ce texte. Par exemple si on saisit 'to', le programme affiche 'tototo'
In [ ]:
# Saisir le code ci-dessous
  1. Exercice :
    • Saisir ci-dessous le code demandant à l'utilisateur de saisir un nombre entier et affichant son triple.
In [ ]:
# Saisir le code ci-dessous
  1. Exercice :
    • Saisir ci-dessous le code demandant à l'utilisateur de saisir la largeur et la longueur d'un rectangle et affichant son périmètre. Les dimensions seront des nombres décimaux.
In [ ]:
# Saisir le code ci-dessous

Les variables

Voici les opérations classiques sur les variables.

  • Les nombres :
In [ ]:
# Aucune sortie lors de l'éxécution !!

entier = 4

entier + 5 # addition
entier - 5 # multiplication
entier * 2 # multiplication
entier ** 2 # puissance entière
entier % 3 # reste de la division euclidienne par 3. nb % 2 est pratique pour tester la parité d'un nombre

from math import pow
pow(entier, 3.5) # puissance décimale entier^3.5

entier += 1 # on ajoute 1 à entier et on stocke le résultat dans entier
entier *= 2 # on double entier et on sticke le résultat dans entier
  • Les chaînes de caractères :
In [ ]:
texte = "Salut"

texte[0] # le premier caractère de texte. On compte toujours à partir de 0
texte[-1] # le dernier caractère de texte, l'avant dernier est le -2

len(texte) # le nombre de caractère de texte

texte * 2 # on écrit "SalutSalut"

texte2 = texte + "le Monde !" # Concaténation : on ajoute des textes

Les imports

Lorsque l'on lance python, l'ordinateur charge un ensemble de fonctions de base que l'on peut utiliser immédiatement :

In [ ]:
min(5,8) # la fonction minimum est chargée immédiatement

D'autres fonctions ne le sont pas comme par exemple la fonction racine carré sqrt :

In [ ]:
sqrt(5)

Il faut donc l'importer.

Il existe deux façons d'importer des fonctions :

  • un import direct de la fonction
  • un import de la bibliothèque (du module)

La seconde méthode est plus "sage" car dans certains cas deux modules peuvent contenir des fonctions ayant le même noms : on risque de s'y perdre.

  • L'import direct :
In [ ]:
from math import sqrt # on importe la fonction sqrt du module math

sqrt(5)
In [ ]:
from math import * # on importe toutes les fonctions du module math (pas très propre mais efficace...)

cos(5*pi)
  • L'import du module (1):
In [ ]:
import math # on importe le module

math.sqrt(5) # on garde la trace de l'origine de la fonction sqrt : elle vient de math
  • L'import du module (2):
In [ ]:
import numpy as np # on importe le module numpy (calculs de maths plus poussés)
# on lui donne le nom np afin de simplifier la notation 

tableau_x = range(10) # on créée nu tableau contenant tous les entiers de 0 à 99

tableau_cos = np.cos(tableau_x) # la fonction cos du module np permet de calculer le "cosinus d'un tableau"
# En fait elle calcule le cosinus de chaque nombre dans le tableau

tableau_cos

Les tests avec if ... elif ... else

Il est très courant en programmation de devoir tester des valeurs. Pour ce faire on utilise un if

In [ ]:
a = 10

if a > 9 :
    print("a est plus grand que 9")

Pour gérer plusieurs cas de figure on utilise des if ... elif ... else

In [ ]:
a = 10

if a > 20 :
    print("a est supérieur à 20")
elif a > 11 :
    print(" a est compris entre 11 et 20")
else :
    print("a est plus petit que 11")
  1. Exercice :
    • Saisir ci-dessous le code demandant à l'utilisateur s'il trouve ce tutoriel clair
    • Si la réponse est "oui", le code affichera "Tant mieux !"
    • Si c'est "non", on affichera "Mince..."
In [ ]:
# Saisir le code ci-dessous
  1. Exercice :
    • Saisir ci-dessous le code demandant à l'utilisateur de saisir sa dernière note d'anglais sur 20 qui sera convertie en un décimal.
    • Si cette note est inférieure strictement à 10 on affichera "Peut mieux faire..."
    • Si elle est comprise entre 10 et 14 (exclu) : "Pas mal"
    • Dans les autres cas : "Bon travail"
In [ ]:
# Saisir le code ci-dessous

Les boucles Tant que avec while

Les boucles Tant que se codent avec while

On rappelle que ces boucles s'utilisent lorsque l'on souhaite répéter des actions jusqu'à ce qu'une certaine condition soit atteinte. On ne sait pas obligatoirement le nombre de répétition que l'on doit effectuer.

Considérons l'exemple suivant :

  • un enfant imaginaire empile des cubes
  • le premier cube à une hauteur de $1$ dm
  • le deuxième $\frac{1}{2}$
  • le troisième $\frac{1}{3}$
  • ...

A partir de combien de cubes la hauteur totale dépassera $1$ m = $10$ dm ?

On va utiliser une boucle while et ajouter dès cubes tant que on n'aura pas atteint la hauteur souhaitée :

In [ ]:
hauteur = 0
nb_cube = 0

while hauteur < 10 :
    nb_cube += 1 # on passe au cube suivant qui mesurera 1/nb_cube
    hauteur += 1/nb_cube

print("Il faut", nb_cube, "cubes pour dépasser 1 mètre !")

  1. Exercice :

    • Saisir ci-dessous le code reprenant l'exemple précédant mais en considérant que les cubes sont de hauteur $1$, $\frac{1}{2}$, $\frac{1}{4}$, $\frac{1}{6}$...

    • On s'arrêtera lorsque l'on dépasse $0.5$ m = $5$ dm

In [ ]:
# Saisir le code ci-dessous
  1. Exercice :
    • Compléter le code suivant qui choisit un nombre entier au hasard entre 0 et 20
    • Le programme demande à l'utilisateur le nombre auquel il pense jusqu'à ce qu'il ait trouvé le bon résultat
    • On gardera trace du nombre d'essais
In [ ]:
# Saisir le code ci-dessous
from random import randint # on import la fonction randint (random integer)

hasard = randint(0,20) # on stocke dans hasard un nombre entier aléatoire entre 0 et 20

Les boucles Pour avec for

Les boucles Pour se codent avec for

Contrairement aux boucles Tant que les Pour répètent certaines actions un nombre de fois connu à l'avance.

Il existe plusieurs façons de saisir une boucle Pour

  1. On n'indique que le nombre de répétitions :
In [ ]:
# On ne saisit qu'un nombre dans range -> i prend les valeurs de 0 jusqu'à ce nombre -1
# Il y a donc autant de répétitions qu'indiqué dans le range 
for i in range(5) :
    print(i)
  1. On indique la valeur de début et la valeur de fin + 1 :
In [ ]:
# On saisit deux nombres (start et end) dans range -> i prend les valeurs de start jusqu'à end -1

for i in range(1, 5) :
    print(i)
  1. On indique la valeur de départ, la valeur de fin + 1 et le pas :
In [ ]:
# On saisit trois nombres (start, end et step) dans range -> i prend les valeurs de start jusqu'à end -1 
# en avançant de step unités à chaque fois

for i in range(1, 5, 2) :
    print(i)

Cette dernière technique permet de parcourir des listes à l'envers (avec un pas/step négatif) :

In [ ]:
for i in range(5, 0, -1):
    print(i)

Python permet de parcourir des listes facilement à l'aide de for :

In [ ]:
liste = ["Bonjour", "je", "suis", "une", "liste"]

# Parcours classique à l'aide de l'index
for i in range( len(liste) ) : # len(liste) renvoie la longueur de la liste. i ira de 0 jusqu'à longueur -1
    print( liste[i] ) # liste[i] est le i-ième élément de liste
In [ ]:
# Parcours simple, spécifique à Python
for mot in liste : # on prend successivement tous les éléments de liste et on les appelle mot dans la boucle
    print(mot)
  1. Exercice :
    • Saisir ci-dessous le code affichant tous les entiers de 8 à 24
In [ ]:
# Saisir le code ci-dessous
  1. Exercice :
    • Saisir ci-dessous le code affichant tous les entiers pairs de 8 à 24
In [ ]:
# Saisir le code ci-dessous

  1. Exercice :

    • Saisir ci-dessous le code affichant les lignes suivantes à l'aide d'une boucle Pour

    *

    **

    ***

    ****

    *****

In [ ]:
# Saisir le code ci-dessous

  1. Exercice :

    • Saisir ci-dessous le code affichant les lignes suivantes à l'aide d'une boucle Pour

    *****

    ****

    ***

    **

    *

In [ ]:
# Saisir le code ci-dessous
  1. Exercice :
    • Saisir ci-dessous le code demandant à l'utilisateur de saisir un mot et affichant successivement toutes les lettres de ce mot
    • On rappelle qu'en python, une chaîne de caractère est une liste
In [ ]:
# Saisir le code ci-dessous