Python Language
Méthodes de chaîne

Syntaxe

• str.capitalize () -> str
• str.casefold () -> str [uniquement pour Python> 3.3]
• str.center (width [, fillchar]) -> str
• str.count (sub [, start [, end]]) -> int
• str.decode (encoding = "utf-8" [, des erreurs]) -> unicode [uniquement dans Python 2.x]
• str.encode (encoding = "utf-8", errors = "strict") -> octets
• str.endswith (suffixe [, début [, fin]]) -> bool
• str.expandtabs (tabsize = 8) -> str
• str.find (sub [, start [, end]]) -> int
• str.format (* args, ** kwargs) -> str
• str.format_map (mapping) -> str
• str.index (sub [, start [, end]]) -> int
• str.isalnum () -> bool
• str.isalpha () -> bool
• str.isdecimal () -> bool
• str.isdigit () -> bool
• str.isidentifier () -> bool
• str.islower () -> bool
• str.isnumeric () -> bool
• str.isprintable () -> bool
• str.isspace () -> bool
• str.istitle () -> bool
• str.isupper () -> bool
• str.join (itérable) -> str
• str.ljust (width [, fillchar]) -> str
• str.lower () -> str
• str.lstrip ([chars]) -> str
• static str.maketrans (x [, y [, z]])
• str.partition (sep) -> (tête, sep, queue)
• str.replace (old, new [, count]) -> str
• str.rfind (sub [, start [, end]]) -> int
• str.rindex (sub [, start [, end]]) -> int
• str.rjust (width [, fillchar]) -> str
• str.rpartition (sep) -> (tête, sep, queue)
• str.rsplit (sep = Aucun, maxsplit = -1) -> liste des chaînes
• str.rstrip ([chars]) -> str
• str.split (sep = Aucun, maxsplit = -1) -> liste de chaînes
• str.splitlines ([keepends]) -> liste des chaînes
• str.startswith (préfixe [, début [, fin]]) -> livre
• str.strip ([chars]) -> str
• str.swapcase () -> str
• str.title () -> str
• str.translate (table) -> str
• str.upper () -> str
• str.zfill (width) -> str

Remarques

Changer la capitalisation d'une chaîne

Le type de chaîne de Python fournit de nombreuses fonctions qui agissent sur la capitalisation d'une chaîne. Ceux-ci inclus :

• str.casefold
• str.upper
• str.lower
• str.capitalize
• str.title
• str.swapcase

Avec les chaînes Unicode (la valeur par défaut dans Python 3), ces opérations ne sont pas des correspondances 1: 1 ou réversibles. La plupart de ces opérations sont destinées à l'affichage, plutôt qu'à la normalisation.

"XßΣ".casefold()
# 'xssσ'

"XßΣ".lower()
# 'xßς'

str.upper()

str.upper prend chaque caractère d'une chaîne et le convertit en son équivalent en majuscule, par exemple:

"This is a 'string'.".upper()
# "THIS IS A 'STRING'."

str.lower()

str.lower fait le contraire; il prend chaque caractère dans une chaîne et le convertit en son équivalent minuscule:

"This IS a 'string'.".lower()
# "this is a 'string'."

str.capitalize()

str.capitalize renvoie une version en majuscule de la chaîne, c'est-à-dire que le premier caractère est en majuscule et le reste plus bas:

"this Is A 'String'.".capitalize() # Capitalizes the first character and lowercases all others
# "This is a 'string'."

str.title()

str.title renvoie la version du titre de la chaîne, c'est-à-dire que chaque lettre au début d'un mot est en majuscule et que toutes les autres sont en minuscule:

"this Is a 'String'".title()
# "This Is A 'String'"

str.swapcase()

str.swapcase renvoie un nouvel objet chaîne dans lequel tous les caractères minuscules sont remplacés par des majuscules et tous les caractères majuscules vers le bas:

"this iS A STRiNG".swapcase() #Swaps case of each character
# "THIS Is a strIng"

Utilisation en tant que méthodes de classe str

Il convient de noter que ces méthodes peuvent être appelées soit sur des objets de type chaîne (voir ci-dessus), soit comme méthode de classe de la classe str (avec un appel explicite à str.upper , etc.).

str.upper("This is a 'string'")
# "THIS IS A 'STRING'"

