04 – Listas en Python 3

Diego Andrés Alvarez Marín
Profesor Asociado
Universidad Nacional de Colombia
Sede Manizales

1
 Tabla de contenido
Operadores Funciones: Métodos:
:, +, * len() append(), copy()
[:], [i], [i:j], [i:j:k] id() extend(), insert()
is, is not eval() count(),index()
in, not in all() join(), remove()
=, != any() pop(), clear()

<, >, <=, >= list() sort(), reverse()

del, [] 2
 Tipos de datos
● Tipos de datos escalares:
– Números enteros, flotantes, complejos, fracciones, lógicos(booleanos)
● Tipos de datos secuenciales:
– Secuencias de bytes, cadenas
● Tipos de datos estructurados:
– Listas (lists): secuencias ordenadas de valores
– Tuplas (tuples): secuencias inmutables de valores ordenados
– Conjuntos (sets): conjunto no ordenado de valores
– Diccionarios (dictionaries): conjunto no ordenado de valores, que tienen una “llave” que los 
identifican
● Objetos: módulos, funciones, clases, métodos, archivos, código compilado, etc.
● “Constantes”

   
 Listas

Las listas pueden tener diferentes 
tipos de elementos
A las listas se les puede indexar y 
hacer slicing

La indexación de las listas 
comienza en 0

Las listas se pueden concatenar

A diferencia de las cadenas, las 
  listas se pueden modificar: son 
 

mutables
Listas

5
 Refiriéndose a elementos fuera de 
la lista

   
 Las listas pueden contener 
cualquier tipo de elemento
Incluso pueden contener otras listas o incluso 
funciones, clases, módulos, etc.

   
 Las listas se pueden anidar

   
 Listas

   
   
 Referencias en 
Python
● Se aplican a tipos de 
datos mutables (ejemplo: 
listas y diccionarios).
● El operador = es un 
operador que copia 
referencias. La instrucción 
d=c copia una referencia a 
lista, no la lista misma
● Utilice slicing[:] o el 
método copy() si quiere 
    copiar como tal la variable
 Visualice la ejecución del código 
con http://www.pythontutor.com/

   
 Revisando 
de nuevo el 
operador de 
asignación 
=

   
 Este proceso se llama en Python 
“garbage collection”
http://en.wikipedia.org/wiki/Garbage_collection_%28computer_science%29

   
o referencias
 Tipos de datos 
mutables vs inmutables
● INMUTABLES:  An  object  with  a 
fixed  value.  Immutable  objects 
include  numbers,  strings  and 
tuples.  Such  an  object  cannot  be 
altered.  A  new  object  has  to  be 
created  if  a  different  value  has  to 
be  stored.  They  play  an  important 
role  in  places  where  a  constant 
hash value is needed, for example 
as  a  key  in  a  dictionary:  ejemplo: 
floats, cadenas, tuplas
● MUTABLES:  Mutable  objects  can 
change  their  value  but  keep  their 
 
id(): ejemplo: listas, diccionarios  
16
Modificando una lista conservando 
la misma ubicación en memoria

observe el uso 
del comando [:]

NOTA: en CPython, el comando 
id(obj) retorna la dirección de 
memoria asociada a obj
17
 Los operadores + y * con listas

Observe que el 
operador + genera una 
copia de “a”, no usa 
una referencia a “a”

   
 Comparación de secuencias

   
https://docs.python.org/3/tutorial/datastructures.html#comparing­sequences­and­other­types
 Ordenamiento lexicográfico de 
cadenas 
(se aplica de igual forma a listas)
The comparison uses lexicographical ordering: first the first two items 
are  compared,  and  if  they  differ  this  determines  the  outcome  of  the 
comparison; if they are equal, the next two items are compared, and so 
on, until either sequence is exhausted. Los diccionarios se ordenan de 
esta forma.
http://es.wikipedia.org/wiki/Orden_lexicográfico

   
Comparación 
The  comparison  uses  lexicographical 
de listas ordering:  first  the  first  two  items  are 
compared,  and  if  they  differ  this  determines 
the  outcome  of  the  comparison;  if  they  are 
equal, the next two items are compared, and 
so  on,  until  either  sequence  is  exhausted. 
Los diccionarios se ordenan de esta forma.

   
 Comparación de listas

