Plan du site  
français  English
pixel
pixel

Articles - Étudiants SUPINFO

Chapitre 01 - Premiers pas

Généralités sur l'algorithmique et la programmation

Nous allons dans cette partie définir et distinguer les notions d'algorithme et de programme, avant de justifier pourquoi avoir choisi le langage Python pour ce cours.

Autour de la notion d'algorithme

Définition du concept

Un algorithme est une suite d’instructions permettant la résolution d’un problème en un nombre fini d’étapes. À partir de données, les entrées de l’algorithme, on va donc parvenir à un résultat, la sortie.

Il est important de noter que les instructions d’un algorithme doivent être indépendantes des données sur lesquelles il va s’appliquer. En effet on ne cherche pas à résoudre des cas particuliers mais un cas général.

Commençons par un exemple n'appartenant ni aux mathématiques ni à l'informatique, les deux disciplines dans lesquelles on rencontre le plus d'algorithmes, mais ceci dit très parlant : une recette de cuisine.

Considérons le problème suivant : comment faire une pâte à crêpes ?

En voici la résolution :

  1. Casser trois œufs dans 250 grammes de farine.

  2. Mélanger.

  3. Diluer avec ½ litre de lait.

  4. Ajouter une cuillère à soupe d’huile.

Cette recette est bien une suite d'instructions indépendantes des données, car le fait que ces dernières proviennent de la ferme du coin ou du supermarché ne change rien. Il s'agit donc bien d'un algorithme résolvant notre problème. Que le lecteur se rassure on donnera des exemples plus sophistiqués par la suite.

Pour l'instant, et sans s'attarder trop longuement, on va évoquer l'origine de ce concept à travers un peu d'étymologie. Le mot algorithme vient du nom du mathématicien perse Abu Abdullah Muhammad ibn Musa al-Khwarizmi (9 ème siècle après Jésus Christ). Son nom a ensuite été latinisé au Moyen Age en algoritmi. Cependant, origine du mot algorithme ne veut pas dire origine du principe. On écrivait des algorithmes dès l’antiquité comme nous allons le voir maintenant sur des exemples historiques.

Algorithme de calculs d’intérêts (1800 avant J.-C.)

Le problème est de trouver en combien d’années on double un montant soumis à un certain taux t annuel.

La résolution est la suivante :

  1. Initialiser le taux t à la valeur voulue, une grandeur a à 0 destinée à décompter les années, et une grandeur b à 1, qui mesurera l'évolution de notre montant.

  2. Tant que b < 2 , remplacer b par b × ( 1 + t ) et ajouter 1 à a.

  3. La valeur finale de a est le nombre d’années cherché.

On comprend vite que la valeur du montant à doubler n'importe pas, c'est pourquoi on a choisi de poser initialement b = 1 .

Voici le déroulé pas à pas de cet algorithme avec un taux t de 20 % :

a b
0 1
1 1,2
2 1,44
3 1,728
4 2,0736

Avec un tel taux il faut donc 4 années.

Figure 1.1. Une photo du manuscrit contenant cet algorithme

Une photo du manuscrit contenant cet algorithme

Algorithme de multiplication égyptienne (1650 avant J.-C.)

Le problème est très simple : multiplier deux entiers a et b.

En voici sa résolution :

  1. Décomposer a comme somme de puissances de 2.

  2. Calculer les puissances de 2, 4, 8, etc. de b.

  3. Additionner les puissances de b qui correspondent aux puissances de 2 trouvées dans a.

Voici le déroulé pas à pas de cet algorithme avec a = 25 et b = 14 , la première colonne de ce tableau renseignant les puissances de 2 utiles au calcul :

2 n a b
1 1 14
2 0 28
4 0 56
8 1 112
16 1 224

La valeur de a × b est alors égale à 14 + 112 + 224 , i.e. 350.

[Note]

La décomposition de a comme somme de puissances de 2 n'est ni plus ni moins que son écriture sous forme binaire. Voir cours 1CPA.

L'intérêt de cet algorithme est qu'il permet la multiplication de deux nombres en utilisant juste des divisions et multiplications par 2, ainsi que des additions.

Figure 1.2. Une photo du manuscrit décrivant l'algorithme de multiplication égyptienne

Une photo du manuscrit décrivant l'algorithme de multiplication égyptienne

