806 lines
23 KiB
Plaintext
806 lines
23 KiB
Plaintext
{
|
||
"cells": [
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "16ae3669",
|
||
"metadata": {},
|
||
"source": [
|
||
"1. Hacer un programa en Python que resuelva la siguiente expresión aritmética\n",
|
||
"del área de un Triángulo, donde el usuario ingresa la base y la altura."
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 3,
|
||
"id": "094fdbdc",
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"El área del triángulo es: 1.5\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"def getTriangleArea(base, height):\n",
|
||
" area = (base * height) / 2\n",
|
||
" return area\n",
|
||
"\n",
|
||
"base = float(input(\"Ingrese la base del triángulo: \"))\n",
|
||
"height = float(input(\"Ingrese la altura del triángulo: \"))\n",
|
||
"\n",
|
||
"area = getTriangleArea(base, height)\n",
|
||
"\n",
|
||
"print(\"El área del triángulo es:\", area)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "d84a2e61",
|
||
"metadata": {},
|
||
"source": [
|
||
"2. Hacer un programa en Python que resuelva la siguiente ecuación de 2o grado.\n",
|
||
"El usuario ingresa los valores de a, b y c"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 4,
|
||
"id": "7aca06e3",
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Hay dos soluciones reales: -1.4379807976820196 y -9.56201920231798\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"def getSecondGradeEcuationSolver(a, b, c):\n",
|
||
" discriminant = b**2 - 4*a*c\n",
|
||
" \n",
|
||
" if discriminant < 0:\n",
|
||
" return \"No hay soluciones reales\"\n",
|
||
" elif discriminant == 0:\n",
|
||
" solution = -b / (2*a)\n",
|
||
" return f\"Hay una solución real: {solution}\"\n",
|
||
" else:\n",
|
||
" solution1 = (-b + discriminant**0.5) / (2*a)\n",
|
||
" solution2 = (-b - discriminant**0.5) / (2*a)\n",
|
||
" return f\"Hay dos soluciones reales: {solution1} y {solution2}\"\n",
|
||
"\n",
|
||
"a = float(input(\"Ingrese el coeficiente a: \"))\n",
|
||
"b = float(input(\"Ingrese el coeficiente b: \"))\n",
|
||
"c = float(input(\"Ingrese el coeficiente c: \"))\n",
|
||
"\n",
|
||
"\n",
|
||
"result = getSecondGradeEcuationSolver(a, b, c)\n",
|
||
"\n",
|
||
"print(result)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "227a94c7",
|
||
"metadata": {},
|
||
"source": [
|
||
"3. Hacer un programa en Python que calcule el salario semanal de un obrero,\n",
|
||
"según los siguientes criterios:\n",
|
||
"○ Si trabajó 40 horas o menos, sele paga $16 por hora.\n",
|
||
"○ Si trabajó más de 40 horas, se le paga $16 por las primeras 40 horas, y $20\n",
|
||
"por cada hora extra."
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 5,
|
||
"id": "5cb648c9",
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"El salario semanal es: 660.0\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"def getWeeklySalary(hoursWorked):\n",
|
||
" baseRate = 16\n",
|
||
" overtimeRate = 20\n",
|
||
"\n",
|
||
" if hoursWorked < 0:\n",
|
||
" return \"El número de horas trabajadas no puede ser negativo.\"\n",
|
||
"\n",
|
||
" if hoursWorked <= 40:\n",
|
||
" salary = hoursWorked * baseRate\n",
|
||
" else:\n",
|
||
" overtimeHours = hoursWorked - 40\n",
|
||
" salary = (40 * baseRate) + (overtimeHours * overtimeRate)\n",
|
||
"\n",
|
||
" return salary\n",
|
||
"\n",
|
||
"\n",
|
||
"hoursWorked = float(input(\"Ingrese el número de horas trabajadas: \"))\n",
|
||
"\n",
|
||
"weeklySalary = getWeeklySalary(hoursWorked)\n",
|
||
"\n",
|
||
"print(\"El salario semanal es:\", weeklySalary)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "a680fec4",
|
||
"metadata": {},
|
||
"source": [
|
||
"4. Hacer un programa en Python que clasifique el tipo de triángulo a partir de sus\n",
|
||
"lados ingresados:\n",
|
||
"Triángulo Medidas de los lados\n",
|
||
"Equilátero Los 3 son iguales\n",
|
||
"Isósceles Tiene 2 lagos iguales y un lado distinto\n",
|
||
"Escaleno Los 3 lados son distintos"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 6,
|
||
"id": "45fd184f",
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"El triángulo es: Escaleno\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"def getTriangleClassification(side1, side2, side3):\n",
|
||
" if side1 == side2 == side3:\n",
|
||
" return \"Equilátero\"\n",
|
||
" elif side1 == side2 or side1 == side3 or side2 == side3:\n",
|
||
" return \"Isósceles\"\n",
|
||
" else:\n",
|
||
" return \"Escaleno\"\n",
|
||
"\n",
|
||
"side1 = float(input(\"Ingrese el primer lado del triángulo: \"))\n",
|
||
"side2 = float(input(\"Ingrese el segundo lado del triángulo: \"))\n",
|
||
"side3 = float(input(\"Ingrese el tercer lado del triángulo: \"))\n",
|
||
"\n",
|
||
"classification = getTriangleClassification(side1, side2, side3)\n",
|
||
"\n",
|
||
"print(\"El triángulo es:\", classification)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "bc8905b0",
|
||
"metadata": {},
|
||
"source": [
|
||
"5. Hacer un programa en Python que calcule el Índice de Masa Corporal de una\n",
|
||
"persona (IMC = peso[kg] / altura\n",
|
||
"2\n",
|
||
"[m]) e indique el estado en el que se encuentra\n",
|
||
"esa persona en función del valor de IMC.\n",
|
||
"Valor de IMC Diagnóstico\n",
|
||
"< 16 Criterio de ingreso en hospital\n",
|
||
"de 16 a 17 Infrapeso\n",
|
||
"de 17 a 18 Bajo peso\n",
|
||
"de 18 a 25 peso normal (saludable)\n",
|
||
"de 25 a 30 Sobrepeso (obesidad de grado I)\n",
|
||
"de 30 a 35 Sobrepeso crónico (obesidad de grado II)\n",
|
||
"de 35 a 40 Obesidad premórbida (obesidad de grado III)\n",
|
||
"\\> 40 Obesidad mórbida (obesidad de grado IV)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 7,
|
||
"id": "6af05555",
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Su IMC es: 30.86\n",
|
||
"Su clasificación de IMC es: Sobrepeso crónico (obesidad de grado II)\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"def getIMC(weight, height): \n",
|
||
" imc = weight / (height ** 2)\n",
|
||
" return imc\n",
|
||
"\n",
|
||
"def getIMCClassification(imc):\n",
|
||
" if imc < 16:\n",
|
||
" return \"Criterio de ingreso en hospital\"\n",
|
||
" elif imc < 17:\n",
|
||
" return \"Infrapeso\"\n",
|
||
" elif imc < 18:\n",
|
||
" return \"Bajo peso\"\n",
|
||
" elif imc < 25:\n",
|
||
" return \"Peso normal (saludable)\"\n",
|
||
" elif imc < 30:\n",
|
||
" return \"Sobrepeso (obesidad de grado I)\"\n",
|
||
" elif imc < 35:\n",
|
||
" return \"Sobrepeso crónico (obesidad de grado II)\"\n",
|
||
" elif imc < 40:\n",
|
||
" return \"Obesidad premórbida (obesidad de grado III)\"\n",
|
||
" else:\n",
|
||
" return \"Obesidad mórbida (obesidad de grado IV)\"\n",
|
||
"\n",
|
||
"weight = float(input(\"Ingrese su peso en kg: \"))\n",
|
||
"height = float(input(\"Ingrese su altura en metros: \"))\n",
|
||
"\n",
|
||
"if weight <= 0 or height <= 0:\n",
|
||
" print(\"Peso y altura deben ser mayores a 0\")\n",
|
||
"else:\n",
|
||
" imc = getIMC(weight, height)\n",
|
||
" classification = getIMCClassification(imc)\n",
|
||
"\n",
|
||
" print(f\"Su IMC es: {imc:.2f}\")\n",
|
||
" print(f\"Su clasificación de IMC es: {classification}\")"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "a30840b9",
|
||
"metadata": {},
|
||
"source": [
|
||
"6. Hacer un programa en Python que, por un número entero dado por el usuario,\n",
|
||
"muestre la lista de números pares inferiores a él."
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 8,
|
||
"id": "c906f952",
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Los números pares menores que 6 son: [2, 4]\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"def getEvenNumbersBelow(n):\n",
|
||
" return [i for i in range(2, n, 2)]\n",
|
||
"\n",
|
||
"\n",
|
||
"number = int(input(\"Ingrese un número entero: \"))\n",
|
||
"\n",
|
||
"if number < 2:\n",
|
||
" print(\"No hay números pares menores que\", number)\n",
|
||
"else:\n",
|
||
" evenNumbers = getEvenNumbersBelow(number)\n",
|
||
" print(\"Los números pares menores que\", number, \"son:\", evenNumbers)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "be62a60c",
|
||
"metadata": {},
|
||
"source": [
|
||
"7. Hacer un programa en Python que muestre los productos del 1 al 10 de la tabla\n",
|
||
"de multiplicar del número 5"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 9,
|
||
"id": "3fe1fa53",
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"5 x 1 = 5\n",
|
||
"5 x 2 = 10\n",
|
||
"5 x 3 = 15\n",
|
||
"5 x 4 = 20\n",
|
||
"5 x 5 = 25\n",
|
||
"5 x 6 = 30\n",
|
||
"5 x 7 = 35\n",
|
||
"5 x 8 = 40\n",
|
||
"5 x 9 = 45\n",
|
||
"5 x 10 = 50\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"number = 5\n",
|
||
"\n",
|
||
"multiplicationTable = [number * i for i in range(1, 11)]\n",
|
||
"\n",
|
||
"for i in range(1, 11):\n",
|
||
" print(f\"{number} x {i} = {multiplicationTable[i-1]}\")"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "587f271a",
|
||
"metadata": {},
|
||
"source": [
|
||
"8. Hacer un programa en Python que imprima la serie de la sumatoria Σ , donde 1\n",
|
||
"𝑛\n",
|
||
"n es ingresado por el usuario.\n",
|
||
"a. Ejemplo de salida: 1/1, 1/2, 1/3, … , 1/n"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 10,
|
||
"id": "ed389ad6",
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"La serie de la sumatoria es: 1/1, 1/2, 1/3, 1/4, 1/5, 1/6\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"def printSummationSeries(n):\n",
|
||
" if n < 1:\n",
|
||
" print(\"El número debe ser mayor o igual a 1.\")\n",
|
||
" return\n",
|
||
"\n",
|
||
" series = [f\"1/{i}\" for i in range(1, n + 1)]\n",
|
||
" print(\"La serie de la sumatoria es:\", \", \".join(series))\n",
|
||
"\n",
|
||
"number = int(input(\"Ingrese un número entero: \"))\n",
|
||
"printSummationSeries(number)\n"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "ecb9882c",
|
||
"metadata": {},
|
||
"source": [
|
||
"9. Hacer un programa en Python que imprima el valor obtenido de la sumatoria\n",
|
||
"Σ , donde n es ingresado por el usuario."
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 11,
|
||
"id": "4aac6ba6",
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"El valor de la sumatoria es: 2.283333333333333\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"def getSummatorySerieValue(n):\n",
|
||
" summatory = 0\n",
|
||
" for i in range(1, n + 1):\n",
|
||
" summatory += 1 / i\n",
|
||
" return summatory\n",
|
||
"\n",
|
||
"\n",
|
||
"inputNumber = input(\"Ingrese un número entero: \")\n",
|
||
"\n",
|
||
"try:\n",
|
||
" numberFloat = float(inputNumber)\n",
|
||
"\n",
|
||
" if not numberFloat.is_integer():\n",
|
||
" print(\"Advertencia: Se ingresó un decimal, se redondeará.\")\n",
|
||
"\n",
|
||
" number = round(numberFloat)\n",
|
||
"\n",
|
||
" if number < 1:\n",
|
||
" print(\"El número debe ser mayor o igual a 1.\")\n",
|
||
" else:\n",
|
||
" summatoryValue = getSummatorySerieValue(number)\n",
|
||
" print(\"El valor de la sumatoria es:\", summatoryValue)\n",
|
||
"\n",
|
||
"except ValueError:\n",
|
||
" print(\"Entrada inválida. Debe ingresar un número.\")"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "939c6d0b",
|
||
"metadata": {},
|
||
"source": [
|
||
"10. Hacer un programa en Python que imprima la serie y además el valor obtenido\n",
|
||
"de la sumatoria n\n",
|
||
"2 Σ , donde n es ingresado por el usuario (n no debe ser mayor\n",
|
||
"de 5)."
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 12,
|
||
"id": "a420c070",
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"El valor de la sumatoria es: 55\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"def getSummarySerieValue(n):\n",
|
||
" summatory = 0\n",
|
||
" for i in range(1, n + 1):\n",
|
||
" summatory += i**2\n",
|
||
" return summatory\n",
|
||
"\n",
|
||
"inputNumber = input(\"Ingrese un número entero: \")\n",
|
||
"\n",
|
||
"if inputNumber.isdigit() and int(inputNumber) <= 5:\n",
|
||
" number = int(inputNumber)\n",
|
||
" summaryValue = getSummarySerieValue(number)\n",
|
||
" print(\"El valor de la sumatoria es:\", summaryValue)\n",
|
||
"else:\n",
|
||
" print(\" El número debe ser un numero entero menor o igual a 5.\")"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "0ef74faf",
|
||
"metadata": {},
|
||
"source": [
|
||
"11. Hacer un programa en Python que permita registrar las calificaciones de varios\n",
|
||
"estudiantes. Cada estudiante tiene un nombre y una lista de calificaciones,\n",
|
||
"implementa funciones para:\n",
|
||
"a. Agregar un estudiante\n",
|
||
"b. Agregar una calificación\n",
|
||
"c. Calcular el promedio de cada estudiante"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 7,
|
||
"id": "fc02f0a6",
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Estructura de datos: {'Pedro': [8.5, 6.5], 'Maria': [10.0, 6.5, 8.5]}\n",
|
||
"El promedio de notas para Pedro es: 7.5\n",
|
||
"El promedio de notas para Maria es: 8.333333333333334\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"students = {}\n",
|
||
"\n",
|
||
"def addStudent(name):\n",
|
||
" if name not in students:\n",
|
||
" students[name] = []\n",
|
||
"\n",
|
||
"def addGrade(studentName, grade):\n",
|
||
" if studentName in students:\n",
|
||
" students[studentName].append(grade)\n",
|
||
" else:\n",
|
||
" print(\"Student not found.\")\n",
|
||
"\n",
|
||
"def getAverageGradeByStudent(studentName):\n",
|
||
" if studentName in students:\n",
|
||
" grades = students[studentName]\n",
|
||
" if len(grades) == 0:\n",
|
||
" return None\n",
|
||
" return sum(grades) / len(grades)\n",
|
||
" else:\n",
|
||
" print(\"Student not found.\")\n",
|
||
" return None\n",
|
||
"\n",
|
||
"\n",
|
||
"addStudent(\"Pedro\")\n",
|
||
"addGrade(\"Pedro\", 8.5)\n",
|
||
"addGrade(\"Pedro\", 6.5)\n",
|
||
"\n",
|
||
"addStudent(\"Maria\")\n",
|
||
"addGrade(\"Maria\", 10.0)\n",
|
||
"addGrade(\"Maria\", 6.5)\n",
|
||
"addGrade(\"Maria\", 8.5)\n",
|
||
"\n",
|
||
"\n",
|
||
"print(\"Estructura de datos:\", students)\n",
|
||
"\n",
|
||
"averageGradePedro = getAverageGradeByStudent(\"Pedro\")\n",
|
||
"averageGradeMaria = getAverageGradeByStudent(\"Maria\") \n",
|
||
"\n",
|
||
"\n",
|
||
"if averageGradePedro is not None:\n",
|
||
" print(f\"El promedio de notas para Pedro es: {averageGradePedro}\")\n",
|
||
"\n",
|
||
"if averageGradeMaria is not None:\n",
|
||
" print(f\"El promedio de notas para Maria es: {averageGradeMaria}\")"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "289ac4e7",
|
||
"metadata": {},
|
||
"source": [
|
||
"12. Crea un programa en Python para gestionar un pequeño catálogo de\n",
|
||
"productos. Cada producto tendrá:\n",
|
||
"a. un código clave\n",
|
||
"b. una tupla con nombre, precio y cantidad disponible\n",
|
||
"Implementa funciones para:\n",
|
||
"a. Agregar productos,\n",
|
||
"b. Consultar un producto por código,\n",
|
||
"c. Calcular el valor total del inventario\n",
|
||
"\n",
|
||
"Ejemplo:\n",
|
||
"productos = {\n",
|
||
" \"A001\": (\"Camisa\", 250.0, 10),\n",
|
||
" \"B002\": (\"Pantalón\", 400.0, 5)\n",
|
||
"}\n"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 6,
|
||
"id": "7b68838b",
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Estructura de datos: {'A001': ('Laptop', 1500.0, 10), 'A002': ('Smartphone', 800.0, 20), 'A003': ('Headphones', 200.0, 50)}\n",
|
||
"Product A003: Headphones, Price: 200.0, Quantity: 50\n",
|
||
"Valor total del inventario: 41000.0\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"products = {}\n",
|
||
"\n",
|
||
"def addProduct(code, name, price, quantity):\n",
|
||
" if code not in products:\n",
|
||
" products[code] = (name, price, quantity)\n",
|
||
" else:\n",
|
||
" print(\"Product already exists.\")\n",
|
||
"\n",
|
||
"def getProductByCode(code):\n",
|
||
" if code in products:\n",
|
||
" return products[code]\n",
|
||
" else:\n",
|
||
" print(\"Product not found.\")\n",
|
||
" return None\n",
|
||
"\n",
|
||
"def getTotalInventoryValue():\n",
|
||
" return sum(price * quantity for name, price, quantity in products.values())\n",
|
||
"\n",
|
||
"\n",
|
||
"addProduct(\"A001\", \"Laptop\", 1500.00, 10)\n",
|
||
"addProduct(\"A002\", \"Smartphone\", 800.00, 20)\n",
|
||
"addProduct(\"A003\", \"Headphones\", 200.00, 50)\n",
|
||
"\n",
|
||
"print(\"Estructura de datos:\", products)\n",
|
||
"\n",
|
||
"product = getProductByCode(\"A003\")\n",
|
||
"if product is not None:\n",
|
||
" name, price, quantity = product\n",
|
||
" print(f\"Product A003: {name}, Price: {price}, Quantity: {quantity}\")\n",
|
||
"\n",
|
||
"totalInventoryValue = getTotalInventoryValue()\n",
|
||
"print(f\"Valor total del inventario: {totalInventoryValue}\")"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "eb2d5c8c",
|
||
"metadata": {},
|
||
"source": [
|
||
"13. Escribe una función en Python que reciba una frase y devuelva un diccionario\n",
|
||
"con la cantidad de veces que aparece cada palabra. Ignora mayúsculas y\n",
|
||
"signos de puntuación\n",
|
||
"Ejemplo:\n",
|
||
"Entrada: \"Hola mundo hola mundo hola\"\n",
|
||
"Salida: {'hola': 3, 'mundo': 2}"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 40,
|
||
"id": "7948a1b2",
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Tipo de dato: <class 'dict'>\n",
|
||
"El diccionario de palabras es: {'hola': 3, 'mundo': 2}\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"def getDictionaryWords(text):\n",
|
||
" lowerText = text.lower()\n",
|
||
" words = lowerText.split()\n",
|
||
" return { word: words.count(word) for word in set(words) }\n",
|
||
"\n",
|
||
"inputText = \"Hola mundo hola mundo hola\"\n",
|
||
"wordDictionary = getDictionaryWords(inputText)\n",
|
||
"\n",
|
||
"print(\"Tipo de dato:\", type(wordDictionary))\n",
|
||
"print(\"El diccionario de palabras es:\", wordDictionary)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "868def8b",
|
||
"metadata": {},
|
||
"source": [
|
||
"14. Crea un programa en Python para gestionar una agenda donde cada contacto\n",
|
||
"tiene:\n",
|
||
"a. un nombre (clave del diccionario)\n",
|
||
"b. una tupla con teléfono y correo\n",
|
||
"Implementa funciones para:\n",
|
||
"a. Agregar un contacto,\n",
|
||
"b. Buscar un contacto por nombre,\n",
|
||
"c. Actualizar datos de un contacto\n",
|
||
"Ejemplo:\n",
|
||
"agenda = {\n",
|
||
" \"María\": (\"555-1234\", \"maria@gmail.com\"),\n",
|
||
" \"Luis\": (\"555-5678\", \"luis@hotmail.com\")\n",
|
||
"}"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 33,
|
||
"id": "0f6d6166",
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Estructura de datos: {'Maria': ('555-1234', 'maria@gmail.com'), 'Luis': ('555-5678', 'luis@gmail.com')}\n",
|
||
"Contact Maria: Phone: 555-1234, Email: maria@gmail.com\n",
|
||
"Estructura de datos después de la actualización: {'Maria': ('555-1234', 'maria@gmail.com'), 'Luis': ('555-8765', 'updated@hotmail.com')}\n",
|
||
"Updated Contact Luis: Phone: 555-8765, Email: updated@hotmail.com\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"contacts = {}\n",
|
||
"def addContact(name, phone, email):\n",
|
||
" if name not in contacts:\n",
|
||
" contacts[name] = (phone, email)\n",
|
||
" else: \n",
|
||
" print(\"Contact already exists.\")\n",
|
||
"\n",
|
||
"def getContactByName(name):\n",
|
||
" if name in contacts:\n",
|
||
" return contacts[name]\n",
|
||
" else:\n",
|
||
" print(\"Contact not found.\")\n",
|
||
" return None\n",
|
||
" \n",
|
||
"def updateContact(name, phone=None, email=None):\n",
|
||
" if name in contacts:\n",
|
||
" currentPhone, currentEmail = contacts[name]\n",
|
||
" newPhone = phone if phone is not None else currentPhone\n",
|
||
" newEmail = email if email is not None else currentEmail\n",
|
||
" contacts[name] = (newPhone, newEmail)\n",
|
||
" else:\n",
|
||
" print(\"Contact not found.\")\n",
|
||
"\n",
|
||
"addContact(\"Maria\", \"555-1234\", \"maria@gmail.com\")\n",
|
||
"addContact(\"Luis\", \"555-5678\", \"luis@gmail.com\")\n",
|
||
"\n",
|
||
"print(\"Estructura de datos:\", contacts)\n",
|
||
"\n",
|
||
"contact = getContactByName(\"Maria\")\n",
|
||
"if contact is not None:\n",
|
||
" phone, email = contact\n",
|
||
" print(f\"Contact Maria: Phone: {phone}, Email: {email}\")\n",
|
||
"\n",
|
||
"updateContact(\"Luis\", phone=\"555-8765\", email=\"updated@hotmail.com\")\n",
|
||
"updatedContact = getContactByName(\"Luis\")\n",
|
||
"\n",
|
||
"print (\"Estructura de datos después de la actualización:\", contacts)\n",
|
||
"\n",
|
||
"if updatedContact is not None:\n",
|
||
" phone, email = updatedContact\n",
|
||
" print(f\"Updated Contact Luis: Phone: {phone}, Email: {email}\")"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "9dafc21b",
|
||
"metadata": {},
|
||
"source": [
|
||
"15. Crea una función en Python que reciba una lista de números y devuelva una\n",
|
||
"tupla con los siguientes datos:\n",
|
||
"a. número mayor,\n",
|
||
"b. número menor,\n",
|
||
"c. promedio,\n",
|
||
"d. cantidad de números pares,\n",
|
||
"e. cantidad de números impares\n",
|
||
"Ejemplo:\n",
|
||
"Entrada: [2, 5, 8, 3, 10]\n",
|
||
"Salida: (10, 2, 5.6, 3, 2)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 5,
|
||
"id": "cc93578e",
|
||
"metadata": {},
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Tipo de dato: <class 'tuple'>\n",
|
||
"Resultado: (10, 2, 5.6, 3, 2)\n"
|
||
]
|
||
}
|
||
],
|
||
"source": [
|
||
"def getNumberCommonDataTuple(listNumbers):\n",
|
||
" \n",
|
||
" minValue = min(listNumbers)\n",
|
||
" maxValue = max(listNumbers)\n",
|
||
" averageValue = sum(listNumbers) / len(listNumbers)\n",
|
||
" parNumbersCount = len([num for num in listNumbers if num % 2 == 0])\n",
|
||
" imparNumbersCount = len([num for num in listNumbers if num % 2 != 0])\n",
|
||
"\n",
|
||
" return (maxValue, minValue, averageValue, parNumbersCount, imparNumbersCount)\n",
|
||
"\n",
|
||
"inputNumbers = [2, 5, 8, 3, 10]\n",
|
||
"\n",
|
||
"result = getNumberCommonDataTuple(inputNumbers)\n",
|
||
"\n",
|
||
"print(\"Tipo de dato:\", type(result))\n",
|
||
"print(\"Resultado:\", result)"
|
||
]
|
||
}
|
||
],
|
||
"metadata": {
|
||
"kernelspec": {
|
||
"display_name": "Python 3",
|
||
"language": "python",
|
||
"name": "python3"
|
||
},
|
||
"language_info": {
|
||
"codemirror_mode": {
|
||
"name": "ipython",
|
||
"version": 3
|
||
},
|
||
"file_extension": ".py",
|
||
"mimetype": "text/x-python",
|
||
"name": "python",
|
||
"nbconvert_exporter": "python",
|
||
"pygments_lexer": "ipython3",
|
||
"version": "3.14.3"
|
||
}
|
||
},
|
||
"nbformat": 4,
|
||
"nbformat_minor": 5
|
||
}
|