séquences & chaines

c’est quoi une séquence ?¶

• suite finie et ordonnée d’objets

• du coup indexable, on peut écrire S[n]

  • en Python, les indices commencent à 0

• peuvent contenir des duplications

les séquences dans le langage Python (entre autres):

• mutable

  • list, bytearray

• immutable

  • str, bytes, tuple, range

fonctions sur toutes les séquences¶

indexation, longueur¶

• S[i]

  • retourne l’élément d’indice i

• len(S)

  • donne la taille en nombre d’éléments

les séquences sont des itérables¶

un itérable en Python, c’est un objet sur lequel on peut faire un for

for item in S:
    # do something with item

concaténation, comparaisons¶

• S + T

• retourne une nouvelle séquence qui est la concaténation de S et T

• S*n ou n*S

  • retourne une nouvelle séquence qui est la concaténation de n shallow copies de S

• sum(S) (resp. min(S) et max(S))

  • retourne la somme des éléments de S (resp. le plus petit, le plus grand)

appartenance, recherches¶

• x in S; selon les types:

  • True si un élément de S est égal à x
    (e.g. S est une list)

  • True si S contient x
    (e.g. S est une str)

• diverses méthodes (voir docs):

  • S.count(a)

    • retourne le nombre d’occurrences de a dans S

  • S.index(a), S.find(a)
    retourne l’indice de la première occurrence de a dans S

slicing¶

• S[i:j] retourne

  • une nouvelle séquence de même type

  • contenant tous les éléments de l’indice i à l’indice j-1

• S[i:j:k] retourne

  • une nouvelle séquence de même type

  • prenant tous les éléments de l’indice i à l’indice j-1,

  • par sauts de k éléments

• les indices i, j et k peuvent être négatifs

voyons des exemples de tout ceci

indices omis et négatifs¶

• omettre les bornes

• compter depuis la fin, avec un indice négatif

s = "egg, bacon"
s[0:3]

# si on omet une borne
# ce sera le début ..
s[:3]

# ... ou la fin:
s[5:]

# les indices peuvent être négatifs
s[-3:10]

# tout entier: une shallow-copy
s[:]

les bornes¶

La convention est choisie pour pouvoir facilement “encastrer” les slices:

s[0:3]

s[3:6]

s[6:]

s[0:3] + s[3:6] + s[6:] == s

le pas¶

• on peut préciser un pas

• qui peut aussi être négatif

• ou omis (défaut 1)

s[0:10:2]

s[::2]

s[:8:3]

s[-2::-3]

pas d’exception¶

les slices ont un comportement plus permissif que l’indexation

# Si j'essaie d'utiliser un index inexistant
try: s[100]
except Exception as e: print("OOPS", e)

OOPS string index out of range

# par contre avec un slice, pas de souci
s[5:100]

# vraiment..
s[100:200]

exemples¶

s[-1]

s[-3:-1]

s[:-3]

s[::-1]

s[2:0:-1]

s[2::-1]

formes idiomatiques¶

s = [1, 2, 3]

# une copie simple
s[:]

# copie renversée
s[::-1]

str pour manipuler du texte¶

• le type str est un cas particuliers de séquence

• qui permet de manipuler du texte

écrire une str de manière littérale¶

