chap1-partie2-str

Chapire 1 - Partie 2

Dans la section 1.4 de la partie 1 du chapitre 2, nous avons abordé les types de variables. Nous avons présenté et manipulé les variables numériques et les variables booléennes. Dans ce qui suit nous allons traiter les variables de type séquentiels qui comprennent :

1. Le type str
2. Le type list
3. Le type tuple
4. Le type range

Le type range est à la fois une fonction et un objet qui permet de ranger un ensemble de nombres entiers ordonnés.

Le point commun des types séquentiels est qu'ils stockent des éléments dans un ordre défini et permettent d'y accéder à l'aide d'un index numérique.

Cette partie est consacrée aux chaines de caractères str

1. Les variables séquentielles¶

1.1. Les chaînes de caractères¶

Contenu

• 1. Les variables séquentielles
  • 1.1. Les chaînes de caractères
  • 1.2. Les chaînes de caractères
    • 1.2.1. Création d'une chaîne
    • 1.2.2. Opérations de base sur les chaînes str
      • 1.2.2.1. Concaténation
      • 1.2.2.2. Duplication
      • 1.2.2.3. Longeur
      • 1.2.2.4. Conversion en nombre
      • 1.2.2.5. Découpage
      • 1.2.2.6. Modification d'une chaîne
    • 1.2.3. Formatage des chaînes
      • 1.2.3.1. Print avec opérateur %
      • 1.2.3.2. Méthode .format()
      • 1.2.3.3. Formatage avec f-string
    • 1.2.4. Fonctions et méthodes des chaînes str

Les chaînes de caractères str sont un type de variables permettant de manipuler des données textuelles.
C'est aussi un type de données ou variable dite : séquentielle, car une chaîne est formée d'une séquence de caractères. Elle est stockée en mémoire dans un tableau contenant les adresses des caractères qu'elle contient.

1.2.1. Création d'une chaîne¶

Il y a trois méthodes en Python pour créer une chaîne de caractères (une variable str)  :

1. en délimitant la chaîne par deux apostrophes ('...') ;
2. en délimitant la chaîne par deux guillemets ("...") ;
3. en délimitant la chaîne par deux triplets d'apostrophes ou de guillemets ('''...''' ou """...""").

Dans les 2 premiers cas, on peut mettre dans la chaîne n'importe quel caractère, sauf celui utilisé pour sa création.

In [1]:

x = 'Master 1 Hydraulique, Option HU & OAH'  # Une chaîne avec apostrophes
y = "Master 1 Hydraulique, Option HU & OAH"  # Une  chaîne avec guillemets 
print(x)
print(y)
print("Type de la variable x :",  type(x))

Master 1 Hydraulique, Option HU & OAH
Master 1 Hydraulique, Option HU & OAH
Type de la variable x : <class 'str'>

In [2]:

# Une chaîne sur plusieurs lignes. 
# On peut évidement remplacer les 3 guillemets : """ par 3 apostrophes : ''' 
z = '''Master 1 
Hydraulique 
Options : HU & OAH'''
print(z)

Master 1 
Hydraulique 
Options : HU & OAH

Pour écrire une chaîne de caractères (variable str) contenant une apostrophe, on utilise des guillemets ; et inversement, dans le cas contraire. Voici 2 exemples :

In [3]:

ch1 = "Dans la vie, il n'y a pas de 'Ctrl+Z'"
ch2 = '"Ctrl+Z" est magique'
print(ch1)
print(ch2)

Dans la vie, il n'y a pas de 'Ctrl+Z'
"Ctrl+Z" est magique

Si on veut une variable str avec des guillemets et des apostrophes en même temps, on a deux possibilités :

1. Créer la variable en utilisant les triples guillemets ou les triples apostrophes
2. Faire précéder par \ chaque guillemet ou apostrophe à l'intérieur de la chaîne.

In [4]:

