====== Séquences, méthodes plus avancées ======

Dans [[nsi:langages:python:sequences|le chapitre sur les bases]] on a présenté ce qu'était une séquence et comment on accédait à ses éléments. En Python, on dispose de syntaxe permettant d'aller plus loin.

===== Indice négatif =====

Un indice négatif indique que l'on compte depuis la fin :

<code python linenums>
>>> t = [4, 19, 25, 78, 29]
>>> t[-1]
29
>>> t[-2]
78
>>> t[-5]
4
>>> t[-6]
IndexError: list index out of range
</code>

Autrement dit, si ''%%n = len(t)%%'' alors ''%%t[-1]%%'' est équivalent à ''%%t[n-1]%%''.

===== Slices =====

Les **slices** sont des découpage que l'on pourra faire dans les séquences. Python est très efficace pour cela -- //slice = tranche, comme un tranche de saucisson.//

<code python linenums>
>>> t = [4, 19, 25, 78, 29, 42, 15, 89]
>>> t[2:5]
[25, 78, 29]
</code>

En choisissant ''%%2:5%%'' à la place de l'indice, on indique que l'on veut les éléments allant du rang 2 au rang **5 non compris**.

<WRAP important>C'est une constante de la syntaxe Python. Quand on indique **de a à b**, il faut comprendre que **b est exclus**.</WRAP>

Les possibilités sont très nombreuses :

<code python linenums>
>>> t = [4, 19, 25, 78, 29, 42, 15, 89]
>>> t[:3]    # jusque au rang 3
[4, 19, 25]
>>> t[3:]    # à partir du rang 3
[78, 29, 42, 15, 89]
>>> t[:-1]   # jusqu'au dernier (non compris comme toujours)
[4, 19, 25, 78, 29, 42, 15]
>>> t[-2:]   # les deux derniers
[15, 89]
</code>

La syntaxe est la même pour une chaîne de caractères

<code python linenums>
>>> t = "abcdefghij"
>>> t[:3]    # jusque au rang 3
'abc'
>>> t[3:]    # à partir du rang 3
'defghij'
>>> t[:-1]   # jusqu'au dernier (non compris comme toujours)
'abcdefghi'
>>> t[-2:]   # les deux derniers
'ij'
</code>

Un peu surprenant, on n'a pas de //IndexError// avec une slice :

<code python linenums>
>>> t = "abcdefghij"
>>> t[5:1000]
'fghij'
</code>

==== Indiquer un pas ====

On peut également indiquer que l'on souhaite parcourir la séquence de 2 en 2, de 3 en 3...

<code python linenums>
>>> t = "abcdefghijjlmn"
>>> t[1:8:3]
'beh'
</code>

''%%1:8:3%%'' -> Du rang 1 au rang 8 (exclus) par pas de 3, donc les rangs 1, 4, 7

En enlevant le 8, ''%%1::3%%'' -> Du rang 1 à la fin, par pas de 3.

<code python linenums>
>>> t = "abcdefghijjlmn"
>>> t[1::3]
'behjn'
</code>

Et avec un pas négatif, on peut parcourir à l'envers !

<code python linenums>
>>> t = "abcdefghijjlmn"
>>> t[8:1:-3]  # parcours les rangs 8, 5, 2
'ifc'
>>> t[::-1]    # totalité, à l'envers !
'nmljjihgfedcba'
</code>

===== Concaténations =====

Concaténer deux séquences ''a'' et ''b'', c'est créer une 3e séquence ''c'' constituée de ''a'' et ''b'' mises bout à bout. On utilise cela l'opérateur ''+''.

<code python linenums>
>>> [4, 5, 6] + [7, 8, 9]
[4, 5, 6, 7, 8, 9]
>>> "abc" + "def"
'abcdef'
>>> (1, 2) + (7, 8)
(1, 2, 7, 8)
</code>

<WRAP tip>En lisant l'opérateur ''+'', Python examine les opérandes et adapte son comportement.
  * ''%%3 + 7%%'' : les opérandes sont des entiers, Python réalise une addition ordinaire,
  * ''%%"abc" + "xyz"%%'' : les opérandes sont des chaînes, Python réalise une concaténation,
  * ''%%"abc" + 5%%'' : voyant une chaîne, Python tente une concaténation mais cela ne fonctionnera pas avec l'entier -> ''%%TypeError: can only concatenate str (not "int") to str%%''.
</WRAP>

Dans la même logique, on peut utiliser l'opérateur ''%%*%%'' :

<code python linenums>
>>> "ab" + "ab" + "ab"
'ababab'
>>> "ab" * 3
'ababab'
</code>

===== Dépaquetage (unpack) =====

On peut distribuer les items contenus dans une séquence vers des variables, à condition que les variables soient en nombre égal au nombre d'items.

<code python>
>>> a, b, c = "xyz"
>>> a
'x'
>>> b
'y'
>>> c
'z'
</code>

Dans cet exemple, la chaîne ''%%"xyz"%%'' contient 3 items, des caractères. En écrivant ''%%a, b, c = "xyz"%%'' on affecte aux variables ''a'', ''b'' et ''c'' ces 3 caractères, respectivement.

Si on met trop ou pas assez de variables, on a une erreur.
<code python>
>>> t = 4, 9, 17
>>> a, b, c, d = t
ValueError: not enough values to unpack (expected 4, got 3)
>>> a, b = t
ValueError: too many values to unpack (expected 2)
</code>

Ce mécanisme est surtout utilisé avec les tuples -- ci dessous, un extrait de [[nsi:langages:python:p-uplets_et_tableaux|p-uplets - tuple]]

{{section>nsi:langages:python:p-uplets_et_tableaux#Cas d'utilisation&nofooter}}