=======
Llistes
=======
Què són les llistes?
====================
- **Llista**: conjunt ordenat de valors identificats per un índex.
- Els valors d'una llista s'anomenen **elements**.
- Les llistes i els *strings* són **seqüències**, vegeu
:ref:`python:typesseq-common`.
Construcció de llistes
======================
- Elements separats per comes i entre claudàtors
.. sourcecode:: python
[10, 20, 30, 40]
["spam", "bungee", "swallow"]
["hello", 2.0, 5, [10, 20]]
- Llista **homogènia**: tots els elements són del mateix
tipus. Altrament, la llista és **heterogènia**.
- Llista **buida**: ``[]``, :py:class:`list`.
- Llistes i expressions booleanes.
- Una variables es pot referir a una llista (assignació).
Operacions comunes als tipus seqüència
======================================
Accés als elements
------------------
- L'**operador claudàtor** [] selecciona un únic element de la llista.
- Els índex són enters i comencen per 0.
- L'accés a un element inexistent provoca in error d'execució.
- Els **índexs negatius** comencen a comptar des del final de la
llista.
Longitud d'una llista
---------------------
- La funció ``len`` retorna el nombre d'elements de la llista.
- Els darrer element d'una llista ocupa l'índex longitud menys u.
- Recorregut d'una llista amb ``while``.
Pertinença a una llista
-----------------------
- L'operador de pertinença és ``in``.
- També es pot usar ``not in``.
Concatenació de llistes
-----------------------
- Concatenació: ``+``.
- Repetició: ``*``.
Llesques
--------
- L'operador llesca ``llista[n:m]`` obté la subllista que comença en
l'element d'índex ``n`` inclòs i acaba en el d'índex ``m`` exclòs.
- ``n`` es pot ometre: comença en el primer element.
- ``m`` es pot ometre: va fins al darrer element.
- Si s'ometen tots dos: tota la llista.
Strings i llistes
=================
- Mètodes :py:meth:`str.split` i :py:meth:`str.join`.
- Exemples:
- `Divises `_
(split).
- :doc:`fi:temes/iteracions/Dígits_d_un_nombre_enter/index`: 3 (list, join).
- :doc:`fi:temes/strings/Afegir_**_al_mig/index`: 2 (list,
join).
- Separar les paraules només amb un espai en blanc (split, join).
- Analitzar una adreça electrònica (split). Construir una adreça
electrònica (join).
- Funció :py:class:`list`: retorna una llista a partir d'un tipus
seqüència.
- Funció :py:class:`str`: retorna un *string* a partir de qualsevol
valor.
- :py:class:`str` no és la funció inversa de :py:class:`list`.
Funcions predefinides sobre llistes
===================================
- :py:func:`sum`: retorna la suma els elements d'una llista.
- :py:func:`min` i :py:func:`max`: retornen el mínim i màxim
respectivament dels elements d'una llista.
- :py:func:`sorted`: retorna la llista ordenada dels elements d'una llista.
Les llistes són mutables
========================
- Les llistes són mutables: podem canviar els elements.
- Operador d'accés usat a l'esquerra d'una assignació.
.. code-block:: pycon
>>> fruit = ["banana", "apple", "quince"]
>>> fruit[0] = "pear"
>>> fruit[2] = "orange"
>>> fruit
['pear', 'apple', 'orange']
- Operador llesca usat a l'esquerra d'una assignació.
.. code-block:: pycon
>>> a_list = ["a", "b", "c", "d", "e", "f"]
>>> a_list[1:3] = ["x", "y"]
>>> a_list
['a', 'x', 'y', 'd', 'e', 'f']
- Operador llesca usat per esborrar.
.. code-block:: pycon
>>> a_list = ["a", "b", "c", "d", "e", "f"]
>>> a_list[1:3] = []
>>> a_list
['a', 'd', 'e', 'f']
- Operador llesca usat per inserir elements.
.. code-block:: pycon
>>> a_list = ["a", "d", "f"]
>>> a_list[1:1] = ["b", "c"]
>>> a_list
['a', 'b', 'c', 'd', 'f']
>>> a_list[4:4] = ["e"]
>>> a_list
['a', 'b', 'c', 'd', 'e', 'f']
- Vegeu :ref:`typesseq-mutable`.
Esborrat en llistes
===================
- Sentència ``del``: esborrar un element.
.. code-block:: pycon
>>> a = ["one", "two", "three"]
>>> del a[1]
>>> a
['one', 'three']
- Sentència ``del``: esborrar una llesca.
.. code-block:: pycon
>>> a_list = ["a", "b", "c", "d", "e", "f"]
>>> del a_list[1:5]
>>> a_list
['a', 'f']
Mètodes de llistes
==================
.. Prové del capítol 10 (mòduls i fitxers) del "how to think ..."
- Els mètodes de llistes formen part dels objectes llista, i
s’**invoquen** (es criden) aplicant l’**operador punt (.)** després
de l’objecte seguit pel nom del mètode.
- Exemples: :py:meth:`~list.append`, :py:meth:`~list.insert`,
:py:meth:`~list.extend`, :py:meth:`~list.count`,
:py:meth:`~list.index`, :py:meth:`~list.reverse`,
:py:meth:`~list.sort` i :py:meth:`~list.remove`.
- Vegeu :ref:`typesseq-mutable`.
Generació de llistes
====================
- Generació de llistes a partir dels elements: ``[]`` i
:py:meth:`~list.append`.
Recorregut dels elements d'una llista
=====================================
La sentència `for`
------------------
- L'iterador ``for`` permet recórrer llistes:
.. code-block:: python3
for element in llista:
sentències
- La llista de la capçalera d'un ``for`` pot ser una expressió
qualsevol que s'avaluï a una llista.
Propòsit d'un recorregut
------------------------
Sintetitzar
Calcular un resultat que sintetitza els valors dels elements de la
llista. Per exemple, sumar el elements, calcular el màxim o el
mínim, comptar els elements, :py:meth:`str.join`...
- `Strings i llistes\: conversió, split, join`_: 4, 6, 7.
L'esquema general és
.. code-block:: python3
def sintetiza(llista):
s = element_neutre_acumula
for elem in llista:
s = acumula(s, elem)
return s
on només cal decidir
#. quina és la operació :code:`acumula`, i
#. quin és l'element neutre d'aquesta operació
(:code:`element_neutre_acumula`)
Aplicar
Generar una llista resultat on cada element es calcula aplicant
(cridant) una funció sobre l'element corresponent de la llista
dada. Per exemple, el producte d'un nombre pels elements de la llista...
- `Llistes com a paràmetres de funcions`_: 3.
L'esquema general és
.. code-block:: python3
def aplica(llista):
r = []
for elem in llista:
elem_r = funció(elem)
r.append(elem_r)
return r
on només cal decidir
#. quina és la funció que cal aplicar a cada element
(:code:`funció`).
Filtrar
Generar una llista resultat a partir dels elements de la llista
dada que compleixin una condició. Per exemple, calcular la llista
dels nombres positius...
L'esquema general és
.. code-block:: python3
def filtra(llista):
r = []
for elem in llista:
if condició(elem):
r.append(elem)
return r
on només cal decidir
#. quina és la condició que han de complir els elements triats
(:code:`condició`).
Combinacions dels anteriors
Qualsevol combinació de sintetitzar, aplicar i sintetitzar.
- Filtrar i sintetitzar: `Strings i llistes\: conversió, split, join`_, 7.
Cercar en una llista
--------------------
Decidir si algun dels elements d'una llista compleix una condició.
- `Cercant en llistes`_: 1.
L'esquema general és
.. code-block:: python3
def cerca(llista):
trobat = False
for elem in llista:
trobat = condició(elem)
if trobat:
break
return trobat
on només cal decidir
#. quina és la condició que ha de complir l'element que busquem
(:code:`condició`).
.. _Strings i llistes\: conversió, split, join: http://gie.cs.upc.edu/fi/temes/llistes/Strings_i_llistes:_conversi%C3%B3,_split,_join/
.. _Llistes com a paràmetres de funcions: http://gie.cs.upc.edu/fi/temes/llistes/Llistes_com_a_par%C3%A0metres_de_funcions/
.. _Cercant en llistes: http://gie.cs.upc.edu/fi/temes/llistes/Cercant_en_llistes/
Recorregut dels índexs d'una llista
===================================
- Usant ``for`` i ``range``.
.. code-block:: python3
for índex in range(len(llista)):
sentències
- Usant ``for`` i ``enumerate``.
.. code-block:: python3
for índex, element in enumerate(llista):
sentències
Quan cal recórrer els índexs?
-----------------------------
- Quan el resultat és un índex (o posició).
- Índex del màxim, índex del primer nombre
negatiu...
- Pessetes_: 5.
- Quan cal modificar algun element de la llista.
- `Intercanviar màxim per mínim`_.
- Quan cal recórrer dues llistes en paral·lel.
- Vectors_: 4, 5.
- Quan cal desplaçar finestres.
- `Telèfons`_: 2
- `Llistes imbricades`_: `creixent`.
.. _Pessetes: http://gie.cs.upc.edu/fi/temes/llistes/Pessetes/
.. _Intercanviar màxim per mínim: http://gie.cs.upc.edu/fi/temes/llistes/Intercanviar_m%C3%A0xim_per_m%C3%ADnim/
.. _Positius i negatius: http://gie.cs.upc.edu/fi/temes/llistes/Positius_i_negatius/
.. _Vectors: http://gie.cs.upc.edu/fi/temes/llistes/Vectors/
.. _Daus: http://gie.cs.upc.edu/fi/temes/llistes/Daus/
.. _Telèfons: http://gie.cs.upc.edu/fi/temes/llistes/Tel%C3%A8fons/
Les llistes com a paràmetres
============================
.. sourcecode:: python
def f(p):
p[0] *= 2
a = [1, 2, 3]
f(a)
- Durant la crida a ``f``, el paràmetre ``p`` és àlies de l'argument
``a``: es refereixen al mateix objecte.
Funcions i funcions modificadores
=================================
- **Funció modificadora**: funció que modifica algun dels seus paràmetres.
- **Funció**: funció que no modifica cap dels seus paràmetres.
- Les funcions retornen un valor que només depèn dels seus paràmetres.
Què és millor?
--------------
- En cas de dubte: funcions.
Llistes imbricades
==================
- **Llista imbricada**: llista en què almenys un dels seus element és
una altra llista.
- Exemples d'accés.
- L'operador claudàtor s'avalua d'esquerra a dreta.
- Exemples:
- `Llistes imbricades`_: 1, 2.
- `Cinc al dia`_: 1, 3.
- Daus_: 2, 3.
.. _Llistes imbricades: http://gie.cs.upc.edu/fi/temes/llistes/Llistes_imbricades/
.. _Cinc al dia: http://gie.cs.upc.edu/fi/temes/llistes/Cinc_al_dia/
Matrius
=======
- Les llistes imbricades s'usen sovint per representar matrius.
.. sourcecode:: python
>>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> matrix[1]
[4, 5, 6]
>>> matrix[1][1]
5
Objectes i valors
=================
- Les variables referencien objectes.
- Tot objecte té un identificador únic: funció `id`.
- Exemples amb *strings* i llistes.
Àlies
=====
- Si les variables ``a`` i ``b`` es refereixen al mateix objecte direm
que ``b`` és *àlies* d'``a``.
- Qualsevol canvi en ``a`` es veu reflectit en el seu àlies ``b``.
Clonant llistes
===============
- **Clonar** un objecte consisteix en obtenir-ne una còpia idèntica.
- L'operador llesca sempre obté una nova llista.
- Ús de l'operador llesca per clonar llistes.
El paràmetre :code:`key` en ordenació, màxim i mínim
====================================================
- El mètode :py:meth:`~list.sort` de llistes i les funcions
:py:func:`sorted`, :py:func:`min` i :py:func:`max` tenen un
paràmetre opcional :code:`key`.
- El paràmetre opcional :code:`key` és útil quan cal comparar els
elements de la llista per un criteri diferent de l'ordre estàndard.
- Exemples:
- Donada una llista d'strings ordenar-la per la longitud dels
strings en comptes de per ordre lexicogràfic.
- :py:func:`candidats.can_mes_votat`,
:py:doc:`temes/diccionaris/Directius/index` 2.
Llista per comprensió
=====================
.. Prové del capítol 11 (Recursion and exceptions) del "how to think ..."
- Una `llista per comprensió
`_ és una
construcció sintàctica que permet crear una nova llista a partir
d'una llista donada.
- La notació s'inspira en la de `construcció de conjunts
`_.
- Sintaxi:
.. sourcecode:: python
[expr for item1 in seq1 ... for itemX in seqX if condition]
La funció :py:class:`range`
===========================
- :code:`range(m, n)` retorna un objecte de tipus :py:class:`range` que
representa un interval de nombres enters consecutius que comença per
:code:`m` inclòs i va fins a :code:`n` exclòs.
.. code-block:: pycon
>>> r = range(3, 10)
>>> list(r)
[3, 4, 5, 6, 7, 8, 9]
- :code:`m` es pot ometre: :code:`range(n)` comença per 0.
.. code-block:: pycon
>>> r = range(5)
>>> list(r)
[0, 1, 2, 3, 4]
- :code:`range(m, n, p)` retorna el conjunt d'enters de :code:`m` a
:code:`n` comptant de :code:`p` en :code:`p`.
.. code-block:: pycon
>>> r = range(4, 10, 2)
>>> list(r)
[4, 6, 8]
- ``p`` pot ser negatiu. Aleshores ``m > n``.
.. code-block:: pycon
>>> r = range(8, 3, -1)
>>> list(r)
[8, 7, 6, 5, 4]