Sorbonne Université — UE LU1IN0*1, Éléments de Programmation 1 (+) — Carte de référence — 2022-23

— Grammaire des types — <alternative> : := if <expression> : bool.

Les éléments simples du langage (noms, symboles) <prog> a == b : vérifie que a et b sont égaux
sont en caractères machine, les ensembles d’éléments ou if <expression> : a != b : vérifie que a et b ne sont égaux
simples en caractères sans sérif. Les éléments composés <prog> a >= b : vérifie que a est plus grand ou égal à b
sont entre < et >. L’étoile ⋆ signifie la répétition d’un <alternant> a > b : vérifie que a est strictement plus grand que b
élément et l’étoile ∗ signifie le produit cartésien. <alternant> : := else : a <= b : vérifie que a est inférieur ou égal à b
<type> : :=<type-base> <prog> a < b : vérifie que a est strictement inférieur à b
ou <type-iter> ou elif <expression> :
ou <type-var> <prog> — Opérations sur les nombres —
ou (<type-fonc>) ou elif <expression> :
Les opérateurs suivants travaillent sur des expres-
ou Tuple[<type>⋆ ] <prog>
sions de type float et renvoient une valeur de type
<type-base> : := int ou float <alternant>
float.
ou bool ou None <boucle-while> : := while <expression> : a + b : effectue l’addition de a et de b
<type-iter> : := str ou List[<type>] <prog> a - b : effectue la soustraction de a par b
ou Set[<type>] <boucle-for> : := for variable in <expression> : a * b : effectue la multiplication de a par b
ou Dict[<type>,<type>] <prog> a ** b : effectue l’exponentiation de a par b
<test> : := assert <expression> a / b : effectue la division (réelle) de a par b
<type-var> : := T ou U etc.
<sequence> : := <prog> produit une erreur lorsque b est égal à 0
— Grammaire du langage — <prog>
<prog> : := <definition> — Opérations sur les entiers —
ou <expression> — Commentaires —
ou <affectation> Ligne commençant par un dièse (#) au moins. Les opérateurs suivants travaillent sur des expres-
ou <alternative> — Vocabulaire — sions de type int et renvoient une valeur de type int.
ou <boucle-while> a // b : effectue la division euclidienne de a par b
Mots-clefs réservés : # ( ) ’ + - * / = < > % "
ou <boucle-for> produit une erreur lorsque b est égal à 0
! and or not if elif else while for in assert
ou <test> a % b : rend le reste de la division euclidienne de a par b
import def return
ou <sequence> produit une erreur lorsque b est égal à 0
constante : les booléens True False, les nombres, les
<définition> : := def nom-fonc (<args>)-><type>: chaînes de caractères, None
<prog> variable, nom-fonc : tout ce qui n’est pas constante — Fonctions arithmétiques —
return <expression> ni réservé min(a : float, b : float,...) -> float :
<args> : := variable :<type> — Spécification et signature de fonction — rend le plus petit des arguments
ou variable :<type> , <args> def nom-fonc (<args>)-><type>: max(a : float, b : float,...) -> float :
<expression> : := variable ou constante """ Précondition: texte rend le plus grand des arguments
ou <application> texte descriptif """ abs(x : float) -> float :
ou <op-un> <expression> rend la valeur absolue de x
— Opérations booléennes —
ou <expression> <op-bin> <expression> Les opérateurs suivants travaillent sur des expres-
— Fonctions du module math —
<op-un> : := - not sions de type bool et renvoient une valeur de type bool. sqrt(x : float) -> float :
<op-bin> : := + - * / == != <= >= % // ** not b : rend la négation de b Précondition : x<0√
and or a and b : rend la conjonction de a et b rend la valeur de x
<application> : := nom-fonc(<argument>) a or b : rend la disjonction de a et b cos(x : float) -> float
<argument> : := <expression> — Opérations sur les valeurs — rend le cosinus de x (en radian)
ou <expression> , <argument> Les opérateurs suivants travaillent sur des expres- sin(x : float) -> float
<affectation> : := variable = <expression> sions de type Valeur et renvoient une valeur de type rend le sinus de x (en radian)
 — Fonctions de conversions — — Manipulation des n-uplets — dict() Dict[T, U]
int(x : T) -> int rend le dictionnaire vide
Dans ce qui suit, la variable C est de type Tuple[T1, {k:v,l:w,...} Dict[T, U]
convertit x en un entier
T2, ...], la variable i est de type int et les variables rend le dictionnaire associant
float(x : T) -> float
x, y, ... sont de type T1, T2, ... v à la clé k , w à la clé l , ...
convertit x en un flottant
(x, y, ...) Tuple[T1, T2, ...] D[k] = v None
str(x : T) -> str
rend le n-uplet contenant x , y, ... associe la valeur v à la clé k de D
convertit x en une chaîne de caractères
x, y, ... = C None D[k] U
affecte à x le 1er élément de C, rend la valeur associée à la clé k de D
— Manipulation des chaînes de caractères — à y le second élément de C, ... produit une erreur si la clé k n’existe pas
Dans ce qui suit, les variables s et t sont de type k in D bool
str et les variables i, j et k sont de type int. Les teste si k est une clé de D
expressions suivantes sont toutes de type str. len(D) : int
s + t effectue la concaténation de s avec t — Manipulation des ensembles —
rend le nombre d’associations dans D
s[i] rend le i ème caractère de s Dans ce qui suit, les variables Si sont de type Les itérations sur un dictionnaire peuvent se faire
s[i:j] rend la chaîne composée des caractères de s Set[T], et les variables x et y sont de type T. par clefs : for k in D,
de l’indice i à l’indice j-1 set() : Set[T] ou par associations : for (k,v) in D.items()
s[i:j:k] rend la chaîne composée des caractères de s rend l’ensemble vide — Schémas de compréhension —
de l’indice i à l’indice j-1 par pas de {x, y, ...} Set[T]
k caractères Les schémas de compréhension suivants permettent
rend l’ensemble contenant les valeurs
len(s) : rend le nombre de caractères dans s de créer respectivement des valeurs de type List[T],
x , y , ...
Set[T] et Dict[T,U] :
S.add(x) None
[expr for var in iterable if predicat]
ajoute x à l’ensemble S
— Manipulation des listes — {expr for var in iterable if predicat}
S1 | S2 Set[T]
Dans ce qui suit, les variables L et P sont de type {expr1:expr2 for var in iterable if predicat}
rend l’union de S1 avec S2
List[T], les variables i, j et k sont de type int et les où
S1 & S2 Set[T]
variables x et y sont de type T. rend l’intersection de S1 avec S2 expr et expr1 sont des expressions de type T
[ ] List[T] S1 - S2 Set[T] expr2 est une expression de type U
rend la liste vide rend l’ensemble des éléments de S1 var est une variable
[x, y, ...] List[T] qui ne sont pas dans S2 iterable est une expression de type <type-iter>
rend la liste contenant x , y, ... S1 ^ S2 Set[T]
L.append(x) None predicat est une expression de type bool
rend l’ensemble des éléments qui sont soit
ajoute x à la fin de la liste L dans S1, soit dans S2 mais pas dans les deux — Fonctions diverses —
L + P List[T] S1 <= S2 bool range(n : int, p : int) -> range
effectue la concaténation de L avec P teste si S1 est un sous-ensemble de S2 rend l’intervalle des entiers compris
L[i] T S1 >= S2 bool entre n et p
rend le i ème élément de L teste si S1 est un sur-ensemble de S2 ord(c : str) -> int
produit une erreur si l’indice i x in S bool renvoie l’entier correspondant au code de c
n’est pas valide teste si x est un élément de S chr(i : int) -> str
L[i:j] List[T] len(S) : int renvoie le caractère correspondant au code i
rend la liste des éléments de L de l’indice rend le nombre d’éléments de S help(f) -> None
i à l’indice j-1 affiche la documentation de la fonction f
L[i:j:k] List[T] — Manipulation des dictionnaires — type(x) -> <type>
rend la liste des éléments de L de l’indice rend le type de x
i à l’indice j-1 par pas de k éléments Dans ce qui suit, la variable D est de type Dict[T, print(x) -> None
len(L) : int U], la variable k est de type T et la variable v est de *** Procédure ***
rend le nombre d’éléments de L type U. affiche la représentation de la valeur x