Ceci est très utile lorsque vous appliquez l'une de ces méthodes à plusieurs chaînes en même temps, par exemple, une fonction de map .

map(str.upper,["These","are","some","'strings'"])
# ['THESE', 'ARE', 'SOME', "'STRINGS'"]

Diviser une chaîne basée sur un délimiteur en une liste de chaînes

str.split(sep=None, maxsplit=-1)

str.split prend une chaîne et retourne une liste de sous-chaînes de la chaîne d'origine. Le comportement diffère selon que l'argument sep est fourni ou omis.

Si sep n'est pas fourni, ou est None , alors le fractionnement a lieu partout où il y a des espaces. Toutefois, les espaces blancs de début et de fin sont ignorés et plusieurs caractères d'espacement consécutifs sont traités de la même manière qu'un seul caractère d'espacement:

>>> "This is a sentence.".split()
['This', 'is', 'a', 'sentence.']

>>> " This is    a sentence.  ".split()
['This', 'is', 'a', 'sentence.']

>>> "            ".split()
[]

Le paramètre sep peut être utilisé pour définir une chaîne de délimiteur. La chaîne d'origine est fractionnée à l'endroit où se trouve la chaîne de délimiteur et le délimiteur lui-même est supprimé. Plusieurs délimiteurs consécutifs ne sont pas traités comme une seule occurrence, mais créent plutôt des chaînes vides.

>>> "This is a sentence.".split(' ')
['This', 'is', 'a', 'sentence.']

>>> "Earth,Stars,Sun,Moon".split(',')
['Earth', 'Stars', 'Sun', 'Moon']

>>> " This is    a sentence.  ".split(' ')
['', 'This', 'is', '', '', '', 'a', 'sentence.', '', '']

>>> "This is a sentence.".split('e')
['This is a s', 'nt', 'nc', '.']

>>> "This is a sentence.".split('en')
['This is a s', 't', 'ce.']

La valeur par défaut consiste à diviser chaque occurrence du délimiteur, mais le paramètre maxsplit limite le nombre de fractionnements. La valeur par défaut de -1 signifie aucune limite:

>>> "This is a sentence.".split('e', maxsplit=0)
['This is a sentence.']

>>> "This is a sentence.".split('e', maxsplit=1)
['This is a s', 'ntence.']

>>> "This is a sentence.".split('e', maxsplit=2)
['This is a s', 'nt', 'nce.']

>>> "This is a sentence.".split('e', maxsplit=-1)
['This is a s', 'nt', 'nc', '.']

str.rsplit(sep=None, maxsplit=-1)

str.rsplit ("split droit") diffère de str.split ("split gauche") lorsque maxsplit est spécifié. Le fractionnement commence à la fin de la chaîne plutôt qu'au début:

>>> "This is a sentence.".rsplit('e', maxsplit=1)
['This is a sentenc', '.']

>>> "This is a sentence.".rsplit('e', maxsplit=2)
['This is a sent', 'nc', '.']

Remarque : Python spécifie le nombre maximal de divisions effectuées, tandis que la plupart des autres langages de programmation spécifient le nombre maximal de sous - chaînes créées. Cela peut créer de la confusion lors du portage ou de la comparaison du code.

Remplacer toutes les occurrences d'une sous-chaîne par une autre sous-chaîne

Le type str de Python a également une méthode pour remplacer les occurrences d'une sous-chaîne par une autre sous-chaîne dans une chaîne donnée. Pour les cas plus exigeants, on peut utiliser re.sub .

str.replace(old, new[, count]) :

str.replace prend deux arguments old et new contenant l' old sous-chaîne à remplacer par la new sous-chaîne. L'argument optionnel count spécifie le nombre de remplacements à effectuer:

Par exemple, pour remplacer 'foo' par 'spam' dans la chaîne suivante, on peut appeler str.replace avec old = 'foo' et new = 'spam' :

>>> "Make sure to foo your sentence.".replace('foo', 'spam')
"Make sure to spam your sentence."

Si la chaîne donnée contient plusieurs exemples correspondant à l' old argument, toutes les occurrences sont remplacées par la valeur fournie dans new :

>>> "It can foo multiple examples of foo if you want.".replace('foo', 'spam')
"It can spam multiple examples of spam if you want."

