Module « builtins » Python 3.11.3

Classe « str »

Informations générales

Héritage

builtins.object
    builtins.str

Définition

class str(builtins.object):

Description

Cette classe représente le concept de chaîne de caractères. La manière classique de déclarer une chaîne de caractères consiste à placer les caractères souhaités entre simple quote ou entre double quote.

>>> s = 'Un message'
>>> s
'Un message'
>>> type(s)
<class 'str'>
>>> s = "Un autre message"
>>> s
'Un autre message'
>>> type(s)
<class 'str'>
>>>

Dans une chaîne de caractères, vous pouvez utiliser des séquences particulières : elles sont introduites par un caractère \. Voici quelques séquences utiles.

\a : représente le caractère « Bell » (un bip sonore - pensez à mettre le son pour le tester).
\n : représente le caractère de retour à la ligne.
\t : représente le caractère de tabulation.
\u : représente un caractère Unicode. Vous devez aussi mentionner le numéro du caractère en hexadécimal. Par exemple, "\u03c0" pour avoir le caractère π (minuscule) ou "\u03a0" pour avoir le caractère Π (majuscule). Pour de plus amples informations sur la table de caractères Unicode, je vous propose d'en visualiser son contenu en activant ce lien.
\' : permet d'injecter un simple guillemet dans une chaîne de caractères introduite par ce même caractère.
\" : permet d'injecter un double guillemet dans une chaîne de caractères introduite par ce même caractère.
\\ : représente le caractère \ (étant donné qu'il s'agit d'un caractère d'échappement).

>>> import math
>>> s = "\u03c0 == %f" % math.pi
>>> s
'π == 3.141593'
>>> print("\a")     # Mettre le son

Vous pouvez aussi définir des « raw strings » (des chaînes brutes). Dans ce cas, les séquences débutant par le caractère \ n'auront plus aucune signification particulière. Pour introduire une raw string, il faut utiliser un simple caractère r (pour raw), placé devant la chaîne.

>>> path = "C:\newFolder\truc.txt"
>>> print(path)
C:
ewFolder    ruc.txt
>>> path = r"C:\newFolder\truc.txt"
>>> print(path)
C:\newFolder\truc.txt
>>>

Il existe encore un autre type de chaînes de caractères : les chaînes multi-lignes. On introduit une telle chaîne par trois simples quotes ou trois doubles quotes. Vous devez terminer la chaîne multi-ligne par la même séquence de caractères que celle utilisée en début de chaîne.

>>> usage = """Bienvenue dans ma super Application.
... version 1.0 - KooR.fr - 2020"""
>>> print(usage)
Bienvenue dans ma super Application.
version 1.0 - KooR.fr - 2020
>>>

Vous pouvez cumuler ces possibilités pour définir une chaîne brute multi-ligne : r"""The content ... """.

une chaîne de caractères est non modifiable. Une fois instanciée, vous ne pouvez plus changer le contenu de la chaîne. Par contre, vous pouvez produire une nouvelle chaîne transformée à partir de la première, comme le montre l'exemple suivant.

>>> original = "Hello World!"
>>> original
'Hello World!'
>>> modified = original.upper()
>>> modified
'HELLO WORLD!'
>>> original
'Hello World!'
>>> original[0]
'H'
>>> original[0] = "Z"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>>

Enfin, notez qu'il est possible de convertir n'importe quelle donnée Python en une chaîne de caractères. Pour ce faire, il suffit de construire une nouvelle instance de la classe str en passant en paramètre la donnée à convertir. Voici un petit exemple.

>>> intValue = 123
>>> message = "Valeur == " + str(intValue)
>>> print(message)
Valeur == 123
>>>

help(str)

str(object='') -> str
str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or
errors is specified, then the object must expose a data buffer
that will be decoded using the given encoding and error handler.
Otherwise, returns the result of object.__str__() (if defined)
or repr(object).
encoding defaults to sys.getdefaultencoding().
errors defaults to 'strict'.

Exemple(s) de code

Exemple d'utilisation de la classe str
1 2 3 4 5 6 7 8 9	#!/usr/bin/python3 first_name = input("Veuillez saisir votre prénom : ") first_name = first_name.lower() last_name = input("Veuillez saisir votre nom : ") last_name = last_name.upper() print("Welcome %s %s" % (first_name, last_name))

#!/usr/bin/python3

first_name = input("Veuillez saisir votre prénom : ")
first_name = first_name.lower()

last_name = input("Veuillez saisir votre nom : ")
last_name = last_name.upper()

print("Welcome %s %s" % (first_name, last_name))

