Cours 01

Éléments de programmation 1
Cours 1 : Expressions arithmétiques et fonctions
Jean-Noël Vittaut
© Équipe enseignante LU1IN0X1
Plan du cours
1 Informations pratiques
2 Introduction
Objectifs de l’UE
Un premier exemple
3 Les expressions
Expressions simples
Expressions composées
Opérateurs
Spécification de fonction
Application de fonction
Principe d’évaluation
4 Définition de fonction
Complément sur la spécification
Implémentation
Jeu de tests
5 Conclusion
6 Informations complémentaires
Jean-Noël Vittaut — Cours 1 : Expressions arithmétiques et fonctions — Éléments de programmation 1 — 2022–2023 1/45
Présentation
Vous
PEIP : 5 groupes de TD
CMI + SA + IL : 3 groupes de TD
SHI (mS) : 1/2 groupe de TD
Moi
Jean-Noël Vittaut, Maître de conférences en informatique au LIP6

Mail : jean-noel.vittaut@lip6.fr
Supports de cours
Versions papiers
Tous les documents papiers sont distribués par l’Association Ludique et InformAtique de Sorbonne
Université (ALIAS) 14-15 506
Créneaux réservés pour vous :
mardi 20 septembre 2022 de 18h à 19h pour PEIP + CMI + IL + SA
mercredi 21 septembre 2022 de 12h45 à 13h45 pour SHI
À récupérer :
Cahier d’exercices TD-TME en 2 saisons : semaines 1 à 5
Carte de référence : seul document autorisé aux examens
Supports de cours
Versions numériques
Site de l’UE : https://moodle-sciences-22.sorbonne-universite.fr

Transparents utilisés par section (dépend du prof d’amphi !)
Lien avec un livre associé au cours (pdf, version papier payante possible)
Recueil d’exercices en pdf
Annales d’interro, de TMESolo, de partiel, d’examen, de rattrapage
Information sur le tutorat fait spécifiquement pour cette UE
...
Une mine d’or pour vous !
Prérequis et organisation
Prérequis
Pour les Cours : aucun prérequis en programmation

Pour les Exemples : Mathématiques et Physique de Terminale S
Organisation
1h45 de Cours en amphithéâtre

1h45 de Travaux Dirigés : exercices corrigés sur feuille et au tableau
1h45 de Travaux sur Machine Encadrés : exercices pratiques sur ordinateur
Travail personnel en autonomie : apprentissage du cours, entraînement aux exercices de TDs,
entraînement à la programmation pratique
Tutorat :
se renseigner rapidement
Environnement et évaluation
Environnement
IDE fait-maison : MrPython.

présent dans les salles de TMEs,
téléchargeable pour le travail en autonomie (voir plus loin).
Proche de IDLE.
Évaluation
Note de l’UE sur 100 points :
Soit :
Devoir sur Table le 18 novembre 2022 de 18h30 à 20h sur 15 points,
"TME solo" debut novembre sur 15 points,
Évaluation TD (interro/colles/devoirs/participation) sur 10 points,
Rendus de TME systématiques sur 10 points.
Contrôle final en janvier sur 50 points.
Soit :
2× Contrôle final en janvier sur 50 points.
Règles de validation
Validation si la note de l’UE ⩾ 50.