à moins, bien sûr, que nous fournissions une valeur pour le count . Dans ce cas, les occurrences de count vont être remplacées:

>>> """It can foo multiple examples of foo if you want, \
... or you can limit the foo with the third argument.""".replace('foo', 'spam', 1)
'It can spam multiple examples of foo if you want, or you can limit the foo with the third argument.'

str.format et f-strings: mettre en forme les valeurs dans une chaîne

Python fournit des fonctionnalités d'interpolation et de formatage de chaînes via la fonction str.format , introduite dans la version 2.6 et des f-strings introduites dans la version 3.6.

Compte tenu des variables suivantes:

i = 10
f = 1.5
s = "foo"
l = ['a', 1, 2]
d = {'a': 1, 2: 'foo'}

Les énoncés suivants sont tous équivalents

"10 1.5 foo ['a', 1, 2] {'a': 1, 2: 'foo'}"

>>> "{} {} {} {} {}".format(i, f, s, l, d)

>>> str.format("{} {} {} {} {}", i, f, s, l, d)

>>> "{0} {1} {2} {3} {4}".format(i, f, s, l, d)

>>> "{0:d} {1:0.1f} {2} {3!r} {4!r}".format(i, f, s, l, d)

>>> "{i:d} {f:0.1f} {s} {l!r} {d!r}".format(i=i, f=f, s=s, l=l, d=d)

>>> f"{i} {f} {s} {l} {d}"

>>> f"{i:d} {f:0.1f} {s} {l!r} {d!r}"

Pour référence, Python prend également en charge les qualificateurs de style C pour le formatage des chaînes. Les exemples ci-dessous sont équivalents à ceux ci-dessus, mais les versions de str.format sont préférées en raison des avantages de la flexibilité, de la cohérence de la notation et de l'extensibilité:

"%d %0.1f %s %r %r" % (i, f, s, l, d)

"%(i)d %(f)0.1f %(s)s %(l)r %(d)r" % dict(i=i, f=f, s=s, l=l, d=d)

Les accolades str.format pour l'interpolation dans str.format peuvent également être numérotées pour réduire la duplication lors du formatage des chaînes. Par exemple, les éléments suivants sont équivalents:

"I am from Australia. I love cupcakes from Australia!"

>>> "I am from {}. I love cupcakes from {}!".format("Australia", "Australia")

>>> "I am from {0}. I love cupcakes from {0}!".format("Australia")

Alors que la documentation officielle de python est, comme d'habitude, suffisamment complète, pyformat.info propose un grand nombre d'exemples avec des explications détaillées.

De plus, les caractères { et } peuvent être échappés en utilisant des crochets doubles:

"{'a': 5, 'b': 6}"

>>> "{{'{}': {}, '{}': {}}}".format("a", 5, "b", 6)

>>> f"{{'{'a'}': {5}, '{'b'}': {6}}"

Voir Formatage de chaîne pour plus d'informations. str.format() été proposé dans PEP 3101 et les chaînes de caractères dans PEP 498 .

Comptage du nombre de fois qu'une sous-chaîne apparaît dans une chaîne

Une méthode est disponible pour compter le nombre d'occurrences d'une sous-chaîne dans une autre chaîne, str.count .

str.count(sub[, start[, end]])

str.count renvoie un int indiquant le nombre d'occurrences de non-chevauchement du sous-chaîne sub dans une autre chaîne. Les arguments optionnels start et end indiquent le début et la fin de la recherche. Par défaut start = 0 et end = len(str) signifiant que la chaîne entière sera recherchée:

>>> s = "She sells seashells by the seashore."
>>> s.count("sh")
2
>>> s.count("se")
3
>>> s.count("sea")
2
>>> s.count("seashells")
1

En spécifiant une valeur différente pour start , end , nous pouvons obtenir une recherche plus localisée et compte, par exemple, si start est égal à 13 l'appel à:

>>> s.count("sea", start)
1

est équivalent à:

>>> t = s[start:]
>>> t.count("sea")
1

Tester les caractères de début et de fin d'une chaîne

Pour tester le début et la fin d'une chaîne donnée en Python, on peut utiliser les méthodes str.startswith() et str.endswith() .

str.startswith(prefix[, start[, end]])

