Les données alphanumériques.
À la différence des données numériques, qui sont des entités singulières, les chaînes de caractères (ou string) constituent un "type de donnée composite". Nous entendons par là une entité bien définie qui est faite elle-même d'un ensemble d'entités plus petites, en l'occurrence : les caractères. Suivant les circonstances, nous serons amenés à traiter une telle donnée composite, tantôt comme un seul objet, tantôt comme une suite ordonnée d'éléments. Dans ce dernier cas, nous souhaiterons probablement pouvoir accéder à chacun de ces éléments à titre individuel.
En fait, les chaînes de caractères font partie d'une catégorie d'objets Python que l'on appelle des "séquences", et dont font partie aussi les "listes" et les "tuples".
Le type « string ».
Sous Python, une donnée de type "string" est une suite quelconque de caractères délimitée soit par des apostrophes ("simple quotes"), soit par des guillemets ("double quotes"), soit par des "triples quotes" ( ou """).
Exemples :
»> phrase1 = 'les œufs durs.'
»> phrase2 = '"Oui", répondit-il,'
»> phrase3 = "j'aime bien"
»> print(phrase2, phrase3, phrase1)
"Oui", répondit-il, j'aime bien les œufs durs.
print("""1, " 2", \n 3,
4""")
Résultat :
1, " 2", 
 3,
4
Les trois variables codice_1, codice_2, codice_3 sont donc des variables de type "string".
Accès aux caractères individuels d'une chaîne.
Les chaînes de caractères constituent un cas particulier d'un type de données plus général que l'on appelle des "données composites". Une donnée composite est une entité qui rassemble dans une seule structure un ensemble d'entités plus simples : dans le cas d'une chaîne de caractères, par exemple, ces entités plus simples sont évidemment les caractères eux-mêmes. En fonction des circonstances, nous souhaiterons traiter la chaîne de caractères, tantôt comme un seul objet, tantôt comme une collection de caractères distincts. Un langage de programmation tel que Python doit donc être pourvu de mécanismes qui permettent d'accéder séparément à chacun des caractères d'une chaîne.
Python considère qu'une chaîne de caractères est un objet de la catégorie des séquences, lesquelles sont des "collections ordonnées d'éléments". Cela signifie simplement que les caractères d'une chaîne sont toujours disposés dans un certain ordre. Par conséquent, chaque caractère de la chaîne peut être désigné par sa place dans la séquence, à l'aide d'un index.
Pour accéder à un caractère bien déterminé, on utilise le nom de la variable qui contient la chaîne, et on lui accole entre deux crochets l'index numérique qui correspond à la position du caractère dans la chaîne.
Taille des chaines.
»> print(len(c))
29 #La chaîne de caractères 'c' contient 29 caractères !
»> print(len('Zowerz'))
6
Sous-chaines.
L'opérateur d'indiçage ([]) permet aussi de sélectionner des sous-chaines selon leurs indices. On appelle cette technique le "slicing" (« découpage en tranches »).
Dans la tranche codice_5, le nième caractère est inclus, mais pas le mième. Si vous voulez mémoriser aisément ce mécanisme, il faut vous représenter que les indices pointent des emplacements situés entre les caractères, comme dans le schéma ci-dessous :
Au vu de ce schéma, il n'est pas difficile de comprendre que codice_6 extraira codice_7. Notez qu'il faut impérativement utiliser un deux-points (:) : l'utilisation d'une virgule ou d'un point-virgule retournera une erreur.
De plus, si la borne de départ est le premier caractère (indice 0) ou si celle d'arrivée est la dernière (indice égal à la longueur de la chaine), il devient facultatif. Une borne négative "-x" prendra le "x"-ième caractère en partant de la fin, ainsi -1 désignera le dernier caractère, -2 l'avant-dernier, -3 l’antépénultième, etc. Cela ne marche pas avec [-0], qui retournera le premier caractère car -0 = +0. Exemple :
»> chain = "123456789"
»> print(chain[1:3])
23
»> print(chain[0:-1])
12345678
»> print(chain[:-1])
12345678
»> print(chain[1:len(chain)])
23456789
»> print(chain[1:])
23456789
Pour une chaîne de caractère codice_8, les indices doivent être compris entre codice_9 et codice_10.
En dehors de cet intervalle, l'interpréteur retourne le message d'erreur suivant :
 IndexError: string index out of range
Pour vérifier le début et la fin d'une chaîne sans avoir à déterminer sur quelle longueur, on peut utiliser "startswith()" et "endswith()", mais c'est moins rapide car faisant appel à une fonction de plus haut niveau. 
if chain.startswith('1234'):
 print('ok')
if chain.endswith('89'):
 print('ok')
Concaténation.
L'opération d'assembler plusieurs petites chaînes pour en construire une plus grande s'appelle "concaténation" et on la réalise sous Python à l'aide de l'opérateur "+". Exemple :
a = 'Petit poisson'
b = ' deviendra grand'
c = a + b
print(c)
 petit poisson deviendra grand
Pour convertir en nombre véritable une chaîne de caractères qui représente un nombre. Exemple :
»> chaine = '8647' 
»> print(chaine + 45)
 ==> *** erreur *** on ne peut pas additionner une chaîne et un nombre 
»> print(int(chaine) + 65)
8712 # OK : on peut additionner deux nombres
»> print(chaine + str(65))
864765 # OK : on peut concaténer deux chaines
Dans cet exemple, la fonction intégrée codice_11 convertit la chaîne en nombre entier, et codice_12 convertit l'entier en chaîne.
Parcours d'une séquence : for... in....
Il arrive très souvent que l'on doive traiter l'intégralité d'une chaîne caractère par caractère, du premier jusqu'au dernier, pour effectuer à partir de chacun d'eux une opération quelconque. Nous appellerons cette opération un "parcours". En nous limitant aux outils Python que nous connaissons déjà, nous pouvons envisager d'encoder un tel parcours sur la base de l'instruction codice_13 :
nom = 'Jacqueline'
index = 0
while index < len(nom):
 print(nom[index], '*', end=") # En Python 2: print(nom[index] + ' *'), 
 index = index + 1
Cette boucle « parcourt » donc la chaîne nom pour en extraire un à un tous les caractères, lesquels sont ensuite imprimés avec interposition d'astérisques. Notez bien que la condition utilisée avec l'instruction while est codice_14, ce qui signifie que le bouclage doit s'effectuer jusqu'à ce que l'on soit arrivé à l'indice numéro 9 (la chaîne compte en effet 10 caractères). Nous aurons effectivement traité tous les caractères de la chaîne, puisque ceux-ci sont indicés de "zéro" à 9.
Le parcours d'une séquence est une opération très fréquente en programmation. Pour en faciliter l'écriture, Python vous propose une structure de boucle plus appropriée, basée sur le couple d'instructions codice_15 :
Avec ces instructions, le programme ci-dessus devient :
nom = 'Jacqueline'
for character in nom:
 print(character, '*', end=") # En Python 2: print(character + ' *'),
Comme vous pouvez le constater, cette structure de boucle est plus compacte. Elle vous évite d'avoir à définir et à incrémenter une variable spécifique (un « compteur ») pour gérer l'indice du caractère que vous voulez traiter à chaque itération. La variable codice_16 contiendra successivement tous les caractères de la chaîne, du premier jusqu'au dernier.
L'instruction for permet donc d'écrire des boucles, dans lesquelles "l'itération traite successivement tous les éléments d'une séquence donnée". Dans l'exemple ci-dessus, la séquence était une chaîne de caractères. L'exemple ci-après démontre que l'on peut appliquer le même traitement aux listes :
liste = ['chien','chat','crocodile']
for animal in liste:
 print('longueur de la chaîne', animal, '=', len(animal))
L'exécution de ce script donne :
longueur de la chaîne chien = 5
longueur de la chaîne chat = 4
longueur de la chaîne crocodile = 9
L'instruction codice_17 est un nouvel exemple d’"instruction composée". N'oubliez donc pas le double point obligatoire à la fin de la ligne, et l'indentation du bloc d'instructions qui suit.
Le nom qui suit le mot réservé in est celui de la séquence qu'il faut traiter. Le nom qui suit le mot réservé for est celui que vous choisissez pour la variable destinée à contenir successivement tous les éléments de la séquence. Cette variable est définie automatiquement (c'est-à-dire qu'il est inutile de la définir au préalable), et son type est automatiquement adapté à celui de l'élément de la séquence qui est en cours de traitement.
Exemple :
divers = ['cheval', 3, 17.25, [5, 'Jean']]
for e in divers:
 print(e)
L'exécution de ce script donne :
cheval
3
17.25
[5, 'Jean']
Bien que les éléments de la liste divers soient tous de types différents (une chaîne de caractères, un entier, un réel, une liste), on peut affecter successivement leurs contenus à la variable e, sans qu'il s'ensuive des erreurs (ceci est rendu possible grâce au typage dynamique des variables Python).
Appartenance d'un élément à une séquence : if.. in....
L'instruction codice_18 peut être utilisée indépendamment de codice_17, pour vérifier si un élément donné fait partie ou non d'une séquence. Vous pouvez par exemple vous servir de codice_18 pour vérifier si tel caractère alphabétique fait partie d'un groupe bien déterminé :
car = "e"
voyelles = "aeiouyAEIOUY"
if car in voyelles:
 print (car, "est une voyelle")
D'une manière similaire, vous pouvez vérifier l'appartenance d'un élément à une liste :
n = 5
nombrePremiers = [1, 2, 3, 5, 7, 11, 13, 17]
if n in nombrePremiers:
 print(n, "fait partie de notre liste de nombres premiers")
Cette instruction très puissante effectue donc à elle seule un véritable parcours de la séquence. À titre d'exercice, écrivez les instructions qui effectueraient le même travail à l'aide d'une boucle classique utilisant l'instruction codice_13.
Méthodes des objets string.
Sous Python, les chaînes de caractères sont des objets. On peut donc effectuer de nombreux traitements dessus en utilisant des méthodes appropriées. En voici quelques-unes, choisies parmi les plus utiles. Mais vous pouvez obtenir la liste complète de toutes les méthodes associées à un objet à l'aide de la fonction intégrée codice_22 ou codice_23 :
»> dir(")
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
»> foin = "Portez ce vieux whisky au juge blond qui fume"
»> print (foin.index("w"))
16
»> foin = "Cette leçon vaut bien un fromage, sans doute ?"
»> aiguille = "fromage"
»> print(foin.find(aiguille))
25
<pre>
»> foin = "Cette leçon vaut bien deux fromages, dont un fromage râpé ?"
»> aiguille = "fromage"
»> print(foin.rfind(aiguille))
46
»> foin = "Le héron au long bec emmanché d'un long cou"
»> aiguille = 'long'
»> print(foin.count(aiguille))
2
»> phrase ="ATTENTION : Danger !"
»> print(phrase.lower())
attention : danger !
»> phrase = "Merci beaucoup"
»> print(phrase.upper())
MERCI BEAUCOUP
»> phrase = "quel beau temps, aujourd'hui !"
»> print(phrase.capitalize())
"Quel beau temps, aujourd'hui !"
»> phrase = "La CIGALE et la FOURMI"
»> print(phrase.swapcase())
lA cigale ET LA fourmi
»> phrase = " Monty Python "
»> phrase.strip()
'Monty Python'
»> phrase = "Si ce n'est toi c'est donc ton frère"
»> print(phrase.replace(" ","_"))
Si_ce_n'est_toi_c'est_donc_ton_frère
Dans la plupart de ces méthodes, il est possible de préciser quelle portion de la chaîne doit être traitée, en ajoutant des arguments supplémentaires.
»> print(ch9.index("e")) # cherche à partir du début de la chaîne 
4 # et trouve le premier 'e'
»> print(ch9.index("e",5)) # cherche seulement à partir de l'indice 5
8 # et trouve le second 'e'
»> print(ch9.index("e",15)) # cherche à partir du caractère n° 15
29 # et trouve le quatrième 'e'