Seconde chance :
Écrit de seconde chance en juin.
Séances de TD-TME
Consignes :
Se munir de ses identifiants (login/mot de passe donnés avec la carte d’étudiant) pour les TMEs.
Ne pas changer de groupe de TD.
Transmettre les justificatifs d’absence à Patricia Lavanchy (24-25 204)
Patricia.Lavanchy@sorbonne-universite.fr
Le site Web contient un lien vers le site de soumission des TMEs. Apprenez à soumettre vos TME
correctement !
Conseils pour réussir l’UE
Ne pas se sous-estimer : pas de pré-requis pour ce cours, accessible à tout étudiant de L1.
Ne pas se sur-estimer : des connaissances en informatique (lycée/autodidaxie) et en Python ne
garantissent pas la réussite de l’UE. Vision particulière de l’informatique et de la programmation.
Aller en cours pour prendre des notes et participer : la première visualisation des concepts est
importante, l’écriture des programmes permet de s’entraîner.
Être actif en TD/TME : attention aux binômes "déséquilibrés" en TME et à l’attitude passive en TD.
Travailler seul : refaire les exercices de TD/TME si nécessaire, faire ceux non-traités en TD/TME.
Parler avec l’équipe pédagogique : poser des questions pendant (ou à la fin) des amphis, en TD/TME,
envoyer des mails à l’équipe pédagogique pour des précisions, des corrections, des énoncés
supplémentaires, des exemples d’interrogations ou d’examens.
Ne pas compter sur la seconde chance.
Plan du cours
2 Introduction
Objectifs de l’UE
Un premier exemple
3 Les expressions
Expressions simples
Opérateurs
Implémentation
Jeu de tests
5 Conclusion
Qu’est-ce que l’informatique ?
L’informatique n’est pas plus la science des ordinateurs que l’astronomie n’est celle des télescopes
(Edsger W. Dijkstra)
Science du traitement automatisé de l’information

Science : donc un aspect théorique (domaine des mathématiques)
Traitement automatisé : c’est l’ordinateur (domaine des technologies)
Information (au sens de Shannon) : tout ce qui est numérisable (texte, musique, voix, image, films, ADN, . . .)
L’informatique regroupe un grand nombre de domaines : langage et programmation, architecture et système,

théorie des graphes, réseau, sécurité, base de données, intelligence artificielle, etc.
Programmation
Wikipédia
Un programme informatique est une séquence d’instructions qui spécifie étape par étape les opérations à effectuer pour obtenir un résultat. Il est exprimé sous
une forme qui permet de l’utiliser avec une machine comme un ordinateur pour exécuter les instructions. Un programme est la forme électronique et numérique
d’un algorithme exprimé dans un langage de programmation - un vocabulaire et des règles de ponctuation destinées à exprimer des programmes.
Programmer (écrire des programmes), c’est donner des instructions à une machine en vue de lui faire
réaliser un résultat.
instructions : analogie de la recette de cuisine,
machines : PC, processeur, puce, . . .
résultats :
calculer une expression,
construire une image,
effectuer un geste physique,
mettre en page un texte, . . .
Omniprésence : industrie, économie, physique, média, . . .
Medium entre l’homme et la machine :
langage de programmation.
Objectifs de l’UE
Concepts fondamentaux
Résolution de problèmes (ingénieurs) : "un problème, une fonction"

Démarche :
Spécification de problèmes informatiques
Approche algorithmique des solutions
Programmation dans le langage Python
Éléments incontournables de la programmation
Calculs simples (calculatrice à variables) – Cours 1

Fonction et alternatives – Cours 2
Les boucles – Cours 3, 4 et 5
Manipulation de structures de données :
Structures linéaires simples : listes, n-uplets – Cours 6 et 7
Principe de "compréhension" sur les listes – Cours 8
Structures plus complexes : dictionnaires, ensembles – Cours 9 et 10
Langage support du cours
Langage de programmation utilisé dans le cours

Langage support : Python 3
Environnement de programmation : MrPython :
Sous linux / macOS :
git clone https://github.com/nohtyprm/MrPython.git
cd MrPython
python3 mrpython/Application.py
Sous windows 10 :
installateur disponible
Explications sur l’installation sur votre machine sur le site de l’UE !
Attention : ce cours n’est pas un cours DE Python mais un cours EN Python !
Python vs. ce cours
Wikipedia
Python est un langage de programmation objet, multi-paradigme et multi-plateformes. Il favorise la programmation impérative structurée et orientée objet. Il
est doté d’un typage dynamique fort, d’une gestion automatique de la mémoire par ramasse-miettes et d’un système de gestion d’exceptions ; il est ainsi
similaire à Perl, Ruby, Scheme, Smalltalk et Tcl.
Le langage Python est placé sous une licence libre proche de la licence BSD2 et fonctionne sur la plupart des plates-formes informatiques, des supercalculateurs
aux ordinateurs centraux, de Windows à Unix en passant par GNU/Linux, Mac OS, ou encore Android, iOS, et aussi avec Java ou encore .NET. Il est conçu
pour optimiser la productivité des programmeurs en offrant des outils de haut niveau et une syntaxe simple à utiliser.
Il est également apprécié par les pédagogues qui y trouvent un langage où la syntaxe, clairement séparée par des mécanismes de bas niveau, permet une
initiation aisée aux concepts de base de la programmation.
Écrire du “vrai” Python 3.