El primer ejemplo falla ya que type([1,2,3]) != type(3) y 
el segundo ejemplo es válido ya que 2<3

   
 Los operadores “is” e “is not”
Los operadores "is" e "is not" 
verifican la identidad del 
objeto.

"a is b" retorna True si y solo 
si “a” y “b” son el mismo 
objeto: id(a) == id(b)

"a is not b" retorna True si y 
solo si “a” y “b” no son el 
mismo objeto: id(a) != id(b)

   
 Comparando “is” e “==”
●  == y != son operadores que comparan los 
valores de los objetos
● “is” e “is not” son operadores que comparan 
la identidad de los objetos
● Observe que "a == b" no implica que "a is b"
● De igual forma, "a is b" no implica que "a == b"

   
 El operador is
Variables “intern”

   
 El comando [:]
En cadenas y tuplas el comando [:] 
retorna una referencia al mismo objeto.

En el caso de lista se retorna una copia 
de dicho objeto

[:] no es aplicable a conjuntos y 
diccionarios

26
 Usando == o is para comparar 
contra None
Suponiendo que “x = None”, es preferible hacer comparaciones del 
tipo "if x is None" que "if x == None". Ambas sirven en este caso, 
ya  que  solo  existe  un  objeto  None.  Sin  embargo,  se  prefiere  la 
comparación  con  "is"  ya  que  el  uso  de  "is"  es  más  rápido  y  más 
predecible,  ya  que  este  comando  solo  compara  la  identidad  del 
objeto,  mientras  que  el  comportamiento  de  ==  depende  del  tipo 
exacto de operandos con los que se está trabajando.

Esta recomendación se hace en:
https://www.python.org/dev/peps/pep­0008/#programming­recomm
endations

   
 PEP 8: Style Guide for Python Code:
https://www.python.org/dev/peps/pep­0008

   
 Lectura de listas con eval()

Leyó una cadena de texto

Formó una lista con la cadena de texto

eval() evaluó la cadena de texto como si fuera 
una expresión válida de Python.

   
 Métodos que modifican listas
● L.append(<obj>) Appends an object to a list.
● L.extend(<iterable>)  Extends a list with the                
      objects from an iterable.
● L.insert(<index>, <obj>) Inserts an object into a list.
● L.remove(<obj>) Removes an object from a    
  list.
● L.pop(index=­1) Removes an element from a     
list.

   
 Agregar elementos a una lista, 
concatenación de listas
El operador + concatena lista con lista, no lista con 
elemento. Si quiere agregar un elemento a una lista, 
utilice el método append()

El método append() es mucho más 
eficiente que utilizar el operador + 
especialmente con listas de gran 
tamaño.
   
 + vs. append()

   
 Insertar elementos 
en una lista
No use la forma 1 con 
listas muy grandes, ya que 
es ineficiente.

2. append() agrega un 
elemento a la lista

4. extend() puede agregar 
varios elementos a la lista

5. Con insert() se pueden 
poner elementos en 
cualquier posición de la 
   
lista
   
 Eliminar elementos de una lista

remove() solo 
borra la primera 
ocurrencia de la 
lista

remove() lanzará 
una excepción si 
el elemento a 
    eliminar no existe.
 Eliminando 
elementos de 
pop() con un índice 
una lista con 
retorna y elimina el 
elemento indicado
pop()
Observe que pop() retorna el 
elemento eliminado, mientras que 
remove() y del no lo hacen.

   
 Los operadores in y not in 
Los operadores in y not in verifican si un valor está 
presente en una lista, o si una cadena es una subcadena 
de otra cadena

38
 Los operadores in y not in 
Esos operadores se pueden encadenar:

39
 Buscando valores 
en una lista
● 1. count() retorna el número 
de ocurrencias en una lista
● 2. el operador in es más 

rápido que if count(L) >= 1:
● 4. index() retorna el índice 

de la primera ocurrencia
● 5. si index() no encuentra, 

se lanza una excepción

   
 El método index() en listas

index() retorna el valor de la primera ocurrencia

index()  puede  tener  dos  argumentos  extra  para 

hacer  la  búsqueda  más  ágil.  El  primero  dice 
donde empezar y el último donde terminar (rango 
del  slicing  start:stop).  Recuerde  que  el  primer 
índice de la lista es el cero.
   
 El método index() en listas

