<jupyter_start><jupyter_text>Tarea 1: Semana 1Cada clase que veamos tendrá una tarea asignada, la cual contendrá problemas varios que se pueden resolver con lo visto en clase, de manera que puedas practicar lo que acabas de aprender.En esta ocasión, dados los problemas que tuvimos, la primer tarea tendrá conceptos de las dos primeras clases.Para resolver la tarea, por favor cambiar el nombre del archivo a "Tarea1_ApellidoNombre.ipynb", sin acentos ni letras ñ (ejemplo: en mi caso, el archivo se llamaría "Tarea1_JimenezEsteban.ipynb"). Luego de haber cambiado el nombre, resolver cada uno de los puntos en los espacios provistos.Referencia:- https://www.kaggle.com/learn/python___  1. Complete el código<jupyter_code>pi = 3.14159 # aproximadamente
diametro = 3

# Crear una variable llamada "radio" (sin las comillas), igual a la mitad del diámetro
radio = 3/2
# Imprimir el radio
print(radio)
# Crear una variable llamada "area" (sin las comillas), usando la formula para el radio del circulo: pi por el radio al cuadrado
area = pi * (radio*radio)
# Imprimir el area
print(area)<jupyter_output>1.5
7.0685775<jupyter_text>2. Añada código para intercambiar los valores de las variables `a` y `b`, de manera que `a` tome el valor actual de `b` y viceversa.Mucho cuidado, no se vale escribir directamente los valores. Es decir`>>> a = [3, 2, 1]``>>> b = [1, 2, 3]`no es una solución válida.<jupyter_code>########### Código inicial. No tocar esta parte ######################
# El tipo de variables a continuación son listas. Estudiaremos este
# tipo de variables la próxima clase. Por ahora, basta con saber que
# son otro tipo de variables de Python, como los int, o float.
a = [1, 2, 3]
b = [3, 2, 1]
######################################################################

# Tu código va acá.
a, b = b, a
print(f"a: {a} \nb: {b}")<jupyter_output>a: [3, 2, 1] 
b: [1, 2, 3]<jupyter_text>3.  a) Añadir paréntesis a la siguiente expresión de modo que el resultado sea 1<jupyter_code>(5 - 3) // 2<jupyter_output><empty_output><jupyter_text>b) Añadir paréntesis a la siguiente expresión de modo que el resultado sea 0<jupyter_code>8 - (3 * 2) - (1 + 1)<jupyter_output><empty_output><jupyter_text>4. Juan, María y Alberto acordaron juntar todos los dulces que obtuvieran en Halloween y dividirlo en partes iguales para todos. Para que no haya ningún problema y su amistad se conserve, los dulces que sobren despues de dividir en 3 partes iguales serán tirados. Por ejemplo, si entre todos juntan 91 dulces, tomarán 30 cada uno y tirarán 1.Escribe una expresión aritmética para calcular cuántos dulces deben ser tirados dados los dulces que recojan cada uno.<jupyter_code># Variables que representan el número de dulces juntados por Juan, María y Alberto
dulces_juan = 121
dulces_maria = 77
dulces_alberto = 109

# Escriba en el lado derecho una expresión aritmética de los dulces que deben ser tirados
dulces_sobrantes = ( dulces_juan + dulces_maria + dulces_alberto) % 3
print(f"Después de dividir equitativamente sobran '{dulces_sobrantes}' dulces")<jupyter_output>Después de dividir equitativamente sobran '1' dulces<jupyter_text>5. Escriba el código para la siguiente función de acuerdo a la descripción en la documentación.**Asegúrate de probar tu función**<jupyter_code>def redondear_a_dos_decimales(num):
    """
    Devuelve el número dado redondeado a dos cifras decimales. 
    
    >>> redondear_a_dos_decimales(3.14159)
    3.14
    """
    return round(num, 2)
    # Reemplaza el código con tu solución
    # ("pass" es una palabra clave que no hace nada. La usamos acá
    # para que haga espacio, porque una vez que empezamos un bloque
    # de código Python requiere que se escriba por lo menos una línea.)
    # pass

