{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Les listes"
]
},
{
"cell_type": "code",
"execution_count": 71,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
""
],
"text/plain": [
""
]
},
"execution_count": 71,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Afficher la table des matières\n",
"\n",
"from jyquickhelper import add_notebook_menu\n",
"add_notebook_menu()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Les listes sont très semblables aux chaînes, sauf que chaque élément peut être de n'importe quel type.\n",
"La syntaxe pour créer des listes en Python est [...]:\n",
"\n",
" - Collection ordonnée (de gauche à droite) d’éléments (combinaison de types de données de base, données hétérogènes)\n",
" - De taille quelconque, peut grandir, rétrécir, être modifiée, être encapsulée (liste de listes de listes)"
]
},
{
"cell_type": "code",
"execution_count": 72,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"[1, 2, 3, 4]\n"
]
}
],
"source": [
"l = [1,2,3,4]\n",
"\n",
"print(type(l))\n",
"print(l)"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"Les éléments d'une liste peuvent ne pas être du même type :"
]
},
{
"cell_type": "code",
"execution_count": 73,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, 'a', 1.0, (1-1j)]\n"
]
}
],
"source": [
"l = [1, 'a', 1.0, 1-1j]\n",
"\n",
"print(l)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Les listes Python peuvent être non-homogènes et arbitrairement imbriquées:"
]
},
{
"cell_type": "code",
"execution_count": 74,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[1, [2, [3, [4, [5]]]]]"
]
},
"execution_count": 74,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"l1 = [1, [2, [3, [4, [5]]]]]\n",
"\n",
"l1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Slicing\n",
"Les mêmes techniques de slicing utilisées précédement sur les chaînes de caractères peuvent également être utilisées pour manipuler les listes."
]
},
{
"cell_type": "code",
"execution_count": 75,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"'MC1R '"
]
},
"execution_count": 75,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"L=[ '14 ' ,'14231363 ' ,'14232541 ', 'MC1R ']\n",
"L[3]"
]
},
{
"cell_type": "code",
"execution_count": 76,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"['14 ', '14231363 ']"
]
},
"execution_count": 76,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"L[0:2]"
]
},
{
"cell_type": "code",
"execution_count": 77,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['14 ', 'MC1R ']\n"
]
}
],
"source": [
"print(L[::3])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Manipulation de listes\n",
"On peut modifier les listes en attribuant de nouvelles valeurs aux éléments de la liste. Dans le jargon technique, on dit que les listes sont mutables."
]
},
{
"cell_type": "code",
"execution_count": 78,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"['14 ', '14231363 ', '14232541 ', ' ENSOARG00000002239 ']"
]
},
"execution_count": 78,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"L [3]= ' ENSOARG00000002239 ' # une liste est modifiable\n",
"L"
]
},
{
"cell_type": "code",
"execution_count": 79,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"['14 ', 14231363, 14232541, ' ENSOARG00000002239 ']"
]
},
"execution_count": 79,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"L [1]= int(L[1]) ; L[2]= int(L[2]) # conversion string -> integer\n",
"L # les elements sont de types differents"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Il existe un certain nombre de fonctions pratiques pour générer des listes de différents types. Exemple :"
]
},
{
"cell_type": "code",
"execution_count": 80,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[1, 7, 13, 19]"
]
},
"execution_count": 80,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Sous Python 3.x, on peut générer une liste en utilisant l'instruction suivante : List (range (start, stop, step)\n",
"\n",
"list(range(1, 20, 6)) "
]
},
{
"cell_type": "code",
"execution_count": 81,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"['B', 'o', 'n', 'j', 'o', 'u', 'r']"
]
},
"execution_count": 81,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Convertir une chaîne en une liste :\n",
"s = \"Bonjour\"\n",
"s2=list(s)\n",
"s2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Fonctions/Opérations sur les listes"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* ajoute un élément à la fin de la liste avec `append`"
]
},
{
"cell_type": "code",
"execution_count": 82,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[3, 2, 4, 1, 15]\n"
]
}
],
"source": [
"List =[3 , 2, 4, 1]\n",
"List.append(15) # ajoute un élément à la fin de la liste avec append\n",
"print(List)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* étendre une liste avec `extend`"
]
},
{
"cell_type": "code",
"execution_count": 83,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[3, 2, 4, 1, 15, 7, 8, 9]\n"
]
}
],
"source": [
"List.extend ([7 , 8, 9]) # étendre la liste avec extend\n",
"print(List)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Insérer un élément à une position spécifique à l'aide de `insert`"
]
},
{
"cell_type": "code",
"execution_count": 84,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[111, 3, 2, 4, 1, 15, 7, 8, 9]\n"
]
}
],
"source": [
"List.insert(0, 111)\n",
"print(List)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Supprimer le premier élément correspondant à la valeur donnée à l'aide de `remove`"
]
},
{
"cell_type": "code",
"execution_count": 85,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[111, 3, 2, 4, 1, 7, 8, 9]\n"
]
}
],
"source": [
"List.remove(15)\n",
"print(List)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Supprimer un élément à un emplacement donné à l'aide de `del`"
]
},
{
"cell_type": "code",
"execution_count": 86,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[111, 3, 2, 1, 7, 8, 9]\n"
]
}
],
"source": [
"del List [3] # supprimer l'élément se trouvant à l'index 3 de la liste\n",
"print(List)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Tri d'une liste avec `sort`"
]
},
{
"cell_type": "code",
"execution_count": 87,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 3, 7, 8, 9, 111]"
]
},
"execution_count": 87,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"List.sort () # Tri de liste\n",
"List"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Renoyer le nombre d'occurence d'une valeur dans la liste avec `count`"
]
},
{
"cell_type": "code",
"execution_count": 88,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 88,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"List.count (3) # renvoie le nombre d'occurence de 3 dans la liste"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Voir *help(list)* pour plus de détails, ou lire la documentation en ligne."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Bonnes pratiques"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Arrêter d'untiliser = operator pour faire une copie de liste Python. Utilisze plutôt la méthode \"copy\" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Lorsque vous créez une copie d'une liste Python à l'aide de l'opérateur =, une modification de la nouvelle liste entraînera celle de l'ancienne. C'est parce que les deux listes pointent vers le même objet."
]
},
{
"cell_type": "code",
"execution_count": 89,
"metadata": {},
"outputs": [],
"source": [
"liste_1 = [1, 2, 3]\n",
"liste_2 = liste_1 \n",
"liste_2.append(4)"
]
},
{
"cell_type": "code",
"execution_count": 90,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 3, 4]"
]
},
"execution_count": 90,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"liste_2"
]
},
{
"cell_type": "code",
"execution_count": 91,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 3, 4]"
]
},
"execution_count": 91,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"liste_1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Au lieu d'utiliser l'opérateur **=**, utilisez la méthode `copy()`. Maintenant, votre ancienne liste ne changera pas lorsque vous modifierez votre nouvelle liste."
]
},
{
"cell_type": "code",
"execution_count": 92,
"metadata": {},
"outputs": [],
"source": [
"liste_1 = [1, 2, 3]\n",
"liste_2 = liste_1.copy()\n",
"liste_2.append(4)"
]
},
{
"cell_type": "code",
"execution_count": 93,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 3, 4]"
]
},
"execution_count": 93,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"liste_2"
]
},
{
"cell_type": "code",
"execution_count": 94,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 3]"
]
},
"execution_count": 94,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"liste_1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Enumerate : Obtenir le compteur et la valeur en bouclant"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Généralement pour accéder à la fois à l'index et à la valeur d'un tableau (liste), on a souvent tendance à utiliser : `for i in range(len(tableau))`.\n",
"\n",
" Si c'est le cas, utilisez plutôt `enumerate`. Le résultat est le même, mais il est beaucoup plus propre."
]
},
{
"cell_type": "code",
"execution_count": 95,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0 a\n",
"1 b\n",
"2 c\n",
"3 d\n",
"4 e\n"
]
}
],
"source": [
"Tableau = ['a', 'b', 'c', 'd', 'e']\n",
"\n",
"# Au lieu de\n",
"for i in range(len(Tableau)):\n",
" print(i, Tableau[i])"
]
},
{
"cell_type": "code",
"execution_count": 96,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0 a\n",
"1 b\n",
"2 c\n",
"3 d\n",
"4 e\n"
]
}
],
"source": [
"# Utilisez ça\n",
"for i, val in enumerate(Tableau):\n",
" print(i, val)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Différence entre \"append\" et \"extend\"\n",
"\n",
"Pour ajouter une liste à une autre liste, utilisez la méthode `append`. Pour ajouter des éléments d'une liste à une autre liste, utilisez la méthode `extend`."
]
},
{
"cell_type": "code",
"execution_count": 97,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 3, 4, [5, 6]]"
]
},
"execution_count": 97,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Ajouter une liste à une liste\n",
"a = [1, 2, 3, 4]\n",
"a.append([5, 6])\n",
"a"
]
},
{
"cell_type": "code",
"execution_count": 98,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 3, 4, 5, 6]"
]
},
"execution_count": 98,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Ajouter des éléments à une liste\n",
"a = [1, 2, 3, 4]\n",
"a.extend([5, 6])\n",
"\n",
"a"
]
}
],
"metadata": {
"anaconda-cloud": {},
"interpreter": {
"hash": "40d3a090f54c6569ab1632332b64b2c03c39dcf918b08424e98f38b5ae0af88f"
},
"kernelspec": {
"display_name": "Python [Root]",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.8"
}
},
"nbformat": 4,
"nbformat_minor": 0
}