Série Optimall Python vs.

R pour Data Scientists (Français)

Vol. 001, Num. 002

Python vs. R pour Data Scientists : Structures algorithmiques

Gradi L. Kamingu∗
23 juin 2023

Résumé
Ce papier traite des structures algorithmiques présentes dans les langages Python et
R, en mettant l’accent sur les structures de données simples telles que les variables et les
constantes. Il explore également les opérations couramment utilisées avec ces structures
et les différentes structures de contrôle disponibles dans ces langages de programmation.
L’objectif est de présenter de manière claire les correspondances entre les éléments de
Python et R, facilitant ainsi la compréhension et la transition entre les deux langages.
Mots clés : Langage Python, Langage R, Structure de données, Structure de contrôle.

∗
Chercheur au Laboratoire d’Optimisation et Apprentissage Automatique, RD Congo.
E-mail : [Link]@[Link].
1 Introduction
Une structure algorithmique est une manière d’organiser les éléments d’un algorithme (et par
extension d’un programme) de manière à faciliter la programmation. Ces structures affectent soit
les données (structures de données), soit la disposition des instructions (structures de contrôle). Les
structures de données et les structures de contrôle font donc partie des grandes classes de structures
algorithmiques (Wirth (1987)).

Les structures de contrôle sont des éléments essentiels dans la programmation impérative et sont
présentes dans tous les langages de programmation impératifs, y compris Python et R. Elles jouent
un rôle crucial en permettant de prendre des décisions, de répéter des actions et de gérer les erreurs
dans un programme. Tant Python que R offrent une gamme de structures de contrôle qui facilitent
la logique et le contrôle du flux d’exécution des instructions. En ce qui concerne les structures de
données, il en existe différentes, allant des plus simples aux plus complexes. Dans cet article, nous
nous concentrerons principalement sur les structures de données simples. Les autres structures seront
explorées plus en détail dans des publications ultérieures. Cependant, les lecteurs intéressés peuvent
se référer aux ouvrages de Goodrich et al. (2013), Venables, W. N. et al. (2023) et celui de Prakash,
Dr. PKS and Rao, Achyutuni Sri Krishna (2016) qui abordent, entre autres, les sujets des structures
de données dans les langages Python et R.

Le reste de papier se structure de la manière suivante. Nous commençons par présenter dans la
section 2 les structures algorithmiques de manière générale, ensuite nous procédons à la présentation
des structures algorithmiques du langage Python dans la section 3, puis présentons les structures
algorithmiques du langage R dans la section 4. Enfin, nous discutons des éléments de comparaison de
ces deux langages dans la section 5 avant de conclure.

2 Préliminaires sur les structures algorithmiques

2.1 Structures de données
2.1.1 Notions de variable et de constante
L’ensemble des objets nécessaires à la résolution d’un problème constitue l’environnement de ce
problème. Considérons que nous voulons calculer la moyenne arithmétique de deux nombres x1 et x2 .
Pour cela, nous proposons la séquence d’actions suivante :

1. Donner le premier nombre x1 ;

2. Donner le second nombre x2 ;
3. Calculer la somme s = x1 + x2 ;
4. Calculer la moyenne arithmétique v̄ = 2s .

Notre environnement est composé de sept données. Les nombres x1 , x2 , s et v̄. Les données x1 , x2 ,
s et v̄ peuvent prendre n’importe quelle valeur ; et ils peuvent même changer de valeur pendant que le
programme est en cours d’exécution. Ce sont des variables. D’ailleurs, si par exemple cinq personnes
se présentent, chacune peut introduire les nombres qu’elle souhaite, ce qui modifiera également les
nombres calculés s et v̄. Par contre, une donnée qui ne peut pas changer de valeur est une constante.
Dans notre cas, 2 est une constante.

Une variable aura au moins principalement les caractéristiques suivantes :

23
 • son nom ou identificateur (invariable), c’est-à-dire une séquence de caractères (lettres, chiffres
ou encore caractères spéciaux) servant à le concevoir. Un identifiant doit commencer par une
lettre ;
• sa valeur (variable) ;
• son type (peut être (in)variable), qui décrit l’utilisation possible de la variable.

D’après ce qui précède, une variable est comme une cellule (boîte ou case) mémoire qui peut conte-
nir une valeur. Pour pouvoir utiliser une cellule mémoire (une variable), il faut indiquer au processeur
son identifiant et son type à l’aide d’une déclaration. Dans nos pseudo-code 1 , les variables seront
déclarées à l’aide du mot-clé Var, suivi de la liste de noms séparés par des virgules, puis du type des
variables de la liste. Nous conviendrons qu’au moment de la déclaration d’une variable, sa valeur est
indeterminée.

Comme dit plus haut, 2 est une constante. De l’espace mémoire peut également être réservé pour
cette constante, avec le mot-clé Const, suivi du nom de la constante.

Remarque 2.1. Comme les constantes nommées, dans les langages de programmation de certains pa-
radigmes, comme dans les langages de programmation fonctionnels et logiques, les soi-disant variables
conservent une seule variable tout au long de leur vie en raison d’exigences référentielles. De plus, les
variables sont liées à des expressions.

2.1.2 Type des données

Définition 2.1. Un type de données, ou simplement un type, est le domaine de valeur des données en
question.

On distingue les types élémentaires dits types simples ou types primitifs ou encore types de base,
et les types de composés.
1. Les types de données primitifs, qui sont des types de données à partir desquels tous les autres
types de données sont construits. Les types de données primitifs sont généralement atomiques et
ne peuvent pas être décomposés en éléments plus petits. Ils occupent généralement une quantité
fixe de mémoire et peuvent être directement manipulés par des opérations arithmétiques et
logiques (Cormen et al. (2022)).
2. Les types de données composés, qui sont des types de données résultant de l’association de
plusieurs types élémentaires. Les types de données composés courants incluent les listes, les en-
sembles et les dictionnaires. Les éléments d’une collection peuvent être de différents types et ils
peuvent être ajoutés, supprimés ou modifiés dynamiquement (Sedgewick and Wayne (2011)).

La principale différence entre les types de données primitifs et les types de données composites
réside dans leur capacité à stocker et à représenter des informations. Les types de données primitifs
sont utilisés pour représenter des données individuelles et simples, tandis que les types de données
composites permettent de représenter des ensembles de données plus complexes et structurées.

2.1.3 Types élémentaires

A. Types numériques
Le type numérique est formé de l’ensemble des nombres que le processeur peut manipuler. On
distingue :
1. Un pseudo-code est un « pseudo » langage indépendant de tous les langages de programmation, qui puisse
être clair et facilement transcriptible dans n’importe quel langage.

24
 • Le type entier (integer), associé aux nombres entiers relatifs, c’est-à-dire aux nombres apparté-
nant à l’ensemble Z.
Exemple 2.1. −2, 4, 952000 et 623 sont des entiers.
• Le type réel (real), associé aux nombres réels (nombres ayant une partie entière et une partie
décimale (ou partie fractionnaire)), c’est-à-dire aux nombres apparténant à l’ensemble R.
Exemple 2.2. −2.25, 4.0, 95.2000 et 0.623 sont des réels.

Dans certains langages de programmation, le type de données «real» est parfois appelé «float»
(nombres à virgule flottante). Cette appellation est justifiée par le fait que les réels sont stockés
sous forme de nombre à virgule flottante, ce qui implique qu’ils sont représentés à l’aide d’une
mantisse et d’un exposant. Cependant, certains langages de programmation réservent le terme
float 2 pour désigner les nombres réels à simple précision, c’est-à-dire ceux qui utilisent 32 bits
pour le stockage. Ces langages font alors une distinction entre float et double, où ce dernier fait
référence aux nombres réels à virgule flottante double précision utilisant généralement 64 bits
pour le stockage.

Selon la richesse d’un langage de programmation, on peut distinguer le type complexe, qui est
associé aux nombres complexes, c’est-à-dire aux nombres appartenant à l’ensemble C.
Cependant, les langages de programmation comme R et Fortran fournissent le type complexe comme
type de base, tandis que d’autres langages de programmation comme Python ou C++ nécessitent des
modules supplémentaires pour les inclure.

B. Types alphanumériques
Le type alphanumérique est constitué de l’ensemble des séquences de caractères que le processeur
peut gérer. Ce caractère peut être une lettre (majuscule ou minuscule), un chiffre, un signe de ponc-
tuation, mais aussi un espace, une tabulation, une nouvelle ligne et quelques autres caractères non
imprimables. La valeur d’un alphanumérique est toujours mis entre « » et dans d’autres langages de
programmation entre ‘ ’. On distingue :
• Le type caractère (character), qui est formé d’un seul caractère.
Exemple 2.3. «d», «5», «K» et « » sont des caractères.
• Le type chaîne de caractères (string), qui est formé par une juxtaposition des caractères.
Exemple 2.4. «Maëlys», «007», «Tome 1» et «vibration» sont des chaînes de caractères.

C. Type booléen
Le type booléen est un type de variable à deux états, généralement noté vrai (true) et faux (false).
Ces valeurs sont également représentées respectivement par 1 et 0 selon les langages de programmation.

2.1.4 Types composés

Comme nous l’avons dit plus haut, ce sont des types résultant de l’association de plusieurs types
élémentaires. Notons également que les types composites peuvent résulter de plusieurs types compo-
sites. L’action de construire un type composé est connu sous le nom de composition. Selon la richesse
d’un langage de programmation, on peut construire de nombreux types particuliers tels que le type
liste, le type enuméré, le type ensemble, le type tuple, le type dictionnaire, le type pile, le type queue,
etc.
2. Dans des langages comme BASIC ou Visual Basic, on parle de «single».

25
2.1.5 Opérateurs et opérandes
Un opérateur est souvent un symbole qui joue le rôle d’une fonction dont l’identifiant est généra-
lement écrit avec des caractères non autorisés pour l’identifiant des fonctions ordinaires. Cependant,
un opérateur permet d’agir sur une variable ou d’effectuer des calculs. Un opérande est une donnée
utilisée par un opérateur. La combinaison de ses lexèmes (opérandes, opérateurs, etc.) est appelée
expression.