Algorithme d’Euclide (300 avant J.-C.)

Notre dernier exemple historique sera l'algorithme d'Euclide, bien connu de tous puisqu'il est enseigné au collège. Le problème est de calculer le PGCD de deux entiers a et b.

Sa résolution est la suivante :

  1. Si b est non nul, diviser a par b. On note r le reste de cette division euclidienne.

  2. Remplacer a par b et b par r.

  3. Recommencer tant que cela est possible à partir de l’étape 1.

  4. Le PGCD est alors la dernière valeur non nulle de r.

Voici le déroulé pas à pas de cet algorithme avec a = 142 et b = 38 :

a b r
142 38 28
38 28 10
28 10 8
10 8 2
8 2 0

La valeur du PGCD de a et b est alors égale à 2.

[Note]

Il est à noter que cet algorithme est toujours utilisé de nos jours. Voir le cours d'arithmétique et cryptographie 1ARI à ce sujet.

Figure 1.3. Une photo du manuscrit décrivant l'algorithme d'Euclide

Une photo du manuscrit décrivant l'algorithme d'Euclide

De l’algorithme au programme

En informatique, les instructions d’un algorithme seront bien sûr à destination d’un ordinateur. Pour qu’elles soient compréhensibles par ce dernier, elles doivent évidemment être écrites dans ce que l’on appelle un langage de programmation. Celui-ci sera lui même traduit par un compilateur en langage machine ou exécuté par un interpréteur.

[Note]

Le langage machine est le langage utilisé par le processeur.

L’auteur assume toutes les simplifications de cette partie.

Avant l’étape d’écriture du programme, on peut/doit concevoir l’algorithme en lui même de façon non formelle, en version papier.

L’algorithme contient la réflexion, l’abstraction du programme. Ce dernier n'apparaît alors que comme une sorte de traduction de l'algorithme dans un langage compréhensible par la machine. A noter que cette phase de traduction n'est pas toujours si simple que cela, des contraintes techniques inhérentes au langage pouvant apporter des difficultés.

[Note]

En Python nous n’aurons pas trop de contraintes techniques, c’est d’ailleurs une des raisons principales pour laquelle on va apprendre à programmer avec ce langage. Ça sera beaucoup moins vrai en C par exemple.

Nous n’adopterons pas dans ce cours de syntaxe formalisée des algorithmes, chacun les rédigera pour lui-même dans l’unique but de structurer ses idées.

On peut même tout à fait imaginer faire des schémas en guise d’algorithme :

Example 1.1. Une première "traduction" d'algorithme en programme

L’algorithme de calculs d’intérêts de la sous-partie précédente et de l'organigramme ci-dessus deviendra le programme suivant en Python :

t = 0.2
a, b = 0, 1
while b < 2:
    b = b*(1+t)
    a = a + 1
print("Nombre d'années cherché :",a)
Nombre d'années cherché : 4

[Note]

Même sans avoir encore étudié la syntaxe du Python, on ne peut que constater qu'un tel programme est tout à fait compréhensible.

Que le lecteur exigeant se rassure, on fera des choses beaucoup plus élaborées.

Pourquoi le choix du Python pour apprendre à programmer ?

On va ici donner toute une liste de raisons pour lesquelles on a choisi le langage Python dans ce cours d'apprentissage de la programmation :

  • Il possède une syntaxe simple. On peut donc se concentrer sur la logique algorithmique.

  • Le mode “console” permet de tester des portions de codes immédiatement.

  • C’est un langage interprété, c’est-à-dire que les instructions des programmes seront exécutées au fur et à mesure. Par opposition à un langage compilé où le programme est d’abord traduit dans sa totalité en langage machine avant d’être exécuté. Ainsi même si une erreur est présente dans le code, le programme pourra s'exécuter jusqu'à celle-ci. C'est donc moins frustrant pour le débutant qu'un langage compilé, où toute erreur, même minime, interdira la compilation et donc l'exécution.

  • C’est un langage de haut niveau, on ne souciera pas de la gestion des ressources mémoires.

  • Python possède des structures de données évoluées, listes, ensembles, dictionnaires, etc.

  • Python est de plus en plus populaire et possède de nombreuses ressources bibliographiques.

  • Enfin, c’est un langage open source.

[Note]

Toutes ces caractéristiques vont prendre progressivement leur sens au fil de ce cours.

