Séance 1: Introduction - Cours d'informatique de BCPST Première année - Jimdo
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
Séance 1: Introduction
Cours d’informatique de BCPST Première année.Table des matières
1 Quelques notions d’architecture des ordinateurs 2
1.1 Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1 Modéle de Von Neumann . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.2 Le processeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.3 La mémoire principale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.4 Les bus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.1 Langages de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.2 Système d’exploitation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2 Initiation à Python 4
2.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3 Environnement Pyzo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3 Types de données 5
3.1 Les nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.1.1 Les entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.1.2 Les décimaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.1.3 Les complexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.1.4 Quelques fonctions mathématiques supplémentaires . . . . . . . . . . . . . . . 8
3.2 Les booléens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.3 Les chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.3.1 Premières opérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.3.2 Accès aux caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.3.3 Quelques méthodes pratiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.3.4 Les méthodes lower et upper . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.3.5 D’autres méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13Séance 1: Introduction
1. Quelques notions d’architecture des ordinateurs
1.1 Hardware
• Modéle de Von Neumann
Un ordinateur peut être décrit comme une machine de traitement de l’information : il est capable de
faire les quatre tâches suivantes :
1. Acquérir de l’information.
Cela se fait par l’intermédiaire de périphériques d’entrées que sont le clavier, la souris, le scanner
...
2. Stocker de l’information.
On fait ceci avec la mémoire de masse (disque dur, clé USB, etc.) destinée à un stockage
persistant même en absence d’alimentation électrique, de la mémoire vive (la RAM) utilisée par
le processeur pour traiter les données.
3. Transformer l’information.
C’est le rôle du processeur (le CPU).
4. Restituer l’information.
On dispose pour cela de l’écran, l’imprimante, les enceintes...
Un ordinateur est composé de beaucoup de composants (carte réseau, disque dur, mémoire...) mais,
pour calculer, trois entités suffisent :
• Le processeur qui effectue des calculs sur des nombres, c’est le "cerveau" de l’ordinateur ;
• La mémoire qui stocke ces nombres dans la mémoire ;
• Les bus qui assurent le déplacement des données entre le processeur et la mémoire.
Voici la représentation symbolique la plus classique, c’est le modéle de Von Neumann :
Détaillons le rôle des différents composants :
• Le processeur
Le processeur exécute les suites d’instructions élémentaires des programmes. Ces instructions corres-
pondent à des actions très simples (additionner deux nombres, lire ou écrire dans une case mémoire, .
Institut d’Alzon 2019/2020 page 2Séance 1: Introduction
. .), elles sont cadencées par une horloge qui assure que tous les composants agissent en même temps.
Le nombre de calculs par seconde est nommé la fréquence du processeur. Un processeur de 3 GHz
effectue par exemple 3 milliard de calculs par seconde.
Le processeur est composé de deux éléments :
1. L’unité de commande : elle est responsable de la lecture en mémoire et du décodage des
instructions.
2. L’unité de traitement : l’UAL (unité arithmétique et logique) exécute les instructions.
• La mémoire principale
Bien que les informations traitées par un ordinateur soient de différents types (texte, image, son. . .),
elles sont toujours représentées et manipulées par l’ordinateur sous forme binaire, soit une suite de
0 et de 1 (qu’on appelle bit pour binary digit, chiffre binaire en anglais). Ces 0 et 1 proviennent des
milliards de transistors qui composent le processeur, chacun n’a que deux états de tension de sortie : 0
volt ou bien 5 volts.
La mémoire principale d’un ordinateur est divisée en emplacements de taille fixe, en général 8 bits,
soit un octet. Chaque emplacement est repéré par un numéro qu’on appelle son adresse. Actuellement,
les adresses sont codées sur 32 ou 64 bits, ce qui autorise au maximum 232 ou 264 adresses différentes,
un processeur 32 bits ne peut donc en théorie gérer plus de 4 Go de mémoire vive (Ceci explique la
généralisation actuelle des processeurs 64 bits pour accompagner l’augmentation de la mémoire vive
associée à un ordinateur).
• Les bus
La circulation de l’information entre ces différents éléments est assurée par des connexions appelées
bus (bus de données et bus d’adresse) ; il s’agit tout simplement de fils conducteurs utilisés pour
transmettre des signaux binaires.
1.2 Software
• Langages de programmation
Un programme informatique n’est qu’une suite d’instructions, autrement dit un certain nombre de
mots mémoire écrits en binaire. L’ensemble de ces instructions s’appelle le langage machine. Le langage
machine n’est ainsi pas compréhensible par l’être humain (mis à part quelques informaticiens !), c’est
pourquoi a été inventé l’assembleur, un langage proche du langage machine mais un peu plus lisible.
Voici un exemple de programme en assembleur :
loadn 2 R1 # place le nombre 2 dans le registre R1
storer R1 R2 # copie le contenue de R1 dans R2
add R0 R2 # place le résultat de l'addition de R0 et de R2 dans R2
store R1 1 # place le contenu de R1 à l'adresse mémoire @1
Ceci se code avec une centaine d’octets. Coder en assembleur est donc plus rapide mais manipuler les
données et les placer octet par octet dans la mémoire ou dans les registres est bien trop long. De plus,
ce langage a un énorme défaut, il n’est pas portable (car chaque processeur possède des noms et des
numéros d’instructions différents) !
Les langages de haut niveau ont été inventés pour palier à ces deux inconvénients. Le code écrit
dans ce type de langage est proche du langage humain, il est ensuite compilé en assembleur puis
transformé en langage machine pour être exploitable par le processeur. Ces langages sont nombreux
(C, Java, JavaScript, Python, PHP, Perl...) car chacun va être adapté à un usage spécifique. Par exemple,
Institut d’Alzon 2019/2020 page 3Séance 1: Introduction le langage choisi pour ce cours est le Python, particulièrement bien adapté au calcul scientifique : on peut effectuer en une ligne un calcul numérique qui demanderait plusieurs centaine le lignes en assembleur. • Système d’exploitation Le système d’exploitation est un programme chargé en mémoire vive dès le démarrage de l’ordinateur et qui reste en mémoire jusqu’à son extinction. Il gère le lancement des applications, identifie les utilisateurs, organise le disque dur, contrôle les accès aux ressources de l’ordinateur, isole les programmes des détails du matériel. Un système d’exploitation sait comment fonctionne le disque dur ou comment marche une carte graphique : ainsi, quand un logiciel veut afficher une image, il va demander au système d’exploitation de le faire. C’est le système d’exploitation qui doit connaître les détails du matériel (dans ce cas le type de carte graphique et les instructions qu’elle comprend) et c’est le seul programme à pouvoir autoriser un logiciel à écrire sur le disque dur ou à accéder à la mémoire ou au processeur. Le système d’exploitation est donc l’intermédiaire entre les logiciels, l’utilisateur et le matériel. Cette répartition des rôles simplifie grandement l’écriture des programmes d’application, Actuelle- ment, les systèmes d’exploitation les plus connus appartiennent à l’une des trois familles suivantes : la famille MAC (Mac OS X), la famille Linux et la famille Windows. 2. Initiation à Python 2.1 Présentation Python est un langage de programmation très polyvalent et utilisé dans de très nombreux domaines et par nombres d’acteurs importants (Google, Nasa, Dropbox, etc), scientifiques ou non. Créé en 1989, le langage Python trouve l’origine de son nom dans la célèbre troupe d’humoristes anglais des Monty Python. Python est un langage de programmation très utilisé dans le monde scientifique. Il est caractérisé par une syntaxe simple et aérée, des types de données variés, des bibliothèques extensives abondantes. C’est un langage interprété (par opposition à un langage compilé), c’est à dire que l’exécution d’un programme ne passe pas par une phase de compilation, mais s’exécute directement. En partie pour cette raison, il est d’apprentissage rapide et portable mais est, en revanche, relativement lent à l’exécution. Le langage Python est placé sous une licence libre et est très largement multiplateforme (Windows, Linux, Mac, Unix, etc.). Aujourd’hui, Python est développé par la Python Software Foundation qui fait évoluer le langage (Version 3 actuellement) et rassemble les différentes contributions riches de la communauté des développeurs Python. 2.2 Installation Il existe de multiples installations possibles de Python. L’utilisateur débutant peut donc se sentir dérouté par l’absence d’une référence unique pour Python. Les IDE (environnement de développement intégré, c’est un logiciel qui permet à la fois d’écrire des programmes dans un éditeur adapté au langage, d’exécuter les programmes que l’on a écrits, de corriger des erreurs dans ces programmes et de consulter de la documentation) les plus classiques sont Spyder, Winpython. Wing, IDLE, Gvim. On va utiliser, Pyzo. Ce n’est pas un IDE mais un éditeur de Python. Cela signifie qu’il aide à la mise en forme pour faciliter la programmation en langage Python mais qu’il n’est pas suffisant seul pour faire de la programmation, il faut le compléter avec une distribution plus complète afin de traduire Institut d’Alzon 2019/2020 page 4
Séance 1: Introduction
les instructions Python en langage machine. On va donc installer la distribution complète Anaconda
afin de disposer d’un interprète, d’un éditeur et des bibliothèques utiles (Nous verrons ce concept un
peu plus loin).
Pour plus de détails et installer Pyzo ainsi que Anaconda, vous pouvez visiter le site officiel de Pyzo :
http://www.pyzo.org/. Vous pouvez aller aussi sur le site de la classe des BCPST2 où l’installation est
détaillée : https://bcpst2.jimdo.com/informatique/installation/.
2.3 Environnement Pyzo
Une fois l’installation terminée, on peut lancer Pyzo. S’ouvre alors un panneau de ce type :
On voit apparaître deux principaux panneaux :
1. L’interprète de commande (Panneau en haut) va nous permettre d’engager un dialogue interactif
avec l’interprète de commande en utilisant le langage Python. On va pas mal s’en servir au
début. C’est cette partie que l’on utilise quand on se sert de l’ordinateur comme une calculatrice.
2. L’éditeur de programme (Panneau du bas) est doté de certaines fonctionnalités propres à la pro-
grammation (la coloration syntaxique par exemple) et nous permettra de créer des programmes
et des fonctions. Un programme en Python s’appelle un script, le fichier qui le contient porte
l’extension .py. L’enregistrement et l’exécution des scripts est rendu plus facile grâce aux icônes
et ou au raccourci clavier F5.
3. Types de données
Les commandes envoyées à Python sont construites à partir de données qui sont ou bien connues par
défaut ou bien acquises en chargeant le contenu de bibliothèques (par exemple la bibliothèque math
qui contient les outils classiques du mathématicien). Nous allons décrire dans cette séance les types
de données les plus utilisés : les nombres, les chaînes de caractères et les booléens. Notons tout de
suite que l’instruction qui donne le type d’une expression est type(expression ).
Institut d’Alzon 2019/2020 page 5Séance 1: Introduction
3.1 Les nombres
Python utilise trois classes de nombres : les entiers (relatifs) dont le type est int, les nombres à virgule,
habituellement appelés flottants, dont le type est float et les nombres complexes dont le type est
complex.
Voici les opérations de Python :
+ Addition
∗ Multiplication
− Soustraction
∗∗ Puissance
• Les entiers
Taper les opérations suivantes dans l’interprète de commande :
10 -3 * 2
2 * 3 ** 2
(2 * 3) ** 2
2 * 2 # Derrière un dièse , on peut commenter
print (5+6) # print produit un affichage mais n'a pas retourné de
résultat: il n'y a pas de Out.
6 ** 3 # Libre à vous de gérer les espaces
2 + 3 * 5
(2 + 3) * 5
type (5)
type (5.)
type ('5')
On note que les calculs sont hiérarchisés suivant les conventions mathématiques usuelles. Comme on
peut s’y attendre, les parenthèses permettent de préciser l’ordre des calculs souhaités.
Taper les opérations suivantes dans l’interprète de commande :
23/4
23./4 #Python est tolérant!
23 % 4 # Bien pratique cette commande pour les histoires de parité!
(5 * 3) / 2
5 * (3 / 2)
5 * 3 / 2
2 ** 100
Institut d’Alzon 2019/2020 page 6Séance 1: Introduction
2 ** 10000 #Python sait manipuler de grand nombre!
On note que % permet d’avoir le reste d’une division euclidienne, outil qu’on utilise fréquemment en
informatique. Par exemple, un entier n est pair lorsque n%2 = 0, et impair lorsque n%2 = 1.
• Les décimaux
En Python (comme en informatique en général), on distingue les nombres entiers des nombres
décimaux. Pour ces derniers, le séparateur décimal qu’on représente usuellement par une virgule en
France est ici représenté par un point.
Taper les opérations suivantes dans l’interprète de commande :
10.5 -3 ** 2
2.4 * 3.7 ** 2.14
60200 -60.2 e3
type (2.31)
type (4/2)
type (4./2)
Les opérations addition, soustraction et multiplication se notent donc de la même façon que pour les
entiers : +, − et ∗. On note au passage la manière de représenter en Python la notation scientifique
d’un nombre décimal à l’aide de la lettre e (qui n’est pas le nombre de Néper) et on remarque qu’il
suffit que l’un des opérandes d’un calcul soit flottant pour que le résultat soit donné en flottant.
Il y a des différences à noter avec les entiers. Taper les opérations suivantes dans l’interprète de
commande :
2 ** 10000
2. ** 10000
1.1+2.7 -3.8
0.7 ** 2
1/(3 ** 6) * 3 ** 6
Voici les différences que l’on note avec les entiers :
1. Les décimaux sont limités dans Python.
2. Le résultat des opérations avec des décimaux est le plus souvent inexact. Retenons pour l’instant
que dans les bons cas, on obtient une bonne approximation du résultat mais pas forcément
le résultat exact au sens mathématique. Ceci est dû aux contraintes liées à la représentation
informatique des nombres décimaux, ils sont représentés par leur développement dyadique qui
peut être infini.
• Les complexes
La syntaxe pour écrire le nombre complexe a + ib est a + bj. On constate ainsi que le i mathématiques
s’écrit j. On peut aussi utiliser la fonction complex, on écrit complex(a,b) pour créer le complexe
Institut d’Alzon 2019/2020 page 7Séance 1: Introduction
a + ib. Taper les opérations suivantes dans l’interprète de commande :
j ** 2
1j ** 2
complex (5 ,2)+ complex (7 ,3)
3 * (7+2j)
3 * (7+2 * j)
3 * complex (7 ,2)
5+4j/23
5+j4/23 #Il faut mettre dans le bon ordre!
4j+5/23
5+j/23
type (1j)
type (1j ** 2)
On note que dans l’écriture du nombre complexe a + bj, il est interdit d’omettre b même lorsqu’il vaut
1.
• Quelques fonctions mathématiques supplémentaires
Taper l’opération suivante dans l’interprète de commande :
cos (2)
Lorsqu’on utilise le langage python de base, seul un nombre très limité de fonctions est disponible.
Heureusement, il existe une multitude de modules additionnels que l’utilisateur peut ajouter en
fonction de ses besoins, qui lui fournissent des fonctions supplémentaires. Python possède évidem-
ment toutes les fonctionnalités d’une calculatrice scientifique, à condition de lui faire acquérir la
bibliothèque math. Taper les opérations suivantes dans l’interprète de commande :
import math
math.pi +math.e
math.cos (0)
math.sin(pi /2) #Tiens , cela ne marche pas! Que faut -il faire pour corriger cette
import math as m
m.log(m.e)
from math import *
exp (0) #La bibliothèque math est totalement importée!
Institut d’Alzon 2019/2020 page 8Séance 1: Introduction
abs(-3)
sqrt (2)
factorial (6)
On note que la fonction log désigne le logarithme népérien (la notation ln n’existe pas pour Python).
Pour le logarithme décimal, on utilise log 10.
Avec la bibliothèque math, Python connaît alors les constantes classiques que sont e et π ainsi que les
fonctions mathématiques usuelles :
√
Fonction exp ln sin cos tan |·| · ·!
Instruction Python exp log sin cos tan abs sqrt factorial
D’autres fonctions sont à connaître comme les fonctions trunc, round, floor et ceil. Tester les pour
les valeurs suivantes :
Valeur -1.9 -1.5 -1.1 1.1 1.5 1.9
Trunc
Round
Floor
Ceil
Une commande simple permet de savoir ce qu’il y a dans la bibliothèque math, il suffit de taper :
dir(math)
math # Une variante!
dir(numpy) #une grosse bibliothèque !
La bibliothèque math ne permet pas d’utiliser les nombres complexes. Pour cela, il faut charger la
bibliothèque cmath à la place de math. Les fonctions classiques sont alors étendues aux nombres
complexes (exp désigne l’exponentielle complexe, abs désigne le module, etc) et l’on accède aux
fonctions liées aux nombres complexes (phase désigne l’argument, etc).
3.2 Les booléens
Les booléens, ou valeurs de vérité, peuvent prendre deux valeurs : True (vrai) ou False (faux). Ils
permettent d’indiquer si une assertion (que l’on peut construire à l’aide des différentes relations de
comparaison détaillées dans le tableau ci-dessous) est vraie ou non et seront très utilisés dans les tests
et les boucles while que l’on verra plus tard. Les opérateurs de comparaison sont :
Relation mathématique égalité différent inférieur strict supérieur strict inférieur supérieur
Instruction Python == != < > =
En particulier, on notera bien que la relation d’égalité se note == et non avec un seul symbole =.
a == b ne signifie pas que a vaut b mais correspond à une question, a vaut-il b ?
Taper les opérations suivantes dans l’interprète de commande :
true
True
type(False)
Institut d’Alzon 2019/2020 page 9Séance 1: Introduction
2 = 3
2 == 3
3 * 6==6
3>2
1>2.
2-4)
(8 >14) and (4>-4)
(8 >14) or (4>-4)
not(8>-4)
not (4>5)
3.3 Les chaînes de caractères
• Premières opérations
Outre les types numériques, Python permet la manipulation de données alphanumériques, qu’on
appelle des chaînes de caractères, et qui correspondent au type str (string en anglais). Une chaîne
de caractères se note entre guillemets et peut contenir n’importe quel symbole de votre clavier, les
guillemets étant " ou des ’, ces caractères ne faisant pas partie de la chaîne (le choix est souvent
imposé par le contenu : une chaîne contenant un guillemet simple sera encadré par des guillemets
doubles et réciproquement).
Comme pour les autres types de données, on dispose de commandes opérant sur les chaînes de
caractères :
Institut d’Alzon 2019/2020 page 10Séance 1: Introduction
Opération sur les chaînes égalité concaténation répétition n fois longueur appartenance
Instruction Python == + n∗ len in
Taper les opérations suivantes dans l’interprète de commande :
'ajourd 'hui' #Attention ,certains caractères sont interdits!
"ajourd 'hui" #C'est mieux!
'a'
a
type("BCPST1")
"BCPST1" == "BCPST1"
"BCPST 1" == "BCPST1"
"bon" + "jour"
4 * "cot! " + "codec!"
len("Capucine et Mado")
len("CapucineetMado ") # Les espaces comptent
"cile" in "Lucile"
"cie" in "Lucile"
On note que les espaces sont comptées dans la fonction len et que, lorsqu’il compare deux chaînes,
Python est intransigeant, la moindre différence (espace, accent, virgule, majuscule, . . . ) est détectée
et le sens de la phrase n’est pas pris en compte.
Contrairement à ce que nous avons pu observer entre le type int et le type float, il n’existe pas
ici de conversion automatique de type entre le type int et le type str. Python refuse d’ajouter un
nombre et une chaîne de caractères. Pour insérer un nombre dans une phrase, il faut au préalable le
transformer en chaîne de caractères. Pour cela, on peut ou bien mettre le nombre entre les guillemets,
ou bien utiliser la commande de conversion str qui convertit les nombres en chaîne de caractères
et permet d’effectuer une opération sur des nombres avant d’inclure le résultat dans une phrase. La
fonctions int permet de convertir une donnée adéquate (nombre flottant ou chaîne de caractères) en un
entier, float, permet de convertir une donnée adéquate en un nombre flottant. Taper les opérations
suivantes dans l’interprète de commande :
type (5)
type('5')
type(str (5))
type(int('5'))
5='5'
'a'Séance 1: Introduction
'a'>'b'
"Capucine a " + (2019 -2007) + " ans"
"J'ai 2019 -1984 ans "
"Mado a " + str (2019 -2010) + " ans "
"5" + "6"
int("5") + int("6")
5+"6"
• Accès aux caractères
On peut accéder individuellement aux caractères de la chaîne, il suffit pour cela de l’affecter à une
variable (ch dans notre exemple) puis d’écrire l’instruction suivante :
ch[k]
pour accéder au k + 1i ème caractère de ch.
Quelques remarques :
1. Python numérote les caractères de la chaîne à partir de 0 et augmente de 1 au fur et à mesure, il
comptabilise même les espaces. Par conséquent, le caractère ch[k] est le (k + 1)i ème de la chaîne.
2. On peut utiliser des indices négatifs, cela permet d’accéder aux caractères à partir de la fin de la
chaîne. ch[−1] désigne le dernier élément d’une chaîne, ch[−2] l’avant dernier, etc.
3. ch[i : j] désigne la chaîne constituée des caractères de ch dont les numéros sont entre i et j − 1
(Technique appelée slicing). A noter que ch[: j] donne la même chose que ch[0 : j], ch[i :] donne
la même chose que ch[i : len(ch)].
4. ch[i : j : p] donne tous les caractères de la chaîne dont les index sont compris entre i et j − 1 et
espacés d’un pas égal à p. En particulier, ch[−1 : 0 : −1]+ch[0] inverse les éléments de la chaîne.
Taper les opérations suivantes dans l’interprète de commande :
ch = "Python est un super langage"
ch2= " Pythonestunsuperlangage "
len(ch)
len(ch2) # Les espaces comptent!
print(ch [3])
ch[8]
ch[-2]
ch[len(ch)] #On rappelle qu'on indice à partir de 0
ch[len(ch) -1]==ch[-1] # Pratique ce ch[-1] si on ne connaît pas
Institut d’Alzon 2019/2020 page 12Séance 1: Introduction
# la longueur de la chaîne!
ch [4:13]
ch [4: -1:2]
ch[ -1:0: -1]+ ch[0]
ch [:8]+ ch [12:]
Attention, Python commence la numérotation des caractères au numéro 0. Par conséquent, Le dernier
caractère d’une chaîne de longueur est len(ch)-1 et écrire ch[len(ch)] provoque une erreur.
• Quelques méthodes pratiques
Les méthodes sorte des fonctions particulières associées à un type d’objet (comme des chaînes de
caractères, des listes...). Lorsque obj est un représentant de la bonne catégorie d’objet et meth une
méthode associée, on applique cette dernière à l’objet en suivant la syntaxe suivante :
obj.meth()
Nous allons voir maintenant quelques méthodes classiques des chaînes de caractères. Il en existe
beaucoup et il est totalement inutile de les apprendre (une bonne partie est d’ailleurs facile à recréer
avec des boucles for ou while). Par contre, il est bon de connaître leur existence et de savoir les
retrouver. Pour avoir une liste exhaustive de l’ensemble des méthodes associées à un objet particulier,
il suffit d’utiliser la commande dir(), tester :
c = "blabla"
dir(c )
• Les méthodes lower et upper
En tapant ch.lower(ch), on obtient la même chaîne de caractères ch mais en minusucule. ch.upper(ch),
donne la chaîne de caractères ch mais en majusucule.
On remarque que l’utilisation de ces méthodes n’altèrent pas la chaîne de caractères de départ mais
renvoie la chaîne transformée. Testons-les :
x = "j'aime Python"
x.upper ()
x
"PYTHON".lower ()
x[0]. upper () + x[1:] # La méthode x.capitalize () fait la même chose!
• D’autres méthodes
D’autres méthodes classiques :
1. En tapant ch.replace(ch1,ch2), on obtient la chaîne de caractères ch dans laquelle on a remplacé
toutes les chaînes de caractères ch1 par la chaîne de caractères ch2.
Institut d’Alzon 2019/2020 page 13Séance 1: Introduction
2. En tapant ch.count(ch1), on obtient le nombre d’occurrences d’une chaîne de caractère ch1 dans
la chaîne de caractères ch.
3. En tapant ch.find(ch1), on obtient l’indice de la première occurence de la chaîne de caractère
ch1 dans la chaîne de caractères ch. Si l’élément n’est pas trouvé, alors la valeur −1 est renvoyée.
On peut les tester :
profs = "Bacquelin Blanc"
profs.find("a")
profs.find("z")
profs.find('ac')
profs.count("queli")
profs.count("a")
profs.count("z")
profs.replace("Bacquelin", "")
profs.replace("e", "o")
profs #replace ne modifie pas la la chaîne de caractères de départ.
#On peut faire la même remarque avec count et find
Institut d’Alzon 2019/2020 page 14Vous pouvez aussi lire
