Mes: junio 2024

Ejemplos sobrecarga constructores

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// base y altura que son de tipo double
// Lo vamos a poder crear: Poniendo la base y la altura
// Poniendo la base solamente, la altura valdrá 1
// No poniendo nada, base y altura valdrán 1
public class Rectangulo {
    double base;
    double altura;
     
    Rectangulo(double base, double altura){
        this.base=base;
        this.altura=altura;
    }
    Rectangulo(double base){
        this(base,1);
    }
    Rectangulo(){
        this(1);
    }
}
1
2
3
4
5
6
7
8
9
public class TestClases {
 
    public static void main(String[] args) {
        Rectangulo r1=new Rectangulo(3,4);
        Rectangulo r2=new Rectangulo(3);
        Rectangulo r3=new Rectangulo();
    }
 
}

Soluciones Clases

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
public class Asignatura {
    String nombre;
    int  creditos;
    double precioCredito;
 
 
    double precioTotal(){
        return creditos*precioCredito;
    }
}
 
public class Empleado {
    String nombre;
    double salario;
    public Empleado(String nombre, double salario) {
        this.nombre = nombre;
        this.salario = salario;
    }
 
}
 
public class Mascota {
    String nombre;
    String tipo;
    public Mascota(String nombre) {
        this.nombre = nombre;
    }
}
public class Producto {
    String nombre;
    double precio;
    int stock;
 
    Producto(String nombre){
        this.nombre=nombre;
        precio=0;
        stock=0;
    }
 
    double PVP() {
        return precio*1.21;
    }
    void comprar(int cantidad) {
        stock+=cantidad;
    }
 
    void vender(int cantidad) {
        stock-=cantidad;
    }
}

Sobrecarga de constructores

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package com.trifulcas.oop;
 
public class Empleado2 {
    String nombre;
    double sueldo;
    double irpf;
 
    // COnstructor con dos parámetros
    public Empleado2(String nombre, double sueldo) {
 
        this.nombre = nombre;
        this.sueldo = sueldo;
        if (sueldo<3000) {
            irpf=0.1;
        }else {
            irpf=0.12;
        }
    }
 