Exemple 2.5. Dans l’expression 10+4, l’opérateur est + et les opérandes sont les constantes 10 et 4
sont des opérandes.

Chaque expression a une valeur associée (Goulet (2016)). Les symboles des données fondamentales
représentent ces données, conformément à nos attentes. Il est possible de combiner plusieurs expres-
sions pour en former une expression composée. L’évaluation de cette expression se fait généralement
de gauche à droite, à moins que l’ordre d’évaluation ne soit modifié par des parenthèses, à l’instar des
règles mathématiques.

Il existe plusieurs types d’opérateurs :

1. Les opérateurs arithmétiques qui permettent d’effectuer des opérations arithmétiques entre opé-
randes numériques :
• L’addition : + ;
• La soustraction : − ;
• La multiplication : × ou ∗ ;
• L’exponentiation : ˆ ;
• La division (réelle) : / ;
• La division entière : // ;
• Le modulo : % ;

Exemple 2.6. a // b donne la partie entière du quotient de la division entière de a par b,

tandis que a % b donne le reste de la division entière de a par b.

Voici la règle de priorité des opérateurs arithmétiques couramment utilisée, par ordre décroissant
de priorité :
(a) Les parenthèses : les opérations entre parenthèses sont effectuées en premier. Les paren-
thèses peuvent également être imbriquées pour indiquer des niveaux de priorité supplé-
mentaires ;
(b) La puissance ;
(c) La multiplication, la division et le modulo, qui sont évaluées de gauche à droite dans l’ordre
dans lequel elles apparaissent dans l’expression.
(d) L’addition et la soustraction, qui sont également évaluées de gauche à droite dans l’ordre
dans lequel elles apparaissent dans l’expression.
L’utilisation de parenthèses vous permet de modifier l’ordre d’évaluation et de donner une prio-
rité spécifique à certaines parties d’une expression. Tout ce qui se trouve entre parenthèses est
évalué en premier, puis les autres opérations suivent la règle de priorité mentionnée ci-dessus.

2. Les opérateurs logiques, qui sont :

• La négation ou le NON logique, qui renvoie l’inverse de la valeur booléenne. Si l’expression
est vrai, alors not renvoie faux, et vice versa.

26
 • La conjonction ou le ET logique, qui renvoie vrai si toutes les expressions booléennes sont
vraies, sinon il renvoie faux.
• La disjonction (inclusive) ou le OU logique, qui renvoie vrai si au moins l’une des expres-
sions booléennes est vraie, sinon il renvoie faux.
• La disjonction exlusive ou le XOU logique, renvoie vrai si exactement l’une des expressions
est vraie, et faux dans tous les autres cas.
Voici la règle de priorité des opérateurs logiques, par ordre décroissant de priorité :
(a) La négation, qui la priorité la plus élevée. Il est généralement évalué avant d’autres opéra-
tions logiques ;
(b) La conjonction ;
(c) La disjonction (inclusive) ;
(d) La disjonction exclusive.
L’utilisation de parenthèses peut également modifier l’ordre d’évaluation des opérations logiques
et donner une priorité spécifique à certaines parties d’une expression logique. Tout ce qui se
trouve entre parenthèses est évalué en premier, puis les autres opérations logiques suivent la
règle de priorité mentionnée ci-dessus.

3. Les opérateurs de comparaison, appelés aussi opérateurs relationnels qui permettent de comparer
deux opérandes et produisent une valeur booléenne. Les opérateurs de comparaisons sont :
• L’égalité : est égal(e) à : = ;
• Les inégalités :
• est inférieur(e) à : < ;
• est supérieur(e) à : > ;
• est inférieur(e) ou égal(e) à : ≤ ;
• est supérieur(e) ou égal(e) à : ≥ ;
• est différent(e) de : ̸=.

2.1.6 Actions élémentaires

Définition 2.2. Une action élémentaire est un événement de durée finie qui modifie l’environnement
de travail.

L’exécution d’une action fait passer l’environnement d’un état initial particulier à un nouvel état
bien défini. Une action sera primitive ou élémentaire pour un processeur donné si son instruction est
suffisante pour que le processeur puisse l’exécuter sans information supplémentaire. En bref, les actions
élémentaires sont des opérations simples, directement utilisables.

A. Lecture
Définition 2.3. La lecture est une action élémentaire qui consiste à attribuer une valeur à une variable
saisie au clavier.

Pour effectuer une action, le processeur fait une pause et observe le clavier. Chaque touche tapée
au clavier communique une partie des informations attendues au processeur. Pour indiquer la fin de
l’information, l’utilisateur doit valide sa commande. Avant cette validation, l’utilisateur a la possibilité
de modifier les informations saisies.

Le format de l’action de lecture est :

27
 Lire x
où x est l’identificateur de la donnée auquel on doit attribuer une valeur tapée au clavier.

B. Ecriture
Définition 2.4. L’écriture est une action élémentaire qui consiste à faire apparaître une information
à l’écran.
Le format de l’action d’écriture est :

Ecrire (ou Afficher) inf o

où inf o est l’information à faire apparaître à l’écran.
Exemple 2.7 (Hello, World !). Soit l’algorithme suivant 3 , qui permet d’afficher le message «Bonjour,
le monde !» :
Début
Afficher «Bonjour, le monde !»
Fin.

Avant de lire une variable, il est fortement recommandé d’écrire des étiquettes à l’écran, afin
d’avertir l’utilisateur de ce qu’il doit saisir (Darmangeat (2008)).
Exemple 2.8. Soit le programme suivant qui demande à l’utilisateur son nom s’affiche à l’écran :
Var nom en chaîne de caractères
Début
Afficher «C’est quoi votre nom ?»
Lire nom
Afficher «Votre nom de famille est : », nom
Fin.

C. Affectation
Définition 2.5. L’affectation, également appelée assignation par l’anglicisme, est une action élémentaire
qui consiste à attribuer une valeur à une variable.
Dans cette action, on établit un lien entre le nom de la variable et sa valeur (son contenu) (Swinnen
(2012)). Contrairement à l’action de lecture qui permet d’affecter une valeur à un objet en externe,
c’est-à-dire en tapant la valeur au clavier, l’affectation permet de le faire en interne.

Le format de l’action d’affectation est

x←v
où x est l’indentificateur de la donnée auquel on doit attribuer une valeur ; v est la valeur à affecter
et peut être soit une constante, soit l’identifiant d’une autre donnée qui contient une valeur qui sera
affectée à x, soit une expression du même type que x dont la valeur sera être affecté à x.
3. Il s’agit d’un programme de test. Ce morceau de code a été influencé par un exemple de programme dans
le livre de 1978, The C Programming Language (Ritchie and Kernighan (1978)) par l’informaticien canado-
américain Brian Kernighan et l’informaticien américain Denis Ritchie. Cependant, il n’y a aucune preuve qu’il
trouve son origine dans ce livre, et il est très probable qu’il ait été utilisé auparavant dans BCPL (comme
ci-dessous). Pourtant, dans une interview accordée à l’édition indienne du magazine Forbes, Brian Kernighan
explique que cette phrase provient d’un dessin animé qu’il avait vu, où un poussin sortait de son œuf en disant
«Hello, World !». Cependant, ce programme est resté populaire dans l’apprentissage de la programmation.
Notamment pour l’initiation à un nouveau langage de programmation.

28
Exemple 2.9. Soit l’algorithme suivant :

Var x, y, z en entier
Début
x←2
y←4
z←x
x←x+4∗y
Fin.

Ici, il s’agit d’affecter la valeur 2 à la variable x, la valeur 4 à la variable y, la valeur de la variable

de l’identifiant x à la variable z et la valeur x + 4 × y dans la variable x.

Exemple 2.10. Reprenons l’illustration du point 2.1.1, avec le calcul de la moyenne arithmétique de
deux nombres. Nous avons l’algorithme suivant :

Var x1 , x2 , s, v̄ en réel
Début
Afficher «Donner le premier nombre»
Lire x1
Afficher «Donner le deuxième nombre»
Lire x2
s ← x1 + x2
v̄ ← s/2
Afficher «La moyenne arithmétique de ces deux nombres : », v̄
Fin.

L’action d’affecter une valeur initiale à une variable est appelée initialisation de variable. Cepen-
dant, plusieurs langages de programmation offrent la possibilité de déclarer et d’initialiser la variable
en même temps.

2.2 Structures de contrôle

Définition 2.6. Une structure de contrôle est une instruction particulière d’un algorithme (ou d’un
programme) permettant d’organiser les instructions dans un algorithme.

Une structure de contrôle détermine le flux de contrôle (ou flux d’exécution), c’est-à-dire l’ordre
dans lequel les instructions de l’algorithme doivent être exécutées.

Il existe plusieurs structures de contrôle, dont :

• Les structures séquentielles ;
• Les structures alternatives ;
• Les structures itératives ;
• Les routines 4 .

2.2.1 Structures séquentielles

A. Séquence
Définition 2.7. Une séquence est une suite d’instructions dont l’exécution commence par la première
et pas à pas, passe toutes les instructions jusqu’à la dernière.
4. Les routines seront abordées dans le vol. 001 num. 003.

29
 La séquence est donc la structure de contrôle implicite. Le contrôle passe ainsi d’une instruction à
l’autre selon l’ordre dans lequel elles apparaissent dans l’algorithme.

Cependant, parfois la séquence est interrompue par un saut, également appelé branchement ou
transfert. Un saut est un transfert de contrôle de l’algorithme vers un emplacement spécifique. La
ligne vers laquelle nous bifurquons est spécifiée à l’aide de son étiquette ou de sa balise. Une étiquette
est un numéro ou un identifiant associé à une instruction de code source. Il est destiné à servir de
cible à une structure de contrôle située ailleurs dans le programme. Hormis ce rôle de localisation, une
étiquette n’a aucun effet sur le programme : elle ne modifie pas le comportement de l’instruction à
laquelle elle est associée.

Il existe deux familles d’instructions qui permettent d’adresser ces étiquettes : les sauts incondi-
tionnels et les sauts conditionnels.