Quelle version de Python ?

Il y a principalement deux “branches” différentes de Python : 2.x et 3.x. Même si elles sont assez semblables dans l’esprit, on peut noter d’importantes différences de syntaxes, fonctionnalités, etc. Ce cours est basé sur la branche 3.x, et plus particulièrement sur la version 3.4.

[Note]

On n'utilisera pas la version 3.5 pour la simple raison que le module graphique Pygame présenté dans le huitième chapitre de ce cours n'est pas encore disponible dessus.

Prise en main de l'environnement de développement

On va présenter ici deux environnements gratuits pour développer en Python.

Téléchargement de IDLE et Pycharm

IDLE

L'environnement IDLE est développé par la Python Software Foundation. On le télécharge ici. Comme mentionné précédemment, pour suivre l'intégralité de ce cours dans de bonnes conditions on optera pour la version 3.4.

Il est disponible pour les systèmes Windows, Mac et Linux.

[Note]

Les utilisateurs d'ordinateurs Apple ont la version 2.7 livrée par défaut avec Mac OS X. Ce n’est pas celle que l’on utilisera, ils devront donc eux aussi suivre cette procédure.

Selon les distributions Linux, on aura dans les paquets une version 2 et/ou une version 3. Il faudra donc s'assurer de disposer de la "bonne".

Pycharm Community Edition

L'éditeur de logiciels JetBrains propose lui aussi un environnement de développement. Il s'appelle PyCharm et on peut en télécharger une version communautaire gratuite ici.

Il est lui aussi disponible pour les trois principaux systèmes d'exploitation.

[Note]

Les étudiants de SUPINFO International University disposent en plus d'une licence pour la version professionnelle de Pycharm, leur permettant d'utiliser librement cet outil a priori payant.

Pour utiliser Pycharm, il est nécessaire d'avoir au préalable téléchargé un interpréteur Python à cette adresse.

Cet environnement de développement comporte de nombreuses fonctionnalités en plus par rapport à IDLE, mais a la contrepartie d’être plus lourd. Le débutant pourra donc commencer avec IDLE et basculer vers Pycharm dès que ses projets deviendront conséquents.

Utilisation de la console

Le premier mode d’utilisation de Python est un mode interactif, style calculatrice. Il permet d’exécuter du code à la volée, sans avoir à l'enregistrer. L’intérêt étant de pouvoir tester facilement des petites portions de code, de vérifier la justesse d’une syntaxe, ou même de réaliser des calculs.

Console d'IDLE

Pour l'ouvrir il suffit juste de lancer IDLE. On peut alors saisir nos commandes.

Figure 1.4. La console d'IDLE

La console d'IDLE

Console de Pycharm

Une fois Pycharm ouvert, on accède à la console via le menu "tools", option "Run Python Console", ou à l'aide du raccourci en bas à gauche de la fenêtre.

Figure 1.5. La console de Pycharm

La console de Pycharm

Représentation de la console dans ce cours

Afin de laisser au lecteur la possibilité de copier/coller les codes proposés dans ce cours, et de les tester par lui-même, nous ne présenterons pas les futurs exemples via des captures d'écran. Les commandes saisies dans la console apparaîtons comme cela :

>>> 66*10 + 6
666

Ecriture de scripts

Le mode console ne permet pas de sauvegarder des programmes. On va pour cela écrire des scripts.

Un script en Python est tout simplement un ensemble de commandes qui seront interprétées les unes à la suite des autres, et qui seront mémorisées dans un fichier d'extension ".py".

Pour écrire un script on pourrait se contenter d'un simple éditeur de texte, mais on préfèrera utiliser un environnement de développement afin de bénéficier de fonctionnalités supplémentaires : coloration syntaxique, auto-complétion, etc.

Avec IDLE

Pour écrire un nouveau script on choisit "New File" dans le menu "File". Une fois celui-ci fini, pour l'exécuter on sélectionne "Run Module" dans le menu "Run" ou alors on utilise le raccourci clavier "F5". Le résultat du script apparaît alors dans la console.

Figure 1.6. Ecriture et exécution d'un script avec IDLE

Ecriture et exécution d'un script avec IDLE

Avec Pycharm

On commence par créer un projet via "File", "New Project", puis un script via "File", "New", "Python File". On l'exécute ensuite en choississant "Run" dans le menu "Run".