Sans utiliser toutes les fonctionnalités de Python.
Objectif principal :
Comprendre des éléments de programmation généraux.
Objectifs secondaires :
Connaître des bases d’un langage en particulier.
Etudier un axe de la programmation : la sûreté.
Exemple de problème
Quels sont tous les nombres premiers inférieurs à 30 ?
Quels sont tous les nombres premiers inférieurs à 30 ?

def liste_premiers(n : int) -> list[int]:
"""Precondition : n >= 0
Retourne la liste des nombres premiers inferieurs a n."""

i_est_premier : bool = False # indicateur de primalite
L : list[int] = [] # liste des nombres premiers en resultat
i : int # (entier courant)

for i in range(2, n):
i_est_premier = True
j : int # (candidat diviseur)
for j in range(2, i - 1):
if i % j == 0:
# i divisible par j, donc i n’est pas premier
i_est_premier = False
if i_est_premier:
L.append(i)
return L
Ce programme permet de définir la fonction liste_premiers, qui peut ensuite être invoquée pour répondre
au problème :
>>> liste_premiers(30)
[2,3,5,7,11,13,17,19,23,29]
Définition : def liste_premiers(n : int) -> list[int]

Variables : i_est_premier, L
Expressions : 2, i - 1, i % j == 0, ...
Instructions : if i_est_premier: ..., for i in range(1,n): ..., i_est_premier = False, ...
Ce programme permet de définir la fonction liste_premiers, qui peut ensuite être invoquée pour répondre
au problème :
>>> liste_premiers(30)
[2,3,5,7,11,13,17,19,23,29]
Définition : def liste_premiers(n : int) -> list[int]
Expressions : 2, i - 1, i % j == 0, ...
Dans ce cours, on s’intéresse aux expressions et définitions de fonctions (simples), ainsi qu’à leur processus
d’évaluation.
Plan du cours
2 Introduction
Objectifs de l’UE
Un premier exemple
3 Les expressions
Expressions simples
Opérateurs
Implémentation
Jeu de tests
5 Conclusion
Notion d’expressions
En mathématique comme en informatique, une expression est un texte formel exprimant le calcul d’une valeur.
Deux éléments :
Syntaxe ou comment écrire l’expression : règles de grammaire / contrainte du langage
Sémantique ou que signifie l’expression : règles sémantiques ou d’évaluation
Pour obtenir la valeur, il faut évaluer l’expression.
Deux types d’expressions :

Simples : expressions atomiques, la forme la plus simple
Composées : expressions composées de sous-expressions, simples ou composées
Expressions simples
Un premier exemple :
>>> 42
42
On a donné l’expression 42, l’interprète Python nous a renvoyé la valeur 42.
Expressions simples
>>> 42
42

Évaluation plus complexe qu’il n’y paraît :
1 Lecture de l’expression
2 Représentation en mémoire de l’expression (codage)
3 Évaluation de l’objet représenté en machine
4 Affichage de la valeur à l’écran
Expressions simples
>>> 42
42

Évaluation plus complexe qu’il n’y paraît :
1 Lecture de l’expression
2 Représentation en mémoire de l’expression (codage)
3 Évaluation de l’objet représenté en machine
4 Affichage de la valeur à l’écran
Chaque expression possède un type :
>>> type(42)
<class ’int’>
La représentation interne d’un type est une classe d’objets
Expressions simples
booléens : True, False

type : bool
>>> True
True
>>> False
False
>>> type(True)
<class ’bool’>
Type des expressions logiques, indispensable pour calculer (alternatives, boucles)
entiers : 0, 1, 5, -3,...
type : int
>>> 1
1
>>> -3
-3
>>> 23239287329837298382739284739847394837439487398479283729382392283
23239287329837298382739284739847394837439487398479283729382392283
>>> type(3)
<class ’int’>
Notation mathématique usuelle, taille arbitraire
Expressions simples
réels : 1.2, - 4.6, 1.3e2