Dans un saut conditionnel, le contrôle est transféré inconditionnellement à une ligne de l’algo-
rithme. Ce saut est systématique, il entraîne une rupture dans le flux d’exécution. L’instruction suivant
le saut dans le programme ne peut donc être atteinte que par un autre saut.

Le format d’un saut conditionnel est

Aller à n,
où n est une étiquette pour transférer le contrôle à la partie de l’algorithme qui commence par
l’instruction étiquetée n.

Exemple 2.11. Soit un algorithme qui demande à l’utilisateur son nom et l’affiche en ajoutant au début
«Votre nom est : »

Var nom en chaîne des caractères

Début
Afficher «Entrez votre nom :»
Lire nom
Aller à 10
10. Afficher «Votre nom est : » ; nom
11. Aller à 12
12. Fin.
Dans un saut inconditionnel, le contrôle est transféré à l’une des lignes de l’algorithme en vérifiant
une condition. Si la condition n’est pas vérifiée, l’exécution se poursuit séquentiellement. La condi-
tion est parfois appelée condition de rupture car elle implique généralement une interruption du flux
d’exécution lorsque la condition est vraie.

Remarque 2.2. A noter également que les sauts (dont l’instruction Aller à) ont été critiqués, no-
tamment par le mathématicien et informaticien néerlandais Edsger W. Dijkstra, qui deviendra plus
tard son adversaire emblématique. Voulant lutter contre l’utilisation abuside de l’instruction, il écri-
vit en 1968 pour les Communications de l’ACM un article qu’il intitula «A Case against the GOTO
Statement» («Un Procès contre l’instruction ALLER A») (Dijkstra (1968a)). Voulant publier rapide-
ment l’article sous forme de lettre à l’éditeur, l’éditeur Niklaus Wirth l’a renommé «Go To Statement
Considered Harmful» («L’Instruction Aller à considérée comme nuisible») (Dijkstra (1968b)).

B. Arrêt du programme
Un programme s’arrête généralement après l’exécution de la dernière instruction. La plupart des
langages de programmation fournissent également une ou plusieurs instructions pour arrêter l’exécu-
tion du programme à une position arbitraire.

30
2.2.2 Structures alternatives
Définition 2.8. Une structure alternative ou structure conditionnelle est une structure de contrôle
permettant de choisir entre deux ou plusieurs blocs d’instructions.

A. Structures alternatives simples

Les structures alternatives simples existent sous deux formes. La première forme est :

Si p Alors
s.
Fin Si

Et la deuxième forme est :

Si p Alors
s
Sinon
t.
Fin Si

Si la condition, également appelée test, t est vérifiée, on exécute la séquence d’instructions s sous
les deux formes. Si elle n’est pas vérifiée, dans la seconde forme la séquence d’instructions t est exécuté.

Le délimiteur Fin indique la fin de la séquence d’instructions relatives à la partie Alors pour le
premier formulaire. Pour la deuxième forme, cette terminaison est exécutée par le mot Sinon.
Exemple 2.12. Soit à écrire un algorithme qui calcule la valeur absolue d’un réel x.
Var x, val_abs en réel
Début
Afficher «Entrez le nombre réel :»
Lire x
Si x ≥ 0 Alors
val_abs ← x
Sinon
val_abs ← −x.
Fin Si
Fin.

2.2.3 Structures alternatives généralisées

L’emboîtement de plusieurs schémas alternatifs conduit souvent à l’écriture de séquences algorith-
miques. Pour cela, deux formes sont possibles.

Dans la première forme, on peut enchaîner autant d’instructions Sinon Si que désiré : seule la
première dont la condition sera vérifiée sera exécutée. On peut généralement associer une clause Sinon
qui ne sera exécutée que si aucune clause Sinon si n’a été vérifiée.

Exemple 2.13. Considérons un algorithme qui demande à l’utilisateur l’âge de l’enfant, puis détermine
la catégorie de l’enfant :
Var age en chaîne des caractères

31
 Début
Afficher «Entrez l’âge de l’enfant :»
Lire age
Si age ≥ 12 Alors
Afficher «Catégorie Cadet»
Sinon Si age ≥ 10 Alors
Afficher «Catégorie Minime»
Sinon Si age ≥ 8 Alors
Afficher «Catégorie Pupille»
Sinon Si age ≥ 6 Alors
Afficher «Catégorie Poussin»
Sinon
Afficher «Erreur»
Fin Si
Fin Si
Fin Si
Fin Si
Fin.

La deuxième forme consiste à sélectionner le bloc à exécuter en fonction de la valeur d’une variable.
Cette forme est utilisée lorsqu’un aiguillage offre plusieurs sorties, et qu’une condition doit être testée
plusieurs fois, en utilisant toujours la même variable.

Exemple 2.14. En considérant l’exemple précédent, on a l’algorithme suivant :

Var pays en chaîne des caractères
Début
Afficher «Entrez un pays de l’Afrique centrale :»
Lire pays
Selon pays
Cas «Angola» :
Afficher «La capitale est Luanda»
Cas «Cameroun» :
Afficher «La capitale est Yaoundé»
Cas «Gabon» :
Afficher «La capitale est Libreville»
Cas «Guinée équatoriale» :
Afficher «La capitale est Malabo»
Cas «République centrafricaine» :
Afficher «La capitale est Bangui»
Cas «République démocratique du Congo» :
Afficher «La capitale est Kinshasa»
Cas «République du Congo» :
Afficher «La capitale est Brazzaville»
Cas «Sao Tomé-et-Principe» :
Afficher «La capitale est São Tomé»
Cas «Tchad» :
Afficher «La capitale est N’Djaména»
Cas Autre :
Afficher «Erreur. Le pays n’est pas de l’Afrique centrale»
Fin Cas

32
 Fin.

Structurellement, cela équivaut à une succession de Sinon Si, mais savoir que la valeur de la
variable testée ne changera pas lors de l’évaluation des conditions permet au traducteur de faire
quelques optimisations.

2.2.4 Structures itératives

Définition 2.9. Une structure itérative, également appelée structure répétitive ou boucle, est une
structure de contrôle permettant d’exécuter plusieurs fois de suite certaines instructions.

Il existe plusieurs types de structures itératives, selon que le nombre de répétitions (ou d’itérations)
est prédéterminé ou non.

A. Cas du nombre de répétitions non prédéterminé

Dans le cas où le nombre de répétitions n’est pas prédéterminé, il existe deux schémas de structures
itératives : la boucle «Jusqu’à (ce que)» et la boucle «Tant que».

A.1 Boucle «Jusqu’à (ce que)»

Le format général de la boucle «Jusqu’à (ce que)» est le suivant :

Répéter
s
Jusqu’à (ce que) p

avec s une suite d’instructions et p le prédicat de contrôle de l’itération.

Cette boucle permet de réitérer une instruction ou une suite d’instructions s jusqu’à ce qu’une
condition, appelée condition de sortie soit vérifiée. La suite d’instructions est exécutée au moins une
fois, quelle que soit la condition.

Exemple 2.15. Considérons un algorithme permettant à l’utilisateur d’introduire un nombre de ma-

nière aléatoire et qui ne s’arrête que lorsque ce nombre est égal à 1524. A la fin, l’algorithme doit
fournir le nombre de tentatives de l’utilisateur. D’où l’algorithme suivant :

Var x, i en entier
Début
i←0
Répéter
Afficher «Entrez le nombre S.V.P.»
Lire x
i←i+1
Jusqu’à ce que x = 1524
Afficher «Vous avez trouvé le nombre.»
Afficher «Le nombre de vos tentatives est : » ; i
Fin.

33
 La variable entière i dont la valeur initiale est 0 contient le nombre de fois que l’instruction Lire x
a été répété, une telle variable sera appelée compteur (de boucle), à chaque itération sa valeur aug-
mentera d’une quantité constante. On dira que le compteur est incrémenté.

La valeur constante avec laquelle le compteur augmente à chaque itération sera appelée pas d’in-
crémentation. Dans l’exemple 2.15, le pas d’incrémentation est 1. Lorsque la valeur de la variable de
contrôle décroît constamment d’une itération à l’autre, on l’appelle le décrément du compteur. On
parle aussi de pas de décrémentation.

Ainsi, un compteur est une variable qui contrôle les itérations d’une boucle. Il est ainsi nommé
parce que la plupart des utilisations de cette variable font que la variable prend une plage de valeurs
entières dans une séquence ordonnée. Étant donné que le compteur est une variable, il peut être nommé
à l’aide des conventions de dénomination des variables. Cependant, la dénomination d’identifiant
commun consiste pour le compteur de boucle à utiliser les noms de variable i, j et k (et ainsi de suite
si nécessaire). L’ordre inverse est également utilisé par certains programmeurs. Cette pratique remonte
à la notation mathématique où les indices pour les sommes et les multiplications sont souvent i, j, etc.

A.2. Boucle «Tant que»

Le format général de la boucle «Tant que» est le suivant :

Tant que p
s
Fin Tant que

avec s une suite d’instructions et p le prédicat de contrôle de l’itération.

Si la condition p est vérifiée, la suite d’instructions s est exécutée, puis à la fin du bloc on évalue
à nouveau p et on recommence. Lorsque p renvoie un résultat faux, on quitte la boucle. Le prédicat p
est généralement appelé condition de continuation car le flux d’exécution continue avec s lorsque le p
est vrai.

Exemple 2.16. Considérons un algorithme permettant à l’utilisateur d’introduire un nombre de ma-

nière aléatoire et qui ne s’arrête que lorsque ce nombre est égal à 1524. A la fin, l’algorithme doit
fournir le nombre de tentatives de l’utilisateur. D’où l’algorithme suivant :

Var x, i en entier
Début
i←1
Tantque n ̸= 1524
Afficher «Entrez le nombre S.V.P.»
Lire x
i←i+1
Fin tant que
Afficher «Vous avez trouvé le nombre.»
Afficher «Le nombre de vos tentatives est : » ; i
Fin.

34
B. Cas du nombre de répétitions prédéterminé : boucle «Pour»
Supposons que nous voulions écrire un algorithme nous permettant de multiplier un nombre donné
a par 11 en utilisant uniquement l’addition comme opérateur arithmétique. Il s’agira de trouver trou-
ver P = a + a + a + a + a + a + a + a + a + a + a