Comme son nom l'indique, str.startswith est utilisé pour tester si une chaîne donnée commence par les caractères donnés dans le prefix .

>>> s = "This is a test string"
>>> s.startswith("T")
True
>>> s.startswith("Thi")
True
>>> s.startswith("thi")  
False

Les arguments optionnels start et end spécifient les points de début et de fin à partir desquels les tests vont commencer et se terminer. Dans l'exemple suivant, en spécifiant une valeur de départ de 2 notre chaîne sera recherchée à partir de la position 2 et après:

>>> s.startswith("is", 2)
True

Cela donne True puisque s[2] == 'i' et s[3] == 's' .

Vous pouvez également utiliser un tuple pour vérifier s'il commence par un jeu de chaînes

>>> s.startswith(('This', 'That'))
True
>>> s.startswith(('ab', 'bc'))
False

str.endswith(prefix[, start[, end]])

str.endswith est exactement similaire à str.startswith la seule différence étant qu'il recherche les caractères de fin et non les caractères de départ. Par exemple, pour tester si une chaîne se termine par un arrêt complet, on pourrait écrire:

>>> s = "this ends in a full stop."
>>> s.endswith('.')
True
>>> s.endswith('!')
False

comme avec les startswith plus d'un caractère peut être utilisé comme séquence de fin:

>>> s.endswith('stop.')
True
>>> s.endswith('Stop.')
False

Vous pouvez également utiliser un tuple pour vérifier s'il se termine par un jeu de chaînes

>>> s.endswith(('.', 'something'))
True
>>> s.endswith(('ab', 'bc'))
False

Test de la composition d'une chaîne

Le type str de Python comporte également un certain nombre de méthodes permettant d'évaluer le contenu d'une chaîne. Ce sont str.isalpha , str.isdigit , str.isalnum , str.isspace . La capitalisation peut être testée avec str.isupper , str.islower et str.istitle .

str.isalpha

str.isalpha ne prend aucun argument et renvoie True si tous les caractères d'une chaîne donnée sont alphabétiques, par exemple:

>>> "Hello World".isalpha()  # contains a space
False
>>> "Hello2World".isalpha()  # contains a number
False
>>> "HelloWorld!".isalpha()  # contains punctuation
False
>>> "HelloWorld".isalpha()
True

En tant que casse, la chaîne vide est évaluée à False lorsqu'elle est utilisée avec "".isalpha() .

str.isupper , str.islower , str.istitle

Ces méthodes testent la capitalisation dans une chaîne donnée.

str.isupper est une méthode qui renvoie True si tous les caractères d'une chaîne donnée sont en majuscule et False sinon.

>>> "HeLLO WORLD".isupper()
False
>>> "HELLO WORLD".isupper()
True
>>> "".isupper()
False

Inversement, str.islower est une méthode qui renvoie True si tous les caractères d'une chaîne donnée sont en minuscule et False .

>>> "Hello world".islower()
False
>>> "hello world".islower()
True
>>> "".islower()
False

str.istitle retourne True si la chaîne donnée est str.istitle le titre; c'est-à-dire que chaque mot commence par un caractère majuscule suivi de caractères minuscules.

>>> "hello world".istitle()
False
>>> "Hello world".istitle()
False
>>> "Hello World".istitle()
True
>>> "".istitle()
False

str.isdecimal , str.isdigit , str.isnumeric

str.isdecimal renvoie si la chaîne est une séquence de chiffres décimaux, appropriée pour représenter un nombre décimal.

str.isdigit inclut des chiffres qui ne sont pas sous une forme appropriée pour représenter un nombre décimal, tel que des chiffres en exposant.

str.isnumeric inclut toutes les valeurs numériques, même si ce ne sont pas des chiffres, telles que des valeurs en dehors de l'intervalle 0-9.

            isdecimal    isdigit   isnumeric

12345        True        True       True
១2߃໔5        True        True       True
①²³🄅₅       False       True       True
⑩⒓          False       False      True
Five         False       False      False

Les bytestrings ( bytes dans Python 3, str dans Python 2), ne supportent que isdigit , qui vérifie uniquement les chiffres ASCII de base.

Comme avec str.isalpha , la chaîne vide a la valeur False .

str.isalnum