• une chaîne de caractères est définie de manière équivalente par des simples ou doubles guillemets (' ou ")

• on peut ainsi facilement inclure un guillemet

# une chaine entre double quotes
# pas de souci pour les accents
print("c'est l'été")

c'est l'été

# entre simple quotes
print('on se dit "pourquoi pas"')

on se dit "pourquoi pas"

sur plusieurs lignes¶

• pour écrire une chaîne sur plusieurs lignes on utilise """ ou '''

# bien sûr ici vous pouvez remplacer les """ par '''

print("""et pour entrer plusieurs lignes,
ou bien des chaines avec des " et des '
c'est facile aussi""")

et pour entrer plusieurs lignes,
ou bien des chaines avec des " et des '
c'est facile aussi

chaînes de caractères accolées¶

• lorsque vous voulez entrer une chaine un peu longue

• vous pouvez simplement accoler deux chaines dans votre source:

s = "le début" " et la fin"
print(s)

le début et la fin

s = ("une chaine trop longue"
     " pour tenir sur une ligne")
print(s)

une chaine trop longue pour tenir sur une ligne

échappements dans les chaines¶

• le caractère \ a un sens particulier dans les chaines écrites de manière littérale dans le programme

• on écrit un retour chariot avec un \n

• une tabulation avec \t

• les guillemets peuvent être échappés (e.g. pour entrer un ' dans une chaine délimitée avec un ')

• un backslash avec \\

• enfin on peut aussi entrer des caractères exotiques par leur codepoint avec

  • \x \u \U

s = "deux\nlignes"
print(s)

deux
lignes

s = 'des\ttrucs\tespacés'
print(s)

des	trucs	espacés

# imaginons qu'on ait les deux sortes de guillemets
s = "simple' double\""
print(s)

simple' double"

s = 'backslash \\\tquote \''
print(s)

backslash \	quote '

raw-strings¶

voici un problème commun, surtout sous Windows:
on aurait envie d’écrire

s = 'C:\Temp\test.txt'

# du coup on est amené à utiliser plutôt une raw-string

s = r'C:\Temp\test.txt'
print(s)

C:\Temp\test.txt

en dehors des raw-strings, on utilise fréquemment des backslash pour échapper les caractères spéciaux

docstrings¶

une docstring est une chaine littérale insérée au tout début du code d’une fonction (ou classe ou module) et qui sert à la documenter
on utilise souvent les triples guillemets pour cela

def double(n):
    """
    Returns the double of its input parameter

    The help message usually spans several lines
    """
    return 2*n

help(double)

Help on function double in module __main__:

double(n)
    Returns the double of its input parameter

    The help message usually spans several lines

opérations sur les str¶

toutes les opérations des séquences¶

que l’on a déjà vues :

s1 = 'abcdéfg'
s2 = 'bob'
len(s1)

# concaténation
s1 + s2
'abcdefbob'

# slicing
s1[-1::-2]

'=' * 30

# est-ce une sous-chaine ?
'cdé' in s1

# à quelle position ?
s1.index('cdé')

objet str non mutable¶

par contre ATTENTION un str n’est pas mutable

try:
    s1[2] = 'x'
except TypeError as e:
    print("OOPS", e, type(e))

OOPS 'str' object does not support item assignment <class 'TypeError'>

méthodes sur les str¶

strip()¶

# j'ai lu une chaine dans un fichier
# je ne sais pas trop s'il y a des espaces à la fin
# et si la chaine contient un newline

dirty = "  des blancs au début et à la fin et un newline  \n"
dirty

# c'est la méthode la plus simple pour nettoyer
dirty.strip()

split() et join()¶

# une chaine à découper
s = "une phrase\nsur deux lignes"
s

# sans argument, split
# découpe selon les espaces
# et tabulations et newline
liste = s.split()
liste

# recoller les morceaux
"".join(liste)

# le plus souvent
" ".join(liste)

# ou n'importe quel autre séparateur
"+++".join(liste)

remplacements, recherches¶

s = "une petite phrase"
s.replace('petite', 'grande')

# l'index du premier caractère
s.find('hra')

s[12]

et plein d’autres..¶

• de nombreuses méthodes disponibles

• personne ne retient l’intégralité des méthodes sur les types de base

• le bon réflexe : chercher dans la dos Python qui est très bien faite

• google les simples mots clés ‘python str’, vous trouvez

• https://docs.python.org/3/library/stdtypes.html

un peu d’introspection (avancé)¶

disons qu’on voudrait savoir combien de méthodes sont disponibles sur les chaines.

type("abc")

str

# 'str' est une variable prédéfinie, qui référence
# le type (la classe) de toutes les chaines
type("abc") is str

# du coup son type, c'est .. le type <type>
type(str)

un peu d’introspection...¶

# peu importe... quoi qu'il en soit, dir(str) retourne la liste
# des noms de méthodes connues sur cette classe;
# regardons par exemple les premiers et les derniers
dir(str)[:2], dir(str)[-2:]

# avec len() je peux savoir combien il y en a
len(dir(str))

# mais en fait, pour un décompte significatif
# on enlève celles dont le nom contient `__`
methods = [method for method in dir(str)
           if '__' not in method]
len(methods)

# est-ce que les chaines ont une méthode 'split' ?
'split' in methods