type : float
Sous-ensemble des réels : les constantes à virgule flottante
>>> 1.12
1.12
>>> 1.3e2
130.0
>>> type(1.3e2)
<class ’float’>
chaînes : "bonjour", ’demain’, ...

type : str
>>> ’ma␣chaine’
’ma␣chaine’
>>> "ma␣chaine"
’ma␣chaine’
>>> "aujourd’hui"
"aujourd’hui"
>>> type("demain")
<class ’str’>
À retenir
Principe d’évaluation des expressions simples

Une expression simple s’évalue en elle-même
Ensemble des types (pour le moment)
bool
float
int (sous-type de float)
str
Composées à partir de :
Expressions simples
Opérateurs
Applications de fonctions prédéfinies ou définies par le programmeur
Exemples :
>>> 2 + 3
5
>>> 2 * 2.5 + 1
6.0
>>> max(2,3) * 4
12
>>> type(2 + 3)
<class ’int’>
Composées à partir de :
Expressions simples
Opérateurs
Applications de fonctions prédéfinies ou définies par le programmeur
Exemples :
>>> 2 + 3
5
>>> 2 * 2.5 + 1
6.0
>>> max(2,3) * 4
12
>>> type(2 + 3)
<class ’int’>
On se concentre sur les expressions arithmétiques pour le moment
Opérateurs arithmétiques
Opérateurs sur les nombres :

+, -, * : opérateurs usuels
/ : la division flottante
// : la division euclidienne
% : le modulo (i.e. le reste dans la division euclidienne)
( ) : le parenthésage
Exemples :
>>> 2 + 3
5
>>> -2 + 3
1
>>> 2 + 3 * 4
14
>>> (2 + 3) * 4
20
>>> 2.5 * 2.5
6.25
Opérateurs arithmétiques
Division euclidienne :
3 est le quotient de la division euclidienne de 7 par 2.
1 est le reste de la division euclidienne de 7 par 2.
Ce que l’on vérifie avec : 7 = 3 ∗ 2 + 1
>>> 7 // 2
3
>>> 7 % 2
1
Conversion automatique entre entiers et flottants.

>>> 2 * 5
10
>>> 2 * 5.0
10.0
>>> 10 // 2
5
>>> 10 / 2
5.0
Priorité des opérateurs
Règles habituelles de priorités
priorité de *, / , // et % sur + et - (moins binaire)

le moins unaire - est prioritaire sur les autres opérateurs
les sous-expressions parenthésées sont prioritaires
Exemples :
2 + 3 * 9
==> 2 + 27
==> 29
(2 + 3) * 9
==> 5 * 9
==> 45
>>> 4 + 7 * 3 - 9 * 2
>>> 4 + 3 // 2
>>> 4 + (7 * - 3 - 9) * 2
>>> 4 + 6 / 3
Priorité des opérateurs
Règles habituelles de priorités
priorité de *, / , // et % sur + et - (moins binaire)

le moins unaire - est prioritaire sur les autres opérateurs
les sous-expressions parenthésées sont prioritaires
Exemples :
2 + 3 * 9
==> 2 + 27
==> 29
(2 + 3) * 9
==> 5 * 9
==> 45
>>> 4 + 7 * 3 - 9 * 2
7
>>> 4 + 3 // 2
5
>>> 4 + (7 * - 3 - 9) * 2
-56
>>> 4 + 6 / 3
6.0
Fonctions prédéfinies
En plus des opérateurs, un certain nombre de fonctions sont pré-définies en python. On parle alors de
primitives.
Par exemple :
Fonctions natives : max, min, abs, ...
Fonctions du module math : sqrt, cos, sin, ...
Pour utiliser une fonction, il faut connaître sa spécification.
Par exemple :
def abs(x : float) -> float:
"""retourne la valeur absolue de x"""
Contient 2 informations :
1 def abs(x : float) -> float: : la fonction se nomme abs et prend un paramètre (x) qui est un réel
et retourne un réel
2 """retourne la valeur absolue de x""" : la fonction calcule la valeur absolue
Autre exemple :
def max(a : float, b : float, ...) -> float:
"""retourne la plus grande valeur parmi les parametres"""
1 def max(a : float, b : float, ...) -> float: : la fonction se nomme max et prend un réel
quelconque de paramètres (au moins 2) qui sont des réels et retourne un réel
2 """retourne la plus grande valeur parmi les parametres""" : la fonction calcule la plus grande
des valeurs
Un dernier exemple. Une fonction du module math.