Figure 1.7. Ecriture et exécution d'un script avec Pycharm

Ecriture et exécution d'un script avec Pycharm

Représentation d'un script dans ce cours

Les futurs exemples de scripts de ce cours auront cette apparence :

print(66*10 + 6)

Et le résultat de leurs exécutions dans une console ressemblera à :

666

Notion de variable

Après quelques généralités sur le concept de variable, on étudiera dans cette partie les spécificités du Python à ce sujet.

Variables

Un algorithme ou un programme manipulent des données. Certaines sont connues dès le départ, d’autres sont calculées lors de son exécution. Pour pouvoir manipuler ces données il faut garder leurs valeurs en mémoire. C’est le rôle des variables.

Une variable est un nom désignant une donnée (nombre, texte…) susceptible de changer de valeur.

Une variable possède un type, ce qui permet à l’ordinateur de savoir quelles valeurs elle peut prendre et quelles opérations on peut effectuer avec.

Les types de variables en Python

Voici la liste des différents types élémentaires en Python et les valeurs possibles correspondantes :

Types Valeurs
int nombres entiers relatifs
float nombres décimaux
complex nombres complexes
bool booléens : True ou False
str chaînes de caractères
[Note]

Deux d’entre eux ne sont pas si élémentaires que ça, complex et str, puisqu’ils contiennent en fait nécessairement plusieurs valeurs. Deux nombres décimaux pour le premier et une succession de caractères pour le second.

Spécificités du Python quand à sa gestion des variables

Python est un langage à typage dynamique. Cela signifie qu'avant d’utiliser une variable on n’a pas besoin de déclarer explicitement son type, c’est l’interpréteur qui s’en charge. Cela sera fait automatiquement dès que l’on attribuera une valeur à notre variable.

Python est également un langage à typage fort. Cela veut dire que les opérations possibles sur une variable dépendent intégralement de son type. Les conversions de types implicites afin de réaliser certaines opérations sont donc interdites. On ne pourra donc pas additionner une chaînes de caractères avec un nombre pour espérer produire un nombre. Ni concaténer une chaîne avec un nombre pour obtenir une chaîne.

On explicitera très bientôt ces deux points via des exemples.

Affectation de variables

Voici la syntaxe d'une affectation simple, i.e. une affectation ne concernant qu'une seule variable :

maVariable = valeur
[Note]

On essaiera de respecter la convention classique qui stipule que le nom des variables doit être en lowerCamelCase.

Et voici pour une affectation multiple, i.e. une affectation concernant plusieurs variables simultanément :

var1, var2, ... = val1, val2, ...
[Note]

L’affectation multiple est loin d’être courante dans les autres langages de programmation.

Comme mentionné précédemment, lorsque l’on veut utiliser une variable il n’y a donc pas besoin de déclarer son type. C’est lors de son initialisation que ce typage s’effectue.

[Note]

Ce que l’on appelle initialisation en programmation, c’est le fait d’assigner pour la première fois une valeur à une variable.

On peut toujours vérifier le type d’une variable avec l’instruction type :

type(maVariable)

Example 1.2. Quelques premières affections

On initialise ici plusieurs variables et on constate quel est leur type :

>>> i = 4
>>> type(i)
<class 'int'>
>>> x, z = -5.3, 1+1j
>>> z
(1+1j)
>>> type(z)
<class 'complex'>
>>> type(x)
<class 'float'>
>>> texte = 'Street fighting man'
>>> type(texte)
<class 'str'>
>>> texte
'Street fighting man'
>>> '666' + 111
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    '666' + 111
TypeError: Can't convert 'int' object to str implicitly

La dernière opération montre le typage fort du Python.


[Note]

On remarque que les chaînes de caractères sont délimitées avec des ' '. Ou avec des " ".

Conversions de types

On a vu que les conversions implicites de types ne s'effectuaient pas. Par contre, le programmeur pourra de lui même dans certains cas forcer la conversion d'un type à un autre.

Voici la liste des opérations permettant cela :

Opération Contrainte/Résultat
int(x) x est un décimal (qui sera tronqué) ou une chaîne
int(x,base) x est une chaîne et base un entier
float(x) x est un entier ou une chaîne
complex(x,y) x et y sont des nombres ou x est une chaîne
bool(x) x est un nombre ou un booléen. Le résultat vaut False uniquement si x vaut 0 ou ' '
str(x) x est un nombre ou un booléen
eval(x) x est une chaîne qui est évaluée comme une expression Python
[Note]