Il s'agit d'une combinaison de str.isalpha et de str.isnumeric , en particulier de True si tous les caractères de la chaîne donnée sont alphanumériques , c'est-à-dire qu'ils sont composés de caractères alphabétiques ou numériques:

>>> "Hello2World".isalnum()
True
>>> "HelloWorld".isalnum()
True
>>> "2016".isalnum()
True
>>> "Hello World".isalnum()  # contains whitespace
False

str.isspace

Évalue à True si la chaîne ne contient que des caractères d'espacement.

>>> "\t\r\n".isspace()
True
>>> " ".isspace()
True

Parfois, une chaîne a l'air “vide” mais nous ne savons pas si c'est parce qu'elle contient uniquement des espaces ou pas de caractères du tout.

>>> "".isspace()
False

Pour couvrir ce cas, nous avons besoin d'un test supplémentaire

>>> my_str = ''
>>> my_str.isspace()
False
>>> my_str.isspace() or not my_str
True

Mais le moyen le plus court de tester si une chaîne est vide ou contient simplement des caractères d'espacement est d'utiliser strip (sans arguments, cela supprime tous les caractères blancs avant et après).

>>> not my_str.strip()
True

str.translate: Traduction de caractères dans une chaîne

Python prend en charge une méthode de translate sur le type str qui vous permet de spécifier la table de traduction (utilisée pour les remplacements) ainsi que tous les caractères à supprimer dans le processus.

str.translate(table[, deletechars])

La méthode maketrans ( str.maketrans dans Python 3 et string.maketrans dans Python 2) vous permet de générer une table de traduction.

>>> translation_table = str.maketrans("aeiou", "12345")
>>> my_string = "This is a string!"
>>> translated = my_string.translate(translation_table)
'Th3s 3s 1 str3ng!'

La méthode translate renvoie une chaîne qui est une copie traduite de la chaîne d'origine.

Vous pouvez définir l'argument de la table sur None si vous devez uniquement supprimer des caractères.

>>> 'this syntax is very useful'.translate(None, 'aeiou')
'ths syntx s vry sfl'

Retirer des caractères de début / fin indésirables d'une chaîne

Trois méthodes permettent de str.strip les caractères de str.strip et de fin d’une chaîne: str.strip , str.rstrip et str.lstrip . Les trois méthodes ont la même signature et toutes les trois renvoient un nouvel objet chaîne avec des caractères indésirables supprimés.

str.strip([chars])

str.strip agit sur une chaîne donnée et supprime (strip) les caractères de str.strip ou de fin contenus dans les chars l'argument; Si les chars ne sont pas fournis ou sont None , tous les espaces sont supprimés par défaut. Par exemple:

>>> "    a line with leading and trailing space     ".strip() 
'a line with leading and trailing space'

Si des chars sont fournis, tous les caractères qu'il contient sont supprimés de la chaîne, qui est renvoyée. Par exemple:

>>> ">>> a Python prompt".strip('> ')  # strips '>' character and space character 
'a Python prompt'

str.rstrip([chars]) et str.lstrip([chars])

Ces méthodes ont une sémantique et des arguments similaires avec str.strip() , leur différence se situe dans la direction de départ. str.rstrip() commence à la fin de la chaîne alors que str.lstrip() se sépare du début de la chaîne.

Par exemple, en utilisant str.rstrip :

>>> "     spacious string      ".rstrip()
'     spacious string'

En utilisant str.lstrip :

>>> "     spacious string      ".rstrip()
'spacious string      '

Comparaisons de chaînes insensibles à la casse

Comparer une chaîne de manière insensible à la casse semble être quelque chose d'anodin, mais ce n'est pas le cas. Cette section ne considère que les chaînes Unicode (la valeur par défaut dans Python 3). Notez que Python 2 peut avoir des faiblesses subtiles par rapport à Python 3 - la gestion unicode ultérieure est beaucoup plus complète.

La première chose à noter est que les conversions de suppression de casse dans Unicode ne sont pas triviales. Il y a du texte pour text.lower() != text.upper().lower() , tel que "ß" :

>>> "ß".lower()
'ß'

>>> "ß".upper().lower()
'ss'