ch3 ="""Dans la vie, il n'y a pas de "Ctrl-Z" """    # triple guillemets
ch4 ='''Dans la vie, il n'y a pas de "Ctrl-Z"'''     # triple apostrophe
ch6 ="Dans la vie, il n'y a pas de \"Ctrl-Z\" "      # échappement backslash sur guillemet
ch5 ='Dans la vie, il n\'y a pas de "Ctrl-Z"'        # échappement backslash sur apostrophe
print(ch3)
print(ch4)
print(ch5)
print(ch6)
A = 12.354

Dans la vie, il n'y a pas de "Ctrl-Z" 
Dans la vie, il n'y a pas de "Ctrl-Z"
Dans la vie, il n'y a pas de "Ctrl-Z"
Dans la vie, il n'y a pas de "Ctrl-Z" 

La barre oblique inversée (ou backslash) \ est appelé caractère d'échappement. Elle sert à insérer des caractères spéciaux dans une chaîne str. Voici quelques cas d'utilisation les plus fréquents:

• \' : une apostrophe simple '
• \" : une guillemet "
• \\ : le caractère \ lui même
• \n : insère un saut de ligne et continue le reste du text sur une nouvelle ligne (touche return ↵ du clavier)
• \r : fait un retour au début de ligne et continue le reste texte en écrasant le début.
• \t : insère une tabulation : un long espace comme clui produit par la touche tab ↹ du clavier.
• \b : retour en arrière avec effacement d'un caractère (Backspace)
• \uXXXX : imprime le caractère de code hexadécimal XXXX

In [5]:

# Exemple de retour à la ligne et guillemets
print("Il existe deux façons d'écrire un programme sans erreurs, seule la troisième fonctionne \n\"Alan Perlis\"") 

Il existe deux façons d'écrire un programme sans erreurs, seule la troisième fonctionne 
"Alan Perlis"

In [6]:

# Exemple de chemin d'accès à un dossier  Windows 
print("Les fichiers temporaires sont stockés dans le dossier : C:\\Windows\\Temp")

Les fichiers temporaires sont stockés dans le dossier : C:\Windows\Temp

Remarque : Dans certains cas, on a besoin de construire une chaîne str contenant plusieurs backslash \. Au lieu de faire recours aux dédoublement de ce caractère, on préfère la précéder de r. La chaîne est appelée alors un r-string.

In [7]:

print("chemin :", r'C:\Windows\Temp')

chemin : C:\Windows\Temp

Dans une r-string, le backslash est traité comme tous les autres caractères, il devient sans aucune action :

In [8]:

print(r"un retour à la ligne \n ne s'effectue pas dans une r-string")
print(r"r-string avec backslash et guillemet \" affiche les deux")

un retour à la ligne \n ne s'effectue pas dans une r-string
r-string avec backslash et guillemet \" affiche les deux

Le backslash dans une chaîne str permet d'afficher des caractères ou symboles inexistant dans le clavier classique. Par exemple :

In [9]:

# Exemple pour produire les symboles de tab et return 
print('tabulation : \u21B9  \t  return : \u21B5')

tabulation : ↹  	  return : ↵

1.2.2. Opérations de base sur les chaînes str¶

1.2.2.1. Concaténation¶

On utilise l'opérateur +pour concaténer deux chaînes de caractères ou plus et les joindre joindre bout à bout

In [10]:

a = "L'hydraulique est une technologie et une science appliquée"
b = "La mécanique des fluides est une science fondamentale"

c = a + ". " + b     # on joint les deux phrases en insérant une ponctuation
print(c)

L'hydraulique est une technologie et une science appliquée. La mécanique des fluides est une science fondamentale

1.2.2.2. Duplication¶

L'opérateur * est aussi fréquemment utilisé avec les chaînes de caractères. Il permet de répéter (ou dupliquer) une chaîne un certain nombre de fois.

Par exemple, au lieu d'entrer une longue chaîne de $n$ caractères identiques, il vaut mieux multiplier le caractère par le nombre $n$ :