Ce problème peut être résolu par l’algorithme suivant :

Var i en entier /*Variable entire indiquant le nombre de fois l’opération répétée*/

Var P, a en entier
Début
Afficher «Entrez le nombre à multiplier par 11 :»
Lire a
10. P ← P + a
i←i+1
Si i < 11 Alors
Aller à 10
Fin Si
Afficher «Le produit est : » ; P
Fin.
Pour éviter la déclaration explicite de la variable compteur et l’utilisation du saut conditionnel,
on peut utiliser l’algorithme suivant :

Var P, a en entier
Début
Afficher «Entrez le nombre à multiplier par 11 :»
Lire a
Pour i ← 1 à 11
P ←P +a
Fin Pour
Afficher «Le produit est : » ; P
Fin.

Cette version d’algorithme montre que, lorsque le nombre de répétitions est connu en avance, la
boucle «Pour» est plus efficace que les deux premiers. D’ailleurs, contrairement à la boucle «Tant
que» ou la boucle «Jusqu’à (ce que)», la boucle Pour inclut une variable appelée compteur (et son
initialisation d’ailleurs) dans sa syntaxe. Dans une boucle «Pour», la progression du compteur est
laissée à sa libre disposition. Dans la plupart des cas, nous avons besoin d’une variable qui augmente
de 1 à chaque itération, et généralement on ne spécifie rien sur le pas d’incrémentation. Si par contre
le pas est différent de 1, il suffit de préciser, avec l’instruction pas k, où k est le pas d’incrémentation
(ou de décrémentation).

Exemple 2.17. Considérons un algorithme qui affiche les 3000 premiers multiples de 3 sans faire des
multiplications.

Var i en entier
Début
Pour i ← 3 à 3003 (pas 3)
i
Fin Pour

35
C. Cas général
Les langages de programmation tels que C et le Common LISP permettent d’utiliser des structures
itératives plus générales que celles exprimées plus. Son format général est le suivant :
Itérer
a
Sortir Si p
b
Fin Itérer

avec a, b des suites d’instructions et p le prédicat à évaluer.

Dans un schéma général de structure itérative, la suite d’instructions a se produisent toujours

une fois de plus que la suite d’instructions b car l’évaluation du prédicat de contrôle se fait au milieu
du schéma (après une suite d’instructions a). Lorsqu’une des suites d’instructions a ou b est vide, le
schéma général se réduit soit à une boucle «Jusqu’à (ce que)», soit à une boucle «Tant que», soit à
une boucle «Pour».
1. Lorsque b est vide, le schéma général se réduit à la boucle «Jusqu’à (ce que)». On a donc :
Itérer
s
Sortir Si p
Fin Itérer

2. Lorsque a est vide, plusieurs cas se présente :

• Le cas de la boucle «Tant que» :
Itérer
Sortir Si ¬(p)
s
Fin Itérer

• Le cas de la boucle «Pour» avec incrémentation :

v ← vd
Itérer
Sortir Si v > vl
s
v ← v + inc
Fin Itérer

• Le cas de la boucle «Pour» avec décrémentation :

v ← vd
Itérer
Sortir Si v > vl
s
v ← v − dec
Fin Itérer

Il est possible pour un problème, d’utiliser soit une structure alternative, soit une boucle pour, soit
une boucle «Tantque» ou encore une boucle «Jusqu’à (ce que)». Considérons un problème consistant

36
à écrire un algorithme qui affiche les vingt premiers nombre entiers positifs. Ce problème peut être
résolu par l’algorithme suivant :

Var i en entier
Début
Pour i ← 1 à 20
Afficher i
Fin Pour
Fin.

Avec la structure alternative simple, le même algorithme peut s’écrire de la manière suivante :

Var i en entier
Début
i←0
5. i ← i + 1
Si i < 20 Alors
Afficher i
Aller à 5
Fin Si
Fin.

Cependant, l’utilisation de la structure alternative dans les tâches répétitives nécessite l’utilisa-
tion de la commande Aller à déclaration. Signalons que l’instruction Aller à est de plus en plus
obsolète et de moins en moins accessible dans certains langages de programmation de haut niveau. En
effet, le langage de programmation comme Ruby, depuis la version 1.9, a l’instruction Aller à seule-
ment sous forme de plaisanterie : les instructions __goto__ et __label__ sont activées si la variable
SUPPORT_JOKE est définie lors de la compilation de Ruby. En 1966, le théorème de Böhm-Jacopini
(Böhm and Jacopini (1966) ; Ramshaw (1988)) a démontré que tout programme avec des Aller à
pouvait être transformé en un programme n’utilisant que des sous-programmes, des séquences, des
structures alternatives et des structures itératives.

Avec la boucle «Tant que», le même algorithme peut s’écrire de la manière suivante :

Var i en entier
Début
i←0
Tant que i < 20
i←i+1
Afficher i
Fin tant que Fin.

Avec la boucle «Jusqu’à (ce que)», le même algorithme peut s’écrire de la manière suivante :

Var i en entier
Début
i←0
Répéter
i←i+1
Afficher i

37
 Jusqu’à ce que i ≥ 20
Fin.

Le seul intérêt de la boucle «Pour» par rapport à la boucle «Tant que» ou à la boucle «Jusqu’à (ce
que)» est d’épargner un peu de fatigue au programmeur, en lui évitant de gérer lui-même l’avancement
de la variable qui lui sert de compteur (Darmangeat (2008)).

3 Structures dans le langage Python

3.1 Affectation et types de données Python
Dans les langages de programmation tels que Python, la spécification explicite des types de va-
riables n’est pas nécessaire en raison de leur typage dynamique. Python est donc capable de déterminer
automatiquement le type le plus approprié pour une variable en fonction de valeur qui lui est attri-
buée. Cette fonctionnalité offre une flexibilité accrue dans la manipulation des données et facilite le
développement rapide d’applications. Cette approche diffère du typage statique, qui est utilisé par des
langages tels que C++ ou Java. Dans ces langages, il est nécessaire de déclarer explicitement le nom et
le type des variables avant de leur attribuer une valeur compatible avec le type déclaré. D’ailleurs, le
typage statique est préférable dans le cas des langages compilés, car il permet d’optimiser le processus
de compilation, qui aboutit à un code binaire «figé».

En Python, l’affectation se fait en utilisant le symbole égal (=).

Exemple 3.1. Soit le programme Python suivant :

In [1]: a = 4
b = 50.8
c = " 100 "
Dans l’exemple 3.1, les variables a, b et c reçoivent respectivement les valeurs 4, 50.8 et "100".

Notons que Python accepte les affectations multiples. En effet, on distingue :

• L’affectation d’une valeur à plusieurs variables simultanément.

Exemple 3.2.

In [1]: d = e = 19
Ici, la valeur 19 est attribuée simultanément aux variables d et e.
• Les affectations parallèles à l’aide d’un seul opérateur.

Exemple 3.3.

In [1]: e , f = " Gloria " , " Maelys "

Ici, la valeur "Gloria" est attribuée à la variable e et la valeur "M aelys" est attribuée à la va-
riable "f ".

En Python, il n’y a pas de constantes au sens strict. En effet, pour définir une constante en
Python, il est courant de nommer les constantes en majuscules pour indiquer qu’elles ne doivent pas
être modifiées, bien qu’elles ne soient pas réellement constantes dans le sens strict.

38
Exemple 3.4.

In [1]: CONSTANTE = 3.14159265358979

Il est à noter que l’utilisation de variables et de constantes peut varier selon les conventions de
programmation spécifiques et les besoins du programme. Les exemples ci-dessus illustrent les approches
couramment utilisées, mais il est important de comprendre que les variables peuvent être modifiées et
que les constantes ne sont pas strictement immuables dans les deux langages.

3.1.1 Convention d’écriture

• Par convention, les identificateurs des variables se feront par des lettres minuscules a-z et
majuscule A-Z, les chiffres du système decimal 0-9, et le caractère de soulignement «_».
• Un identificateur de variable ne peut pas commencer par un chiffre. De plus, s’il commence par
un point, le deuxième caractère ne peut pas être un chiffre.
• Python est sensible à la casse. Il fait la distinction entre les majuscules et les minuscules. En
effet, OPTIMALL, OptiMaLL, Optimall et optimall sont des variables différentes.
• Pour une variable ayant un nom composé, il est conseillé d’utiliser le style de casse dit «snake_case»
(de l’anglais, littéralement «casse de serpent»), qui consiste à écrire les mots sont, généralement
en minuscule, séparés par des traits de soulignement.

Exemple 3.5. On utilisera revenu_par_habitant pour exprimer le revenu par habitant et taux_de_change
pour exprimer le taux de chance lorsque nous programmons en Python.

Dans le langage Python, il existe des mots-clés spécifiques qui sont réservés et ont une signification
particulière. Vous pouvez consulter le Tableau 1 pour voir la liste complète de ces mots-clés utilisés
dans Python.

Table 1 – Liste des mots-clés de Python.

and as assert async await

break class continue def del
elif else except False finally
for from global if import
in is lambda None nonlocal
not or pass raise return
True try while with yield

En Python, il n’y a pas de constantes au sens strict. En effet, pour définir une constante en
Python, il est courant de nommer les constantes en majuscules pour indiquer qu’elles ne doivent pas
être modifiées, bien qu’elles ne soient pas réellement constantes dans le sens strict.

Exemple 3.6.

In [1]: CONSTANTE = 3.14159265358979

Remarque 3.1. Il est à noter que l’utilisation de variables et de constantes peut varier selon les conven-
tions de programmation spécifiques et les besoins du programme. L’exemple ci-dessus illustrent les
approches couramment utilisées, mais il est important de comprendre que les variables peuvent être
modifiées et que les constantes ne sont pas strictement immuables dans Python.

39
3.1.2 Types des données
On distingue :

• Le type entier, représenté par le mot-clé int.

