Séance 1

Séance 1#

Objectifs

  • Utilisation de python en mode « calculatrice »

  • Variables : déclaration, affectation, affichage

  • Chaînes de caractères

  • Valeurs et tests logiques

  • Premières fonctions

Présentation rapide de python et jupyter#

python#

Python est un langage de programmation sous licence libre permettant une initiation rapide aux concepts de base de programmation et d’algorithmique. Il est apprécié pour la simplicité de sa syntaxe et sa rapidité de déploiement.

En pratique, il est beaucoup utilisé dans l’enseignement secondaire et supérieur, mais également dans des contextes de recherche académique (calcul scentifique, big data, machine learning) et dans l’industrie (entre autres, comme langage de script pour des interfaces entre programmes).

Référence : https://www.python.org/

jupyter#

Jupyter est une application web qui permet, entre autres, d’utiliser différents langages de programmation (notamment python) de manière interactive et visuelle. Il permet notamment la création de notebook (carnet de note, calepin), où peuvent se mêler du texte, des formules mathématiques, des lignes de codes et le résultat de leur exécution.

Par exemple, ce livre numérique a été éntièrement créé grâce à jupyter. La page actuelle peut être téléchargée sous la forme d’un notebook (extension .ipynb), voir l’icône de téléchargement en haut. Il est ensuite possible de l’exécuter sur votre machine personnelle.

Référence : https://jupyter.org/

Premières commandes#

Calculs élémentaires#

Avec python, il est possible de calculer le résultat d’expressions mathématiques, comme le ferait une calculatrice élémentaire. Pour cela, on entre le calcul à effectuer et on exécute la cellule (avec le bouton d’exécution, ou plus rapidement avec Ctrl+Enter).

Exemple. Pour calculer \(1+1\) :

1 + 1

2

L’addition et la soustraction sont représentées par + et -. La multiplication est notée *, l’opération d’exponentation (« mise à la puissance ») est quant à elle **. Python respecte les priorités usuelles sur les opérateurs, mais il est toujours préférable de bien parenthéser ses expressions.

Exemple. Pour calculer le résultat de l’expression \(2^3 + (3 \times 4 - 1)\), on entre :

2**3 + (3 * 4 - 1)

19

Remarque. Python n’est pas sensible aux espaces.

2              **3 + (3*4-1)

19

Le cas de la division#

En mathématiques, il existe deux types de divisions : la division exacte (éventuellement avec un résultat décimal) et la division euclidienne (avec reste). Voyons comment python implémente ces deux opérations.

Calculons le résultat de la division \(5/3\) :

5 / 3

1.6666666666666667

On observe qu’on obtient une valeur décimale approchée : cela signifie que, nativement, python ne sait pas manipuler des valeurs exactes de rationnel.

Si l’on souhaite obtenir le quotient de la division euclidienne, il faut utiliser le double caractère // :

5 // 3

1

Pour ce qui est du reste de la division euclidienne (le « modulo »), l’opérateur est %. Par exemple :

5 % 3

2

Résumé. Voici un tableau récapitulatif :

Opération (exemple)

Syntaxe python

Résultat

Addition \(7 + 3\)

7 + 3

\(10\)

Soustration \(7 - 3\)

7 - 3

\(4\)

Multiplication \(7 \times 3\)

7 * 3

\(21\)

Exponentiation \(7 ^ 3\)

7 ** 3

\(343\)

Division « exacte » \(7 / 3\)

7 / 3

\(2.3333333333333335\)

Division euclidienne de \(7\) par \(3\)

7 // 3

\(2\)

Reste de la division de \(7\) par \(3\) (\(7\) modulo \(3\))

7 % 3

\(1\)

Variables#

Python permet de garder en mémoire des valeurs, dans des « objets mémoire » représentés par des variables. On doit nommer une variable par un texte sans espace et essentiellement sans caractère spécial (excepté le _) , et commençant par une lettre.