Mais disons que vous vouliez comparer sans "BUSSE" et "Buße" . Heck, vous voulez probablement aussi comparer "BUSSE" et "BUẞE" égaux - c'est la nouvelle forme de capital. La méthode recommandée est d'utiliser le casefold :

>>> help(str.casefold)
"""
Help on method_descriptor:

casefold(...)
      S.casefold() -> str
    
     Return a version of S suitable for caseless comparisons.
"""

Ne pas utiliser lower . Si le casefold n'est pas disponible, faire .upper().lower() aide (mais seulement un peu).

Ensuite, vous devriez considérer les accents. Si votre moteur de rendu est bon, vous pensez probablement "ê" == "ê" - mais ce n’est pas le cas:

>>> "ê" == "ê"
False

C'est parce qu'ils sont en fait

>>> import unicodedata

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E WITH CIRCUMFLEX']

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E', 'COMBINING CIRCUMFLEX ACCENT']

La manière la plus simple de gérer cela est unicodedata.normalize . Vous souhaitez probablement utiliser la normalisation NFKD , mais n'hésitez pas à consulter la documentation. Alors on fait

>>> unicodedata.normalize("NFKD", "ê") == unicodedata.normalize("NFKD", "ê")
True

Pour finir, ceci est exprimé en fonctions:

import unicodedata

def normalize_caseless(text):
    return unicodedata.normalize("NFKD", text.casefold())

def caseless_equal(left, right):
    return normalize_caseless(left) == normalize_caseless(right)

Joindre une liste de chaînes dans une chaîne

Une chaîne peut être utilisée comme séparateur pour joindre une liste de chaînes en une seule chaîne à l'aide de la méthode join() . Par exemple, vous pouvez créer une chaîne où chaque élément d'une liste est séparé par un espace.

>>> " ".join(["once","upon","a","time"])
"once upon a time"

L'exemple suivant sépare les éléments de chaîne avec trois traits d'union.

>>> "---".join(["once", "upon", "a", "time"])
"once---upon---a---time"

Les constantes utiles du module String

Le module de string de Python fournit des constantes pour les opérations liées aux chaînes. Pour les utiliser, importez le module de string :

>>> import string

string.ascii_letters :

Concaténation de ascii_lowercase et ascii_uppercase :

>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.ascii_lowercase :

Contient tous les caractères ASCII minuscules:

>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'

string.ascii_uppercase :

Contient tous les caractères ASCII majuscules:

>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.digits :

Contient tous les caractères numériques décimaux:

>>> string.digits
'0123456789'

string.hexdigits :

Contient tous les caractères hexadécimaux:

>>> string.hexdigits
'0123456789abcdefABCDEF'

string.octaldigits :

Contient tous les caractères numériques octaux:

>>> string.octaldigits
'01234567'

string.punctuation :

Contient tous les caractères considérés comme des signes de ponctuation dans les paramètres régionaux C :

>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

string.whitespace :

Contient tous les caractères ASCII considérés comme des espaces:

>>> string.whitespace
' \t\n\r\x0b\x0c'

En mode script, print(string.whitespace) imprimera les caractères réels, utilisez str pour obtenir la chaîne retournée ci-dessus.

string.printable :

Contient tous les caractères considérés imprimables. une combinaison de string.digits , string.ascii_letters , string.punctuation et string.whitespace .

>>> string.printable
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

Inverser une chaîne

Une chaîne peut être inversée à l'aide de la fonction Reverse reversed() intégrée, qui prend une chaîne et renvoie un itérateur dans l'ordre inverse.

>>> reversed('hello')
<reversed object at 0x0000000000000000>
>>> [char for char in reversed('hello')]
['o', 'l', 'l', 'e', 'h']

reversed() peut être inclus dans un appel à ''.join() pour créer une chaîne à partir de l'itérateur.

>>> ''.join(reversed('hello'))
'olleh'

Bien que l'utilisation de reversed() soit plus lisible pour les utilisateurs non initiés de Python, l'utilisation du découpage étendu avec un pas de -1 est plus rapide et plus concise. Ici, essayez de le mettre en œuvre en tant que fonction:

>>> def reversed_string(main_string):
...     return main_string[::-1]
...
>>> reversed_string('hello')
'olleh'

Justifier les chaînes

Python fournit des fonctions pour justifier les chaînes, permettant un remplissage du texte pour faciliter l'alignement des différentes chaînes.