    // Constructor con un parámetro
    public Empleado2(String nombre) {
        this.nombre = nombre;
        this.sueldo = 1600;
        irpf=0.1;
    }
    // Constructor sin parámetros
    public Empleado2() {
        this.nombre = "Anónimo";
        this.sueldo = 1600;
        irpf=0.1;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package com.trifulcas.oop;
 
public class Empleado {
    String nombre;
    double sueldo;
    double irpf;
 
    // COnstructor con dos parámetros
    public Empleado(String nombre, double sueldo) {
 
        this.nombre = nombre;
        this.sueldo = sueldo;
        if (sueldo<3000) {
            irpf=0.1;
        }else {
            irpf=0.12;
        }
    }
 
    // Constructor con un parámetro
    public Empleado(String nombre) {
        this(nombre,1600);
    }
    // Constructor sin parámetros
    public Empleado() {
        this("Anónimo");
    }
}

Ejemplo Clases

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Voy a crear una clase para almacenar productos
// EL producto tiene un nombre, un precio y un stock
// Cuando creo el producto obligatoriamente le tengo que dar un nombre
// El stock y el precio por defecto valen 0
// Voy a crear una función PVP que me devuelve el precio  más el iva
// Voy a crear una función comprar que me añade una cantidad al stock
public class Producto {
    String nombre;
    double precio;
    int stock;
     
    Producto(String nombre){
        this.nombre=nombre;
        precio=0;
        stock=0;
    }
     
    double PVP() {
        return precio*1.21;
    }
    void comprar(int cantidad) {
        stock+=cantidad;
    }
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static void main(String[] args) {
        Producto tuerca=new Producto("Tuerca");
        tuerca.precio=20;
        System.out.println(tuerca.PVP());
        tuerca.comprar(30);
        System.out.println(tuerca.stock);
        tuerca.comprar(30);
        System.out.println(tuerca.stock);
         
        Producto misterio;
        misterio=tuerca;
         
        System.out.println(misterio.stock); // ¿? 0 60 error
         
        misterio.comprar(40);
         
        System.out.println(tuerca.stock); // 0 20 no existe 60 100 10000
        System.out.println(misterio==tuerca);
    }

Constructores

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package com.trifulcas.oop;
 
// La sintaxis de una clase es muy sencilla 'class'
public class Alumno {
    // Propiedades
    String nombre;
    // 2) Para obligar a dar valor a alguna propiedad
    // El constructor de alumno requiere de un parámetro
    // de tipo String. Esto quiere decir que cuando
    // cree un objeto alumno le tendré que pasar un nombre
    Alumno(String nombre){
        // ¿Qué es this? This hace referencia al propio objeto
        // Por qué aquí hace falta y en saludo no?
        // Lo uso para diferenciar entre el parámetro y la propiedad
        this.nombre=nombre;
    }
    // Funciones
    void saludo() {
        System.out.println(this.getSaludo() + this.nombre);
        // Sin this también funciona ¿Por qué?
        // Porque Java por defecto busca funciones y propiedades en this
        System.out.println(getSaludo() + nombre);
    }
    String getSaludo() {
        return "Hola que tal ";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Coche {
    String marca;
    int velocidad=0;
     
    public Coche(String marca) {
        super();
        this.marca = marca;
    }
    void acelerar() {
        System.out.println("brum brum");
        // Lo interesante de las clases es que sus funciones
        // Pueden acceder y modificar las propiedades
        velocidad+=10;
    }
    void frenar() {
        System.out.println("Ñññic");
         
        velocidad-=10;
        if (velocidad<0) {
            velocidad=0;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class Cuadrado {
    // Cada objeto cuadrado tendrá su lado
    double lado;
 
    // COnstructor: es una función especial que se llama
    // Cuando creamos (instanciamos) el objeto
    // se llama igual que la clase
    // ¿Para qué se usa?
    // 1) Para inicializar valores de mis propiedades
    // 2) Para obligar a dar valor a alguna propiedad
    Cuadrado() {
        lado=1;
    }
 
    // Todas las funciones devuelven el valor en función
    // de la propiedad de la clase, no como un parámetro
    double area() {
        return lado * lado;
    }
 
    double perimetro() {
        return lado * 4;
    }
 
    double diagonal() {
        return Math.sqrt(lado * lado * 2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
public static void main(String[] args) {
        // String es la plantilla y cadena es un objeto
        // Cada cadena es una instancia de la clase String
        String cadena = "Hola que tal";
        String otracadena = "Hola que tal";
        String yotracadena = "Hola que tal";
        // Como cada objeto es instancia de la clase String
        // Todos comparten las mismas propiedades y funciones
        System.out.println(cadena.length());
        System.out.println(otracadena.length());
        System.out.println(yotracadena.length());
 
        // Yo tengo la clase Alumno
        // La clase alumno es una plantilla para crear alumnos
        // La palabra clave new es la que me crea el objeto
        Alumno ana = new Alumno("Ana Pi");
     
        ana.saludo();
        Alumno eva = new Alumno("Eva Pérez");
         
        eva.saludo();
        // juan está declarado pero no he creado ningún objeto
        // Es como si no existiera. No puedo poner juan.nombre="sss"
        Alumno juan;
 
        Coche seat = new Coche("Seat Panda");
         
        seat.acelerar();
        seat.acelerar();
        System.out.println(seat.velocidad);
        seat.frenar();
        seat.frenar();
        seat.frenar();
        seat.frenar();
        System.out.println(seat.velocidad);
        // Otro coche nuevo
        Coche citroen = new Coche("Citroen");
         
        for (int i = 0; i < 10; i++) {
            citroen.acelerar();
        }
        System.out.println(citroen.velocidad);
 
        // Esto no tiene sentido:
        // Coche.marca="Seat";
        // Las propiedades se ponen en los objetos, no en la clase
        // Porque la clase es la plantilla
        // Nosotros no usamos el plano de una casa para colgar un cuadro
 
        // Cada objeto que creamos de la clase cuadrado
        // Encapsula las funciones que nos dan información de su propia
        // clase. No tenemos que pasar esos valores como parámetro
        Cuadrado c1 = new Cuadrado();
        c1.lado = 2;
        System.out.println(c1.area());
        System.out.println(c1.perimetro());
        System.out.println(c1.diagonal());
 
        System.out.println(cadena.toUpperCase());
         
        // Yo puedo crear un ArrayList con la clase Cuadrado
        // Igual que lo hacía de string o de cualquier otra cosa
        ArrayList<Cuadrado> lista =new ArrayList<>();
        for(int i=1;i<=10;i++) {
            // Creo un objeto
            Cuadrado c=new Cuadrado();
            c.lado=i;
            // Añado a la lista
            lista.add(c);
        }
        // Recorrer esa lista
        for(Cuadrado c:lista) {
            // Imprimir el área
            System.out.println(c.area());
        }
         
        Cuadrado a=new Cuadrado();
        Cuadrado b=new Cuadrado();
        a.lado=1;
        b.lado=1;
        System.out.println(a==b); // false porque no son el mismo objeto
         
        System.out.println("Cuadrado nuevo con constructor");
        Cuadrado nuevo=new Cuadrado();
        System.out.println(nuevo.lado);
    }

Introducción OOP

1
2
3
4
5
6
7
8
9
10
// La sintaxis de una clase es muy sencilla 'class'
public class Alumno {
    // Propiedades
    String nombre;
 
    // Funciones
    void saludo() {
        System.out.println("Hola " + nombre);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Coche {
    String marca;
    int velocidad=0;
     
    void acelerar() {
        System.out.println("brum brum");
        // Lo interesante de las clases es que sus funciones
        // Pueden acceder y modificar las propiedades
        velocidad+=10;
    }
    void frenar() {
        System.out.println("Ñññic");
        velocidad-=10;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.trifulcas.oop;
 
public class Cuadrado {
    // Cada objeto cuadrado tendrá su lado
    double lado;
     
    // Todas las funciones devuelven el valor en función
    // de la propiedad de la clase, no como un parámetro
    double area() {
        return lado*lado;
    }
    double perimetro() {
        return lado*4;
    }
    double diagonal() {
        return Math.sqrt(lado*lado*2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
public class Introduccion {
 
    public static void main(String[] args) {
        // String es la plantilla y cadena es un objeto
        // Cada cadena es una instancia de la clase String
        String cadena="Hola que tal";
        String otracadena="Hola que tal";
        String yotracadena="Hola que tal";
        // Como cada objeto es instancia de la clase String
        // Todos comparten las mismas propiedades y funciones
        System.out.println(cadena.length());
        System.out.println(otracadena.length());
        System.out.println(yotracadena.length());
         
        // Yo tengo la clase Alumno
        // La clase alumno es una plantilla para crear alumnos
        // La palabra clave new es la que me crea el objeto
        Alumno ana = new Alumno();
        ana.nombre="Ana Pi";
        ana.saludo();
        Alumno eva=new Alumno();
        eva.nombre="Eva Pérez";
        eva.saludo();
        // juan está declarado pero no he creado ningún objeto
        // Es como si no existiera. No puedo poner juan.nombre="sss"
        Alumno juan;
         
        Coche seat=new Coche();
        seat.marca="Seat Panda";
        seat.acelerar();
        seat.acelerar();
        System.out.println(seat.velocidad);
        seat.frenar();
        System.out.println(seat.velocidad);
        // Otro coche nuevo
        Coche citroen=new Coche();
        citroen.marca="Citroen";
        for(int i=0;i<10;i++) {
            citroen.acelerar();
        }
        System.out.println(citroen.velocidad);
 
        // Esto no tiene sentido:
        // Coche.marca="Seat";
        // Las propiedades se ponen en los objetos, no en la clase
        // Porque la clase es la plantilla
        // Nosotros no usamos el plano de una casa para colgar un cuadro
 
// Cada objeto que creamos de la clase cuadrado
        // Encapsula las funciones que nos dan información de su propia
        // clase. No tenemos que pasar esos valores como parámetro
        Cuadrado c1 = new Cuadrado();
        c1.lado = 2;
        System.out.println(c1.area());
        System.out.println(c1.perimetro());
        System.out.println(c1.diagonal());
 
        System.out.println(cadena.toUpperCase());
 
// Yo puedo crear un ArrayList con la clase Cuadrado
        // Igual que lo hacía de string o de cualquier otra cosa
        ArrayList<Cuadrado> lista =new ArrayList<>();
        for(int i=1;i<=10;i++) {
            // Creo un objeto
            Cuadrado c=new Cuadrado();
            c.lado=i;
            // Añado a la lista
            lista.add(c);
        }
        // Recorrer esa lista
        for(Cuadrado c:lista) {
            // Imprimir el área
            System.out.println(c.area());
        }
 
Cuadrado a=new Cuadrado();
        Cuadrado b=new Cuadrado();
        a.lado=1;
        b.lado=1;
        System.out.println(a==b); // false porque no son el mismo objeto
}
 
}

Soluciones ejercicios HashMap

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package com.trifulcas.colecciones;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
 
public class SolucionesColecciones {
 
    public static void main(String[] args) {
        HashMap<String, Integer> notas = new HashMap<>();
        notas.put("JS", 5);
        notas.put("c#", 8);
        notas.put("Java", 9);
        System.out.println(calculaMedia(notas));
        System.out.println(100 / 3.0);
        HashMap<String, ArrayList<Integer>> productos = new HashMap<>();
        productos.put("Tuerca", new ArrayList<>());
        productos.get("Tuerca").add(1);
        productos.get("Tuerca").add(2);
        productos.get("Tuerca").add(3);
        productos.put("Tornillo", new ArrayList<>(Arrays.asList(2, 3, 4)));
        productos.put("Arandela", new ArrayList<>(Arrays.asList(4, 5, 6)));
        System.out.println(productos);
        System.out.println(precioMinimo(productos));
    }
 
    static double calculaMedia(HashMap<String, Integer> notas) {
        double suma = 0;
        // Recorro los valores que es lo que me hace falta
        for (int nota : notas.values()) {
            suma += nota;
        }
        // Redondear a dos decimales OJO cuando en java dividimos dos enteros nos hace
        // la división entera
        // Por lo tanto quita los decimales. Si queremos conservarlos ponemos .0
        return Math.round((suma / notas.size()) * 100) / 100.0;
    }
 
    // Ojo con los parámetros de entrada y salida
    static HashMap<String, Integer> precioMinimo(HashMap<String, ArrayList<Integer>> productos) {
        HashMap<String, Integer> res = new HashMap<String, Integer>();
        // Recorro el hashmap
        for (String producto : productos.keySet()) {
            // Añado la clave la misma y el valor aprovecho el min de collections
            res.put(producto, Collections.min(productos.get(producto)));
            // Si no me acuerdo del collections me creo yo la función
            res.put(producto, minimoValor(productos.get(producto)));
        }
        return res;
    }
    // No hace falta pero bueno...
    static int minimoValor(ArrayList<Integer> numeros) {
        int minimo = numeros.get(0);
        for (int numero : numeros) {
            if (numero < minimo) {
                minimo = numero;
            }
        }
        return minimo;
    }
}

Ejercicios preexamen

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
# vamos a hacer una función a la que le pasamos un tipo de bono
# un tipo de cliente y una cantidad y nos calcule el precio de acuerdo a lo siguiente
# bono=vip precio=3000
# bono=extra precio=2000
# bono=normal precio=1000
# tipo cliente= standard, el precio no cambia
# tipo cliente=premium, el precio es la mitad
# por defecto el bono sea normal y el cliente tambien
# los parámetros por defecto siempre al final
 
 
 
def precioTotal(cantidad, tipoBono="normal", tipoCliente="normal"):
    if tipoBono == "normal":
        precio = 1000
    elif tipoBono == "extra":
        precio = 2000
    else:
        precio = 3000
    if tipoCliente == "premium":
        precio = precio / 2
    return cantidad * precio
 
 
print(precioTotal(10, "normal", "normal"))
print(precioTotal(10, "normal", "premium"))
print(precioTotal(10, "vip", "premium"))
print(precioTotal(10))
 
# esta función, en teoría, cuenta el número de pares que hay en la lista
# ¿Funciona? Si es que no por qué y como arreglarlo
def contarPares(lista):
    total=0
    for i in lista:
        if total%2==0:
            total+=i
    return total
 
def contarPares(lista):
    total = 0
    for i in lista:
        if i % 2 == 0:
            total += 1
    return total
 
# Una función a la que le pasamos un proyecto como este:
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},
]
# Y nos devuelve una lita de las tareas que ocupan más de 10 horas. En el caso anterior, desarrollo y pruebas
# tareasLargas(proyecto)->["Desarrollo","Pruebas"]
 
def tareasLargas(proyecto):
    res=[]
    for tarea in proyecto:
        if tarea["horas"]>10:
            res.append(tarea['nombre'])
    return res
print(tareasLargas(proyecto))
 
# una función a la que le pasamos una cadena y nos devuelve una lista con la última letra de cada palabra
# ultimaLetra("hola que tal")->["a","e","l"]
 
def ultimaLetrafor(cadena):
    palabras=cadena.split()
    res=[]
    for palabra in palabras:
        res.append(palabra[-1])
    return res
 
def ultimaLetra(cadena):
    return [palabra[-1] for palabra in cadena.split()]
print(ultimaLetra("hola que tal"))

Soluciones ejercicios funciones

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
# Crear una función areaCuadrado(lado) a la que le pasamos un lado y nos devuelve el área
# areaCuadrado(2)-> 4
 
def areaCuadrado(lado):
    return lado*lado
 
# 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
def multiploTres(numero):
    return numero % 3==0
    """
    if numero % 3==0:
        return True
    else:
        return False
        """
# 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
def numeroPares(lista):
    contador=0
    # recorrer la lista
    for numero in lista:
        # cada vez que haya un par contarlo
        if numero % 2 == 0:
            contador += 1
    return contador
 
# 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"]
def buscaCaracter(cadena,caracter):
    res=[]
    # recorrer las palabras
    for palabra in cadena.split():
        # Si en esas palabras está el caracter lo añado a res
        # Si no está, no hago nada
        if caracter in palabra:
            res.append(palabra)
    return res
# Crear una función a la que le pasamos una cadena y nos devuelve la lista de palabras
# ordenada por longitud
 
# TODO: Preguntar que hacer si la longitud de dos cadenas es igual
def ordenarCadena(cadena):
    # obtener la lista de palabras
    palabras=cadena.split()
    palabras=sorted(palabras,key=len)
    return palabras

Más ejemplos diccionarios anidados

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
# 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))