El rango analizado 
corresponde al slicing 6:9

   
 len(), min() y max()

   
 Eliminar elementos de una lista
Observe que las listas no 
quedan con vacíos después 
de eliminar elementos
Equivalente a milista.clear()
Borra la variable milista 
de la memoria RAM

“del” no es aplicable a 
cadenas (son inmutables)

   
 Borrando elementos de una lista con [] y slicing y 
el método clear() (en vez de usar del)

   
 Error en el uso de “del”

Es  una  mala  práctica  de 

programación  eliminar  los 
elementos  de  una  lista 
sobre  la  cual  se  está 
iterando, ya que se presta 
para  confusiones  y 
errores.

   
 Asignación de elementos usando 
listas (sequence unpacking)

Se puede utilizar este truco con funciones, 
de modo que estas retornen varios valores 
a la vez.

   
 Listas en un contexto booleano

Una lista vacía retorna falso, una lista con al 
menos un elemento retorna verdadero
   
   
 OJO: “shallow” copy

insert() ,remove() y sort() 
retornan “None”

   
 L.sort() vs sorted(L)

sorted(L)  crea  una 

copia

L.sort()  no  crea  una 

copia

L.sort() retorna None

   
   
 Ejemplos con all() y any()

   
 Ejemplos con all() y any()

Observe estas dos posibles 
formas de verificar los tipos 
   
de datos de los elementos
 Usando una lista como una pila

   
 Usando una lista como una cola

   
 Matrices: listas de listas

   
 “nested list 
comprenhension”

Implementando 
matrices con 
listas de listas

   
 Otra forma correcta de crear las 
matrices

   
 Forma incorrecta de crear matrices

   
 Otra forma incorrecta de crear 
matrices

   
 Forma incorrecta de copiar matrices

   
 Forma correcta 
de copiar 
matrices

   
 Copiando matrices usando “deep 
copy”

   
 Shallow copy vs Deep copy
The difference between shallow and deep copying is only relevant for compound 
objects (objects that contain other objects, like lists or class instances):
● A  shallow  copy  constructs  a  new  compound  object  and  then  (to  the  extent 
possible)  inserts references into it to the objects  found  in  the original.  Shallow 
copies duplicate as little as possible. A shallow copy of a collection is a copy of 
the collection structure, not the elements. With a shallow copy, two collections 
now  share  the  individual  elements.  Se  hace  usando  el  método  copy(),  el 
operador de slicing [:] o con copy.copy().
● A deep copy constructs a new compound object and then, recursively, inserts 
copies  into  it  of  the  objects  found  in  the  original.  Deep  copies  duplicate 
everything. A deep copy of a collection is two collections with all of the elements 
in the original collection duplicated. Se hace con copy.deepcopy()

   
 Tamaño de las variables en 
memoria
● Varían de implementación a implementación 
del interpretador.

   
 Notas finales
● Las listas de python son análogas a la funcionalidad que provee 
el comando cell() de MATLAB
● Cuando  se  tienen  listas  de  datos  en  las  que  todas  las  entradas 
son del mismo tipo, es frecuentemente mucho más eficiente usar 
la librería numpy y su tipo de dato array. Un array de numpy es 
un  bloque  de  memoria  contigua  en  la  cual  se  almacenan  datos 
del  mismo  tipo;  esto  permite  hacer  operaciones  sobre  los 
elementos  de  forma  más  veloz  ya  que  los  elementos  se  tienen 
un acceso mucho más fácil en memoria, y python los accesa de 
esta forma mucho más rápido. Adicionalmente, la mayoría de las 
rutinas de numpy están escritas en lenguaje C.

   
 Referencias
● Wikipedia
● http://www.inventwithpython.com/
● http://www.diveintopython3.net/
● Documentación de Python:
– https://docs.python.org/3/tutorial/index.html
– https://docs.python.org/3/
● Marzal Varó, Andrés; Gracia Luengo, Isabel; García Sevilla, Pedro 
(2014). Introducción a la programación con Python 3. Disponible en: 
http://dx.doi.org/10.6035/Sapientia93
● https://realpython.com/python­lists­tuples/

68