In [11]:

ch = "abcd"
trait = "--"
print(ch*10)
print(trait*20)

abcdabcdabcdabcdabcdabcdabcdabcdabcdabcd
----------------------------------------

1.2.2.3. Longeur¶

Pour connaître la longueur d'une chaîne, il suffit de faire appel à la fonction standard len (de l'anglais «length») :

La longueur d'une chaîne str est le nombre de caractères qu'elle contient.

In [12]:

alpha_num = 'abcdef ... 123'
print("alpha_num contient", len(alpha_num), "caractères")

alpha_num contient 14 caractères

1.2.2.4. Conversion en nombre¶

Si une chaîne str ne contient que des chiffres, on peut la convertir en nombre entier en utilisant la fonction int. Si de plus elle contient un point, on peut la convertir en nombre décimal avec float. Il faut que le contenu de la chaîne soit compatible avec les format des nombres.

In [13]:

ch_ent = '12345'      # Entier
ch_flt = '123.45'     # Réel à virgule flottante
ch_exp ='12345e-02'   # Réel en notation scientifique e-2 ou E-2, ou e-02
n = int(ch_ent)
x = float(ch_flt)
y = float(ch_exp)
print(n, x, y)        # noter que x et y sont les mêmes

12345 123.45 123.45

1.2.2.5. Découpage¶

On utilise de l'opérateur [] pour découper une sous-chaîne à l'intérieur d'une chaîne en précisant les positions du début et de fin de découpage.

Les positions des caractères dans une chaîne str de longueur $n$ sont numérotées de $0$ à $n-1$.

D'une façon générale, la notation [i:j:k] permet d'extraire tous les caractères qui sont situés entre les positions de coupure i et j avec un pas k. Si k n'est pas donné, il prend par défaut la valeur k=1.

Lorsque 'on omet de préciser le premier point de coupure en écrivant [:j], cela est équivalent à écrire [0:j], soit un découpage du début de la chaîne jusqu'au point de coupure j.

De même, pour découper d'un point de coupure i jusqu'à la fin de la chaîne, on peut omettre de préciser j en écrivant plus simplement [i:], ce qui est équivalent à écrire [i:n], où n correspondrait à la longueur de la chaîne.

On peut aussi utiliser des indices négatifs. Dans ce cas, on compte vers la gauche à partir de la fin.

Par exemple : la chaîne de caractère M1-HU&OH contient 8 caractères avec indexés comme suit :

Caractère	A	B	C	D	E	F	G	H
Indice +	0	1	2	3	4	5	6	7
Indice -	-8	-7	-6	-5	-4	-3	-2	-1

In [14]:

ch = 'ABCDEFGH'
print('premier caractère  :', ch[0])
print('dernier caractère  :', ch[-1])
print('3ème caractère à partir du début  :', ch[2])
print('3ème caractère à partir de la fin :', ch[-3])
print("la sous chaîne à partir 3ème caractère jusqu'à  la fin :", ch[3:])
print("la sous chaîne  jusqu'au 5ème caractère :", ch[:5])
print("pour extraire HU :", ch[3:5], ch[-5:-3])
print("pour extraire OH :", ch[6:8], ch[-2:])          # remarquer que [-2:-1] ne fait extraire que 
print("début à la fin avec un pas de 2 : ", ch[::2]) 
print("de la fin au début un pas de -1 : ", ch[::-1])  # inverse la chaîne 

premier caractère  : A
dernier caractère  : H
3ème caractère à partir du début  : C
3ème caractère à partir de la fin : F
la sous chaîne à partir 3ème caractère jusqu'à  la fin : DEFGH
la sous chaîne  jusqu'au 5ème caractère : ABCDE
pour extraire HU : DE DE
pour extraire OH : GH GH
début à la fin avec un pas de 2 :  ACEG
de la fin au début un pas de -1 :  HGFEDCBA

1.2.2.6. Modification d'une chaîne¶