Ces opérations ne modifient nullement les paramètres x et y auxquelles elles s’appliquent.

Voir le cours 1CPA pour des généralités sur les bases de numération.

Example 1.3. Quelques conversions de types

A noter en particulier le fonctionnement de la commande eval :

>>> x = 666.6
>>> y = int(x)
>>> y
666
>>> eval('y+111')
777
>>> int('10101',2)
21
>>> str(y)
'666'

La chaîne de caractères 'y+111' a été évaluée, c'est-à-dire qu'une addition a été effectuée entre la valeur de la variable y, i.e. 666, et l'entier 111.


Affichage et saisie

En mode console on peut afficher le contenu d’une variable en tapant juste son nom (voir exemples précédents). Pour réaliser un affichage sur la console à partir d’un script, et/ou pour réaliser des affichages plus sophistiqués, on aura besoin de l’instruction print.

En voici sa syntaxe :

print(expr_1,expr_2,...,sep=' ',end='\n')

Les différentes expressions (en nombre variable) sont soit des chaînes, soit des résultats de calculs convertis en chaînes, soit des variables dont on souhaite afficher la valeur.

Cette instruction comporte deux paramètres dont voici la signification :

  • sep indique ce qui va séparer les différentes expressions, par défaut il s’agit d’un espace.

  • end indique ce qui sera affiché après toutes les expressions, par défaut il s’agit d’un retour à ligne.

[Note]

"Par défaut" signifie que si l’on ne mentionne rien, ce sont ces valeurs qui seront utilisées.

Example 1.4. Manipulations de la fonction "print"

On réalise ici quelques affichages pour tester en particulier le fonctionnement de sep et end :

age = 30
print("J'ai",age,"ans et dans deux ans j'aurais",age+2,"ans")
print("des","traits","bas","pour","séparer",sep='_')
print("et","des","plus","à","la","suite",sep='_',end='+++ ')
print("et la fin")
J'ai 30 ans et dans deux ans j'aurais 32 ans
des_traits_bas_pour_séparer
et_des_plus_à_la_suite+++ et la fin

Pour mettre en forme nos affichages, on utilisera régulièrement les caractères '\t' et '\n' qui produisent respectivement une tabulation et un retour à la ligne.

Example 1.5. Utilisations de '\t' et '\n'

>>> print("The \tRolling Stones")
The 	Rolling Stones
>>> print("The Rolling\nStones")
The Rolling
Stones

Pour faire saisir une donnée à l'utilisateur on se servira de l'instruction "input" dont voici la syntaxe générale :

var = input(expression)

Le paramètre “expression” est facultatif, il sert juste à réaliser un affichage sur la ligne de la saisie.

Ce que va saisir l’utilisateur sera affecté sous forme de chaîne de caractère à la variable “var”. Si l’on veut conserver le côté numérique d’une saisie, il faudra utiliser la fonction eval dont nous avons déjà parlé.

Example 1.6. Manipulations de la fonction "input"

Une même saisie avec et sans l'utilisation de eval :

>>> a = input()
>? 12
>>> print(a,type(a))
12 <class 'str'>
>>> b = eval(input("saisir un nombre : "))
saisir un nombre : >? 12
>>> print(b,type(b))
12 <class 'int'>

Opérations sur les variables

Nous allons évoquer maintenant les opérations possibles sur les nombres (entiers ou décimaux) ainsi que sur les chaînes de caractères. Les opérations sur les variables booléennes seront quand à elle étudiées lors du prochain chapitre. Nous n’aborderons pas les opérations sur les nombres complexes dans ce cours.

Opérations arithmétiques

Voici la liste des principales opérations arithmétiques en Python :

Opération Résultat
x + y Addition de x et y
x - y Soustraction de y à x
x * y Multiplication de x et y
x ** y Élévation de x à la puissance y
x / y Quotient réel de x par y
x // y Quotient entier de x par y
x % y Reste du quotient entier de x par y

