# Así defino un diccionario
libro = {"titulo": "El Quijote", "autor": "Cervantes", "precio": 20}
# así accedo al valor de una clave
print(libro["precio"])
# Así recorro todas las claves
for clave in libro:
print(clave)
# los valores de esa clave
print(libro[clave])
# Puedo tener una lista de diccionarios
biblioteca = [
{"titulo": "El Quijote", "autor": "Cervantes", "precio": 20},
{"titulo": "Las olas", "autor": "Virginia Woolf", "precio": 17},
{"titulo": "Los detectives salvajes", "autor": "Roberto Bolaño", "precio": 23},
{"titulo": "Tom va a la escuela", "autor": "Rick Sánchez", "precio": 10}
]
# para acceder a un elemento primero accedo a la posición de la lista
print(biblioteca[1]) # {"titulo": "Las olas", "autor": "Virginia Woolf", "precio": 17},
print(biblioteca[1]["autor"]) # "Virginia Woolf"
# Recorrer esa lista de diccionarios
for libro in biblioteca:
print(libro)
# Quiero ver todos los autores de la biblioteca
for libro in biblioteca:
print(libro["autor"])
# Puedo hacer cálculos por ejemplo media de precios
suma = 0
for libro in biblioteca:
suma += libro["precio"]
print(suma / len(biblioteca))
proyecto = [
{"nombre": "Análisis", "horas": 10, "precio": 60},
{"nombre": "Desarrollo", "horas": 50, "precio": 50},
{"nombre": "Implementación", "horas": 5, "precio": 70},
{"nombre": "Pruebas", "horas": 15, "precio": 40},
]
# función que me calcule el total de importe del proyecto
def totalProyecto(proyecto):
total = 0
# recorro las tareas
for tarea in proyecto:
# Accedo a las propiedades que me interesan. En este caso horas y precio
total += tarea["horas"] * tarea["precio"]
return total
print(totalProyecto(proyecto))
# listas que tienen diccionarios que tienen listas de diccionarios
biblioteca = [
{"titulo": "El Quijote",
"autor": {"nombre": "Miguel de Cervantes", "pais": "España"},
"ediciones": [
{"editorial": "Alianza", "precio": 15},
{"editorial": "Cátedra", "precio": 20}
]
},
{"titulo": "2666",
"autor": {"nombre": "Roberto Bolaño", "pais": "Chile"},
"ediciones": [
{"editorial": "Anagrama", "precio": 30},
{"editorial": "Alfaguara", "precio": 28}
]
}
]
# Al precio de la primera edición de mi primer libro
print(biblioteca[0]["ediciones"][0]["precio"]) # 15
# Al precio de la segunda edición de mi segundo libro
print(biblioteca[1]["ediciones"][1]["precio"]) # 28
# Si quiero el total de precios de toda la biblioteca
# Tengo que recorrer los libros
# después recorrer las ediciones
# sumar los precios
def sumaPreciosBiblioteca(biblioteca):
suma=0
for libro in biblioteca:
for edicion in libro["ediciones"]:
suma+=edicion["precio"]
return suma
print(sumaPreciosBiblioteca(biblioteca))
Ejemplos clase Collection
package com.trifulcas.colecciones;
import java.util.ArrayList;
import java.util.Collections;
public class EjemplosCollection {
public static void main(String[] args) {
ArrayList<String> nombres = new ArrayList<String>();
nombres.add("Juan");
nombres.add("María");
Collections.addAll(nombres, "Pedro", "Luis");
System.out.println("Hemos añadido elementos sueltos en una sola línea");
System.out.println(nombres); // [Juan, María, Pedro, Luis]
System.out.println("Invertimos el arrayList");
Collections.reverse(nombres);
System.out.println(nombres); // [Luis, Pedro, María, Juan]
System.out.println("Ordenamos el arrayList");
Collections.sort(nombres);
System.out.println(nombres); // [Juan, Luis, María, Pedro]
System.out.println("Si está ordenado podemos usar binarySearch");
System.out.println(Collections.binarySearch(nombres, "Pedro"));
System.out.println("Desordenamos el arrayList");
Collections.shuffle(nombres);
System.out.println(nombres); //
// Intercambiamos los valores de dos posiciones
Collections.swap(nombres, 1, 2);
System.out.println("Intercambiar posición 1 y 2");
System.out.println(nombres); //
System.out.println("Podemos obtener el máximo");
System.out.println(Collections.max(nombres)); //Pedro
System.out.println("Y el mínimo");
System.out.println(Collections.min(nombres)); //Juan
System.out.println("Rellenar toda la lista con un valor");
Collections.fill(nombres, "Ana");
System.out.println(nombres);
ArrayList<Integer> numeros=new ArrayList<>();
Collections.addAll(numeros, 1,2,2,3,3,3,4,4,4,4);
System.out.println("Frecuencia (numero de apariciones) de un elemento en una lista");
System.out.println(numeros);
System.out.println(Collections.frequency(numeros, 3));
}
}
Ejemplos tipos genéricos
package com.trifulcas.colecciones;
public class EjemplosGenericos {
public static void main(String[] args) {
// Al ser tipo int llama a la primera función
System.out.println(mayor(4,3));
// Al ser tipo dobule llama a la segunda
System.out.println(mayor(4.6,3.5));
// Llamo a la función con parámetros de tipo double
System.out.println(mayorG(4.6,3.5));
// Llamo a la función con parámetros de tipo int
System.out.println(mayorG(3,4));
// Llamo a la función con parámetros de tipo String
System.out.println(mayorG("ana","pep"));
}
// Esta función tiene de tipo int
static int mayor(int a, int b) {
if (a>b) {
return a;
}
return b;
}
// Esta función es una sobrecarga con double
static double mayor(double a, double b) {
if (a>b) {
return a;
}
return b;
}
// Aquí utilizo un tipo genérico, puedo llamar a la función
// Con cualquier tipo (siempre que se pueda comparar, que eso es lo que significa extends Comparable<T>)
static <T extends Comparable<T>> T mayorG(T a, T b){
if (a.compareTo(b)>0) {
return a;
}
return b;
}
}
Ejemplos HashSet
package com.trifulcas.colecciones;
import java.util.HashSet;
public class EjemplosHashSet {
public static void main(String[] args) {
// Lo creamos con HashSet igual que cualquier colección
HashSet<String> alumnos = new HashSet<>();
// añado los elementos con add
alumnos.add("Ana");
alumnos.add("Eva");
alumnos.add("Pep");
System.out.println("Imprimo el conjunto entero");
System.out.println(alumnos);
// Si añado un elemento que ya existe es como si no hiciera nada
alumnos.add("Ana");
System.out.println("Al añadir Ana no cambia porque ya estaba");
System.out.println(alumnos);
System.out.println("Contains me devuelve true porque Ana está en el conjunto");
System.out.println(alumnos.contains("Ana"));
System.out.println("Recorro los elementos del conjunto");
for (String alumno : alumnos) {
System.out.println(alumno);
}
System.out.println("Elimino el valor de Ana");
alumnos.remove("Ana");
System.out.println(alumnos);
}
}
Un ejemplo de HashMap
package com.trifulcas.colecciones;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
public class UsosHashMap {
public static void main(String[] args) {
ArrayList<String> usuarios=new ArrayList<>();
Collections.addAll(usuarios, "Ana","Eva","Juan","Rosa","Pep","Sara");
System.out.println(generaClaves(usuarios));
HashMap<String,ArrayList<Integer>> hash02=new HashMap<>();
hash02.put("Ana", new ArrayList<>());
hash02.get("Ana").add(5);
hash02.get("Ana").add(7);
hash02.get("Ana").add(9);
hash02.put("Eva", new ArrayList<>());
hash02.get("Eva").add(6);
hash02.get("Eva").add(8);
hash02.get("Eva").add(10);
System.out.println(getMedias(hash02));
}
// Una función a la que le pasamos un arraylist de nombres y nos genera
// Un diccionario con la clave el nombre y un valor que será una contraseña
// basada en el nombre, la primera letra del nombre, el índice del arraylist
// y la última letra del nombre
// generaClaves(ArrayList)
static HashMap<String,String> generaClaves(ArrayList<String> usuarios){
HashMap<String,String> res=new HashMap<String,String>();
for (int i=0;i<usuarios.size();i++) {
String usuario=usuarios.get(i);
String password=usuario.substring(0,1)+i+usuario.substring(usuario.length()-1);
res.put(usuarios.get(i), password);
}
return res;
}
// Una función a la que le pasamos un diccionario con el nombre de un alumno
// Y el valor un arraylist de notas y nos devuelve el hashmap con las medias
static HashMap<String,Double> getMedias(HashMap<String,ArrayList<Integer>> notas){
HashMap<String,Double> res=new HashMap<String,Double>();
for(String alumno:notas.keySet()) {
double suma=0;
for(int nota: notas.get(alumno)) {
suma+=nota;
}
res.put(alumno, suma/notas.get(alumno).size());
}
return res;
}
}
Ejemplos HashMap
package com.trifulcas.colecciones;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map.Entry;
public class EjemplosHashMap {
public static void main(String[] args) {
// Creo un hashmap de clave cadena y valor integer
HashMap<String, Integer> diccionario = new HashMap<String, Integer>();
// Añado valores
diccionario.put("Ana", 7);
diccionario.put("Eva", 8);
diccionario.put("Rosa", 6);
// Recupero valores
System.out.println(diccionario.get("Ana"));
System.out.println(diccionario.get("Pep"));
// Compruebo si existe una clave (en este caso no)
System.out.println(diccionario.containsKey("Pep"));
// Recorro las claves
for (String clave : diccionario.keySet()) {
// COn la clave tengo el valor vía get
System.out.println(clave + " - " + diccionario.get(clave));
}
// Recorro solo los valores
for (Integer valor : diccionario.values()) {
System.out.println(valor);
}
// Recorro el par clave valor con entryset
for (Entry<String, Integer> entrada : diccionario.entrySet()) {
System.out.println(entrada.getKey()+" - "+entrada.getValue());
}
// Eliminar elementos
diccionario.remove("Rosa");
System.out.println(diccionario);
// Cambio un valor
diccionario.put("Ana",9);
System.out.println(diccionario);
// Borro todo el hasmap
diccionario.clear();
System.out.println(diccionario);
// Yo puedo hacer hashmap de cualquier cosa
HashMap<Integer,String> hash01=new HashMap<>();
hash01.put(27, "Hola");
hash01.put(19, "Adios");
System.out.println(hash01);
// Un hashmap que tiene como valores un arraylist
HashMap<String,ArrayList<Integer>> hash02=new HashMap<>();
hash02.put("Ana", new ArrayList<>());
hash02.get("Ana").add(5);
hash02.get("Ana").add(7);
hash02.get("Ana").add(9);
hash02.put("Eva", new ArrayList<>());
hash02.get("Eva").add(6);
hash02.get("Eva").add(8);
hash02.get("Eva").add(10);
System.out.println(hash02);
for(String alumno:hash02.keySet()) {
System.out.println(alumno);
for(int nota:hash02.get(alumno)) {
System.out.println(nota);
}
}
// El primer elemento del alumno "Ana"
System.out.println(hash02.get("Ana").get(0));
}
}
Soluciones ejercicios
package com.trifulcas.colecciones;
import java.util.ArrayList;
import java.util.LinkedList;
public class SolucionesEjercicios {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(tablaMultiplicar(7));
System.out.println(menoresQue(new int[] { 1, 2, 3, 4, 5, 6 }, 4));
System.out.println(menoresQue(new String[] { "hola","que","tal","estamos" }, 4));
LinkedList<Integer> a=new LinkedList<Integer>();
a.add(1);
a.add(2);
a.add(3);
a.add(4);
LinkedList<Integer> b=new LinkedList<Integer>();
b.add(3);
b.add(4);
b.add(5);
b.add(6);
System.out.println(diferencia(a,b));
}
/*
* Crear una función tablaMultiplicar(numero) a la que le pasamos un número y
* nos devuelve un arraylist con la tabla de multiplicar de ese número
* tablaMultiplicar(5)->[5,10,15,20,25,30,35,40,45,50]
*/
static ArrayList<Integer> tablaMultiplicar(int numero) {
ArrayList<Integer> res = new ArrayList<Integer>();
for (int i = 1; i <= 10; i++) {
res.add(i * numero);
}
return res;
}
/*
* Crear una función menoresQue a la que le pasamos un array de enteros y un
* entero y nos devuelve un arraylist con los números menores o iguales a ese
* entero menoresQue([1,2,3,4,5,6],4)->[1,2,3,4]
*/
static ArrayList<Integer> menoresQue(int[] lista, int limite) {
ArrayList<Integer> res = new ArrayList<Integer>();
for (int numero : lista) {
if (numero <= limite) {
res.add(numero);
}
}
return res;
}
/*
* Crear una sobrecarga con String que nos devuelva las cadenas de longitud
* menor o igual al entero menoresQue(["Eva","Ana","Jaimito"],4)->["Eva","Ana"]
*/
static ArrayList<String> menoresQue(String[] lista, int limite) {
ArrayList<String> res = new ArrayList<String>();
for (String cadena : lista) {
if (cadena.length() <= limite) {
res.add(cadena);
}
}
return res;
}
/*
* Crear una función diferencia a la que le pasamos dos
* linkedlist de enteros y nos devuelve un linkedlist
* con los elementos del primer linkedlist que no están
* en el segundo
diferencia([1,2,3,4],[3,4,5,6])->[1,2]
*/
static LinkedList<Integer> diferencia(LinkedList<Integer> a, LinkedList<Integer> b){
LinkedList<Integer> res=new LinkedList<Integer>();
for (int numero:a) {
if (!b.contains(numero)) {
res.add(numero);
}
}
return res;
}
}
Ejercicios preexamen
# Crear una función areaCuadrado(lado) a la que le pasamos un lado y nos devuelve el área
# areaCuadrado(2)-> 4
# Crear una función a la que le pasamos un número y nos devuelve true si es divisible por
# 3 y false en caso contrario
# multiploTres(8)->False multiploTres(9)->True
# Crear una función a la que le pasamos una lista de números y nos dice
# el número de pares que hay
# numeroPares([1,2,3,4])->2
# Crear una función a la que le pasamos una cadena y un carácter y nos devuelve una lista
# con las palabras que tienen ese caracter
# buscaCaracter("Hola que tal","a")->["hola","tal"]
# buscaCaracter("Hola que tal","u")->["que"]
# Crear una función a la que le pasamos una cadena y nos devuelve la lista de palabras
# ordenada por longitud
Repaso funciones
# funciones
# pilar básico de la programación
# Nos sirve para encapsular un trozo de código
# Y procuramos que las funciones sean 'puras'
# los mismos parámetros de entrada devuelven los mismos resultados
import math
# No es una función pura porque depende del entorno (consola)
def saludo():
print("hola que tal")
saludo()
# Función pura que devuelve un resultado
def saludo():
return "hola que tal"
# Puedo imprimir en la consola
print(saludo())
archivo = open("saludo.txt", "w")
# O en un archivo
archivo.write(saludo())
archivo.close()
# o crear una variable
holi = saludo()
def saludar(nombre):
return "Hola " + nombre + " ¿que tal estás?"
print(saludar("Ana"))
alumnos = ["Ana", "Eva", "Pep", "Rosa"]
for alumno in alumnos:
print(saludar(alumno))
saludos = [saludar(alumno) for alumno in alumnos]
print(saludos)
def esPrimo(numero):
for i in range(2, int(math.sqrt(numero))):
if numero % i == 0:
return False
return True
# divide y vencerás
def listaPrimos(limite):
res=[]
for i in range(2,limite+1):
if esPrimo(i):
res.append(i)
return res
print(esPrimo(17))
print(esPrimo(18))
primos=listaPrimos(50)
print(primos)
Repaso for y listas
# estructuras de control
"""
if condidicion:
lo que hacemos si se cumple
else:
lo que hacemos si no se cumple
if condicion:
si se cumple
elif otra condicion:
si se cumple la otra
else:
en cualquier otro caso
if a<1000:
0-1000
elif a<2000:
1000-2000
elif a<3000
2000-3000
las condiciones: tenemos operadores: not, and y or
and : Se tienen que cumplir las dos
or : Basta que se cumpla una de ellas
if edad>=18 and dinero>20:
print("Entra en la discoteca")
else:
Si entra por aquí puede ser porque es menor de 18, porque tiene menos de 20 o por las dos
if edad>12 or altura>135:
print("Sube a la atracción")
Aquí entra porque es mayor de 12, su altura es> 135 o las dos
else:
Es <12 años y altura<135
"""
lista = [1, 2, 3, 4, 5]
alumnos = ["aa", "bb", "cc", "dd"]
mixta = [1, "cadenas", True]
# bucle for. El bucle for nos recorre una lista
for numero in lista: # recorro la lista
print(numero) # imprime 1,2,3,4,5
for alumno in alumnos:
print(alumno)
for i in range(10):
print(i)
numeros = range(20)
print(list(numeros))
lista.append(8)
# Yo tengo una lista, o cualquier otro objeto complejo (tuplas, diccionarios, conjuntos)
# SI quiero procesar los elementos de la lista tendré que hacer EL ESQUEMA
# una variable donde calcularé algo
# recorreré la lista
# modificaré el cálculo a veces dependiendo de una condición
# sumar todos los números del 1 al 100
# suma=0
# recorro los numeros del 1 al 100 y los sumo
suma = 0
for i in range(1, 101):
suma += i
print(suma)
suma = 0
for i in range(1, 101):
if i % 2 == 0:
suma += i
print(suma)
pares = []
for i in range(11):
if i % 2 == 0:
pares.append(i)
print(pares)
# Comprension de listas sintaxis:
#[ transformación de elemento for elemento in lista condicion de filtro ]
codigos=["123","4560","7890","1234","5678"]
c1=[elemento for elemento in codigos]
print(codigos)
print(c1)
c2=[len(elemento) for elemento in codigos]
print(c2)
c3=[elemento[-1] for elemento in codigos]
print(c3)
c4=["hola" for elemento in codigos]
print(c4)
c5=[elemento for elemento in codigos if len(elemento)>3]
print(c5)
c6=[elemento for elemento in codigos if elemento[-1]=="0"]
print(c6)
c7=[elemento[0:2] for elemento in codigos if elemento[-1]=="0"]
print(c7)
res=[]
for elemento in codigos:
if elemento[-1] == "0":
res.append(elemento[0:2])
print(res)