Initialisation de chaînes

Pour les chaînes simples, on peut utiliser les guillemets simples : 

s = "Le mot magique est 'abracadabra'"

ou doubles : 

s = 'Le mot magique est "abracadabra"'

On peut concatener les chaines constantes avec des espaces : 

s = "avec des 'guillemets simples', mais aussi" 'des "guillemets doubles"...'

Pour les chaines qui contiennent des sauts de lignes, on triple les guillemets : 

s = """Ceci est une longue
chaîne de caractères.
En plus, elle contient des
guillemets de toutes les
formes : " ' « »..."""

On peut aussi remplacer """ par '''.

Caractère d'échappement

Le symbole \ est spécial : il permet de transformer le caractère suivant :

Si on veut que le symbole \ reste simplement un \ dans une chaîne, on peut utiliser une chaîne « brute » ("raw string") en préfixant le premier guillemets avec un r : 

s = r"Ceci est une chaîne de caractères\nsur une seule ligne"

Exemples (à compléter)

>>> s = "Ceci est une chaîne de caractères\nsur deux lignes."
>>> print(s)



>>> s = r"Ceci est une chaîne de caractères\nsur une ligne."
>>> print(s)


>>> s = "Et ça fait BIP\a BIP\a..."
>>> print(s)


>>> s = "Zut\b\b\bTabernacle !"
>>> print(s)


>>> s = "| a\t| bb\t| ccc\t| dddd\t| eeeee\t| ffffff\t|"
>>> print(s)

Méthodes : exemples (à compléter)

Les objets « chaînes » peuvent accéder à de nombreuses méthodes. Voici quelques exemples, à compléter pendant le cours et à terminer chez vous... 

>>> s = "salut, Je m'appelle Bob..."
>>> print(s.lower())


>>> print(s.upper())


>>> print(s.title())


>>> print(s.capitalize())


>>> print(s.swapcase())


>>> s = "abracadabra"
>>> print(s.count("bra"), "et", s.count("a"))


>>> print("abc".isalpha())


>>> print("𐤄س狼".isalpha())


>>> print( ",".isalpha() , "∫".isalpha() )



>>> # voir aussi s.isdigit(), s.isalnum(), s.isnumeric()...
...
>>> t = [ "Ceci" , "est" , "un" , "tableau" , "de mots" , "..." ]
>>> print( " ".join(t) )


>>> print( ",".join(t) )


>>> s = "Où est le centre du monde ?"
>>> print(s.center(50))


>>> s = "Où est le centre de l'univers ?"
>>> print(s.center(50,"⋆"))     # avec le second argument explicite


>>> s = "Et la priorité à droite ?"
>>> print(s.rjust(50))          # il y a aussi un second argument, à " " par défaut


>>> s = "  \n\t  Ceci est une chaîne avec des blancs\n\tun peu partout...  \n\n\n"
>>> print(s.strip())



>>> print(s.strip("\n\t Ct,.;?!"))   # il y a des variante s.lstrip() et s.rstrip()



>>> print("Abracadabra".replace("bra" , "bro"))


>>> s = """Ici, il y a :
des espaces, des virgules, des lettres
et le reste."""
>>> print(s.split(","))



>>> print(s.split())    # par défaut, utilise tous les caractères blancs ("\n", "\t", " ")

Exemple d'application

Pour demander une liste de nombres à l'utilisateur : 

>>> def demande_nombres():
        s = input("Rentrez 5 nombres entiers, séparés par des espaces :\n")
        t = s.split()
        for i in range(len(t)):
            t[i] = int(t[i])
        return(t)

Formatage de chaînes de caractères

On peut créer des chaînes « à trous ». La méthode s.format(...) permet de combler ces trous en donnant la liste des valeurs à mettre dans les trous : 

>>> s = "Voici {0}chaîne à {1} trous."
>>> print(s)


>>> print(s.format("une " , 2))


>>> print("a{0}cada{0}".format("bra"))

On peut ainsi insérer des chaînes, des entiers, des flottants ou la plupart des objets de Python...

règles de formatage

Pour les nombres entiers, on peut préciser s'il faut ajouter des espaces ou des 0 devant le nombre : 

>>> print("Un nombre '{0}', et encore '{1:5}' et encore '{2:05}'.".format(42, 43, 44))

On peut préciser qu'il faut mettre le signe + pour les nombres positifs : 

>>> print("Le résultat est '{0:+}'.".format())

On peut indiquer la base (binaire, octal, hexadécimal) pour les nombres entiers, ou la précision pour les nombres flottants, ou si on veut aligner une valeur à gauche / droite / centre d'un trou, etc. Reportez-vous à la documentation de langage pour les détails...

On peut également utiliser des noms explicites pour les champs : 

>>> s = "Le numéro d'étudiant de {prenom} {nom} est {no_etu}"
>>> print(s.format(nom = "Tartempion" , prenom = "Lucien" , no_etu = "01020304"))

Expressions régulières

Les expressions régulières sont un outils pour reconnaitre des chaînes de caractères variables. Par exemple, comment peut-on reconnaitre si une chaine de caractères est une adresse email valide ?

On utilise une notation spéciale (qui peut varier selon les langages) pour repérer des morceaux d'une chaîne de caractères :

Ces notations pour les expressions sont assez standard et existent dans de nombreux autres langages de programmation. Il y a de nombreuses autres expression, pour par exemple mettre une borne sup ou inf sur un nombre de répétition, ou repérer un caractère avant ou après une expression. Reportez vous à la documentation de la bibliothèque "re".

Pour utiliser les expressions régulières, il faut charger la bibliothèque "re" et utiliser la fonction "search(...)". Par exemple, pour repérer un nombre flottant, on peut utiliser l'expression régulière "^[0123456789]*\.[0123456789]*$". 

>>> import re
>>> def is_float(s):
...     m = re.search("^[0123456789]*\.[0-9]*$" , s)
...     if m != None:
...         return True
...     else:
...         return False
>>> is_float("12.34")


>>> is_float(".23")


>>> is_float("12.")


>>> is_float("12")


>>> is_float(".")

Le résultat de la fonction "re.search(...)" est un objet spécial avec en particulier la méthode "group()" qui permet de récupérer le morceau de chaîne de caractères repérée par un groupe (entre parenthèses) : 

>>> m = re.search('<img src="([^"]+)".*>' , '<img src="./Images/logo.gif" width="200"/>')
>>> nom_fichier = m.group(1)
>>> print(nom_fichier)

Le résultat est un tuple avec :

Par exemple 

import re

def nom_prenom(s):
    """Si "s" est une adresse email (chaîne de caractère) de l'université de Savoie,
la fonction renvoie un tuple composé du prénom et du nom de la personne.
Renvoie "None" sinon."""
    s = s.strip()
    m = re.search("^([\\w_-]+)\.([\\w_-]+)@univ-savoie\.fr$" , s)
    if m != None:
        prenom, nom = m.group(1,2)
        return (prenom.capitalize(), nom.capitalize())
    else:
        return None

D'autres fonctions disponibles dans la bibliothèque "re" :

Remarque : il y a de nombreuses autres fonctionnalités autour des expressions régulières. Reportez vous à la page correspondante dans la documentation des bibliothèques Python.