Exemple 3.7. −2, 4, 952000 et 623 sont des entiers.
• Le type réel, représenté par le mot-clé float.
Exemple 3.8. −2.25, 4.0, 95.2000 et 0.623 sont des réels.
• Le type complexe, représenté par le mot-clé complex 5 , et il est créé en utilisant la fonction
complex(x, y), x est la partie réelle et y la partie imaginaire.
Exemple 3.9. Les nombres complex(1, 4) et complex(7, −3) sont de type complexe du langage
Python.
• Le type caractère, qui est formé d’une seul caractère.
Exemple 3.10. "d", "5", "K" et " " sont des caractères.
• Le type chaîne de caractères, qui est formé par une juxtaposition des caractères.
Exemple 3.11. "Maelys", "007", "Tome 1" et "vibration" sont des chaînes de caractères.
Les types caractère et chaîne de caractères sont représentés par le mot-clé str.
• Le type booléen, qui a pour valeur True ou False (avec une majuscule au début).

3.1.3 Transtypage
On peut passer d’un type d’objet à un autre. Dans ce moment, on doit utiliser une technique qu’on
appel transtypage ou conversion de type.

Pour effectuer le transtypage en Python, la syntaxe appropriée est nom_nouveau_type(nom_objet).

Exemple 3.12 (Transtypage avec Python).

In [1]: num_str = " 3.14 "

num_num = float ( num_str )
num_num
Out [1]: 3.14

In [2]: type ( num_str )

Out [2]: str

In [3]: type ( num_num )

Out [3]: num_num
Dans l’exemple précédent, la chaîne de caractères "3.14" est convertie en un nombre réel à l’aide
de la float(). La vérification de type avec type(nom_objet) se fait aisément.

En Python, le transtypage est souvent implicite, ce qui signifie que Python convertira automati-
quement les types de données si cela est nécessaire. En effet, si on additionne un entier et un réel,
Python convertira automatiquement l’entier en réel avant d’effectuer l’addition.

Remarque 3.2. Notons que pour connaître le type d’objet (de la variable) en Python, on utilise type().
5. La notion de fonction sera abordée plus bas.

40
3.2 Opérateurs et opérandes en Python
Les opérateurs (arithmétiques) applicables sur les variables numériques en Python sont :

Table 2 – Opérateurs arithmétiques de Python.

Opérateur Python
Addition +
Soustraction -
Multiplication *
Division (réelle) /
Puissance **
Modulo (Reste de la division entière) %
Division entière //

Les opérateurs (logiques) applicables sur les variables booléenes sont :

Table 3 – Opérateurs logiques de Python.

Opérateur Python
Négation (NON logique) not
Conjonction (ET) and
Disjonction (OU logique) or
Disjonction exclusive ˆ

Les opérateurs de comparaison sont :

Table 4 – Opérateurs de comparaison de Python.

Opérateur Python
Égal (=) ==
Différent (̸=) !=
Supérieur (>) >
Inférieur (<) <
Supérieur ou égal (≥) >=
Inférieur ou égal (≤) <=

Exemple 3.13. Ci-après de script Python illustrant les opérateurs :

In [3]: 4.8 + 3 # L ’ addition

Out [3]: 7.8

In [4]: 4.8 - 3 # La soustraction

Out [4]: 1. 79 99 99 99 99 999 99 8

In [5]: 4.8 * 3 # La multiplication

Out [5]: 14 .3 99 99 99 99 999 99 9

In [6]: 4.8 / 3 # La division reelle

Out [6]: 1. 59 99 99 99 99 999 99 9

41
 In [7]: 4.8 ** 3 # La puissance
Out [7]: 11 0. 59 19 99 99 999 99 8

In [8]: 5 % 3 # Le modulo
Out [8]: 2

In [9]: 5 // 3 # La division entiere

Out [9]: 1

In [10]: 5 / 3 # La division reelle

Out [10]: 1. 66 66 66 66 66 66 666 7

In [11]: not ( True ) # La negation

Out [11]: False

In [12]: not ( False ) # La negation

Out [12]: True

In [13]: True and False # La conjonction

Out [13]: False

In [14]: True or False # La disjonction ( inclusive )

Out [14]: False

In [15]: True ^ False # La disjonction exclusive

Out [15]: False

Remarque 3.3 (Opérations illicites). Il est important de souligner qu’en Python, certaines opérations
sont considérées comme illicites, ce qui signifie qu’elles sont incorrectes ou invalides selon les règles
de syntaxe et de sémantique du langage. Par conséquent, ces opérations ne peuvent pas être exécutées
correctement et entraîneront une erreur lors de leur exécution. Voici quelques exemples d’opérations
illicites en Python :
• La division par zéro, qui génère l’erreur ZeroDivisionError ;
• La conversion de types incorrecte, lorsqu’on effectue des opérations entre des types de données
incompatibles (comme les opérations les numériques et les chaînes de caractères). L’erreur gé-
nérée est TypeError ;
• Le dépassement de capacité, lorsqu’on effectue des calculs qui dépassent la capacité maximale
d’un type numérique, qui génère l’erreur OverflowError.

Exemple 3.14. Ci-après de script Python illustrant quelques opérations illicites :

In [3]: 4/0
------------------------------------------------------------
Zer oDivis ionErr or Traceback ( most recent call last )
< ipython - input -4 -221068 dc2815 > in < module >
----> 1 4/0

Zer oDivis ionErr or : division by zero

In [4]: 0/0

42
 ------------------------------------------------------------
Zer oDivis ionErr or Traceback ( most recent call last )
< ipython - input -4 -221068 dc2815 > in < module >
----> 1 0/0

Zer oDivis ionErr or : division by zero

In [5]: " Maelys " + 2500

------------------------------------------------------------
TypeError Traceback ( most recent call last )
< ipython - input -6 - d88561fd932a > in < module >
----> 1 " Maelys " + 2500

TypeError : can only concatenate str ( not " int " ) to str

3.3 Lecture et écriture dans Python

3.3.1 Lecture dans Python
Pour rappel, le format de l’écriture sur l’écran est :

Lire x
où x est l’identificateur de la donnée auquel on doit attribuer une valeur tapée au clavier. En Python,
ce format peut se traduire par :

x = input().
Python donne également la possibilité de demander à l’utilisateur d’entrer ses propres valeurs à
partir du clavier. Pour cela, la syntaxe utilisée est la suivante :

nom_variable = input("msg")
où "msg" est le message d’attente optionnel qui indique à l’utilisateur ce qu’il doit entrer.

Exemple 3.15. Le script Python ci-après demande à l’utilisateur d’entrer son nom :

In [1]: nom = input ( " Entrer votre nom : " )

3.3.2 Ecriture dans Python

Rappelons que l’écriture à l’écran a pour format général :

Ecrire (ou Afficher) inf o

où inf o est l’information à faire apparaître à l’écran. En Python, cela est implémenté par :

print(info).

Exemple 3.16. Le programme Hello, world ! de l’exemple 2.7 s’implémente en Python de la manière
suivante :

43
 In [1]: print ( " Salut , le monde ! " )
Salut , le monde !
Dans Python, l’affichage en utilisant print ne fonctionne que dans un environnement interactif
tel que l’interpréteur Python ou un notebook Jupyter. En particulier, pour afficher une variable à
l’écran, on utilise soit l’identificateur de la variable, soit le format print(x), avec x l’indentifieur de
la variable. Lorsque ce dernier est utilisée, la sortie sera affichée dans une cellule précédé d’un «Out».
On peut l’observé dans la figure 1.

Figure 1 – Programme Hello World ! en Python avec et sans print().

Cette méthode peut être pratique pour une sortie rapide sans utiliser print(). Cependant, si on
souhaite afficher plusieurs valeurs ou ajouter du texte à votre sortie, print() doit être utilisé. De
plus, si on souhaite afficher une valeur spécifique à un moment précis dans le code, print() doit être
également utilisé.

Exemple 3.17. Reprenons l’illustration du point 2.1.1, avec le calcul de la moyenne arithmétique de
deux nombres. Nous avons l’implémentation en Python de la Figure 2

Figure 2 – Calcul de la moyenne de deux nombres avec Python.

44
 Dans le script précédent, l’instruction input() est utilisée pour recevoir une entrée sous forme
de chaîne de caractères. Cependant, pour effectuer des calculs arithmétiques, nous devons convertir
ces chaînes de caractères en nombres réels à l’aide de float(x1) et float(x2). Ainsi, l’instruction
combine ces deux étapes en une seule pour faciliter la conversion des entrées de l’utilisateur au type
souhaité :