print(redondear_a_dos_decimales(3.14159))<jupyter_output>3.14<jupyter_text>6. Aplicando la función `help()` sobre la función `round()`, dice que el parámetro de entrada `ndigits` puede ser negativo. Elija bien el valor del parámetro `ndigits` para que la siguiente celda imprima el número 2300.<jupyter_code>print(round(2345.32, ndigits=-2))<jupyter_output>2300.0<jupyter_text>7. En el ejercicio 4, presentamos tres amigos que compartían dulces. Como resultado, ellos tenían un total de dulces que debían repartir en partes iguales entre ellos. Los dulces restantes debían ser tirados. Por ejemplo, si entre todos juntaban 91 dulces, tomarían 30 cada uno y tiraían 1.Allí, escribiste un código para calcular cuántos dulces debían tirar, suponiendo que cada uno había juntado un número particular.Abajo presentamos una simple función que calcula el número de dulces a tirar para cualquier cantidad de dulces totales. Modificarla de manera que reciba opcionalmente un segundo argumento que represente el número de amigos entre los cuales se van a repartir los dulces. Si no se recibe un segundo argumento, por defecto se deben asumir 3 amigos, como antes.**Asegúrate de probar tu función**<jupyter_code>def dulces_sobrantes(dulces_totales, numero_amigos = 3):
    """
    Devuelve el número de dulces sobrantes que deben ser tirados luego
    de distribuir el número de dulces_totales en partes iguales entre
    los tres amigos.
    
    >>> dulces_sobrantes(91)
    1
    """
    return dulces_totales % numero_amigos
dulces_totales = 91
print(f"Asumiendo 3 amigos por default y '{dulces_totales}' dulces, sobran '{dulces_sobrantes(dulces_totales)}'.")
print(f"Asumiendo 4 amigos y '{dulces_totales}' dulces, sobran '{dulces_sobrantes(dulces_totales,4)}'.")<jupyter_output>Asumiendo 3 amigos por default y '91' dulces, sobran '1'.
Asumiendo 4 amigos y '91' dulces, sobran '3'.<jupyter_text>8. Puede no ser divertido, pero leer y entender los mensajes de error que nos brinda Python es muy, MUY importante.Cada celda abajo contiene codigos con errores.Para cada celda:1. Leer el código y pensar qué crees que pasa cuando corra.2. Correr la celda y ver qué pasa.3. Arregla el código, de modo que no arroje ningún error.<jupyter_code>redondear_a_dos_decimales(9.9999)
x = -10
y = 5
# Cuál de las dos variables tiene el valor absoluto más pequeño?
abs_mas_pequeño = min(abs(x), abs(y))
abs_mas_pequeño
def f(x):
    y = abs(x)
    return y