Bien qu'on parle de modification, une fois créée, une chaîne de caractères en python n'est pas modifiable. On dit alors qu'elle c'est une variable immuable. Par exemple, si l'on veut la changer de minuscule à majuscule des lettres d'une phrase, on ne peut pas procéder ainsi :

ch = "programmation en python"
ch[0] = "P"   # provoque une erreur
ch[17] = "P"  # provoque aussi une erreur

Pour modifier une chaîne, il faut en créer une autre, puis l'affecter à la chaîne à modifier, comme suit :

In [15]:

ch = "programmation en python"
ch = 'P' + ch[1:]   # on crée une concaténation de 'P' et de la sous-chaîne de 1 à la fin
print(ch)   

Programmation en python

In [16]:

# Si on veut mettre les deux p en majuscule 
ch = "programmation en python"
ch = 'P' + ch[1:17] + 'P' + ch[18:]  
print(ch)   

Programmation en Python

A noter que dans le cas précédant en particulier, on peut précisément utiliser la fonction replace : ch = ch.replace('p','P') qui va remplacer tous les p minuscule en P majuscule.

1.2.3. Formatage des chaînes¶

D'une manière générale, le formatage d'une chaîne de caractères consiste à la mettre sous une forme souhaitée en utilisant un modèle d'affichage ou d'écriture donné.

Il existe de nombreuses façons de mettre en forme des chaînes de caractères avec Python :

• Utiliser une concaténation comme nous l'avons vu dans les sections précédentes.
• Utiliser des virgules directement dans 'print' (revoir les exemples précédents)
• Utiliser fonction format
• Utiliser un f-string

L'utilisation de print permet de contrôler l'affichage à l'aide de descripteur %. Cependant le formatage avec l'opérateur % est obsolète et doit être évité. Il est remplacé par les deux autres méthodes plus lisibles f-string et format. Les f-strings sont la méthode recommandée et la plus courante pour le formatage en Python depuis la version 3.6

On montre ci-dessous comment utiliser ces trois méthodes:

1.2.3.1. Print avec opérateur %¶

Pour utiliser l'opérateur % dans print, on écrit:

Pour réaliser un formatage ave % on écrit entre guillemets à l'intérieur de print le texte literal (qui sera affiché tel quel) comportant des %s pour marquer les emplacements où on veut insérer les variables. Ensuite complète la commande avec les noms de variables qu'on met entre parenthèses précédées de %.

Exemple :

In [17]:

var1, var2, var3 = "Text1", 12345,  123/45
print("var1 = %s, var2 = %s , et var3 = %s" %(var1, var2, var3))

var1 = Text1, var2 = 12345 , et var3 = 2.7333333333333334

Le %s convient aux variables str mais il permet aussi d'afficher des variables numériques. Pour ces dernières, il est préférable d'utiliser %d pour les int et %f pour les float qui offrent la possibilité de préciser le nombre de chiffres à afficher. Par exemple %kd et %l.mf si on veut k espaces pour un entier et l chiffres,m décimaux pour un réel.

Si on ajoute 0 aux descripteurs de format : %0kd et 0l.mf, on remplit par des zéros les espaces à gauche non utilisés.

Si on ajoute le signe moins (-) aux descripteurs %-kd et -l.mf on obtient des textes alignés à gauche au lieu d'un alignement à droite par défaut.

In [18]:

method = "Euler"
n = 300
dx = 2/n
# sans espaces ni précisions
print("Méthode : %s, avec n = %d et delta x = %f comme pas initial."  % (method, n,dx))

# avec espaces et précisions
print("Méthode : %20s, avec n = %8d et delta x = %12.4f comme pas initial."  % (method, n,dx))

# remplissage d'espaces par de 0
print("Méthode : %20s, avec n = %08d et delta x = %012.4f comme pas initial."  % (method, n,dx))

# alignement à gauche
print("Méthode : %-20s, avec n = %-8d et delta x = %-012.4f comme pas initial."  % (method, n,dx))