nom_variable = type_cible(input(["msg"])
où type_cible est le type ciblé, différent de chr, de la variable nom_variable.

Exemple 3.18. La Figure 3 illustre bien le changement apporté au programme de la Figure 2.

Figure 3 – Calcul de la moyenne de deux nombres avec Python, deuxième version.

Pour afficher les contenus des variables en les insérant dans une chaîne de caractères, il existe au
moins deux méthodes couramment utilisées : (i) l’écriture avec un affichage simple et (ii) l’écriture
avec un affichage formaté. Ces deux approches sont illustrées respectivement dans les exemples de
code présentés dans les Figures 10 et 5.

Exemple 3.19. La Figure 10 illustre le cas de l’affichage sans formattage.

Exemple 3.20. La Figure 5 illustre le cas de l’affichage en écriture formatée.

45
Figure 4 – Calcul de la moyenne de deux nombres et affichage en insérant les valeurs des
variables en écriture sans formattage.

Figure 5 – Calcul de la moyenne de deux nombres et affichage en insérant les valeurs des
variables en écriture formatée.

46
3.4 Structures de contrôle dans Python
3.4.1 Structures alternatives
La première forme de la structure conditionnelle simple :
if p :
s
où p est la condition et s la suite d’instructions à exécuter si la condition est satisfaite.

La deuxième forme de la structure conditionnelle simple :

if p :
s
else :
t

Exemple 3.21. En reprenant l’exemple 2.12, nous avons l’implémentation suivante :

In [14]: x = float ( input ( " Entrez le nombre reel : " ) )

if x >= 0:
val_abs = x
else :
val_abs = -x

print ( " La valeur absolue de " , x , " est " , val_abs )

La structure alternative la plus générale de Python a pour forme ce qui suit :

if p1 :
s1
elif p2 :
s2
[...]
elif pn :
sn
else :
t
Cette structure peut s’expliquer de la manière suivante :
• L’instruction if p1: vérifie la condition p1. Si la condition p1 est satisfaite, la suite d’ins-
tructions s1 qui suit sera exécuté. Si la condition p1 n’est satisfaite, le programme passe à
l’instruction elif.
• L’instruction elif p2: permet de vérifier une deuxième condition, p2. Si la condition p2 est
satisfaite et que les conditions précédentes (p1) sont ne sont pas satisfaites, la suite d’instructions
s2 sera exécuté. Si la condition p2 est n’est pas verifiée, le programme passe à l’instruction elif
suivante, s’il y en a.
• Les instructions elif peuvent être répétées autant de fois que nécessaire avec des conditions
différentes (p3, p4, ..., pn). Chaque instruction elif permet tester une condition supplé-
mentaire. Si une des conditions pi est satisfaite, la suite d’instructions si correspondant sera
exécuté et les autres clauses elif et le bloc else seront ignorés.

47
 • L’instruction else: est facultative. Elle est utilisée lorsque toutes les conditions précédentes
(p1, p2, ..., pn) sont évaluées ne sont pas satisfaites. La suite d’instructions t qui suit sera
exécuté si aucune des conditions précédentes n’est satisfaite.

Exemple 3.22. On peut implémenter l’exemple 2.13 en Python de la manière suivante.

In [1]: age = input ( " Entrez l ’ age de l ’ enfant : " )

if int ( age ) >= 12:

print ( " Categorie Cadet " )
elif int ( age ) >= 10:
print ( " Categorie Minime " )
elif int ( age ) >= 8:
print ( " Categorie Pupille " )
elif int ( age ) >= 6:
print ( " Categorie Poussin " )
else :
print ( " Erreur " )
Nous pouvons également imbriquer 6 deux structures alternatives dans ce programme afin que l’une
de ces structures puisse vérifier si le nombre saisi par l’utilisateur est bien un entier.

Étant donné que la fonction input() ne récupère que des chaînes de caractères, il est nécessaire
de s’assurer que tous les caractères entrés sont des chiffres. Pour ce faire, nous pouvons utiliser la
méthode isdigit() qui permet de vérifier si une chaîne de caractères est composée uniquement de
chiffres.

Exemple 3.23. Ainsi, l’exemple 3.22 devient :

In [4]: age = input ( " Entrez l ’ age de l ’ enfant : " )

if age . isdigit () : # Verifie si l ’ age est un nombre entier

age = int ( age ) # Convertit l ’ age en entier

if age >= 12:

print ( " Categorie Cadet " )
elif age >= 10:
print ( " Categorie Minime " )
elif age >= 8:
print ( " Categorie Pupille " )
elif age >= 6:
print ( " Categorie Poussin " )
else :
print ( " Erreur " )
else :
print ( " Erreur : Veuillez entrer un age valide . " )

6. En programmation, l’imbrication fait référence à l’utilisation de structures de contrôle (telles que des
boucles et des structures conditionnelles) à l’intérieur d’autres structures de contrôle. Cela signifie qu’une struc-
ture de contrôle peut être placée à l’intérieur d’une autre structure de contrôle, créant ainsi une hiérarchie ou
une superposition de blocs de code.

48
 Parmi les méthodes disponibles pour effectuer des vérifications sur des chaînes de caractères, on
a : isdigit(), isnumeric(), isdecimal() et isalnum().

• isdigit() : Cette méthode vérifie si tous les caractères d’une chaîne sont des chiffres.
• isnumeric() : Cette méthode est similaire à isdigit(), mais elle accepte également d’autres types
de caractères numériques tels que les chiffres en exposant, les fractions et les chiffres en langue
étrangère.
• isdecimal() : Cette méthode vérifie si tous les caractères d’une chaîne sont des chiffres décimaux
(base 10).
• isalnum() : Cette méthode vérifie si tous les caractères d’une chaîne sont alphanumériques,
c’est-à-dire des lettres ou des chiffres.
Exemple 3.24. La Figure 6 illustre l’utilisation de ces méthodoes.
Python n’a pas de structure spécifique appelée «Selon Cas». Cependant, Python offre une alter-
native avec la structure généralisée avec des Si ... Alors ... Sinon ... Fin Si, qui peut être
utilisée pour gérer des conditions multiples de manière similaire à « Selon Cas ».
Exemple 3.25. L’exemple 2.14 dans la Figure 7 montre une implémentation de cette structure en
Python.

3.4.2 Structures itératives

En Python, la boucle «Tant que» est implémenter de la manière suivante :
while p :
s
avec s une suite d’instructions et p le prédicat de contrôle de l’itération.

Exemple 3.26. L’exemple 2.16 peut être implémentée en Python de la manière suivante :

In [1]: x = 0
i = 1

while x != 1524:
print ( " Entrez le nombre S . V . P . " )
x = int ( input () )
i += 1

print ( " Vous avez trouve le nombre . " )

print ( " Le nombre de vos tentatives est : " , i )
En Python, il n’existe pas de boucle «Jusqu’à (ce que)» spécifique. Cette boucle est une variante
de la boucle «Tant que», où la condition de sortie est évaluée à la fin de chaque itération plutôt qu’au
début. Toutefois, on peut obtenir le même effet qu’une boucle «Jusqu’à (ce que)» en utilisant la boucle
«Tant que» avec une condition négative. Ainsi, voici la forme générale de l’implémentation de cette
boucle en Python :
while not p :
s
avec s une suite d’instructions et p le prédicat de contrôle de l’itération.

49
Figure 6 – Illustration de l’utilisation des méthodes de vérification des chaînes de caractères.

50
 Figure 7 – Une impémentation de l’exemple 2.14.

Exemple 3.27. L’exemple 2.15 peut être implémentée en Python de la manière suivante :

In [1]: x , i = 0 , 0

while x != 1524:
print ( " Entrez le nombre S . V . P . " )
x = int ( input () )
i += 1

print ( " Vous avez trouve le nombre . " )

print ( " Le nombre de vos tentatives est : " , i )
Pour la boucle «Pour» en général, nous utilisons les formes suivantes :
for i in range (1 , n +1) :
s
ou
for i in range (1 , n +1 , k ) :
s
si le pas d’incrémentation est différent de 1. Avec s une suite d’instructions à exécuter.

Exemple 3.28. En reprénant l’affichage des 3000 premiers multiples de 3 sans faire des multiplications.

# Declaration de la variable i
i = 3

51
# Boucle pour afficher les multiples de 3
for i in range (3 , 3004 , 3) :
print ( i )

4 Structures dans le langage R

4.1 Affectation et types de données R
Tout comme Python, le langage R utilise également un typage dynamique.

En R, l’affectation se fait en utilisant soit <-, -> ou =.

Exemple 4.1. Soit le programme R suivant :

> a <- 4
> 50.8 -> b
> c = " 100 "
Il est important de noter la position de l’identificateur de la variable et de sa valeur. Lorsque nous
utilisons l’opérateur « -> », la valeur est à gauche de l’opérateur et l’identificateur est à droite.

De plus, il est recommandé d’éviter d’utiliser l’opérateur « = » pour affecter une valeur à une
variable. Cette pratique peut prêter à confusion avec les constructions « symbole = valeur » dans les
appels de fonction. Les règles de syntaxe de R indiquent d’utiliser les opérateurs « <- » ou « ->» pour
l’affectation.

Exemple 4.2.

> d <- 19
> e <- " Gloria "
> f <- " Maelys "

4.1.1 Convention d’écriture

• Par convention, les identificateurs de variables seront en minuscules a-z et en majuscules A-Z,
les chiffres du système décimal 0-9 et le caractère de soulignement «_».
• le caractère «.» peut être utilisé à l’intérieur d’un identificateur de variable. L’utilisation de
lettres accentuées dans les noms d’objets peut être autorisée selon l’environnement linguistique
de l’ordinateur. Cependant, il est fortement recommandé d’éviter cette pratique, car elle peut
nuire à la portabilité du code (Goulet (2023)).
• Un identificateur de variable ne peut pas commencer par un chiffre. De plus, s’il commence par
un point, le deuxième caractère ne peut pas être un chiffre.
• R est sensible à la casse. Il font donc la distinction entre les majuscules et les minuscules. En
effet, OPTIMALL, OptiMaLL, Optimall et optimall sont des variables différentes.
• Pour une variable ayant un nom composé, il est conseillé d’utiliser le style de casse dit «camelCase»
(de l’anglais, littéralement «casse de chameau»), qui consiste écrire un ensemble de mots en les
liant sans espace ni ponctuation, et en mettant en majuscule la première lettre de chaque mot,
sauf la première lettre du nom de l’objet.

52
Exemple 4.3. On utilisera revenuParHabitant pour exprimer le revenu par habitant et tauxDeChange
pour exprimer le taux de chance lorsque nous programmons en R.

R dispose également de certains mots-clés qui sont réservés et utilisés dans le langage. Vous pouvez
consulter le Tableau 5 pour voir la liste des mots-clés spécifiques à R.

Table 5 – Liste des mots-clés de R.

NA NA_character_ NA_complex_ NA_integer_

FALSE break continue else
for function if in
next NULL NaN TRUE
and as assert finally
nonlocal or repeat while
break

En R, il n’y a pas de constantes au sens strict. En effet, pour définir une constante dans R, il est
courant d’utiliser la fonction const pour indiquer que la valeur ne doit pas être modifiée. Cependant,
il est important de noter que cette utilisation de const n’empêche pas strictement la modification
de la valeur. Au contraire, cela sert d’indice aux autres programmeurs que la valeur ne doit pas être
modifiée intentionnellement.

Exemple 4.4.

> CONSTANTE <- const (3 .14 15 9265 35 89 79 )

Remarque 4.1. Il est à noter que l’utilisation de variables et de constantes peut varier selon les conven-
tions de programmation spécifiques et les besoins du programme. L’exemple ci-dessus illustrent les
approches couramment utilisées, mais il est important de comprendre que, comme dans Python, les
variables peuvent être modifiées et que les constantes ne sont pas strictement immuables dans R.

4.1.2 Types des données

On distingue :

• Le type entier, représenté par le mot-clé integer.

Exemple 4.5. −2, 4, 952000 et 623 sont des entiers.

• Le type réel, représenté par le mot-clé numeric.

Exemple 4.6. −2.25, 4.0, 95.2000 et 0.623 sont des réels.

• Le type complexe, représenté par le mot-clé complex.

Exemple 4.7. Les nombres 1 + 4i et 7 − 3i sont de type complexe du langage R

• Le type caractère, qui est formé d’une seul caractère.

53
 Exemple 4.8. "d", "5", "K" et " " sont des caractères.

• Le type chaîne de caractères, qui est formé par une juxtaposition des caractères.

Exemple 4.9. "Maelys", "007", "Tome 1" et "vibration" sont des chaînes de caractères.

Les types caractère et chaîne de caractères sont représentés par le mot-clé character.
• Le type booléen, qui a pour valeur TRUE ou FALSE (toutes les lettres en majuscules), que l’on
peut abréger avec T et F.

4.1.3 Transtypage
On peut passer d’un type d’objet à un autre. Dans ce moment, on doit utiliser une technique qu’on
appel transtypage ou conversion de type.

Pour effectuer le transtypage en R, la syntaxe appropriée est nomNouveauType(nomObjet).

Exemple 4.10 (Transtypage avec R).

> num_str <- " 3.14 "

> num_num <- as . numeric ( num_str )
> class ( num_str )
[1] " character "
> class ( num_num )
[1] " numeric "
Dans l’exemple précédent, la chaîne de caractères "3.14" est convertie en un nombre réel à l’aide
de la [Link](). La vérification de type avec class(nomObjet) se fait aisément.

En R, le transtypage est souvent explicite, ce qui signifie qu’on doit spécifier explicitement le
type de données qu’on souhait convertir. De plus, R a une approche plus stricte en matière de transty-
page, ce qui signifie que les conversions de type peuvent échouer si les données ne sont pas compatibles.

Remarque 4.2. Notons que pour connaître le type d’objet (de la variable) en R, on utilise class().

54
4.2 Opérateurs et opérandes en R
Les opérateurs (arithmétiques) applicables sur les variables numériques en R sont :

Table 6 – Opérateurs arithmétiques de R.

Opérateur R
Addition +
Soustraction -
Multiplication *
Division (réelle) /
Puissance ˆ
Modulo %%
Division entière %/%

Les opérateurs (logiques) applicables sur les variables booléenes sont :

Table 7 – Opérateurs logiques de R.

Opérateur R
Négation !
Conjonction &&
Disjonction ||
Disjonction exclusive xor()

Les opérateurs de comparaison sont le même que ceux de R.

Exemple 4.11. Ci-après de script R illustrant les opérateurs :

> 4.8 + 3 # L ’ addition

[1] 7.8
> 4.8 - 3 # La soustraction
[1] 1.8
> 4.8 * 3 # La multiplication
[1] 14.4
> 4.8 / 3 # La division reelle
[1] 1.6
> 4.8 ^ 3 # La puissance
[1] 110.592
> 5 %% 3 # Le modulo
[1] 2
> 5 %/% 3 # La division entiere
[1] 1
> 5 / 3 # La division reelle
[1] 1.666667
> ! T # La negation
[1] FALSE
> ! F # La negation
[1] TRUE
> T && F # La conjonction
[1] FALSE

55
> T || F # La disjonction ( inclusive )
[1] TRUE
> xor (T , F ) # La disjonction exclusive
[1] TRUE

Remarque 4.3 (Quelques valeurs particulières). Dans le langage R, la division par zéro et les divisions
par l’infini génèrent des résultats spécifiques régis par les règles de l’arithmétique des nombres réels.
Voici les résultats qu’on obtient dans R pour différentes divisions :
• Le résultat Inf ce qui signifie «Infinite» (en français «Infini»). Cela est représenté par le symbole
«Inf» ou «-Inf» (pour l’infini positif et négatif respectivement), lorsqu’on fait d’un nombre
quelconque par zéro.
• Le résultat NaN, ce qui signifie «Not a Number» (en français «Pas un nombre»), lorsqu’on fait
la division de zéro par zéro ou infini sur infini.
• Si on divise zéro par un nombre non nul (même s’il s’agit de l’infini), le résultat est toujours
zéro.

Exemple 4.12. Ci-après de script R illustrant valeurs particulières :

> a <- 4/0

> a
[1] Inf
> is . infinite ( a )
[1] TRUE
> b <- -5.8/0
> b
[1] - Inf
> is . infinite ( b )
[1] TRUE
> c <- 0/0
> c
[1] NaN
> is . nan ( c )
[1] TRUE
> d <- Inf / Inf
> d
[1] NaN
> is . nan ( d )
[1] TRUE
> e <- 0/1420
> e
[1] 0
> f <- 0/ Inf

4.3 Lecture et écriture dans R

4.3.1 Lecture dans R
En R, le format général de la lecture peut s’implémenter par :

x <- readline()

56
 où
x est l’identificateur de la donnée auquel on doit attribuer une valeur tapée au clavier.

R donne également la possibilité de demander à l’utilisateur d’entrer ses propres valeurs à partir
du clavier. Pour cela, la syntaxe utilisée est la suivante :

nomVariable <- readline(prompt = "msg")

où "msg" est le message d’attente optionnel qui indique à l’utilisateur ce qu’il doit entrer.

Exemple 4.13. Le script R ci-après demande à l’utilisateur d’entrer son nom :

> x <- readline ( prompt = " Entrer votre nom : " )

Notons aussi que le mot-clé prompt= peut être omis. L’exemple suivant est équivalent à l’exemple
4.13 :

Exemple 4.14.

> x <- readline ( " Entrer votre nom : " )

4.3.2 Ecriture dans R

En R, il existe plusieurs façons d’afficher le contenu d’une variable. Voici les différences entre les
fonctions print(), cat() et l’affichage direct de la variable.

Le premier schéma d’affichage est :

print(info).

Exemple 4.15. Le programme Hello, world ! de l’exemple 2.7 s’implémente en R de la manière suivante :

> print ( " Salut , le monde ! " )

[1] " Salut , le monde ! "

Remarque 4.4. Lorsque print(info), le résultat sera affiché avec l’indice de la ligne du résultat.

Le deuxième schéma d’affichage est :

cat(info).

Exemple 4.16. Avec ce schéma, le programme Hello, world ! de l’exemple 2.7 s’implémente en R de la
manière suivante :

> print ( " Salut , le monde ! " )

" Salut , le monde ! "

Remarque 4.5. Contrairement au schéma avec print(), lorsque cat(info), le résultat sera affiché
sans indice de la ligne du résultat.

Le troisième schéma est l’utilisation directe de info. Il peut s’agir du contenu d’une variable ou
d’une constante. Donc,

info.

57
Exemple 4.17. Le programme Hello, world ! de l’exemple 2.7 s’implémente en R de la manière suivante :

> " Salut , le monde ! "

[1] " Salut , le monde ! "

Remarque 4.6. Ici également, le résultat sera affiché avec l’indice de la ligne du résultat.

Comme avec Python, si on souhaite afficher plusieurs valeurs ou ajouter du texte à votre sortie,
print() doit être utilisé. De plus, si on souhaite afficher une valeur spécifique à un moment précis
dans le code, print() doit être également utilisé.

Exemple 4.18. Reprenons l’illustration du point 2.1.1, avec le calcul de la moyenne arithmétique de
deux nombres. Nous avons l’implémentation en R de la Figure 8

Figure 8 – Calcul de la moyenne de deux nombres avec R.

Dans le script précédent, l’instruction readline() est utilisée pour recevoir une entrée sous forme
de chaîne de caractères. Cependant, pour effectuer des calculs arithmétiques, nous devons convertir
ces chaînes de caractères en nombres réels à l’aide de [Link](x1) et [Link](x2). Ainsi,
l’instruction combine ces deux étapes en une seule pour faciliter la conversion des entrées de l’utilisateur
au type souhaité :

nomVariable = as.type_cible(readline(["msg"])
où type_cible est le type ciblé, différent de character, de la variable nomVariable.

Exemple 4.19. La Figure 9 illustre bien le changement apporté au programme de la Figure ??.

Pour afficher les contenus des variables en les insérant dans une chaîne de caractères, il existe deux
méthodes couramment utilisées : (i) l’écriture avec un affichage simple et (ii) l’écriture avec un affichage
formaté. Ces deux approches sont illustrées respectivement dans les exemples de code présentés dans
les Figures 10 et 5.

Exemple 4.20. La Figure 10 illustre le cas de l’affichage sans formattage.

58
 Figure 9 – Calcul de la moyenne de deux nombres avec R, deuxième version.

Figure 10 – Calcul de la moyenne de deux nombres et affichage en insérant les valeurs des
variables en écriture sans formattage.

59
 Dans le script de la Figure 10 , nous avons utilisé des variables dans le message affiché en les
séparant par virgules (,) comme nous le ferions avec Python. Cependant, la valeur affichée comporte
trois décimales après la virgule, ce qui est le nombre de décimales par défaut.

Exemple 4.21. La Figure 5 illustre le cas de l’affichage en écriture formatée.

Figure 11 – Calcul de la moyenne de deux nombres et affichage en insérant les valeurs des
variables en écriture formatée.

Dans ce script, nous avons utilisé l’instruction sprintf et les spécificateurs de format pour for-
mater les valeurs selon différents critères. Ces spécificateurs de format peuvent être combinés avec des
options supplémentaires pour contrôler la largeur du champ, le remplissage, l’alignement, etc. Voici
quelques cas d’autres spécificateurs de format couramment utilisés :

• %d : Entier décimal (en effet, sprintf("%d", 42) affiche "42").

• %s : Chaîne de caractères (en effet, sprintf("%s", "Hello") affiche "Hello").
• %e : Notation scientifique (en effet, sprintf("%e", 1000) affiche "1.000000e+03").
• %g : Format général (en effet, sprintf("%g", 3.14159) affiche "3.14159").
• %c : Caractère (en effet, sprintf("%c", 65) affiche "A").

4.4 Structures de contrôle dans R

4.4.1 Structures alternatives
La première forme de la structure conditionnelle simple :
if ( p ) {
s
}

60
 où p est la condition et s la suite d’instructions à exécuter si la condition est satisfaite.

La deuxième forme de la structure conditionnelle simple :

if ( p ) {
s
} else {
t
}

Exemple 4.22. En reprenant l’exemple 2.12, nous avons l’implémentation suivante :

x <- as . numeric ( readline ( " Entrez le nombre reel : " ) )

if ( x >= 0) {
val_abs <- x
} else {
val_abs <- -x
}

cat ( " La valeur absolue de " , x , " est " , val_abs )

Le format de la structure alternative précédente peut être simplifié, en particulier lorsqu’il s’agit
d’effectuer une simple affectation. Le format général de cette simplification est le suivant :

x <- as . numeric ( readline ( " Entrez le nombre reel : " ) )

val_abs <- ifelse ( x >= 0 , x , -x )
cat ( " La valeur absolue de " , x , " est " , val_abs )
La structure alternative la plus générale de R a pour forme ce qui suit :

if ( p1 ) {
s1
} else if ( p2 ) {
s2
} else if ( p3 ) {
s3
}
[...]
else {
t
}

Exemple 4.23. On peut implémenter l’exemple 2.13 en R de la manière suivante.

age <- readline ( " Entrez l ’ age de l ’ enfant : " )

if ( as . integer ( age ) >= 12) {

cat ( " Categorie Cadet " )
} else if ( as . integer ( age ) >= 10) {

61
 cat ( " Categorie Minime " )
} else if ( as . integer ( age ) >= 8) {
cat ( " Categorie Pupille " )
} else if ( as . integer ( age ) >= 6) {
cat ( " Categorie Poussin " )
} else {
cat ( " Erreur " )
}
Les structures alternatives «Selon» sont conçues en R avec la fonction switch. Son format général
est le suivant :
switch ( expr ,
cas1 = p1 ,
cas1 = p1 ,
[...]
casn = pn
default = pDefaut )
La structure commence par évaluer l’expression expr. Si le résultat est une valeur numérique k,
alors la suite d’instructions tk est exécutée. En revanche, si le résultat de expr correspond à l’une des
chaînes de caractères cas1, cas2, ..., alors la suite d’instructions correspondante est exécutée.

Exemple 4.24. L’exemple 2.14 dans la Figure 12 montre une implémentation de cette structure en R.

62
Figure 12 – Une impémentation de l’exemple 2.14.

63
4.4.2 Structures itératives
En R, la boucle «Tant que» est implémenter de la manière suivante :
while ( p ) {
s
}
avec s une suite d’instructions et p le prédicat de contrôle de l’itération.

Exemple 4.25. L’exemple 2.16 peut être implémentée en Python de la manière suivante :

x <- 0
i <- 1

while ( x != 1524) {
cat ( " Entrez le nombre S . V . P .\ n " )
x <- as . integer ( readline () )
i <- i + 1
}

cat ( " Vous avez trouve le nombre .\ n " )

cat ( " Le nombre de vos tentatives est : " , i )
En R, la boucle «Jusqu’à (ce que)» a pour format générale de l’implémentation de cette boucle en
Python :
repeat {
if ( p ) {
break
}
s
}
avec s une suite d’instructions et p le prédicat de contrôle de l’itération.

Exemple 4.26. L’exemple 2.15 peut être implémentée en R de la manière suivante :

x <- 0
i <- 0
repeat {
cat ( " Entrez le nombre S . V . P .\ n " )
x <- as . integer ( readline () )
i <- i + 1
if ( x == 1524) {
break
}
}

cat ( " Vous avez trouve le nombre .\ n " )

cat ( " Le nombre de vos tentatives est : " , i , " \ n " )
Pour la boucle «Pour» en général, nous utilisons les formes suivantes :

64
for ( i in 1: n ) {
s
}
ou
for ( i in seq (1 , n , k ) ) {
s
}
si le pas d’incrémentation est différent de 1. Avec s une suite d’instructions à exécuter.

Exemple 4.27. En reprénant l’affichage des 3000 premiers multiples de 3 sans faire des multiplications.

# Declaration de la variable i
i <- 3

# Boucle pour afficher les multiples de 3

for ( i in seq (3 , 3004 , 3) ) {
print ( i )
}

5 Comparaison des structures algorithmiques de Python et R

Ci-après les tableaux comparatifs sur les structures algorithmiques de Python et R.

Table 8 – Comparaisons des types de données.

Type de données Python R

Entier int integer
Nombre réel float numeric
Chaîne de caractères str character
Booléen bool logical

Table 9 – Comparaisons des opérateurs arithmétiques.

Opérateur arithmétique Python R

Addition + +
Soustraction - -
Multiplication * *
Division (réelle) / /
Puissance ** ˆ
Modulo % %%
Division entière // %/%

65
 Table 10 – Comparaison des opérateurs de comparaison.

Opérateur de comparaison Python R

Égal à == ==
Différent de != !=
Supérieur à > >
Inférieur à < <
Supérieur ou égal à >= >=
Inférieur ou égal à <= <=

Table 11 – Comparaison des opérateurs logique.

Opérateur logique Python R

Négation not !
Conjonction (opérateur ET) and &&
Disjonction (opérateur OU) or ||
Disjonction exclusive ˆ xor()

Table 12 – Actions élémentaires.

Action élémentaire Python R

Affectation = <- ou -> ou =
Lecture x = input("msg") x <- readline("msg")
Ecriture print(x) ou x print(x) ou cat(x) ou x

Table 13 – Structures alternatives.

Pseudo-code Python R

Si p Alors if p : if ( p ) {
s. s s
Fin Si }

Si p Alors if p : if ( p ) {
s s s
Sinon else : } else {
t. t t
Fin Si }

66
 Table 14 – Structures répétitives.

Pseudo-code Python R

Répéter while not p : repeat {

s s if ( p ) {
Jusqu’à (ce que) p break
}
s
}

Tant que p while p : 1 while ( p ) {

s s 2 s
Fin Tant que 3 }

Table 15 – Structures répétitives (suite).

Pseudo-code Python R

Pour i ← 1 à n for i in range (1 , n +1) for ( i in 1: n ) {

s : s
Fin Pour s }

Pour i ← 1 à n pas k for i in range(1,n+1,k): for (i in seq(1,n,k)) {

s s s
Fin Pour }

67
6 Conclusion
L’objectif de cet papier était de présenter de manière simple les principales structures de données
primitives et les structures de contrôle en Python et R.

Python et R sont des langages de programmation qui fournissent des structures de données pri-
mitives, telles que les variables et les constantes, pour représenter des entiers, des booléens, des réels,
des caractères et des nombres complexes. Ces deux langages offrent la possibilité d’effectuer des opé-
rations mathématiques, des comparaisons et des opérations logiques sur ces types de données de base.
Néanmoins, il est important de souligner qu’il existe des distinctions significatives entre Python et R
dans la manière dont ils gèrent ces structures de données.

Python se distingue par sa syntaxe claire et lisible, qui facilite la manipulation des types de don-
nées primitifs. Il offre également des fonctionnalités avancées pour convertir et manipuler des chaînes
de caractères. En revanche, R est spécifiquement conçu pour l’analyse statistique et possède des fonc-
tionnalités plus puissantes pour travailler avec des vecteurs et des tableaux de données. R propose
des opérations vectorisées qui simplifient les calculs et les transformations sur les jeux de données.
De plus, en ce qui concerne les nombres complexes, Python et R prennent en charge les opérations
mathématiques sur ces nombres, mais R offre des fonctionnalités plus avancées pour les calculs et les
manipulations de nombres complexes grâce à sa prise en charge native de ce type de données.

Nous avons également couvert les structures de contrôle telles que les structures séquentielles, les
structures alternatives et les structures en boucle. Nous avons observé que Python et R utilisent des
structures de contrôle très similaires, mais la syntaxe de Python est plus lisible et moins verbeuse
que celle de R. En revanche, R privilégie une syntaxe adaptée au traitement de grandes quantités
de données. De plus, R propose des structures spécifiques telles que switch...case ou until, que
Python ne propose pas nativement, mais qui peuvent être facilement adaptées.

Dans notre prochain papier, nous présenterons des structures de contrôle avancées appelées sous-
algorithmes, qui structurent davantage le code et le rendent plus modulaire et réutilisable.

68
Références
Böhm, C. and Jacopini, G. (1966). Flow diagrams, turing machines and languages with only two
formation rules. Communications of the ACM, 9(5) :366–371.

Cormen, T. H., Leiserson, C. E., Rivest, R. L., and Stein, C. (2022). Introduction to Algorithms. MIT
Press and McGraw-Hill, 4th edition.

Darmangeat, C. (2008). Algorithme et Programmation pour les non-matheux. Cours complet avec
exercices, corrigés et citations philosophiques. Université Paris 7.

Dijkstra, E. W. (1968a). A Case against the GO TO Statement. (EWD 215).

Dijkstra, E. W. (1968b). Go To Statement is Hamful. Communications of the ACM, 11(3) :147–148.

Goodrich, M. T., Tamassia, I. R., and Goldwasser, M. H. (2013). Data Structures and Algorithms in
Python. John Wiley & Sons, New York.

Goulet, V. (2016). Introduction à la programmation R. CRAN.

Goulet, V. (2023). Programmer avec R. CRAN.

Prakash, Dr. PKS and Rao, Achyutuni Sri Krishna (2016). R Data Structures and Algorithms. Packt
Publishing, Birmingham.

Ramshaw, L. (1988). Eliminating go to’s while preserving program structure. Journal of the ACM,,
35(4) :893–920.

Ritchie, D. M. and Kernighan, B. W. (1978). The C programming language. Bell Laboratories.

Sedgewick, R. and Wayne, K. (2011). Algorithms. Princeton University Press, Princeton, 4th edition.

Swinnen, G. (2012). Apprendre à programmer avec Python 3. Eyrolles, Paris.

Venables, W. N., Smith, D. M., and R Core Team (2023). An Introduction to R, Notes on R : A
Programming Environment for Data Analysis and Graphics. Version 4.3.0.

Wirth, N. (1987). Algorithmes et structures de données. Eyrolles, Paris, 2 edition.

69