Donnons quelques précisions sur ces opérations :

  • Si les deux opérandes des opérations +, -, *, ** sont entiers (resp. réels) le résultat est entier (resp. réel).

  • Si un des deux opérandes est réel, le résultat est réel.

  • Le résultat de l’opération / est toujours un réel.

  • Si les deux opérandes sont des entiers, le résultat de l’opération // est le quotient de la division euclidienne et le résultat de l’opération % le reste.

  • Si l’un des deux opérandes est un réel, le résultat de l’opération // est la partie entière du quotient de la division réelle.

[Note]

On a donc toujours x = (x // y) * y + (x % y).

Example 1.7. Quelques calculs

>>> -3 + 5
2
>>> 3 * 5
15
>>> 5 ** 2
25
>>> 13 / 4
3.25
>>> 13 // 4
3
>>> 13 % 4
1
>>> 13 // 4.6
2.0
>>> 13 % 4.6
3.8000000000000007

Les opérations précédentes possèdent une version avec affectation, qui non seulement va réaliser le calcul demandé mais va également modifier l'opérande de gauche.

Opération Résultat
x += y x = x + y
x -= y x = x - y
x *= y x = x * y
x **= y x = x ** y
x /= y x = x / y
x //= y x = x // y
x %= y x = x % y
[Note]

Ce n'est certes pas très puissant conceptuellement mais assez utile en pratique.

Example 1.8. Quelques calculs avec affectations

>>> x = 25
>>> y = 0.5
>>> x **= y
>>> print(x)
5.0
>>> y += 1
>>> print(y)
1.5

Pour effectuer des calculs mathématiques plus élaborés, on pourra utiliser un module de fonctions complémentaires appelé math.

Avant de l’utiliser, il convient de l’importer :

from math import *
[Note]

On reviendra plus en détail dans le troisième chapitre de ce cours sur ces imports de modules.

Le lecteur trouvera la liste des fonctions de ce module ici. A noter qu'il existe également un module cmath, voir , contenant des fonctions agissant sur les nombres complexes.

Example 1.9. Quelques fonctions du module "math"

>>> from math import *
>>> exp(1)
2.718281828459045
>>> pi
3.141592653589793
>>> cos(pi/2)
6.123233995736766e-17

Opérations sur les chaînes

En Python, une chaîne de caractères est considérée comme une suite de caractères. Cela signifie entre autres que l’on pourra avoir accès à n’importe lequel de ces caractères via sa position dans la chaîne.

Particularité importante, une variable dont le type est str est en fait une constante. Elle ne pourra donc pas être modifiée.

[Note]

Ces points seront communs à beaucoup de langages de programmation.

Figure 1.8. Visualisation d'une chaîne de caractères

Visualisation d'une chaîne de caractères

[Note]

Comme dans quasiment tous les langages de programmations ces indices commencent à 0. La particularité du Python est que l’on peut accéder aux caractères avec des indices négatifs, en partant de la fin de la chaîne.

Comme mentionné précédemment, on peut accéder aux caractères via leur position. Pour cela on renseignera cette position entre crochets [ ] :

Opération Résultat
s[i] i-ème caractère de s
s[i:j] Sous-chaîne de s constituée des caractères entre le i-ème (inclus) et le j-ème (exclus)
s[i:j:k] Sous-chaîne de s constituée des caractères entre le i-ème (inclus) et le j-ème (exclus) pris avec un pas de k
[Note]

Cette technique permettant d'accéder à une sous-chaîne et pas seulement à un caractère est propre au Python et est appelée slicing.

Voici quelques compléments d'informations sur ces opérations :

  • Les deux dernières opérations peuvent renvoyer une chaîne vide.

  • La première utilisée avec un indice incorrect (typiquement trop grand) retourne une erreur. Pour éviter ce genre de problème on va bientôt présenter une fonction calculant le nombre de caractères d’une chaîne. On pourra donc toujours vérifier la validité de nos indices.

  • Si l’on omet le premier argument dans l’une des deux opérations de slicing, il vaut par défaut 0, et si l’on omet le second il vaut par défaut le nombre de caractères de la chaîne.

Example 1.10. Opérations de slicing sur une chaîne

>>> s = 'street'
>>> print(s[0],s[-1])
s t
>>> s[2:]
'reet'
>>> s[1:4]
'tre'
>>> s[2] = 'z'
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    s[2] = 'z'
TypeError: 'str' object does not support item assignment

L’erreur provient du fait que l’on essaie de modifier une chaîne alors que les chaînes sont des constantes.


Une question importante à se poser est celle de l'encodage des caractères. En Python 3, il se fait suivant la norme UTF-8. Les caractères sont donc codés sur une séquence de 1 à 4 octets.

[Note]

Voir le cours d’architecture des ordinateurs 1CPA, pour des précisions sur cette norme.

Le nombre entier correspondant à cette séquence d’octets est appelé unicode. La fonction ord permet de récupérer le code d’un caractère, tandis que la fonction chr fait l’opération inverse.

Figure 1.9. Les codes des 128 premiers caractères

Les codes des 128 premiers caractères

Example 1.11. Utilisations des fonctions "ord" et "chr"

>>> ord('α')
945
>>> chr(916)
'Δ’
>>> chr(1046)
'Ж'

[Note]

Ces deux fonctions nous seront bien utiles dans le cours d'arithmétique et cryptographie 1ARI, lorsque nous implémenterons des algorithmes cryptographiques.

Il existe nativement en Python un certain nombre de fonctions facilitant le traitement des chaînes de caractères. En voici les principales :

Opération Résultat
x in s Teste si x appartient à s
x not in s Teste si x n’appartient pas à s
s + t Concaténation de s et t
s * n ou n * s Concaténation de n copies de s
len(s) Nombre de caractères de s
min(s) Plus petit caractère de s
max(s) Plus grand caractère de s
s.count(x) Nombre d’occurences de x dans s
s.index(x) Indice de x dans s
[Note]

On reviendra sur la signification de la syntaxe des opérations count et index dans le cours de programmation orientée objet en Python 2OOP.

Voici quelques compléments d'informations sur ces opérations :

  • Les opérations min et max fonctionnent bien sûr avec les numéros unicode des caractères.

  • Si l’élément x n’est pas dans la chaîne s, s.index(x) retourne une erreur. S’il y est plusieurs fois s.index(x) retournera la position de sa première occurence.

  • A noter que pour toutes ces opérations x n’est pas nécessairement un caractère mais peut être également une chaîne.

Example 1.12. Quelques manipulations de chaînes

>>> texte = "street"
>>> 'z' not in texte
True
>>> len(texte)
6
>>> 3*texte
'streetstreetstreet'
>>> texte.count('e')
2
>>> max(texte)
't'

Pour terminer cette partie et ce chapitre, présentons maintenant des opérations permettant de convertir une chaîne de caractères en majuscules ou en minuscules :

Opération Résultat
s.lower() Convertit la chaîne de caractères s en minuscules
s.upper() Convertit la chaîne de caractères s en majuscules
[Note]

Ces opérations ne modifient pas la chaîne sur laquelle on les applique. Elles retournent une nouvelle chaîne. Si on veut modifier notre chaîne, on doit effectuer une nouvelle affectation, i.e. faire plus ou moins cela : s = s.lower().

Les caractères non alphabétiques ne sont pas convertis.

L'alphabet latin n'est pas le seul pris en compte, les alphabets grecs, chinois etc. le sont également.

Example 1.13. Conversions minuscule/majuscule

Le texte de cet exemple est d'abord converti en majuscules puis en minuscules, mais il n'est pas modifié en soi :

>>> texte = "The Rolling Stones"
>>> texte.upper()
'THE ROLLING STONES'
>>> texte.lower()
'the rolling stones’
>>> texte
'The Rolling Stones'
>>> chr(916).lower()
'δ'

La dernière ligne de commande montre une conversion dans l'alphabet grec.


A propos de SUPINFO | Contacts & adresses | Enseigner à SUPINFO | Presse | Conditions d'utilisation & Copyright | Respect de la vie privée | Investir
Logo de la société Cisco, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société IBM, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Sun-Oracle, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Apple, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Sybase, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Novell, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Intel, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Accenture, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société SAP, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Prometric, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo du IT Academy Program par Microsoft, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management

SUPINFO International University
Ecole d'Informatique - IT School
École Supérieure d'Informatique de Paris, leader en France
La Grande Ecole de l'informatique, du numérique et du management
Fondée en 1965, reconnue par l'État. Titre Bac+5 certifié au niveau I.
SUPINFO International University is globally operated by EDUCINVEST Belgium - Avenue Louise, 534 - 1050 Brussels