Equivalente en Java: —->
Una lista es una colección de elementos que mantienen un orden entre sí. Este orden se refiere a la posición que ocupan estos elementos dentro de la lista.
Los elementos pueden ser cadenas, números, variables…y en general cualquier otro tipo de datos que se nos pueda ocurrir (incluso listas dentro de listas).
milista=["Cristiano", "Messi", "Joaquín", "Morata", "Pedri"]
print(milista)Resultado:
['Cristiano', 'Messi', 'Joaquín', 'Morata', 'Pedri']Las listas comienzan con el primer elemento con índice 0. Podemos acceder al último elemento de una lista utilizando el índice -1. El penúltimo elemento tendrá índice -2 y así sucesivamente.
Podemos dar un nuevo valor a cualquier elemento de la lista simplemente asignándole el nuevo valor.
milista=["Cristiano", "Messi", "Joaquín", "Morata", "Pedri"]
mi_preferido=milista[0]
goleador=milista[2]
delantero=milista[-2]
print(f"Mi preferido es {mi_preferido}.")
print(f"El máximo goleador es {goleador}.")
print(f"Nuestro delantero es {delantero}.")
milista[1]="Butrageño"
goleador=milista[1]
print(f"Ahora el nuevo goleador es {goleador}.")Resultado:
Mi preferido es Cristiano.
El máximo goleador es Joaquín.
Nuestro delantero es Morata.
Ahora el nuevo goleador es Butrageño.len (lista) Con la función len( ) podemos obtener la longitud de una lista, es decir, el número de elementos que contiene.
milista=["Cristiano", "Messi", "Joaquín", "Morata", "Pedri"]
total=len(milista)
print(f"milista tiene {total} elementos.")Resultado:
milista tiene 5 elementos.lista.append (nuevo_elemento) Para añadir un nuevo elemento a la lista, usamos el método .append
milista=["Cristiano", "Messi", "Joaquín", "Morata", "Pedri"]
milista.append("Casillas")
print(milista)Resultado:
['Cristiano', 'Messi', 'Joaquín', 'Morata', 'Pedri', 'Casillas']Como vemos, hemos añadido un nuevo elemento al final de la lista.
lista.insert (posición, nuevo_elemento) También podemos insertar un elemento en la lista, en la posición indicada como primer parámetro del método .insert
milista=["Cristiano", "Messi", "Joaquín", "Morata", "Pedri"]
milista.insert(2,"Santillana")
print(milista)Resultado:
['Cristiano', 'Messi', 'Santillana', 'Joaquín', 'Morata', 'Pedri']Hemos insertado un nuevo elemento en la posición 2 (recordemos que empezamos por 0)
del lista (posición) Con esta función eliminamos de la lista el elemento que se encuentra en la posición indicada como parámetro.
milista=["Cristiano", "Messi", "Joaquín", "Morata", "Pedri"]
milista.insert(2,"Santillana")
del milista[1]
print(milista)Resultado:
['Cristiano', 'Santillana', 'Joaquín', 'Morata', 'Pedri']Primero hemos insertado un elemento en la posición 2. Después hemos eliminado el elemento que ocupaba la posición 1.
variable= lista.pop(posición) Con este método también se elimina el elemento que ocupa la posición indicada, pero ahora queda almacenado en la variable que se indique.
milista=["Cristiano", "Messi", "Joaquín", "Morata", "Pedri"]
milista.insert(2,"Santillana")
eliminado=milista.pop(3)
print(eliminado)
print(milista)Resultado:
['Cristiano', 'Messi', 'Santillana', 'Morata', 'Pedri']Ahora hemos insertado un elemento en la posición 2. Después hemos eliminado el elemento que ocupaba la posición 3. Este elemento, pasa a ser almacenado en la variable que hemos decidido llamar “eliminado”
Si no hubiésemos indicado ningún valor para .pop, la función eliminará por defecto el último elemento de la lista.
milista=["Cristiano", "Messi", "Joaquín", "Morata", "Pedri"]
milista.insert(2,"Santillana")
eliminado=milista.pop()
print(eliminado)
print(milista)Resultado:
['Cristiano', 'Messi', 'Santillana', 'Joaquín', 'Morata']lista.remove(elemento) Con este método, podemos eliminar la primera aparición en lista del elemento indicado como parámetro.
sulista=[15, 45, 0.14, 32, 46, 45, 55, 45]
eliminamos=45
sulista.remove(eliminamos)
print(sulista)Resultado:
[15, 0.14, 32, 46, 45, 55, 45]Este método debe de ser utilizado con cuidado. Si su argumento no está dentro de la lista, el programa se detiene y nos muestra un mensaje de error.
Para evitar este error, podemos recurrir a comprobar previamente si el elemento está incluido en la lista:
sulista=[15, 45, 0.14, 32, 46, 45, 55, 45]
eliminamos=157
if eliminamos in sulista:
sulista.remove(eliminamos)
print(sulista)Resultado:
[15, 45, 0.14, 32, 46, 45, 55, 45]Si queremos eliminar todas las apariciones del número 45 en la lista, utilizaremos while combinado con remove
sulista=[15, 45, 0.14, 32, 46, 45, 55, 45]
eliminamos=45
while eliminamos in sulista:
sulista.remove(eliminamos)
print(sulista)Resultado:
[15, 0.14, 32, 46, 55]Segmentos de listas. Partiendo de una lista, podemos obtener o trabajar con un segmento o fracción de esta:
lista_numeros=[1,3,5,7,11,13,17,19,23,29]
##segmento entre dos posiciones
##la posición [-2] (penúltima) no se incluye
lista_uno=lista_numeros[2:-2]
#segmento desde inicio hasta posición [5]
#no se incluye la posición [6]
lista_dos=lista_numeros[:6]
#segmento desde posición [3] hasta final.
lista_tres=lista_numeros[3:]
#segmento desde posición [2] hasta [6]
#no se incluye posición [7]
lista_cuatro=lista_numeros[2:7]
print (lista_uno)
print (lista_dos)
print (lista_tres)
print (lista_cuatro)Resultado:
[5, 7, 11, 13, 17, 19]
[1, 3, 5, 7, 11, 13]
[7, 11, 13, 17, 19, 23, 29]
[5, 7, 11, 13, 17]Listas y cadenas. Tal y como hemos visto al tratar las cadenas, una cadena no es más que una lista de caracteres.
En el siguiente código vemos una cadena, averiguamos su longitud, extraemos segmentos y los sumamos. A continuación, creamos una nueva cadena partiendo de la primera, pero eliminamos las vocales no acentuadas.
micadena="Hola, soy una cadena y también una lista."
print(len(micadena))
print(micadena[:6]+micadena[14:21])
nueva_cadena=""
for letra in micadena:
if letra not in "aeiou":
nueva_cadena+=letra
print (nueva_cadena)Resultado:
41
Hola, cadena
Hl, sy n cdn y tmbén n lst.cadena.split( ) Con este método podemos extraer una lista con todas las palabras que estén incluidas en una cadena.
micadena="Este verano está siendo muy caluroso"
milista=micadena.split()
print(milista)Resultado:
['Este', 'verano', 'está', 'siendo', 'muy', 'caluroso']Si las palabras dentro de la cadena están separadas por un carácter (o cadenas de caracteres), diferente al espacio en blanco, podemos especificarlo
como parámetro de split (delimitándolo por comillas). Si no se especifica ninguno, por omisión es espacio en blanco.
otra_cadena="143--22--543--54--75--56--"
milista=otra_cadena.split("--")
print(milista)
suma=0
for numero in milista:
try:
suma=suma+int(numero)
except ValueError:
pass
print(f"La suma de todos los números es {suma}.")otra_cadena="143--22--543--54--75--56"
milista=otra_cadena.split("--")
print(milista)
suma=0
for numero in milista:
suma=suma+int(numero)
print(f"La suma de todos los números es {suma}.")['143', '22', '543', '54', '75', '56']
La suma de todos los números es 893.En el ejemplo anterior, tenemos una cadena que contiene números separados por un doble guion. Primero hemos creado una lista con todos los
números. Como los números están representados en formato cadena, los hemos pasado a tipo numérico y el entero resultante lo hemos ido añadiendo a una suma.
Tenemos la posibilidad de especificar el número de veces que la cadena se cortará por el carácter que indiquemos. Si el carácter separador es el espacio en blanco, tenemos que incluirlo explícitamente.
micadena="Este verano está siendo muy lluvioso"
milista=micadena.split(" ",2)
print(milista)
otra_cadena="143--22--543--54--75--56--"
milista=otra_cadena.split("--",3)
print(milista)Resultado:
['Este', 'verano', 'está siendo muy lluvioso']
['143', '22', '543', '54--75--56--']La instrucción milista=micadena.split(» «,2) contiene un espacio en blanco entre las comillas.
separador.join(lista_cadenas) Podemos hacer también la operación inversa. Partiendo de una lista de cadenas, se puede conseguir una sola cadena que una todos los elementos de la lista, y que incluya como separador el que se indique como prefijo de .join
mi_cadena="Hola, soy una cadena."
mi_lista=list(mi_cadena)
print(mi_lista) ##crea una lista
nueva_cadena="-".join(mi_lista)
print(nueva_cadena) ##crea una cadena.
mi_otra_lista=['Este', 'verano', 'está', 'siendo', 'muy', 'lluvioso']
cadena=" ".join (mi_otra_lista) ##entre comillas va espacio en blanco.
print (cadena)Resultado:
['H', 'o', 'l', 'a', ',', ' ', 's', 'o', 'y', ' ', 'u', 'n', 'a', ' ', 'c', 'a', 'd', 'e', 'n', 'a', '.']
H-o-l-a-,- -s-o-y- -u-n-a- -c-a-d-e-n-a-.
Este verano está siendo muy lluviosolista.clear( ) Con este método vaciamos la lista de todos los elementos que contiene.
milista=[3,4,5,7]
print (milista)
milista.clear()
print (milista)Resultado:
[3, 4, 5, 7]
[]También podemos redefinir la lista. Si la redefinimos como una nueva lista vacía, hacemos lo mismo que en el caso anterior (vaciarla de elementos).
milista=["Carlos","Juan","Javier", "José"]
print (milista)
milista=[]
print (milista)['Carlos', 'Juan', 'Javier', 'José']
[]También podemos asignarle directamente unos nuevos valores. En este caso los nuevos sustituyen automáticamente a los anteriores.
milista=["a","b","c"]
print(milista)
milista=[23,444,1]
print(milista)Resultado:
['a', 'b', 'c']
[23, 444, 1]Sumar listas. Si tenemos dos listas, podemos obtener una nueva lista con los elementos de ambas, simplemente con el operador “+”
lista_uno=["Cerezas","Sandías"]
lista_dos=["manzana","limón"]
lista_dos=lista_uno+lista_dos
print(lista_dos)Resultado:
['Cerezas', 'Sandías', 'manzana', 'limón']sum (lista) Si una lista está formada exclusivamente por datos numéricos, podemos sumar todos sus componentes de una forma muy sencilla con la función sum(lista)
listado=[3.1, 4.3, 5.7, 7.83 , 124.85 , 23 ,43]
suma_total=sum(listado)
print("La suma de todos los números de la lista es:",suma_total)Resultado:
La suma de todos los números de la lista es: 211.78lista.count (elemento) Si necesitamos contar el número de veces que aparece un determinado elemento en una lista, haremos uso del método .count. Si no aparece ninguna vez, el resultado del método nos dará 0, pero
no dará ningún tipo de error.
campeon=["Nadal","Federer","Nadal","Djokovic","Nadal"]
nveces=campeon.count("Nadal")
print (f"Nadal ha sido campeón {nveces} veces.")Resultado:
Nadal ha sido campeón 3 veces.max (lista) // min (lista) Partiendo de una lista de números, podemos averiguar el valor máximo y
mínimo que contiene con estas dos funciones.
lista_numeros=[14,-7,23,87,-54,139,0,2,328]
mayor=max(lista_numeros)
menor=min(lista_numeros)
print (f"El número mayor es {mayor} y el menor {menor}")Resultado:
El número mayor es 328 y el menor -54Estas dos funciones también se pueden aplicar a una cadena. En este caso nos dará su mayor o menor código ASCII
mi_cadena="Hola, soy una cadena."
print("["+min(mi_cadena)+"]")
print(max(mi_cadena))Resultado:
[ ]
ySu menor código ASCII es espacio en blanco. El mayor la letra “y”
lista.index(elemento)Podemos averiguar el primer lugar de una lista donde aparece un determinado elemento con lista.index(elemento). Debemos de estar seguros de que elemento está contenido en la lista. Si no estamos seguros, lo más recomendable es comprobarlo previamente, ya que nos exponemos a que, en caso
de no estar, el programa se detenga y lance un mensaje de error.
mi_cadena="Hola, soy una cadena."
tu_lista=["Tomate","pera","calabaza","Calabaza","melón","pera"]
mis_numeros=[2,11,14,23,102,-1,0,87,14,2,22,14]
if "a" in mi_cadena:
print(mi_cadena.index("a"))
if "pera" in tu_lista:
print(tu_lista.index("pera"))
if 14 in mis_numeros:
print(mis_numeros.index(14))(recordar que el primer elemento se corresponde con la posición 0)
Resultado:
3
1
2lista.sort( ) Con este método podemos ordenar una lista alfabéticamente. Si es una lista de números, el sistema de ordenación es de menor a mayor. Si la lista es de cadenas, es de menor a mayor código ASCII.
colores=["verde", "azul", "amarillo", "naranja", "rojo"]
colores.sort()
print(colores)Resultado:
['amarillo', 'azul', 'naranja', 'rojo', 'verde']numeros=[100,10,20,30,43,9]
numeros.sort()
print(numeros)Resultado:
[9, 10, 20, 30, 43, 100]cadenas=["100","10","20","30","43","9"]
cadenas.sort()
print(cadenas)Resultado:
['10', '100', '20', '30', '43', '9']lista.sort (reverse=True) Si al método .sort le añadimos el argumento (reverse=True) obtenemos una
lista ordenada en orden inverso.
colores=["verde", "azul", "amarillo", "naranja", "rojo"]
colores.sort(reverse=True)
print(colores)Resultado:
['verde', 'rojo', 'naranja', 'azul', 'amarillo']lista.reverse( ) Con este otro método, obtenemos una lista invirtiendo el orden actual de sus elementos.
colores=["verde", "azul", "amarillo", "naranja", "rojo"]
colores.reverse()
print(colores)Resultado:
['rojo', 'naranja', 'amarillo', 'azul', 'verde']sorted(lista) Con esta función podemos crear una nueva lista que contenga todos los elementos de otra, pero ordenadamente dispuestos. También podemos añadir el parámetro reverse=”True”. La lista original no se ve modificada.
colores=["verde", "azul", "amarillo", "naranja", "rojo"]
colores_ordenados=sorted(colores)
colores_ordenados_reves=(sorted(colores, reverse=True))
print(colores)
print(colores_ordenados)
print(colores_ordenados_reves)Resultado:
['verde', 'azul', 'amarillo', 'naranja', 'rojo']
['amarillo', 'azul', 'naranja', 'rojo', 'verde']
['verde', 'rojo', 'naranja', 'azul', 'amarillo']for variable in lista: Con este bucle podemos recorrer uno por uno todos los elementos de una lista.
nombres=["Ana", "Luisa", "Juan", "José", "Pedro"]
for persona in nombres:
print(f"Su nombre es {persona}")Resultado:
Su nombre es Ana
Su nombre es Luisa
Su nombre es Juan
Su nombre es José
Su nombre es PedroTambién se puede recorrer una parte de la lista. En el siguiente ejemplo, comienza por el elemento 1, y acaba en el 3 (el cuatro no está incluido).
colores=["verde", "azul", "amarillo", "naranja", "rojo"]
for micolor in colores [ 1 : 4]:
print (micolor)Resultado:
azul
amarillo
naranjaPodemos añadir un tercer parámetro que nos indique los saltos entre elemento y elemento. En el siguiente ejemplo comenzamos en el elemento listanumeros[2], los siguientes son listanumeros[5], listanumeros[8], y
listanumeros[11]
listanumeros=[ 22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39]
for numero in listanumeros [ 2 : 12 : 3]:
print (numero)24
27
30
33while lista: Con una lista podemos utilizar un bucle while. Dicho bucle se ejecutará mientras lista tenga algún elemento, aunque también podremos interrumpir el bucle mediante la instrucción break.
invitados=["Pedro", "Juan", "Francisco", "Eduardo", "Ana", "María"]
recibidos=[ ]
while invitados:
llegado= invitados.pop(0)
print(f"Gracias por venir {llegado}.")
recibidos.append(llegado)
print (invitados)
print (recibidos)Resultado:
Gracias por venir Juan.
Gracias por venir Francisco.
Gracias por venir Eduardo.
Gracias por venir Ana.
Gracias por venir María.
[]
['Pedro', 'Juan', 'Francisco', 'Eduardo', 'Ana', 'María']Veamos ahora un ejemplo con break:
invitados=["Pedro", "Juan", "Francisco", "Eduardo", "Ana", "María"]
recibidos=[ ]
while invitados:
llegado= invitados.pop()
if llegado!="Eduardo":
print(f"Gracias por venir {llegado}.")
recibidos.append(llegado)
else:
print("¡¡Ha llegado Eduardo!!")
break
print ("Invitados: ",invitados)
print ("Recibidos: ",recibidos)Gracias por venir María.
Gracias por venir Ana.
¡¡Ha llegado Eduardo!!
Invitados: ['Pedro', 'Juan', 'Francisco']
Recibidos: ['María', 'Ana']Si queremos copiar una lista a partir de otra, NO debemos utilizar la instrucción simple lista_1=lista_2
Si lo hacemos así, lo único que conseguimos es tener la misma lista con dos nombres diferentes. Para copiar una lista a partir de otra, tenemos dos opciones.
La primera opción es utilizando el método lista.copy( )
miscolores=["verde", "azul", "amarillo", "naranja", "rojo"]
tuscolores=miscolores.copy()
del tuscolores[2]
print(miscolores)
print(tuscolores)Resultado:
['verde', 'azul', 'amarillo', 'naranja', 'rojo']
['verde', 'azul', 'naranja', 'rojo']La otra opción es utilizando la instrucción:
lista_1=lista_2 [ : ]
miscolores=["verde", "azul", "amarillo", "naranja", "rojo"]
tuscolores=miscolores[:] ##NO OLVIDAR LOS DOS PUNTOS
del miscolores[3]
print(miscolores)
print(tuscolores)Resultado:
['verde', 'azul', 'amarillo', 'rojo']
['verde', 'azul', 'amarillo', 'naranja', 'rojo']Con esta segunda opción, se puede elegir qué elementos de la lista original se van a copiar en la nueva lista.
miscolores=["verde", "azul", "amarillo", "naranja", "rojo"]
tuscolores=miscolores[1:4] ##El último copiado será miscolores[3]
print(miscolores)
print(tuscolores)Resultado:
['verde', 'azul', 'amarillo', 'naranja', 'rojo']
['azul', 'amarillo', 'naranja']Listas de más de una dimensión.
Una lista puede contener cualquier tipo de elementos. Incluso estos
elementos pueden estar mezclados entre ellos (NO deben de ser todos del mismo tipo).
Uno de los elementos que pueden contener, son otras listas. Una
consecuencia de ello es que las listas pueden tener dos o más dimensiones. En este caso, deberemos hacer referencia a cada uno de sus índices para acceder a cada uno de sus elementos.
En el ejemplo que vemos a continuación, vamos a acceder al cuarto
elemento de la lista (índice 3), que es a su vez un listado de animales. Dentro de este listado accedemos al elemento tercero (índice 2).
A continuación, accedemos al segundo elemento de la lista (indice1), que es
a su vez un listado de números. En concreto accedemos a su cuarto elemento
(índice 3), y lo multiplicamos por lista[0], que es el 2.
lista=[2,[34,43,12,35],4,["perro","gato","león"]]
print (lista[3][2])
producto=lista[0]*lista[1][3]
print(producto)Resultado:
león
70Un detalle para tener en cuenta es que, si queremos crear una nueva lista, partiendo de otra que tenga 2 o más dimensiones, deberemos utilizar el comando
copy.deepcopy( ) que se encuentra en el paquete copy.
import copy
lista1=[2,[83,3,-2],4,["melón","sandía","pera"]]
lista2=copy.deepcopy(lista1)
lista2[3][1]="limón"
print (lista1)
print (lista2)Resultado:
[2, [83, 3, -2], 4, ['melón', 'sandía', 'pera']]
[2, [83, 3, -2], 4, ['melón', 'limón', 'pera']]Listas por comprensión Una curiosa forma de crear listas es la creación de listas por comprensión.La construcción de este tipo de listas consiste en un valor que se va generando según un bucle. El valor a generar se escribe a la izquierda de la sentencia y el bucle que servirá de base para el cálculo de valores se escribe a la derecha.
cuadrados = [x ** 2 for x in range(1,11)]
print(cuadrados)Resultado:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]Hemos generado la lista llamada cuadrados. El valor a generar ha sido x**2, y el bucle base ha sido for x in range(1,11)
El bucle base puede ser también una lista ya existente:
cuadrados = [x ** 2 for x in range(1,11)]
medios_cuadrados=[cuadrado/2 for cuadrado in cuadrados]
print(medios_cuadrados)Resultado:
[0.5, 2.0, 4.5, 8.0, 12.5, 18.0, 24.5, 32.0, 40.5, 50.0]En general, nos vale cualquier conjunto de valores que nos pueda servir de base, y que nos pueda generar el valor a añadir a la lista:
su_conjunto={1,2,3,4,5,6,7,8,9,10}
dobles=[numero*2 for numero in su_conjunto]
print(dobles)Resultado:
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]También podemos formar por comprensión, listas dentro de listas:
tabla = [[(i*j) for i in range(0,7)] for j in range(0,10)]
print(tabla[9][6])
print(tabla[7][3])
print(tabla)Resultado:
54
21
[[0, 0, 0, 0, 0, 0, 0], [0, 1, 2, 3, 4, 5, 6], [0, 2, 4, 6, 8, 10, 12],
[0, 3, 6, 9, 12, 15, 18], [0, 4, 8, 12, 16, 20, 24],
[0, 5, 10, 15, 20, 25, 30], [0, 6, 12, 18, 24, 30, 36],
[0, 7, 14, 21, 28, 35, 42], [0, 8, 16, 24, 32, 40, 48],
[0, 9, 18, 27, 36, 45, 54]]Aquí vemos que se ha creado una lista cuyos elementos son 10 listas. Los elementos de cada una de las listas que componen la lista principal, se han ido creando gracias a la expresión (i*j)
En este ejemplo, vemos que el valor que ha quedado
almacenado en tabla[9][6]=54 que es el resultado
de 9×6; y que en tabla[7][3]=21 que es el resultado de 7×3.
En el siguiente ejemplo se forma una lista de dos dimensiones. Una de ellas contiene el día de la semana (codificado del 0 al 6). La otra contiene un fenómeno
meteorológico (codificado del 0 al 2).
El generador de los elementos de la matriz es la expresión dia+»_»+dato+»:»
A continuación se actualizan los datos de “viento” de los días de la semana. Aprovechando que estos datos son los últimos cuatro caracteres de la cadena formada, se extraen y se tratan.
semana=["lunes","martes","miércoles","jueves","viernes","sábado","domingo"]
fenomeno=["lluvia","viento","temperatura"]
meteorologia=[[dia+"_"+dato+":" for dato in fenomeno] for dia in
semana]
meteorologia[0][1]=meteorologia[0][1]+"14.7"
meteorologia[1][1]=meteorologia[1][1]+"41.2"
meteorologia[2][1]=meteorologia[2][1]+"12.8"
meteorologia[3][1]=meteorologia[3][1]+"33.5"
meteorologia[4][1]=meteorologia[4][1]+"43.1"
meteorologia[5][1]=meteorologia[5][1]+"82.0"
meteorologia[6][1]=meteorologia[6][1]+"102."
total=0
for k in range (0,6):
print(meteorologia[k])
viento=float((meteorologia[k][1])[-4:])
total+=viento
media=round(total/7,2) ##se redondean dos decimales.
print(f"La media de los vientos en la semana ha sido {media} Km/h")Resultado:
['lunes_lluvia:', 'lunes_viento:14.7', 'lunes_temperatura:']
['martes_lluvia:', 'martes_viento:41.2', 'martes_temperatura:']
['miércoles_lluvia:', 'miércoles_viento:12.8', 'miércoles_temperatura:']
['jueves_lluvia:', 'jueves_viento:33.5', 'jueves_temperatura:']
['viernes_lluvia:', 'viernes_viento:43.1', 'viernes_temperatura:']
['sábado_lluvia:', 'sábado_viento:82.0', 'sábado_temperatura:']
La media de los vientos en la semana ha sido 32.47 Km/hEn el siguiente ejercicio vamos a configurar un tablero de ajedrez. Crearemos
una lista de dos dimensiones (una lista dentro de otra). La primera lista contiene las filas del tablero (en este caso nombradas del 0 al 7), la segunda las columnas (nombradas también del 0 al 7).
A continuación “colocaremos” las piezas en el tablero.
tablero = [["" for columna in range(8)] for fila in range(8)]
for i in range(8):
tablero[1][i]="peón blanco"
for i in range(8):
tablero[6][i]="peón negro"
tablero[0][0],tablero[0][7]="torre blanca","torre blanca"
tablero[0][1],tablero[0][6]="caballo blanco","caballo blanco"
tablero[0][2],tablero[0][5]="álfil blanco","álfil blanco"
tablero[0][3]="dama blanca"
tablero[0][4]="rey blanco"
tablero[7][0],tablero[7][7]="torre negra","torre negra"
tablero[7][1],tablero[7][6]="caballo negro","caballo negro"
tablero[7][2],tablero[7][5]="álfil negro","álfil negro"
tablero[7][3]="dama negra"
tablero[7][4]="rey negro"
for k in range (7,-1,-1):
print(tablero[k])Resultado:
['torre negra', 'caballo negro', 'álfil negro', 'dama negra', 'rey negro', 'álfil negro', 'caballo negro', 'torre negra']
['peón negro', 'peón negro', 'peón negro', 'peón negro', 'peón negro', 'peón negro', 'peón negro', 'peón negro']
['', '', '', '', '', '', '', '']
['', '', '', '', '', '', '', '']
['', '', '', '', '', '', '', '']
['', '', '', '', '', '', '', '']
['peón blanco', 'peón blanco', 'peón blanco', 'peón blanco', 'peón blanco', 'peón blanco', 'peón blanco', 'peón blanco']
['torre blanca', 'caballo blanco', 'álfil blanco', 'dama blanca', 'rey blanco', 'álfil blanco', 'caballo blanco', 'torre blanca']A continuación vamos a “construir” un complejo de apartamentos. Serán 3 edificios, cada uno con 4 plantas, y cada planta 5 habitaciones. Inicialmente
estarán todas libres.
Después ocuparemos aleatoriamente 55 habitaciones, quedando 5 libres las cuales serán mostradas. Necesitaremos una lista de 3 dimensiones.
from random import randint
habitacion = [[["LIBRE" for puerta in range (5)]for planta in range(4)]for edificio in range(3)]
for k in range (55):
vacante=True
while vacante==True:
edificio=randint(0,2)
planta=randint(0,3)
puerta=randint(0,4)
if habitacion[edificio][planta][puerta]=="LIBRE":
habitacion[edificio][planta][puerta]="OCUPADA"
vacante=False
for edificio in range(0,3):
for planta in range(0,4):
for puerta in range(0,5):
if habitacion[edificio][planta][puerta]=="LIBRE":
print(f"La habitación {puerta} de la planta {planta} del edificio {edificio}, está LIBRE.")Posible resultado:
La habitación 0 de la planta 0 del edificio 0, está LIBRE.
La habitación 2 de la planta 0 del edificio 1, está LIBRE.
La habitación 3 de la planta 3 del edificio 1, está LIBRE.
La habitación 3 de la planta 0 del edificio 2, está LIBRE.
La habitación 3 de la planta 1 del edificio 2, está LIBRE.Las listas son un instrumento eficaz para almacenar y tratar datos. Las más simples de una sola dimensión son muy fáciles de entender y gestionar. Las de dos
dimensiones pueden ser útiles en algunas ocasiones y las de tres dimensiones, va a ser raro que nos las encontremos. Se podría llegar a más dimensiones, pero serían muy poco manejables.
Para más de una dimensión, podemos valorar si utilizar listas o utilizar otro tipo de estructura de datos como los objetos con sus atributos y métodos.