Méthode : Euler, avec n = 300 et delta x = 0.006667 comme pas initial.
Méthode :                Euler, avec n =      300 et delta x =       0.0067 comme pas initial.
Méthode :                Euler, avec n = 00000300 et delta x = 0000000.0067 comme pas initial.
Méthode : Euler               , avec n = 300      et delta x = 0.0067       comme pas initial.

Remarque : Lorsqu'on n'a qu'une seule variable à afficher, on peut s'en passer des parenthèses après %

In [19]:

pi = 3.141592653589793
print("La valeur de pi est approximativement %.3f" % pi)

La valeur de pi est approximativement 3.142

1.2.3.2. Méthode .format()¶

La méthode .format() insère des valeurs dans une chaîne de caractères à afficher en utilisant des accolades {} comme emplacements réservés.

On écrit entre guillemets à l'intérieur de print le texte literal et on marque par{} les emplacements où on veut insérer les variables. Ensuite complète la commande avec .format() et on met les noms des variables dans les parenthèses.

L'ordre des arguments détermine leurs positions dans la chaîne sauf si on précise quelle variable placer en utilisant les indexes.

In [20]:

x = 12.34
ch = 'abcde'
print('{} - {}'  .format(ch, x))   # positionne  ch puis x  (par défaut selon l'ordre)
print('{0} - {1}'.format(ch, x))   # positionne  ch puis x  (par indices : 0,1)
print('{0} - {0}'.format(ch, x))   # positionne  ch puis ch (par indices : 0,0)
print('{1} - {0}'.format(ch, x))   # positionne  x  puis ch (par indices : 1,0)
print('{1} - {1}'.format(ch, x))   # positionne  x  puis x  (par indices : 1,1)

abcde - 12.34
abcde - 12.34
abcde - abcde
12.34 - abcde
12.34 - 12.34

On peut aussi preciser les emplacements des variables avec des noms de champs de remplacement à l'intérieur des accolades.

Exemple :

print('{nombre} - {text}'.format(nombre = x, text = ch))

ici nombre et text, sont des noms de champs. Ils servent d'identifiants pour indiquer où insérer des valeurs ultérieurement.

In [21]:

print('{nombre} - {text}'.format(nombre = x, text = ch))

12.34 - abcde

Comme dans le cas de l'opérateur %, on peut aussi ajuster le formatage des valeurs lors de la substitution, en ajoutant d'autres informations à l'intérieur des paires d'accolades.

In [22]:

pi = 3.1415926
d = 200  # em [mm]
p = pi*d
mat ="Acier"


# On reserve un espace de 15 caractères pour le texte (mat)
# et un espace de 12 pour le nombre (p) dont 5 pour la virgule et les 4 chiffres de précision

# l'alignement par défaut : gauche pour le text et droite pour le nombre
print('Conduite en {0:15}, périmètre = {1:12.4f} [mm]'.format(mat, p)) 

# Même formatage des alignements inversés
print('Conduite en {0:>15}, périmètre = {1:<12.4f} [mm] '.format(mat, p)) 

# Même formatage avec du texte centré
print('Conduite en {0:^15}, périmètre = {1:^12.4f} [mm] '.format(mat, p)) 

Conduite en Acier          , périmètre =     628.3185 [mm]
Conduite en           Acier, périmètre = 628.3185     [mm] 
Conduite en      Acier     , périmètre =   628.3185   [mm] 

1.2.3.3. Formatage avec f-string¶

Cette méthode offre une plus grande flexibilité pour formater les chaînes de caractères. Elle permet de faire tout ce que .format fait avoir à appeler explicitement cette fonction.

Dans une f-string, on fait précéder la chaîne par la lettre f et on utilise des paires d'accolades afin de spécifier des formats, mais au lieu de référer aux indices des variables, on inclut directement les variables elles mêmes.

Il est aussi possible de mettre à la place d'une variable n'importe quelle expression python valable, sa valeur viendra remplacer la paire d'accolades et son contenu.