Lorsqu’on place une valeur dans une variable, on dit qu’on lui affecte ou assigne une valeur. Une affectation se fait par un signe égal =, en donnant à gauche le nom de la variable, et à droite la valeur à lui affecter. Attention, ce n’est pas symétrique !!

Question. Affecter la valeur \(15\) à la variable a.

a = 15

On observe qu’aucun affichage n’est donné en sortie. En effet, l’affectation d’une valeur à une variable ne retourne aucun résultat. Si l’on souhaite voir ce qu’il y a dans une variable, on peut l’afficher avec la fonction print.

Question. Affecter \(8\) à la variable b puis l’afficher.

b = 8
print(b)

8

La fonction print prend ici en entrée le paramètre b. Ce paramètre est passé entre parenthèses, après le nom de la fonction.

Remarque importante. L’environnement jupyter mémorise les différents calculs efféctués dans les cellules. Ainsi, on peut afficher la valeur de la variable a qui a été définie dans une des cellules précédentes.

print(a)

15

Il est possible d’effectuer des calculs sur les variables comme on l’avait précédemment fait directement sur les valeurs.

Question. Créer une variable c et l’affecter avec la somme des valeurs contenues dans a et b. Puis, afficher c.

c = a + b
print(c)

23

La valeur d’une variable peut être mise à jour au cours du temps. On écrase alors l’ancienne valeur (elle est perdue).

Question. Affecter à la variable a la valeur \(6\), puis incrémenter a de \(1\), et enfin afficher le résultat.

a = 6
a = a + 1
print(a)

7

Notons que, pour l’incrémentation, la syntaxe plus compacte += sera souvent utilisée :

a = 6
a += 1
print(a)

7

Cette syntaxe s’étend d’ailleurs à de nombreux opérateurs :

  • x *= 2 pour doubler le contenu de la variable x;

  • y -= 3 pour ôter \(3\) au contenu de la variable y;

  • z %= 10 pour ne garder de z que son chiffre des unités;

  • etc.

Chaînes de caractères#