Exemple d'utilisation de la classe str

Et voici les résultats produits par cet exemple.

Veuillez saisir votre prénom : James
Veuillez saisir votre nom : Bond
Welcome james BOND

Constructeur(s)

Signature du constructeur	Description
__new__(args, *kwargs)	Create and return a new object. See help(type) for accurate signature. _{[extrait de __new__.__doc__]}
__init__(self, /, args, *kwargs)	Initialize self. See help(type(self)) for accurate signature. _{[extrait de __init__.__doc__]}

Liste des opérateurs

Signature de l'opérateur	Description
__add__(self, value)	Return self+value. _{[extrait de __add__.__doc__]}
__contains__(self, key)	Return key in self. _{[extrait de __contains__.__doc__]}
__eq__(self, value)	Return self==value. _{[extrait de __eq__.__doc__]}
__ge__(self, value)	Return self>=value. _{[extrait de __ge__.__doc__]}
__getitem__(self, key)	Return self[key]. _{[extrait de __getitem__.__doc__]}
__gt__(self, value)	Return self>value. _{[extrait de __gt__.__doc__]}
__le__(self, value)	Return self<=value. _{[extrait de __le__.__doc__]}
__lt__(self, value)	Return self<value. _{[extrait de __lt__.__doc__]}
__mod__(self, value)	Return self%value. _{[extrait de __mod__.__doc__]}
__mul__(self, value)	Return self*value. _{[extrait de __mul__.__doc__]}
__ne__(self, value)	Return self!=value. _{[extrait de __ne__.__doc__]}
__rmod__(self, value)	Return value%self. _{[extrait de __rmod__.__doc__]}
__rmul__(self, value)	Return value*self. _{[extrait de __rmul__.__doc__]}

Liste des méthodes

Toutes les méthodes Méthodes d'instance Méthodes statiques