Une f-string est donc une chaîne de caractère ordinaire, mais dans laquelle le contenu des paires d'accolades est directement évalué par l'interpréteur Python.

Sans la lettre f, Python n'effectue défaut aucun traitement sur les paires d'accolades mais il les affiche telles quelles.

In [23]:

#Dans cet exemple, la valeur de l'expression `pi/2` remplacera la paire d'accolades `{pi/E}`.
pi = 3.141592653589793

print(f"pi/2 = {pi/2}")  # noter le f précédant la chaîne

# Le même affichage que le précédent en plus simple
# noter l'absence du texte 'pi/2 =', il est généré automatiquement
print(f"{pi/2 = }")  

# sans la lettre f python ne fait pas de traitement, il affiche tout en text
print( "pi/2 = {pi/2}")  

pi/2 = 1.5707963267948966
pi/2 = 1.5707963267948966
pi/2 = {pi/2}

On peut utiliser les spécificateurs de formatage et d'alignments comme dans .format
Voici un exemple d'organisation d'une sortie sous forme d'un tableau

In [24]:

pi = 3.141592653589793
c1, c2, c3 = 'Alignement', 'angle [rad]', 'angle [deg]'

angle_rad = pi/7
angle_deg = angle_rad*180/pi

h_line = f":{'-'*25} : {'-'*20} : {'-'*20} :"

print(h_line)
print(f":{c1 :25} : {c2 :20} : {c3:20s} :")
print(h_line)
print(f":{'Défaut' :25s} : {angle_rad  :20.4f} : {angle_deg :20.3f} :")
print(h_line)
print(f":{'Gauche':<25s} : {angle_rad :<20.4f} : {angle_deg:<20.3f} :")
print(h_line)
print(f":{'Droite':>25s} : {angle_rad :>20.4f} : {angle_deg:>20.3f} :")
print(h_line)
print(f":{'Centré':^25s} : {angle_rad :^20.4f} : {angle_deg:^20.3f} :")
print(h_line)

:------------------------- : -------------------- : -------------------- :
:Alignement                : angle [rad]          : angle [deg]          :
:------------------------- : -------------------- : -------------------- :
:Défaut                    :               0.4488 :               25.714 :
:------------------------- : -------------------- : -------------------- :
:Gauche                    : 0.4488               : 25.714               :
:------------------------- : -------------------- : -------------------- :
:                   Droite :               0.4488 :               25.714 :
:------------------------- : -------------------- : -------------------- :
:         Centré           :        0.4488        :        25.714        :
:------------------------- : -------------------- : -------------------- :

1.2.4. Fonctions et méthodes des chaînes str¶

De nombreuses fonctions standards sont disponibles pour effectuer divers traitements sur les chaînes de caractères. Voici quelques unes d'entre elles :

• Majuscule/minuscule

  • capitalize() : Met la première lettre en majuscule et le reste en minuscule.

        "programmation en python".capitalize()  → 'Programmation en python'
    

  • lower() : Convertit la chaîne en minuscules.

        'Programmation en PYTHON'.lower()       → 'programmation en python'
    

  • upper() : Convertit en majuscules.

        'Programmation en Python'.upper()       → 'PROGRAMMATION EN PYTHON'
    

  • title() : Met en majuscule la première lettre de chaque mot.

        'Programmation en Python'.title()       → 'Programmation En Python'
    

  • swapcase() : Inverse la casse des lettres.

        'Programmation en PYTHON'.swapcase()    → 'pROGRAMMATION EN python'
    

