Ejercicios de Introducción a Python#

Exercise 41

Crea una función merge que acepte un número arbitrario de diccionarios y devuelva un diccionario cuyas claves sean las uniones de las claves de los diccionarios de entradas y los valores listas donde se concatenan los valores de los diccionarios originales. Por ejemplo,

dict1 = {
    "foo": 1,
    "bar": [3, 4],
    "baz": None
}

dict2 = {
    "foo": "Hello world",
    5: "five"
}

dict3 = {
    "bar": "yes"
}

>>> merge(dict1, dict2, dict3)

{
    'foo': [1, 'Hello world'],
    'bar': [[3, 4], 'yes'],
    'baz': [None],
    5: ['five']
}

d = {"a": "foo", "b": "bar"}
for k in d:
    print(k)

a
b

def merge(*args):
    merge_dict = {}
    for dictionary in args:
        # iterar sobre las claves de dictionary
        for key in dictionary:
            if key in merge_dict:
                merge_dict[key].append(dictionary[key])
            else:
                merge_dict[key] = [dictionary[key]]
    return merge_dict

dict1 = {
    "foo": 1,
    "bar": [3, 4],
    "baz": None
}

dict2 = {
    "foo": "Hello world",
    5: "five"
}

dict3 = {
    "bar": "yes"
}

merge(dict1, dict2, dict3)

{'foo': [1, 'Hello world'], 'bar': [[3, 4], 'yes'], 'baz': [None], 5: ['five']}

Exercise 42

Considera el siguiente ejemplo

a = [1, 2, [3, 4]]
b = list(a)

¿Cambia algún elemento de la lista a tras ejecutar b.append(100)?¿Y tras ejecutar b[2][0] = -100? ¿Por qué?

a = [1, 2, [3, 4]]
b = list(a)

b[2][0] = -100
print(a)

[1, 2, [-100, 4]]

Exercise 43

Crea una función concat_to_str que convierta una secuencia de objetos de Python en una cadena de transcripciones siguiendo las siguientes normas:

  • Si el objeto es un entero, entonces escribimos cada dígito en español separados por guiones. Si el entero es negativo, lo indicamos empezando la cadena por menos:

    • 142 -> uno-cuatro-dos

    • -12 -> menos-uno-dos

  • Si el objeto es un flotante, nos quedamos con la parte entera y hacemos lo mismo que en el caso anterior añadiendo "y decimales" al final.

    • 12.324 -> uno-dos y decimales

  • Si el objeto es una cadena, lo dejamos como está.

  • Si el objeto es de otro tipo (incluido bool), añadimos "<OTRO>".

Las transcripciones deben estar separas por " | ". Por ejemplo,

>>> s = concat_to_str([12, -14.23, "hello", True, None, 10.1, 5])
"uno-dos | menos-uno-cuatro y decimales" | hello | <OTRO> | <OTRO> | uno-cero y decimales | cinco"

[i for i in str(-5438543)]

['-', '5', '4', '3', '8', '5', '4', '3']

def traduce(objeto):
    if isinstance(objeto, int) and not isinstance(objeto, bool):
        return traduce_entero(objeto)

    if isinstance(objeto, float):
        return traduce_flotante(objeto)

    if isinstance(objeto, str):
        return objeto

    return "<OTRO>"

def traduce_entero(n):
    n_str = str(n)
    digits = [i for i in n_str]
    return "-".join([traduce_digito(digit) for digit in digits])

traductor_digitos = {
    "1": "uno",
    "2": "dos",
    "3": "tres",
    "4": "cuatro",
    "5": "cinco",
    "6": "seis",
    "7": "siete",
    "8": "ocho",
    "9": "nueve",
    "0": "cero",
    "-": "menos"
}

def traduce_digito(digito):
    return traductor_digitos[digito]

def traduce_flotante(f):
    f_rounded = round(f)
    return traduce_entero(f_rounded) + " y decimales"

def concat_to_str(iterable):
    traducciones = [traduce(i) for i in iterable]
    return " | ".join(traducciones)

concat_to_str([12, -14.23, "hello", True, None, 10.1, -5])

'uno-dos | menos-uno-cuatro y decimales | hello | <OTRO> | <OTRO> | uno-cero y decimales | menos-cinco'