def sqrt(x : float) -> float:
"""Precondition : x >= 0
retourne la racine carree de x"""
1 def sqrt(x): : la fonction se nomme sqrt et prend un paramètre (x) qui est un réel et la valeur de
retour est un réel
2 """Precondition : x >= 0 : la valeur du paramètre x doit être positive ou nulle
√
3 """retourne la racine carree de x""" : calcule x.
Un dernier exemple. Une fonction du module math.

def sqrt(x : float) -> float:
"""Precondition : x >= 0
retourne la racine carree de x"""
1 def sqrt(x): : la fonction se nomme sqrt et prend un paramètre (x) qui est un réel et la valeur de
retour est un réel
2 """Precondition : x >= 0 : la valeur du paramètre x doit être positive ou nulle
√
3 """retourne la racine carree de x""" : calcule x.
Remarque : pour utiliser une fonction d’un module, il faut déclarer le module :
>>> import math
>>> math.sqrt(4)
2.0
Plus généralement :
La spécification d’une fonction contient
sa signature : précise son nom et le nom de ses paramètres avec leurs types et le type de la valeur de retour
ses éventuelles préconditions : précise les domaines de validité des paramètres
sa description : décrit le problème résolu par la fonction
À partir d’une définition

def fun(param1 : type1, param2 : type2, ..., paramn : typen)
on peut appliquer
fun(expr1, expr2, ..., exprn)
>>> abs(3)
3
>>> abs(-3)
3
>>> abs(-3.5)
3.5
>>> max(1,3)
3
>>> max(-1, -5)
-1
>>> max(1, 2, 4.5)
4.5
>>> max(1, 2, 4.5, 6)
6
Évaluation des fonctions
Principe d’évaluation des fonctions

Soit une application de fonction fun(expr1, expr2, ..., exprn).
1 on évalue d’abord les expressions expr1, expr2, ..., exprn
2 on remplace l’appel de la fonction par la valeur calculée par la fonction

Exemple :
max(2+3, 4*12)
==> max(5,4*12)
==> max(5,48)
==> 48

Exemple :
max(2+3, 4*12)
==> max(5,4*12)
==> max(5,48)
==> 48
Attention : l’appel de fonction est prioritaire sur les opérateurs

max(2+3, 4*12) * 2
==> max(5,48) * 2
==> 48 * 2
==> 96
Évaluation des expressions
Principe d’évaluation des expressions

Deux cas sont possibles lors de l’évaluation d’une expression e :
1 soit e est une expression simple → la valeur est immédiate
2 soit e est une expression composée. Alors

i) on détermine la sous-expression e1 à évaluer en 1er :
si e1 est unique on lui applique le principe d’évaluation (cf. point 1)
sinon, on évalue de gauche à droite
ii) on réitère le processus d’évaluation jusqu’à sa terminaison
Évaluation des expressions
Principe d’évaluation des expressions

Deux cas sont possibles lors de l’évaluation d’une expression e :
1 soit e est une expression simple → la valeur est immédiate
2 soit e est une expression composée. Alors

i) on détermine la sous-expression e1 à évaluer en 1er :
si e1 est unique on lui applique le principe d’évaluation (cf. point 1)
sinon, on évalue de gauche à droite
ii) on réitère le processus d’évaluation jusqu’à sa terminaison
Exemple :
(3 + 5) * (max(2, 6) - 5) - 9
==> 8 * ( max(2, 6) - 5 ) - 9 [parenthésage - gauche]
==> 8 * ( 6 - 5 ) - 9 [appel de la fonction max]
==> 8 * 1 - 9 [soustraction entre parenthèses]
==> 8 - 9 [multiplication prioritaire]
==> -1 [soustraction]
Plan du cours
2 Introduction
Objectifs de l’UE
Un premier exemple
3 Les expressions
Expressions simples
Opérateurs
Implémentation
Jeu de tests
5 Conclusion
Motivation
Question : Quel est le périmètre d’un rectangle de largeur 2 unités et longueur 5 unités ?
Réponse : 14. Il suffit d’évaluer l’expression arithmétique 2 + 2 + 5 + 5
Pas satisfaisant car on voudrait :
Motivation