Voici un exemple de str.ljust et de str.rjust :

interstates_lengths = {
    5: (1381, 2222),
    19: (63, 102),
    40: (2555, 4112),
    93: (189,305),
}
for road, length in interstates_lengths.items():
    miles,kms = length
    print('{} -> {} mi. ({} km.)'.format(str(road).rjust(4), str(miles).ljust(4), str(kms).ljust(4)))

  40 -> 2555 mi. (4112 km.)
  19 -> 63   mi. (102  km.)
   5 -> 1381 mi. (2222 km.)
  93 -> 189  mi. (305  km.)

ljust et rjust sont très similaires. Les deux ont un paramètre width et un paramètre facultatif fillchar . Toute chaîne créée par ces fonctions est au moins aussi longue que le paramètre width qui a été transmis à la fonction. Si la chaîne est plus longue que la width , elle n'est pas tronquée. L'argument fillchar , qui fillchar défaut le caractère d'espace ' ' doit être un caractère unique et non une chaîne à caractères multiples.

La ljust fonction Tapis de la fin de la chaîne , il est appelé avec la fillchar jusqu'à ce qu'il soit de width caractères. La fonction rjust le début de la chaîne de la même manière. Par conséquent, le l et le r dans les noms de ces fonctions font référence au côté dans lequel la chaîne d'origine, pas le fillchar , est positionnée dans la chaîne de sortie.

Conversion entre les données str ou bytes et les caractères unicode

Le contenu des fichiers et des messages réseau peut représenter des caractères codés. Ils doivent souvent être convertis en Unicode pour un affichage correct.

Dans Python 2, vous devrez peut-être convertir des données str en caractères Unicode. La valeur par défaut ( '' , "" , etc.) est une chaîne ASCII, les valeurs en dehors de la plage ASCII étant affichées en tant que valeurs échappées. Les chaînes Unicode sont u'' (ou u"" , etc.).

# You get "© abc" encoded in UTF-8 from a file, network, or other data source

s = '\xc2\xa9 abc'  # s is a byte array, not a string of characters
                    # Doesn't know the original was UTF-8
                    # Default form of string literals in Python 2
s[0]                # '\xc2' - meaningless byte (without context such as an encoding)
type(s)             # str - even though it's not a useful one w/o having a known encoding

u = s.decode('utf-8')  # u'\xa9 abc'
                       # Now we have a Unicode string, which can be read as UTF-8 and printed properly
                       # In Python 2, Unicode string literals need a leading u
                       # str.decode converts a string which may contain escaped bytes to a Unicode string
u[0]                # u'\xa9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # unicode

u.encode('utf-8')   # '\xc2\xa9 abc'
                    # unicode.encode produces a string with escaped bytes for non-ASCII characters

Dans Python 3, vous devrez peut-être convertir des tableaux d'octets (appelés «littéraux d'octets») en chaînes de caractères Unicode. La valeur par défaut est désormais une chaîne Unicode, et ByteString littéraux doit maintenant être entré comme b'' , b"" , etc. Un octet littéral retourne True à isinstance(some_val, byte) , en supposant some_val être une chaîne qui pourrait être codé en octets.

# You get from file or network "© abc" encoded in UTF-8

s = b'\xc2\xa9 abc' # s is a byte array, not characters
                    # In Python 3, the default string literal is Unicode; byte array literals need a leading b
s[0]                # b'\xc2' - meaningless byte (without context such as an encoding)
type(s)             # bytes - now that byte arrays are explicit, Python can show that.

u = s.decode('utf-8')  # '© abc' on a Unicode terminal
                       # bytes.decode converts a byte array to a string (which will, in Python 3, be Unicode)
u[0]                # '\u00a9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # str
                    # The default string literal in Python 3 is UTF-8 Unicode

u.encode('utf-8')   # b'\xc2\xa9 abc'
                    # str.encode produces a byte array, showing ASCII-range bytes as unescaped characters.

Chaîne contient

Python le rend extrêmement intuitif pour vérifier si une chaîne contient une sous-chaîne donnée. Utilisez simplement l'opérateur in :

>>> "foo" in "foo.baz.bar"
True

Note: tester une chaîne vide donnera toujours True :

>>> "" in "test"
True