• Alignement/Remplissage

  • center(width, fillchar=' ') : Centre la chaîne dans une largeur donnée.

        'py'.center(10)          →  '    py    '
        'py'.center(10, '.')     →  '....py....'
    

  • ljust(width, fillchar=' ') : Aligne la chaîne à gauche dans une largeur donnée.

        'py'.ljust(10)           → 'py        '
        'py'.ljust(10, '.')      → 'py........'
    

  • ljust(width, fillchar=' ') : Aligne la chaîne à droite dans une largeur donnée.

        'py'.rjust(10)           → '        py'
        'py'.rjust(10, '-')      → '........py'
    

  • zfill(width) : Ajoute des zéros à gauche jusqu’à la largeur donnée.

        '12.34'.zfill(8)       → '00012.34'
    

• Recherche/compatage

  • find(sub[, start, end]) : Renvoie l’indice de la première occurrence, ou -1.

        'programmation en python'.find('t')  → 9
    

  • rfind(sub[, start, end]) : Indice de la dernière occurrence, ou -1.

        'programmation en python'.rfind('t')  → 19
    

  • count(sub[, start, end]) : Compte le nombre d’occurrences d’une sous-chaîne.

        'programmation en python'.count('o')        → 3
        'programmation en python'.count('o',2,12)   → 2
    

• Tests

  • isalnum() : Vérifie si tous les caractères sont alphanumériques.

        'abc123' .isalnum()     → True
        'abc_123'.isalnum()     → False
    

  • isalpha() : Vérifie si tous les caractères sont alphabétiques.

        'abcABC'.isalpha()     → True
        'abc123'.isalpha()     → False
    

  • isdecimal() : Vérifie si tous les caractères sont des chiffres décimaux.

        '123'.isdecimal()       → True
    

  • isnumeric() : Vérifie si tous les caractères sont numériques.

        'Ⅳ'.isnumeric()        → True
    

  • islower() : Vérifie si tous les caractères alphabétiques sont minuscules.

        'abc'.islower()         → True
    

  • isupper() : Vérifie si tous les caractères alphabétiques sont majuscules.

        'ABC'.isupper()          → True
    

  • istitle() : Vérifie si chaque mot commence par une majuscule.

        'Programmation En Python'.istitle() → True
        'Programmation en Python'.istitle() → False
    

  • isspace() : Vérifie si la chaîne contient uniquement des espaces.

        '    '.isspace()         → True
    

  • startswith(prefix[, start, end]) : Vérifie si la chaîne commence par prefix.
    Exemple : 'Python'.startswith('Py') → True
    

• Suppression

  • lstrip([chars]) : Supprime les caractères spécifiés à gauche.

        '       py'.lstrip()       → 'py'
        '_______py'.lstrip('_')    → 'py'  
    

  • rstrip([chars]) : Supprime les caractères spécifiés à droite.

        'py       '.rstrip()       → 'py'
        'py_______'.rstrip('_')    → 'py'  
    

  • strip([chars]) : Supprime les caractères spécifiés des deux côtés.

        '    py     '.strip()       → 'py'
        '____py_____'.strip('_')    → 'py'
    

    • removeprefix(prefix) : Supprime un préfixe si présent.

          'impossible'.removeprefix('im')     → 'possible'
      

  • removesuffix(suffix) : Supprime un suffixe si présent.

        'aimablement'.removesuffix('ment') → 'aimable'
    

• Découpage/Partition

  • partition(sep) : Sépare la chaîne en trois parties : avant, séparateur, après.

        'a=b'.partition('=')        → ('a', '=', 'b')
    

  • rsplit(sep=None, maxsplit=-1) : Découpe la chaîne à partir de la droite.

        'a,b,c'.rsplit(',', 1)      → ['a,b', 'c']
    

  • split(sep=None, maxsplit=-1) : Découpe la chaîne en liste de sous-chaînes.

        'a,b'.split(',')            → ['a', 'b']
    

    • splitlines(keepends=False) : Découpe la chaîne en lignes. Utile pour la lecture d'un fichier

        'ligne 1\nligne2\nligne3'.splitlines() → ['ligne 1', 'ligne2', 'ligne3']
    

In [25]:

# si on veut la liste des fonctions de str
str_funcs = [name for name in dir(str) if not '_' in name]
print(str_funcs)

['capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']