Résoudre un problème plus général (abstraction du problème)
Éviter de faire appel plusieurs fois à une expression complexe (factorisation du code)
Motivation

Résoudre un problème plus général (abstraction du problème)
Éviter de faire appel plusieurs fois à une expression complexe (factorisation du code)
→ On aimerait en fait une fonction perimetre qui, étant donné la largeur et la longueur d’un rectangle,
calcule son périmètre.
Définition de fonction
Avec seulement des primitives : calculatrice améliorée

Programmation : définition de fonctions par le programmeur
Les fonctions ont une place centrale en informatique
Elles permettent de paramétrer, d’automatiser et de généraliser des calculs
Étapes de réflexion
Pour définir une fonction, il faut
1 Établir la spécification de la fonction

2 Inventer les opérations à effectuer pour répondre au problème
3 Traduire la solution dans le langage choisi
4 Tester la correction de la fonction
Périmètre : spécification
1 La spécification : fonction qui prend deux réels et renvoie un réel
def perimetre(largeur : float, longueur : float) -> float:

"""Precondition : (largeur >= 0) and (longueur >=0)
Precondition : largeur <= longueur
retourne le perimetre du rectangle defini par sa largeur et sa longueur"""
Périmètre : spécification
1 La spécification : fonction qui prend deux réels et renvoie un réel

Remarques sur la spécification
c’est le mot-clef def qui permet de commencer la définition et la spécification de la fonction