print(f(5))<jupyter_output>5<jupyter_text>9. Muchos lenguajes de programación tienen la función [sign](https://en.wikipedia.org/wiki/Sign_function) disponible como parte de la librería estándar. Python no la tiene, ¡pero podemos definir nuestra propia función!En la celda siguiente, defina una función llamada `sign`, que tome un argumento numérico y devuelva -1 si el número es negativo, 1 si es positivo y 0 si es 0.**Asegúrate de probar tu función**<jupyter_code># Definir una función llamada sign con las especificaciones dadas
def sign(number):
    if number > 0:
        return 1
    if number < 0:
        return -1
    return 0
#Examples
print(sign(300))
print(sign(-300))
print(sign(0))<jupyter_output>1
-1
0<jupyter_text>10. La función `es_negativo()` en la celda de abajo es correcta (devuelve `True` si el número dado es negativo y `False` de otro modo).Sin embargo, se usan muchas líneas de código para una tarea tan simple. Podemos reducir el número de líneas de código en esta función en un 75`%`, con exactamente el mismo resultado.Veamos si puedes obtener una función equivalente que use solo una línea de código. Escribir tu solución en la función `es_negativo_conciso()`.**Asegúrate de probar tu función**<jupyter_code>def es_negativo(num):
    if num < 0:
        return True
    else:
        return False
def es_negativo_conciso(number):
    return (number < 0)
#Examples
print(es_negativo_conciso(300))
print(es_negativo_conciso(-300))<jupyter_output>False
True<jupyter_text>11.Las variables booleanas `ketchup`, `mostaza` y `cebolla` representan si un cliente quiere un ingrediente en particular en su hot dog. Queremos implementar varias funciones booleanas que correspondan a ciertas preguntas de si o no acerca del pedido del criente.Por ejemplo:<jupyter_code>def sin_cebolla(ketchup, mostaza, cebolla):
    """
    Devuelve True si el cliente no quiere cebolla, y False de lo contrario.
    """
    return not cebolla
sin_cebolla(True, False, True), sin_cebolla(False, True, False)<jupyter_output><empty_output><jupyter_text>Para las siguientes funciones escriba el código para que la función haga lo que se dice en su documentación.**Asegúrate de probar tus funciones**<jupyter_code>def todos_los_ingredientes(ketchup, mostaza, cebolla):
    """
    Devuelve True si el cliente quiere todos los ingredientes, y False de lo contrario
    """
    return ketchup and mostaza and cebolla
def sin_ingrediente(ketchup, mostaza, cebolla):
    """
    Devuelve True si el cliente no quiere ningún ingrediente, y False de lo contrario.
    """
    return not ketchup and not mostaza and not cebolla
print(sin_ingrediente(True, True, True))
print(sin_ingrediente(False, True, True))
print(sin_ingrediente(False, True, False))
print(sin_ingrediente(False, False, True))
print(sin_ingrediente(False, False, False))
def solo_un_aderezo(ketchup, mostaza, cebolla):
    """
    Devuelve True si el cliente quiere ketchup o mostaza, pero no ambos.
    """
    return not (ketchup and mostaza) and (ketchup or mostaza)
print(solo_un_aderezo(True, True, True))
print(solo_un_aderezo(False, True, True))
print(solo_un_aderezo(True, False, True))<jupyter_output>False
True
True<jupyter_text>12.Hemos visto que llamar la función `bool()` sobre un número entero devuelve `False` si el número es igual a 0 y `True` en otro caso. Qué pasa si llamamos `int()` sobre un booleano? Inténtalo en la siguiente celda.<jupyter_code>int(False)<jupyter_output><empty_output><jupyter_text>¿Puedes usar esto para escribir una función que devuelva `True` si el cliente quiere uno y sólo un ingrediente y `False` de lo contrario?**Asegúrate de probar tu función**<jupyter_code>def exactamente_un_ingrediente(ketchup, mostaza, cebolla):
    """
    Devuelve True si el ciente quiere exactamente un ingrediente, False de lo contrario.
    """
    return bool(ketchup + mostaza + cebolla == 1)
#verdaderos
print(exactamente_un_ingrediente(True, False,False))
print(exactamente_un_ingrediente(False, True,False))
print(exactamente_un_ingrediente(False, False,True))
#Falsos
print(exactamente_un_ingrediente(True, True,False))
print(exactamente_un_ingrediente(True, False,True))
print(exactamente_un_ingrediente(False, True,True))
print(exactamente_un_ingrediente(True, True,True))
print(exactamente_un_ingrediente(False, False,False))<jupyter_output>True
True
True
False
False
False
False
False<jupyter_text>13.Escriba el cuerpo de la siguiente función de acuerdo a su documentación.<jupyter_code>def segundo_elemento(L):
    """
    Devuelve el segundo elemento de la lista dada. Si la lista no tiene 
    segundo elemento, devuelve None.
    
    >>> segundo_elemento([10, 4, 9, 10])
    4
    >>> segundo_elemento([5])
    
    """
    return L[1] if len(L)>=2 else None
def elemento_n(L, n):
    return L[n-1] if len(L)>=n else None<jupyter_output><empty_output><jupyter_text>Prueba tu función:<jupyter_code>L1 = [10, 4, 9, 10]
L2 = [5]
print(segundo_elemento(L1))
print(segundo_elemento(L2))<jupyter_output>4
None<jupyter_text>14.Implemente el cuerpo de la siguiente función de acuerdo a su documentación **utilizando únicamente listas y sus métodos: NO SE ACEPTA EL USO DE CICLOS!**<jupyter_code>#whitout list comprehensions...but you need to have a 0 
def cuantos_negativos(list):
    """
    Devuelve la cantidad de números negativos en la lista dada.
    
    >>> cuantos_negativos([5, -1, -2, 0, 3])
    2
    """
    #Append a 0 to have an index of the first positive number, it doesnt matter if you have more than 1
    list.append(0)
    list.sort()
    return list.index(0)<jupyter_output><empty_output><jupyter_text>**Ayuda: `help(list.sort)`**Prueba tu función:<jupyter_code>cuantos_negativos([5, -1, -2, 0, 3])
cuantos_negativos([5, -1, -2, 3, 10, 12, 51, -15, -30])<jupyter_output><empty_output><jupyter_text>15.La siguiente función no funciona correctamente de acuerdo a lo descrito en su documentación. A esto en programación se le llama un bug. Al correr la función no se marca ningún error, pero la función no hace lo que debería hacer.Identifica el bug de la siguiente función y arréglalo:<jupyter_code>def es_chida(nums):
    """
    Devuelve True si la lista dada es chida. Una lista chida es aquella que 
    contiene al menos un número divisible por 7.
    
    >>> es_chida([1, 14, 3, 8])
    True
    """
    for num in nums:
        if num % 7 == 0 and num != 0:
            return True
    return False<jupyter_output><empty_output><jupyter_text>Muestra que tu función corregida funciona correctamente:<jupyter_code>#The function fails with [0] because 0 % 7 == 0, so I add a != 0 condition
es_chida([0,8])<jupyter_output><empty_output><jupyter_text>16.Algunos dicen que "los científicos de datos usan el 80% de su tiempo limpiando datos, y el 20% restante quejándose acerca de la limpieza de datos". Veamos si puedes escribir una función que nos ayude a limpiar datos correspondientes a códigos postales.Dado un string, la función debe devolver True si dicho string representa un código postal válido, de lo contrario devuelve False. Para nuestros propósitos, un código postal es válido si es un string que contiene exactamente **5 dígitos**.Ayuda: **help(str.isdigit)**<jupyter_code>def cp_valido(cp):
    """
    Devuelve True si el string dado es un código postal válido:
    string de 5 dígitos.
    
    >>> cp_valido('45017')
    True
    >>> cp_valido('450015')
    False
    >>> cp_valido('45a15')
    False
    """
    return (cp.isdigit() and len(cp) == 5)<jupyter_output><empty_output><jupyter_text>Prueba que tu función trabaje correctamente:<jupyter_code>cp = '451215'
cp_valido('45017') , cp_valido('450015') , cp_valido('45a15')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.0906795556196797, 'fraction_numerical': 0.02200259702784591, 'mean_word_length': 4.881629189647858, 'pattern_counts': {'":': 0, '<': 84, '<?xml version=': 0, '>': 117, 'https://': 2, 'lorem ipsum': 0, 'www.': 1, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '23', 'dir': 'jupyter-structured-clean-dedup', 'id': '294155', 'license': 'MIT', 'n_tokens_mistral': 5168, 'n_tokens_neox': 4937, 'n_words': 1677, 'path': 'Semana1/Tarea1-HernandezAlejandro.ipynb', 'repo_name': 'AlexNoelHdz/prope_programacion_2021', 'size': '13862'}