Python permet de manipuler d’autres structures de données que des nombres. Par exemple, les chaînes de caractères permettent de stocker du texte. Elles sont définies par des guillemets (simples ' ou doubles ", c’est équivalent).

Question. Affecter à la variable a la chaîne de caractère « Hello ».

a = "Hello"
a

'Hello'

On peut également concaténer (= mettre à la suite) deux chaînes de caractères. Pour cela on utilise une nouvelle fois l’opérateur +.

Question. Affecter à la variable b la chaîne de caractère « world ». Puis, afficher la concaténation de a, d’un espace, et de la variable b.

b = "world"
print(a + " " + b)

Hello world

Remarque. L’opérateur + peut donc s’appliquer à la fois à des nombres, et à des chaînes de caractères. Il n’a pas le même rôle dans ces deux cas : on parle de surcharge d’opérateur.

On souhaite maintenant répéter plusieurs fois une même chaîne de caractères. Plutôt que d’appliquer l’opérateur + un certain nombre de fois, on peut utiliser l’opérateur *.

'a' * 12

'aaaaaaaaaaaa'

Enfin, on peut accéder à la longueur d’une chaîne de caractère (c’est-à-dire, son nombre de caractères), par la fonction len() :

len('Hello')

5

La chaîne de caractère vide "" existe et a une longueur nulle :

len("")

0

Valeurs logiques#

Python permet de manipuler des valeurs logiques booléennes (vrai ou faux). La valeur « vraie » est représentée par True et la valeur « fausse » par False.

True

True

On peut effectuer des opérations sur les valeurs booléennes. La négation s’écrit not, le « et » logique and et le « ou inclusif » logique or.

Question. Afficher la table logique de « et ».

print(True and True)
print(True and False)
print(False and True)
print(False and False)

True
False
False
False

Comparaisons#

Les valeurs logiques sont souvent issues de comparaisons entre objets (égalité, différence, inégalité, etc.). Voici un tableau des opérations de comparaison possibles pour des nombres :

Comparaison

Syntaxe python (avec deux variables a et b)

Égal

a == b

Différent

a != b

Strictement inférieur

a < b

Inférieur ou égal

a <= b

Strictement supérieur

a > b

Supérieur ou égal

a >= b

Question. Affecter \(15\) et \(8\) aux variables a et b. Puis, tester si leur somme est égale à \(23\).

a = 15
b = 8
a + b == 23

True

Question. Tester si \(2^{13} < 4000\).

2 ** 13 < 4000

False

Question. Tester si \(5+7 \ge 12\).

5 + 7 >= 12 

True

Question. Tester si \(a \ne 1\).

a != 1

True

On peut également effectuer des tests sur des chaînes de caractères, notamment l’égalité.

Question. Vérifier que l’on peut utiliser de manière équivalente les guillemets simples et les guillements doubles pour définir une chaîne de caractères.

"Hello" == 'Hello'

True

Tests et conditions#

Dans un algorithme, on peut vouloir effectuer des instructions selon si une condition est vérifiée (ou non). Par exemple, dans le morceau de code suivant, on teste si le contenu de la variable x est strictement positive, et si c’est le cas, on affiche le texte « Positif ».

x = 1
if (x > 0):
    print("Positif")

Positif

Le bloc syntaxique doit être impérativement respecté :

if (test):
    instructions

Notez la présence du mot-clef if, suivi d’un test et du caractère : en fin de première ligne. Puis, apès un retour à la ligne, les instructions sont indentées (il faut utiliser la touche de tabulation ↹).

Pour ajouter le cas où la condition n’est pas satisfaite, on utilise le mot-clef else :

x = -1
if (x > 0):
    print("Positif")
else:
    print("Négatif")	

Négatif

Enfin, on peut introduire un second test dans le cas où la première condition n’est pas satisfaite, avec le mot-clef elif (compression de else et if).

x = 0
if (x > 0):
    print("Positif")
elif (x == 0):
    print("Nul")
else:
    print("Négatif")

Nul

Fonctions#

En programmation, il est d’usage de placer des instructions dans des fonctions, destinées à ensuite être réutisées avec divers arguments (aussi appelés paramètres).

La signature d’une fonction consiste en son nom et la description de ses arguments. Par exemple, si l’on souhaite nommer une fonction ma_fonction et ses arguments sont arg1 et arg2 (par exemple), alors sa signature sera :

ma_fonction(arg1, arg2)

Remarque (avancée). Il n’est pas nécessaire de donner le type des arguments, ni celui de la valeur de sortie de la fonction (mais on peut le faire à titre indicatif).

En python, une fonction est déclarée avec le mot clef def. Voici un exemple de la déclaration d’une fonction qui permet de calculer l’aire d’un triangle, étant donnée sa base et sa hauteur.

def aire_triangle(base, hauteur):
    resultat = (base * hauteur) / 2
    return resultat

On observe la présence du mot-clef return qui permet de retourner une valeur. Ce mot-clef n’est pas obligatoire dans la déclaration d’une fonction, mais s’il est absent, alors la fonction ne retournera rien.

Après l’avoir déclarée, on peut ensuite appeler cette fonction avec des arguments quelconques.

aire_triangle(12, 5)

30.0

aire_triangle(2.5, 4)

5.0

Dans la déclaration d’une fonction, on peut bien sûr appeler d’autres fonctions.

def plus_grand_triangle(base1, hauteur1, base2, hauteur2):
    aire1 = aire_triangle(base1, hauteur1)
    aire2 = aire_triangle(base2, hauteur2)
    if aire1 > aire2:
        return 1
    else:
        return 2
        
plus_grand_triangle(12, 5, 2.5, 4)

1
Contenu