Exercise 44

Visita este sitio web y copia el enlace de descarga de un libro a tu elección en texto plano en una variable url. Por ejemplo, este es el enlace de descarga de Orgullo y Prejuicio.

Utiliza el módulo requests para realizar una petición http y guardar el cuerpo de la respuesta en una variable book tal y como se indica a continuación

import requests

url = "https://gutenberg.org/cache/epub/1342/pg1342.txt"
book_request = requests.get(url)
book = book_request.text

Escribe una función count_words que devuelva un diccionario con las 50 palabras más frecuentes del libro que tenga como claves dichas palabras y como valor el número de apariciones.

import requests

url = "https://gutenberg.org/ebooks/2000.txt.utf-8"

book_request = requests.get(url)
book = book_request.text

book_processed = (
    book
    .replace("\n", " ")
    .replace("\r", " ")
    .replace("-", " ")
)

words = book_processed.split(" ")
words = [w.lower() for w in words if w != "" if len(w) >= 10]
results = {}
for word in words:
    if word in results:
        results[word] += 1
    else:
        results[word] = 1

results = sorted(results.items(), key=lambda item: item[1], reverse=True)[:100]

Exercise 45

Crea una clase CarritoCompra, donde cada instancia almacenará dos listas de cadenas representando productos

  • una lista para productos que necesitamos, necesitados.

  • otra para productos ya comprados, comprados.

Un producto no puede aparecer más de una vez en cada lista.

Crea un método __init__ que acepte una cadena o un iterable de cadenas representando productos que se añadirán a la lista de necesitados y además métodos para

  • añade_necestidados: añadir nuevos elementos necesitados al carrito,

  • compra: marcar un producto como comprado (pasa de necesitados a comprados),

  • elimina_necesitados, elimina_comprados: eliminar un producto, ya sea de la lista de necesitados o comprados,

  • lista_necestidados y lista_comprados: listar los elementos necesitados o comprados en orden alfabético.

[1, 2, 3].extend([4])

l = ["foo", "bar"]
l.sort()
print(l)

['bar', 'foo']

from typing import List
from collections.abc import Iterable

class CarritoCompra:
    def __init__(self, necesitados: Iterable[str] = []):
        self.necesitados: List = necesitados
        self.comprados: List = []

    def anade_necesitados(self, elementos: Iterable[str]):
        self.necesitados.extend(elementos)

    def compra(self, elemento: str):
        self.comprados.append(elemento)
        self.necesitados.remove(elemento)

    def elimina_necesitados(self, elemento: str):
        self.necesitados.remove(elemento)

    def elimina_comprados(self, elemento: str):
        self.comprados.remove(elemento)

    def lista_necesitados(self):
        self.necesitados.sort()
        print(self.necesitados)

    def lista_comprados(self):
        self.comprados.sort()
        print(self.comprados)

carrito = CarritoCompra()

carrito.anade_necesitados(["manzana", "pera", "pescado"])

['manzana', 'pera', 'pescado']

carrito.lista_necesitados()
carrito.lista_comprados()

carrito.compra("pescado")
carrito.compra("pera")
carrito.compra("carne")
carrito.lista_necesitados()
carrito.lista_comprados()

carrito.elimina_necesitados("pera")
carrito.elimina_necesitados("manzana")
carrito.elimina_comprados("pera")
carrito.lista_necesitados()
carrito.lista_comprados()

['manzana', 'pera', 'pescado']
[]

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-62-3445b7b93df5> in <cell line: 6>()
      4 carrito.compra("pescado")
      5 carrito.compra("pera")
----> 6 carrito.compra("carne")
      7 carrito.lista_necesitados()
      8 carrito.lista_comprados()

<ipython-input-60-844dd3155c5f> in compra(self, elemento)
     12     def compra(self, elemento: str):
     13         self.comprados.append(elemento)
---> 14         self.necesitados.remove(elemento)
     15 
     16     def elimina_necesitados(self, elemento: str):

ValueError: list.remove(x): x not in list

Exercise 46 (:label: return-none)

Lee este blog sobre en una función que devuelve None es mejor

  • No incluir return

  • Incuir solamente return

  • Incluir return None

Y pon ejemplos de cuándo deberíamos usar cada uno de ellos.