on définit une fonction pour les utilisateurs et autres programmeurs
→ la spécification sert de référence
la spécification comprend la signature (commençant par le mot clé def) ainsi que les préconditions et la
description (encadrées par 3 guillemets """)
l’indentation est obligatoire : 4 espaces ou 1 tabulation
les hypothèses sont des expressions booléennes
les hypothèses restreignent le domaine de valeurs possibles
Périmètre : implémentation
2 Inventer : il suffit d’additionner largeur et longueur deux fois

3 Traduire : ce qui correspond à l’expression 2 * (largeur + longueur)

return 2 * (largeur + longueur)
Périmètre : implémentation
2 Inventer : il suffit d’additionner largeur et longueur deux fois

3 Traduire : ce qui correspond à l’expression 2 * (largeur + longueur)

return 2 * (largeur + longueur)
Remarques sur l’implémentation
l’indentation est obligatoire : 4 espaces ou 1 tabulation

c’est l’instruction return expr qui permet de clore la définition :
i) Évaluation de l’expression expr
ii) Retour de la fonction à l’appelant avec la valeur de retour
Plusieurs implémentations possibles pour une spécification :
return (largeur + longueur) + (largeur + longueur)
Périmètre : jeu de tests
4 Tester : grâce à l’instruction assert
assert perimetre(2,5) == 14
Périmètre : jeu de tests
4 Tester : grâce à l’instruction assert
Remarques sur les jeux de tests
Ils servent au programmeur pour valider la définition

Ils doivent couvrir tous les cas possibles
les cas de base
les cas extrêmes
Ils n’affichent rien, sauf si un test ne passe pas
assert perimetre(2, 3) == 12
Erreur: ligne 13
==> Erreur d’assertion (test invalide ?)
Conclusion
Ce qu’il faut savoir faire à l’issue de ce cours :

Appliquer les principes d’évaluation pour les expressions arithmétiques
Définir des fonctions simples consistant à paramétrer des expressions arithmétiques, avec :
une spécification précise du problème résolu (signature, préconditions et description)
une implémentation du corps de la fonction
un jeu de tests complet permettant la validation de la fonction
Informations importantes (rappel)
Site de l’UE
https://moodle-sciences-22.sorbonne-universite.fr
Versions papiers
Tous les documents papiers sont distribués par l’Association Ludique et InformAtique de
Sorbonne Université (ALIAS) 14-15 506
Créneaux réservés pour vous :
mardi 20 septembre 2022 de 18h à 19h pour PEIP + CMI + IL + SA
mercredi 21 septembre 2022 de 12h45 à 13h45 pour SHI
À récupérer :
Cahier d’exercices TD-TME en 2 saisons : semaines 1 à 5
Carte de référence : seul document autorisé aux examens
Points abordés dans le semestre

Cours 2 : Séquences, variables et alternatives
Cours 3 : Répétitions et boucles while
Cours 4 : Correction, terminaison et efficacité
Cours 5 : Intervalle, itération et chaînes de caractères
Cours 6 : Listes
Cours 7 : N-uplets, listes avancées et fonctionnelles
Cours 8 : Compréhensions de listes
Cours 9 : Ensembles et dictionnaires
Cours 10 : Compréhensions d’ensembles et de dictionnaires
Cours 11 : Cours d’ouverture ou révisions

Cours 01

Transféré par

Informations du documentcliquez pour développer les informations du document

Informations du documentcliquez pour développer les informations du document

Droits d'auteur :

Formats disponibles

Cours 01

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours 01

Transféré par

Droits d'auteur :

Formats disponibles

Éléments de programmation 1

Cours 1 : Expressions arithmétiques et fonctions

Jean-Noël Vittaut, Maître de conférences en informatique au LIP6

Site de l’UE : https://moodle-sciences-22.sorbonne-universite.fr

Pour les Cours : aucun prérequis en programmation

1h45 de Cours en amphithéâtre

IDE fait-maison : MrPython.

Validation si la note de l’UE ⩾ 50.

Science du traitement automatisé de l’information

L’informatique regroupe un grand nombre de domaines : langage et programmation, architecture et système,

Résolution de problèmes (ingénieurs) : "un problème, une fonction"

Éléments incontournables de la programmation

Calculs simples (calculatrice à variables) – Cours 1

Langage de programmation utilisé dans le cours

Attention : ce cours n’est pas un cours DE Python mais un cours EN Python !

Écrire du “vrai” Python 3.

Quels sont tous les nombres premiers inférieurs à 30 ?

Quels sont tous les nombres premiers inférieurs à 30 ?

Retourne la liste des nombres premiers inferieurs a n."""

L : list[int] = [] # liste des nombres premiers en resultat

i : int # (entier courant)

Définition : def liste_premiers(n : int) -> list[int]

Définition : def liste_premiers(n : int) -> list[int]

Deux types d’expressions :

On a donné l’expression 42, l’interprète Python nous a renvoyé la valeur 42.

On a donné l’expression 42, l’interprète Python nous a renvoyé la valeur 42.

On a donné l’expression 42, l’interprète Python nous a renvoyé la valeur 42.

La représentation interne d’un type est une classe d’objets

booléens : True, False

réels : 1.2, - 4.6, 1.3e2

chaînes : "bonjour", ’demain’, ...

Principe d’évaluation des expressions simples

Ensemble des types (pour le moment)

On se concentre sur les expressions arithmétiques pour le moment

Opérateurs sur les nombres :

Conversion automatique entre entiers et flottants.

Règles habituelles de priorités

priorité de *, / , // et % sur + et - (moins binaire)

Règles habituelles de priorités

priorité de *, / , // et % sur + et - (moins binaire)

Pour utiliser une fonction, il faut connaître sa spécification.

Un dernier exemple. Une fonction du module math.

retourne la racine carree de x"""

Un dernier exemple. Une fonction du module math.

retourne la racine carree de x"""

À partir d’une définition

Principe d’évaluation des fonctions

Principe d’évaluation des fonctions

Principe d’évaluation des fonctions

Attention : l’appel de fonction est prioritaire sur les opérateurs

Principe d’évaluation des expressions

2 soit e est une expression composée. Alors

Principe d’évaluation des expressions

2 soit e est une expression composée. Alors

Pas satisfaisant car on voudrait :

Pas satisfaisant car on voudrait :

Pas satisfaisant car on voudrait :

Avec seulement des primitives : calculatrice améliorée