Signature de la méthode	Description
__format__(self, format_spec)	Return a formatted version of the string as described by format_spec. _{[extrait de __format__.__doc__]}
__getattribute__(self, name)	Return getattr(self, name). _{[extrait de __getattribute__.__doc__]}
__getnewargs__
__hash__(self)	Return hash(self). _{[extrait de __hash__.__doc__]}
__iter__(self)	Implement iter(self). _{[extrait de __iter__.__doc__]}
__len__(self)	Return len(self). _{[extrait de __len__.__doc__]}
__repr__(self)	Return repr(self). _{[extrait de __repr__.__doc__]}
__sizeof__(self)	Return the size of the string in memory, in bytes. _{[extrait de __sizeof__.__doc__]}
__str__(self)	Return str(self). _{[extrait de __str__.__doc__]}
capitalize(self) -> str	Cette méthode produit une nouvelle chaîne de caractères dont la première lettre sera mise en majuscule et les autres en minuscules.
casefold(self) -> str	Cette méthode produit une nouvelle chaîne de caractères mise en minuscules, en utilisant une technique plus aggressive que la méthode `lower`.
center(self, width, fillchar=' ') -> str	Cette méthode produit une nouvelle chaîne de caractères de taille `width` avec son contenu centré.
count(self, substring, start=0, end=None) -> int	Cette méthode calcule le nombre d'occurrences d'une sous-chaîne dans tout ou une partie de la chaîne caractères courante.
encode(self, encoding="utf-8", errors="strict") -> bytes	Permet de réencoder la chaîne courante de UFT-16 (utilisé en interne par Python) vers l'encodage spécifié (par défaut UTF-8).
endswith(self, suffix, start=0, end=None) -> bool	Cette méthode permet de déterminer si une chaîne (ou une sous-chaîne) se termine par le suffixe spécifié.
expandtabs(self, tabsize=8) -> str	Renvoie une copie de la chaîne de caractères courante dans laquelle les tabulations sont remplacées par des espaces.
find(self, substring, start=0, end=None) -> int	Renvoie la position dans la chaîne courante de la première occurrence de la chaîne passée en paramètre.
format(self, args, *kwargs)) -> str	Permet de formater une chaîne de caractères en y injectant les données passées en paramètres.
format_map(self, dictionnary)) -> str	Permet de formater une chaîne de caractères, un peu comme la méthode `format` mais en utilisant un dictionnaire comme source de données.
index(self, substring, start=0, end=None) -> int	Renvoie la position dans la chaîne courante de la première occurrence de la chaîne passée en paramètre.
isalnum(self) -> bool	Cette méthode permet de vérifier si la chaîne courante, qui doit être non vide, ne contient que des lettres et des chiffres.
isalpha(self)	Return True if the string is an alphabetic string, False otherwise. _{[extrait de isalpha.__doc__]}
isascii(self)	Return True if all characters in the string are ASCII, False otherwise. _{[extrait de isascii.__doc__]}
isdecimal(self)	Return True if the string is a decimal string, False otherwise. _{[extrait de isdecimal.__doc__]}
isdigit(self)	Return True if the string is a digit string, False otherwise. _{[extrait de isdigit.__doc__]}
isidentifier(self)	Return True if the string is a valid Python identifier, False otherwise. _{[extrait de isidentifier.__doc__]}
islower(self)	Return True if the string is a lowercase string, False otherwise. _{[extrait de islower.__doc__]}
isnumeric(self)	Return True if the string is a numeric string, False otherwise. _{[extrait de isnumeric.__doc__]}
isprintable(self)	Return True if the string is printable, False otherwise. _{[extrait de isprintable.__doc__]}
isspace(self)	Return True if the string is a whitespace string, False otherwise. _{[extrait de isspace.__doc__]}
istitle(self)	Return True if the string is a title-cased string, False otherwise. _{[extrait de istitle.__doc__]}
isupper(self)	Return True if the string is an uppercase string, False otherwise. _{[extrait de isupper.__doc__]}
join(self, iterable)	Concatenate any number of strings. _{[extrait de join.__doc__]}
ljust(self, width, fillchar=' ')	Return a left-justified string of length width. _{[extrait de ljust.__doc__]}
lower(self) -> str	Cette méthode produit une nouvelle chaîne de caractères dont l'ensemble des caractères seront mis en minuscules.
lstrip(self, chars=None) -> str	La méthode lstrip renvoie une copie de la chaîne courante, dans laquelle les caractères d'espacement sont retirés en début de chaîne.
maketrans	Return a translation table usable for str.translate(). _{[extrait de maketrans.__doc__]}
partition(self, sep)	Partition the string into three parts using the given separator. _{[extrait de partition.__doc__]}
removeprefix(self, prefix)	Return a str with the given prefix string removed if present. _{[extrait de removeprefix.__doc__]}
removesuffix(self, suffix)	Return a str with the given suffix string removed if present. _{[extrait de removesuffix.__doc__]}
replace(self, old, new, count=-1) -> str	Produit une nouvelle chaîne en replaçant les occurrences d'une chaîne de caractères par une autre.
rfind(self, substring, start=0, end=None) -> int	Renvoie la position dans la chaîne courante de la dernière occurrence de la chaîne passée en paramètre.
rindex(self, substring, start=0, end=None) -> int	Renvoie la position dans la chaîne courante de la dernière occurrence de la chaîne passée en paramètre.
rjust(self, width, fillchar=' ')	Return a right-justified string of length width. _{[extrait de rjust.__doc__]}
rpartition(self, sep)	Partition the string into three parts using the given separator. _{[extrait de rpartition.__doc__]}
rsplit(self, /, sep=None, maxsplit=-1)	Return a list of the substrings in the string, using sep as the separator string. _{[extrait de rsplit.__doc__]}
rstrip(self, chars=None) -> str	La méthode rstrip renvoie une copie de la chaîne courante, dans laquelle les caractères d'espacement sont retirés en fin de chaîne.
split(self, /, sep=None, maxsplit=-1)	Return a list of the substrings in the string, using sep as the separator string. _{[extrait de split.__doc__]}
splitlines(self, /, keepends=False)	Return a list of the lines in the string, breaking at line boundaries. _{[extrait de splitlines.__doc__]}
startswith(self, prefix, start=0, end=None) -> bool	Cette méthode permet de déterminer si une chaîne (ou une sous-chaîne) commence par le préfixe spécifié.
strip(self, chars=None) -> str	La méthode strip renvoie une copie de la chaîne courante, dans laquelle les caractères d'espacement sont retirés en début et fin de chaîne.
swapcase(self) -> str	Cette méthode produit une nouvelle chaîne de caractères dont la casse de chaque caractère aura été inversée (minuscule <-> majuscule).
title(self) -> str	Cette méthode produit une nouvelle chaîne de caractères dont chaque première lettre d'un groupe de lettres sera mise en majuscules, les autres lettres seront en minuscules.
translate(self, table)	Replace each character in the string using the given translation table. _{[extrait de translate.__doc__]}
upper(self) -> str	Cette méthode produit une nouvelle chaîne de caractères dont l'ensemble des caractères seront mis en majuscules.
zfill(self, width)	Pad a numeric string with zeros on the left, to fill a field of the given width. _{[extrait de zfill.__doc__]}