isaacm
/
MDCIPROPE2026
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

first commit

This commit is contained in:
Isaac Mejia 2026-06-12 22:56:56 -06:00
commit 20f1477b2b
20 changed files with 27149 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1038
ValoresExtremosFunciones/valores_extremos_imf.ipynb Normal file
View File

File diff suppressed because it is too large Load Diff

805
ejerciciosMDCI/.ipynb_checkpoints/ejerciciosPython_IMF-checkpoint.ipynb Normal file
View File

@ -0,0 +1,805 @@
{
"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
}

805
ejerciciosMDCI/ejerciciosPython_IMF.ipynb Normal file
View File

@ -0,0 +1,805 @@
{
"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
}

443
practica_sistemas_ecuaciones/sistemas_ecuaciones_lineales_imf.ipynb Normal file
View File

@ -0,0 +1,443 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "b680955d",
"metadata": {},
"source": [
"#### Alumno: Isaac Mejia Flores\n",
"#### Definicion de la logica para la correcta solucion y clasificacion de los sistemas de ecuaciones usando numpy y sympy "
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "49dc1fac",
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import sympy as sp\n",
"\n",
"\n",
"def solve_equations_sp(equations, variables):\n",
" try:\n",
" solutions = sp.solve(equations, variables, dict=True)\n",
"\n",
" if not solutions:\n",
" return \"El sistema no tiene solución\"\n",
"\n",
" sol = solutions[0]\n",
"\n",
" free_vars = []\n",
" dependent_vars = []\n",
"\n",
" for var in variables:\n",
" if var in sol:\n",
" expr = sol[var]\n",
"\n",
" # Detecta si la solución depende de otras variables\n",
" # para determinar variables libres\n",
" if any(sym in variables for sym in expr.free_symbols):\n",
" dependent_vars.append(f\"{var} = {expr}\")\n",
" else:\n",
" free_vars.append(str(var))\n",
"\n",
" # Si existen variables libres, entonces el sistema\n",
" # tiene infinitas soluciones\n",
" if free_vars:\n",
" deps = \", \".join(dependent_vars)\n",
"\n",
" if len(free_vars) == 1:\n",
" libres = free_vars[0]\n",
" else:\n",
" libres = \" y \".join(free_vars)\n",
"\n",
" return (\n",
" f\"Infinitas soluciones: \"\n",
" f\"{deps}, con {libres} libres\"\n",
" )\n",
"\n",
" return sol\n",
"\n",
" except Exception as e:\n",
" return f\"Error: {e}\"\n",
"\n",
"\n",
"def solve_equations_np(A, b):\n",
" try:\n",
" A = np.array(A, dtype=float)\n",
" b = np.array(b, dtype=float)\n",
"\n",
" # Teorema de Rouché-Frobenius:\n",
" #\n",
" # rank(A) = rank([A|b]) = n\n",
" # -> solución única\n",
" #\n",
" # rank(A) = rank([A|b]) < n\n",
" # -> infinitas soluciones\n",
" #\n",
" # rank(A) < rank([A|b])\n",
" # -> sistema inconsistente\n",
"\n",
" rank_A = np.linalg.matrix_rank(A)\n",
" rank_aug = np.linalg.matrix_rank(np.c_[A, b])\n",
"\n",
" num_vars = A.shape[1]\n",
"\n",
" if rank_A < rank_aug:\n",
" return \"El sistema no tiene solución\"\n",
"\n",
" if rank_A < num_vars:\n",
" return \"Infinitas soluciones\"\n",
"\n",
" # Se utiliza lstsq en lugar de solve porque\n",
" # permite resolver sistemas rectangulares\n",
" # (m ecuaciones con n incógnitas),\n",
" # incluyendo sistemas sobredeterminados.\n",
" sol, _, _, _ = np.linalg.lstsq(\n",
" A,\n",
" b,\n",
" rcond=None\n",
" )\n",
"\n",
" return {\n",
" f'x{i+1}': round(float(s), 6)\n",
" for i, s in enumerate(sol)\n",
" }\n",
"\n",
" except Exception as e:\n",
" return f\"Error: {e}\"\n",
"\n",
"def classify_system(A, b):\n",
" rank_A = np.linalg.matrix_rank(A)\n",
" rank_aug = np.linalg.matrix_rank(np.c_[A, b])\n",
"\n",
" num_vars = A.shape[1]\n",
"\n",
" # Teorema de Rouché-Frobenius\n",
"\n",
" if rank_A < rank_aug:\n",
" return \"Sin solución\"\n",
"\n",
" if rank_A < num_vars:\n",
" return \"Infinitas soluciones\"\n",
"\n",
" return \"Solución única\"\n",
"\n",
"def print_system_info(A, system_type):\n",
" rows, cols = A.shape\n",
"\n",
" print(f\"Sistema {rows}x{cols}\")\n",
"\n",
" if system_type == \"Solución única\":\n",
" print(\"Solución única:\")\n",
"\n",
" elif system_type == \"Infinitas soluciones\":\n",
" print(\"Infinitas soluciones:\")\n",
"\n",
" else:\n",
" print(\"El sistema no tiene solución\")"
]
},
{
"cell_type": "markdown",
"id": "2c028080",
"metadata": {},
"source": [
"## Ejercicio 1 — Sistema cuadrado 2×2 (solución única)\n",
"Se tiene el siguiente sistema de 2 ecuaciones con 2 incógnitas ($x, y$):\n",
"\n",
"$$\n",
"\\begin{cases} \n",
"2x + 3y = 8 \\\\ \n",
"x - 4y = -5 \n",
"\\end{cases}\n",
"$$\n",
"\n",
"### Objetivo\n",
"Verificar que tanto **NumPy** como **SymPy** resuelven correctamente este caso base (sistema compatible determinado con solución única)."
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "f45cf88e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Sistema 2x2\n",
"Solución única:\n",
"Numpy: {'x1': 1.545455, 'x2': 1.636364}\n",
"Sympy: {x: 17/11, y: 18/11}\n"
]
}
],
"source": [
"x, y = sp.symbols('x y')\n",
"equations = (sp.Eq(2*x + 3*y, 8), sp.Eq(x - 4*y, -5))\n",
"\n",
"A = np.array([[2, 3], [1, -4]])\n",
"b = np.array([8, -5])\n",
"\n",
"solution_sp = solve_equations_sp(equations, (x, y))\n",
"solution_np = solve_equations_np(A, b)\n",
"\n",
"system_type = classify_system(A,b)\n",
"print_system_info(A, system_type)\n",
"print('Numpy:', solution_np)\n",
"print('Sympy:', solution_sp)\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "07e4c825",
"metadata": {},
"source": [
"## Ejercicio 2 — Sistema cuadrado 3×3\n",
"Sistema de 3 ecuaciones con 3 incógnitas (x, y, z):\n",
"\n",
"$$\n",
"\\begin{cases} \n",
"x + y + z = 6 \\\\ \n",
"2x - y + z = 3 \\\\\n",
"x + 2y - 3z = -4 \n",
"\\end{cases}\n",
"$$"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "7798069d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Solving equations using SymPy and numpy: \n",
"\n",
"Sistema 3x3\n",
"Solución única:\n",
"Numpy: {'x1': 1.0, 'x2': 2.0, 'x3': 3.0}\n",
"Sympy: {x: 1, y: 2, z: 3}\n"
]
}
],
"source": [
"print('Solving equations using SymPy and numpy: \\n')\n",
"x, y, z = sp.symbols('x y z')\n",
"\n",
"eq1 = sp.Eq(x + y + z, 6)\n",
"eq2 = sp.Eq(2*x - y + z, 3)\n",
"eq3 = sp.Eq(x + 2*y - 3*z, -4)\n",
"\n",
"equations = (eq1, eq2, eq3)\n",
"A = np.array([[1, 1, 1], [2, -1, 1], [1, 2, -3]])\n",
"b = np.array([6, 3, -4])\n",
"\n",
"solution_sp = solve_equations_sp(equations, (x, y, z))\n",
"solution_np = solve_equations_np(A, b)\n",
"\n",
"system_type = classify_system(A, b)\n",
"print_system_info(A, system_type)\n",
"print('Numpy:', solution_np)\n",
"print('Sympy:', solution_sp)\n"
]
},
{
"cell_type": "markdown",
"id": "6d01413a",
"metadata": {},
"source": [
"## Ejercicio 3 — Sistema 3×3\n",
"Sistema de 3 ecuaciones con 3 incógnitas donde las ecuaciones son linealmente dependientes:\n",
"$$\n",
"\\begin{cases} \n",
"x + y + z = 4 \\\\ \n",
"2x + 2y + 2z = 8 \\\\\n",
"3x + 3y + 3z = 12 \n",
"\\end{cases}\n",
"$$"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "09de85e4",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Solving equations using SymPy and numpy: \n",
"\n",
"Sistema 3x3\n",
"Infinitas soluciones:\n",
"Numpy: Infinitas soluciones\n",
"Sympy: Infinitas soluciones: x = -y - z + 4, con y y z libres\n"
]
}
],
"source": [
"print('Solving equations using SymPy and numpy: \\n')\n",
"x, y, z = sp.symbols('x y z')\n",
"\n",
"eq1 = sp.Eq(x + y + z, 4)\n",
"eq2 = sp.Eq(2*x + 2*y + 2*z, 8)\n",
"eq3 = sp.Eq(3*x + 3*y + 3*z, 12)\n",
"\n",
"equations = (eq1, eq2, eq3)\n",
"A = np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]])\n",
"b = np.array([4, 8, 12])\n",
"\n",
"solution_sp = solve_equations_sp(equations, (x, y, z))\n",
"solution_np = solve_equations_np(A, b)\n",
"\n",
"system_type = classify_system(A, b)\n",
"print_system_info(A, system_type)\n",
"print('Numpy:', solution_np)\n",
"print('Sympy:', solution_sp)\n"
]
},
{
"cell_type": "markdown",
"id": "c018e193",
"metadata": {},
"source": [
"## Ejercicio 4 — Sistema 2×2 sin solución (inconsistente)\n",
"Sistema de 2 ecuaciones con 2 incógnitas cuyas rectas son paralelas:\n",
"$$\n",
"\\begin{cases} \n",
"3x - 6y = 9 \\\\ \n",
"x - 2y = -1 \n",
"\\end{cases}\n",
"$$"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "9057d167",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Solving equations using SymPy and numpy: \n",
"\n",
"Sistema 2x2\n",
"El sistema no tiene solución\n",
"Numpy: El sistema no tiene solución\n",
"Sympy: El sistema no tiene solución\n"
]
}
],
"source": [
"print('Solving equations using SymPy and numpy: \\n')\n",
"x, y = sp.symbols('x y')\n",
"\n",
"eq1 = sp.Eq(3*x - 6*y, 9)\n",
"eq2 = sp.Eq(x - 2*y, -1)\n",
"\n",
"equations = (eq1, eq2)\n",
"A = np.array([[3, -6], [1, -2]])\n",
"b = np.array([9, -1])\n",
"\n",
"solution_sp = solve_equations_sp(equations, (x, y))\n",
"solution_np = solve_equations_np(A, b)\n",
"\n",
"system_type = classify_system(A, b)\n",
"print_system_info(A, system_type)\n",
"print('Numpy:', solution_np)\n",
"print('Sympy:', solution_sp)\n"
]
},
{
"cell_type": "markdown",
"id": "678e269f",
"metadata": {},
"source": [
"## Ejercicio 5 — Sistema rectangular 4×3 (M > N)\n",
"Sistema sobredeterminado: 4 ecuaciones con 3 incógnitas (x, y, z):\n",
"$$\n",
"\\begin{cases} \n",
"x + y + z = 6 \\\\ \n",
"2x - y = 1 \\\\\n",
"3y + 2z = 11 \\\\\n",
"x + y - 2z = 0\n",
"\\end{cases}\n",
"$$"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "dda9eae8",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Solving equations using SymPy and numpy: \n",
"\n",
"Sistema 4x3\n",
"Solución única:\n",
"Numpy: {'x1': 1.666667, 'x2': 2.333333, 'x3': 2.0}\n",
"Sympy: {x: 5/3, y: 7/3, z: 2}\n"
]
}
],
"source": [
"print('Solving equations using SymPy and numpy: \\n')\n",
"x, y, z = sp.symbols('x y z')\n",
"\n",
"eq1 = sp.Eq(x + y + z, 6)\n",
"eq2 = sp.Eq(2*x - y, 1)\n",
"eq3 = sp.Eq(3*y + 2*z, 11)\n",
"eq4 = sp.Eq(x + y - 2*z, 0)\n",
"\n",
"equations = (eq1, eq2, eq3, eq4)\n",
"A = np.array([[1, 1, 1], [2, -1, 0], [0, 3, 2], [1, 1, -2]])\n",
"b = np.array([6, 1, 11, 0])\n",
"\n",
"solution_sp = solve_equations_sp(equations, (x, y, z))\n",
"solution_np = solve_equations_np(A, b)\n",
"\n",
"system_type = classify_system(A, b)\n",
"print_system_info(A, system_type)\n",
"print('Numpy:', solution_np)\n",
"print('Sympy:', solution_sp)\n"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "propedeutico",
"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.10.20"
}
},
"nbformat": 4,
"nbformat_minor": 5
}

1
proyectoPrediccionDeRetornoDeClientes Submodule

@ -0,0 +1 @@
Subproject commit 83d9bbe2d92a2fd1cd42ee257796f7d5c79a3f81

10001
sesion2_3/DataSources/automobile_parts.csv Normal file
View File

File diff suppressed because it is too large Load Diff

10001
sesion2_3/DataSources/automobile_parts_updated.csv Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
sesion2_3/Graphs/dispersion.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 49 KiB

10
sesion2_3/conjuntos.py Normal file
View File

@ -0,0 +1,10 @@
conjunto1 = {1, 2, 3, 4, 5}
conjunto2 = {4, 5, 6}
print(conjunto1 & conjunto2) # Intersección: Devuelve un nuevo conjunto con los elementos que están presentes en ambos conjuntos.
print(conjunto1 | conjunto2) # Unión: Devuelve un nuevo conjunto con los elementos que están presentes en al menos uno de los conjuntos.
print(conjunto1 - conjunto2) # Diferencia: Devuelve un nuevo conjunto con los elementos que están presentes en el primer conjunto pero no en el segundo.
print(conjunto1 ^ conjunto2) # Diferencia simétrica: Devuelve un nuevo conjunto con los elementos que están presentes en uno de los conjuntos pero no en ambos.

48
sesion2_3/machine-learning-introduction.py Normal file
View File

@ -0,0 +1,48 @@
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier as KNN
from sklearn.metrics import accuracy_score
import pandas as pd
iris = load_iris()
#Esto es solo para visualizar de manera mas clara que datos tenemos en nuestro dataset, esto no se suele usar en ML
df = pd.DataFrame(data=iris.data, columns=iris.feature_names)
df["target"] = iris.target
print(df.head())
XirisData = iris.data
YTarget = iris.target
XTrain, XTest, YTrain, YTest = train_test_split(XirisData, YTarget, test_size=0.2, random_state=42)
model = KNN(n_neighbors=3)
model.fit(XTrain, YTrain)
predictions = model.predict(XTest)
print(f"Predictions: {predictions}")
accuracy = accuracy_score(YTest, predictions)
print(f"Accuracy: {accuracy * 100:.2f}%")
"""Ejemplo: [cm] -> R: "Setosa"
Largo del sepalo = 5.1
Ancho del sepalo = 3.5
Largo del petalo = 1.4
Ancho del petalo = 0.2
"""
newFlower = pd.Series({
"sepal length (cm)": 5.1,
"sepal width (cm)": 3.5,
"petal length (cm)": 1.4,
"petal width (cm)": 0.2
})
newFlowerArray = newFlower.values.reshape(1, -1)
predicitionNewFlower = model.predict(newFlowerArray)
specie = iris.target_names[predicitionNewFlower[0]]
print(f"Specie: {specie}")

102
sesion2_3/matplotlib_introduccion.py Normal file
View File

@ -0,0 +1,102 @@
import matplotlib.pyplot as plt
import numpy as np
#Grafico Curva Simple
plt.plot([1, 2, 3], [4, 5, 6])
plt.show()
x = [1, 2, 3]
y = [4, 5, 6]
#Grafico de barras simple
plt.bar(x, y, width=0.5, color='RED')
plt.show()
#Grafico de dispersión
x = np.array([5, 7, 8, 7, 2, 17, 2, 9, 4, 11, 12, 9, 6])
y = np.array([99, 86, 87, 88, 111, 86, 103, 87, 94, 78, 77, 85, 86])
plt.scatter(x, y)
plt.xticks(np.arange(2, 19, 1)) # Establecer los ticks del eje x utilizando np.arange para generar una secuencia de valores desde 2 hasta 19 con un paso de 0.5. Esto asegurará que los ticks del eje x estén espaciados uniformemente y cubran el rango de los datos en el gráfico de dispersión.
plt.yticks(np.arange(min(y), max(y), 10)) # Establecer los ticks del eje y utilizando np.arange para generar una secuencia de valores desde el mínimo hasta el máximo de y con un paso de 10. Esto asegurará que los ticks del eje y estén espaciados uniformemente y cubran el rango de los datos en el gráfico de dispersión.
plt.title("Dispersion")
plt.xlabel("X")
plt.ylabel("Y")
plt.savefig("Graphs/dispersion.png", dpi=300, bbox_inches='tight') # Guardar el gráfico actual como un archivo de imagen con el nombre "Graphs.png" y una resolución de 300 puntos por pulgada (dpi). El param bbox_inches='tight' se utiliza para ajustar automáticamente los bordes del gráfico para que se ajusten al contenido, evitando recortes innecesarios alrededor del gráfico.
plt.show()
"""Tambien se pueden poner otros valores en los ejes"""
fruits = ["Manzanas", "Mangos", "Fresas"]
sales = [10 ,15, 7]
plt.bar(fruits, sales)
plt.show()
"""Mas variacones de graficas"""
x = np.array([_ for _ in range(30)])
y = np.array([np.random.randint(1, 100) for _ in range(30)])
plt.plot(x, y)
plt.title("Prueba")
plt.xlabel("X: 0 a 100")
plt.ylabel("Y: 0 a 100")
plt.show()
"""Multiples graficas en una sola figura"""
x = np.linspace(-1, 1, 100) # Generar un array de 100 valores equidistantes entre 0 y 2 utilizando la función linspace de NumPy. Esto se utiliza para crear un conjunto de puntos en el eje x para graficar una función matemática.
f1 = np.copy(x) # Crear una copia del array x y asignarla a f1. Esto se hace para preservar los valores originales de x mientras se realizan operaciones matemáticas en f1 debido que si solo se hace f1 = x pertenece a la misma instancia de memoria por lo quue toda modificacion a f1 se vera reflejada a x sin copy.
f2 = np.copy(x)**2
f3 = np.copy(x)**3
plt.figure(figsize=(5, 3)) # Crear una nueva figura para graficar con un tamaño específico de 5 pulgadas de ancho y 3 pulgadas de alto utilizando la función figure de Matplotlib.
plt.subplot(131) # Crear un subplot en la figura actual que ocupará la primera posición en una cuadrícula de 1 fila y 3 columnas utilizando la función subplot de Matplotlib. Esto permite organizar múltiples gráficos en una sola figura.
plt.plot(x, f1)
plt.title("Funcion n1")
plt.xlabel("X")
plt.ylabel("f1")
plt.subplot(132)
plt.plot(x, f2)
plt.title("Funcion n2")
plt.xlabel("X")
plt.ylabel("f2")
plt.subplot(133)
plt.plot(x, f3)
plt.title("Funcion n3")
plt.xlabel("X")
plt.ylabel("f3")
plt.show()
"""Otra opcion de multi figs"""
fig, ax = plt.subplots(figsize=(5,3))
ax.plot(x, f1, label="lineal")
ax.plot(x, f2, label="cuadratica")
ax.plot(x, f3, label="cubica")
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_title("Prueba de plots")
ax.legend()
plt.show()
n_f = np.sin(np.linspace(0, 10, 100))
x = np.arange(len(n_f))
fig, ax = plt.subplots(figsize=(5,3))
ax.plot(x, n_f, color="purple", linewidth=1, linestyle='-')
plt.show()

58
sesion2_3/my_queue.py Normal file
View File

@ -0,0 +1,58 @@
"""Queue es una EDA que se basa en el principio FIFO (First In First Out), es decir,
el primer elemento en entrar es el primero en salir.
Es una estructura de datos lineal que permite almacenar y gestionar elementos de manera ordenada.
Las operaciones básicas de una cola incluyen:"""
class Queue:
def __init__(self): #Constructor de la clase Queue
self.lista = [] #Atributo de una clase en python, para que figure como un atributo de la clase se debe de usar self
def enqueue(self, item): # 11 <- 22 <- 33 <- 44 <- 55
self.lista.append(item)
def dequeue(self): # return el primer elemento de la lista y lo elimina de la lista
return self.lista.pop(0)
#Metodo de la clase de hoy
# def is_empty(self):
# respuesta_booleana = False
# if not self.lista: #Si la lista esta vacia, entonces la respuesta booleana es True
# respuesta_booleana = True
# return respuesta_booleana
def is_empty(self):
return len(self.lista) == 0
#Sintaxis que indica python como se va a imprimir un objeto de la clase Queue (Metodo magico) similar a un @Override
# def __str__(self):
# string_out = ""
# for e in self.lista:
# string_out += str(e) + " <- "
# return string_out
#Otra forma de escribir el metodo __str__ es la siguiente, es mas simple y mas eficiente, ya que no se necesita concatenar strings, sino que se puede convertir la lista a string directamente
def __str__(self):
return str(self.lista)
if __name__ == "__main__":
cola = Queue()
print(cola.is_empty())
cola.enqueue(11)
cola.enqueue(22)
cola.enqueue(33)
cola.enqueue(44)
cola.enqueue(55)
print(cola.is_empty())
cola.print()
while not cola.is_empty():
print(cola.dequeue())

163
sesion2_3/numpy_introduction.py Normal file
View File

@ -0,0 +1,163 @@
import numpy as np
"""Numpy Arrays"""
arr_1 = np.array([1, 2, 3, 4, 5]) # Create a numpy array from a list
arr_2 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) # Create a 2D numpy array
arr_1[2] = 99 # Modify an element in the array
print("arr_1:", arr_1) # Output: [ 1 2 99 4 5]
arr_2[1][2] = 111 # Modify an element in the 2D array
print("arr_2:", arr_2) # Output: [[ 1 2 3]
arr_2.shape = (1, 9) # Reshape the array to 1 row and 9 columns
#Modern version of shape is arr_2.reshape(1, 9)
arr_2 = arr_2.reshape(1, 9) #Reshape the array to 1 row and 9 columns
print("arr_2:", arr_2) # Output: [[ 1 2 3 4 5 6 7 8 9]]
"""Data types in numpy arrays: https://numpy.org/doc/stable/user/basics.types.html"""
# Create an array of type int8, this data type value range is from -128 to 127, if we try to create an array with values outside this range, it will wrap around and give us overflowed values
arr_int8 = np.array([_ for _ in range(11, 100, 11)], dtype='int8')
print("arr_int8 dataType:", arr_int8.dtype) # Output: int8
print("arr_int8:", arr_int8) # Output: [11 22 33 44 55 66 77 88 99]
"""Common Automatic Arrays"""
ceros_1 = np.zeros(3) # Create an array of zeros with 5 elements
print("ceros_1:", ceros_1)
ceros_2 = np.zeros((2, 2)) # Create a 2D array of zeros with 3 rows and 4 columns
print("ceros_2: \n", ceros_2)
unos_1 = np.ones(5) # Create an array of ones with 5 elements
print("unos_1: \n", unos_1)
unos_2 = np.ones((4, 5)) # Create a 2D array of ones with 2 rows and 3 columns
print("unos_2: \n", unos_2)
identidad = np.identity(4) # Create a 4x4 identity matrix
print("identidad: \n", identidad)
eye_matrix = np.eye(3,4) # Create a 5x5 identity matrix, diferences between identity and eye is that eye can create non square matrices, while identity only creates square matrices
print("eye_matrix: \n", eye_matrix, "\n")
"""----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------"""
a = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int32) # Create a 2D array of int32
print("a: \n", a)
ones_matrix = np.ones_like(a) # Create an array of ones with the same shape and data type as 'a' as a mask
print("ones_matrix: \n", ones_matrix)
steps_1 = np.arange(11, 100, 11) # Create an array of values from 0 to 10 with a step of 2
print("steps_1: \n", steps_1)
steps_2 = np.arange(11, 100, 11).reshape((3, 3)) # Create a 2D array of values from 0 to 10 with a step of 2, and reshape it to 3 rows and 3 columns
print("steps_2 dataType:", steps_2.dtype)
print("steps_2: \n", steps_2)
linealArray = np.linspace(0, 1, 10) # Create an array of 10 linearly spaced values between 0 and 1, an lineal array is an array that has values that are equally spaced between a start and end value, in this case we are creating an array of 10 values that are equally spaced between 0 and 1
print("linealArray dataType:", linealArray.dtype) # Output: float64, the default data type for linspace is float64, but we can specify a different data type if we want
print("linealArray: \n", linealArray)
randomArray = np.random.random(100) # Create an array of 100 random values between 0 and 1, the random function generates random values between 0 and 1
print("randomArray: \n", randomArray)
print("randomArray dataType:", randomArray.dtype, "\n")
"""Properties and Attributes of Numpy Arrays"""
arr_3 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.uint16)
print("Array Properties")
print("Dimensions:", arr_3.ndim)
print("Shape:", arr_3.shape)
print("Size:", arr_3.size)
print("Data Type:", arr_3.dtype, "\n")
"""Math Operations on Numpy Arrays"""
arr1 = np.array([10, 20, 30]) # Create an array of values from 1 to 30 with a step of 10
arr2 = np.array([1, 2, 3]) # Create an array of values from 1 to 3
print("arr1: \n", arr1)
print("arr2: \n", arr2)
print(f"Addition: {arr1} + {arr2} = {arr1 + arr2}")
print(f"Multiplication: {arr1} * {arr2} = {arr1 * arr2}")
print(f"Power: {arr1} ** {arr2} = {arr1 ** arr2}")
print(f"Sine: sin({arr1}) = {np.sin(np.radians(arr2))}")
arr3 = np.arange(1, 10).reshape((3, 3))
arr4 = np.arange(11, 100, 11).reshape((3, 3))
print("arr3: \n", arr3)
print("arr4: \n", arr4)
print(f"Addition: {arr3} + {arr4} = {arr3 + arr4}")
print(f"Multiplication: {arr3} * {arr4} = {arr3 * arr4}")
print(f"Power: {arr3} ** {arr4} = {arr3 ** arr4}")
print(f"Cosine: cos({arr3}) = {np.cos(np.radians(arr4))} \n") #trigonometrics functions are defined in radians (argument)
"""Indexing and Slicing Numpy Arrays"""
matrix = np.array([[10, 20, 30], [40, 50, 60], [70, 80, 90]])
print("matrix: \n", matrix)
print(f"Element (1,2) of matrix: {matrix[1, 2]} \n") # Access the element at row 1, column 2 (0-based indexing)
print(f"First row of matrix: {matrix[0, :]} \n") # Access the first row of the matrix
print(f"All rows of the matrix: \n {matrix[:, :]} \n") # Access all rows and columns of the matrix
print(f"Last column of the matrix: {matrix[:, 1]} \n") # Access the last column of the matrix
print(f"First 2 rows and columns: \n {matrix[:2, :2]} \n") # Access the first 2 rows and first 2 columns of the matrix
"""Reshaping numpy arrays"""
original = np.arange(12)
reestructurado = original.reshape((3, 4)) # Reshape the original array to 3 rows and 4 columns (make a matrix of 3 rows and 4 columns)
print("Original array: \n", original)
print("Reshaped array: \n", reestructurado)
print("transposed array: \n", reestructurado.T) # Transpose the reshaped array (swap rows and columns)
"""Stadistics and aggregation functions on numpy arrays (statistic topic)"""
data = np.array([[1, 2], [3, 4]])
print(f"Sum of all elements: {np.sum(data)}")
print(f"Mean of all elements: {np.mean(data)}")
print(f"Standard deviation of all elements: {np.std(data)}")
print(f"Variance of all elements: {np.var(data)}")
print(f"Sum of each column: {np.sum(data, axis=0)}") # Sum along columns, indicated by axis were 0 is the first axis (columns) and 1 is the second axis (rows) in a 2D array, so when we specify axis=0, we are telling numpy to sum along the columns, which means that it will sum all the elements in each column and return an array with the sums of each column, while if we specify axis=1, we are telling numpy to sum along the rows, which means that it will sum all the elements in each row and return an array with the sums of each row.
print(f"Sum of each row: {np.sum(data, axis=1)}") # Sum along rows
print(f"Maximum value: {np.max(data)}, minimum value: {np.min(data)} \n")
print(f"Sum of the first 2 rows and first column: {data[:2, 0].sum()}") # Sum of the first 2 rows and first column of the data array
"""Boolean masking with numpy arrays"""
numbers = np.array([1, 15, 8, 20, 3 ,12])
print(f"Original array: \n {numbers}")
greater_than_10 = numbers[numbers > 10] # Create a boolean mask for elements greater than 10
print(f"Boolean mask for elements greater than 10: \n {greater_than_10} \n")
"""More function of numpy arrays"""
numbers.sort() # Sort the array in-place
print("Order of the elements in the array: ", numbers)
a = np.array([11, 22, 33, 44])
b = np.array([55, 66, 77, 88])
print(f"Concatenation of a and b: {np.concatenate((a, b))}") # Concatenate two arrays, tuples are required as argument
a1 = np.array([[1, 1], [2, 2]])
a2 = np.array([[3, 4], [5, 6]])
print(f"Stacking a1 and a2 vertically: \n {np.vstack((a1, a2))}") # Stack arrays vertically (row-wise), tuples are required as argument
print(f"Stacking a1 and a2 horizontally: \n {np.hstack((a1, a2))}") # Stack arrays horizontally (column-wise), tuples are required as
a = np.array([11, 11, 22, 33, 44, 11, 55, 33, 44, 11, 99])
print(f"Unique elements in a: {np.unique(a)}") # Find unique elements in the array

31
sesion2_3/pandas_introduction.py Normal file
View File

@ -0,0 +1,31 @@
import pandas as pd # pyright: ignore[reportMissingModuleSource]
import numpy as np
ages = pd.Series([25, 30, 35, 40], name="Ages") # Create a pandas Series from a list
print("ages: \n", ages)
names = pd.Series(["Alice", "Bob", "Charlie", "David"], name="Names") # Create a pandas Series from a list of strings
print("names: \n", names)
"""DataFrame Creation"""
table = pd.concat([names, ages], axis=1) # Concatenate the two Series along the columns to create a DataFrame, axis-1 is for columns
print("table: \n", table)
data = {
"Motor": ["AC_Standard", "Servo", "Stepper", "DC_Brushless"],
"Voltage": [220, 24, 12, 5],
"Current": [5.5, 2.1, 1.8, 0.8],
"Efficiency": [True, True, False, True]
}
df = pd.DataFrame(data) # Create a DataFrame from a dictionary, where keys are column names and values are lists of column data
print("DataFrame: \n", df)
"""Create a DataFrame from a CSV file"""
df = pd.read_csv("DataSources/automobile_parts.csv") # Read a CSV file and create a DataFrame from it, this source can be a SQL data, excel file, json, etc.
print("DataFrame from CSV: \n", df)

96
sesion2_3/pandas_introduction_2.py Normal file
View File

@ -0,0 +1,96 @@
import pandas as pd # pyright: ignore[reportMissingModuleSource]
import numpy as np
"""Crear un DataFrame desde un archivo CSV"""
df = pd.read_csv("DataSources/automobile_parts.csv") # Leer un archivo CSV y crear un DataFrame a partir de él, esta fuente puede ser datos SQL, archivo Excel, JSON, etc.
#------------------------------------------------inspeccionar el dataframe-------------------------------------
print("inspeccionar dataframe: \n", df.head(2), end="\n\n") # Mostrar las primeras filas del DataFrame para inspeccionar su contenido, se puede usar un valor int como argumento para especificar el número de filas a mostrar, por defecto es 5.
print(df.tail(3), end="\n\n") # Mostrar las últimas filas del DataFrame, se puede usar un valor int como argumento para especificar el número de filas a mostrar, por defecto es 5.
print(df.info(), end="\n\n") # Mostrar un resumen conciso del DataFrame, incluyendo el número de entradas no nulas, tipos de datos de cada columna y uso de memoria.
print(df.describe(), end="\n\n") # Generar estadísticas descriptivas del DataFrame, incluyendo conteo, media, desviación estándar, mínimo y máximo para cada columna numérica.
description = df.describe()
"""Indexación y segmentación (Seleccion y filtrado)"""
keys = df.keys()
print("claves: \n", keys, end="\n\n") # Mostrar los nombres de las columnas del DataFrame.
print(df.columns, end="\n\n") # Mostrar los nombres de las columnas del DataFrame, similar a keys().
print(list(df.columns), end="\n\n") # Convertir los nombres de las columnas a una lista y mostrarla.
# for i, j in zip(df.columns, list(df.columns)):
# print(i, "-", j, end=", ") # Iterar a través de los nombres de las columnas usando zip para mostrar cada nombre de columna dos veces. El método zip se usa para combinar dos o más iterables (como listas, tuplas, etc.) en un solo iterable de tuplas. En este caso, combina los nombres de las columnas de df.columns y la lista de nombres de columnas de list(df.columns) para mostrar cada nombre de columna dos veces.
print("\n")
print(df['TYPE'], end="\n\n") # Mostrar los valores de la columna 'TYPE' en el DataFrame. Esto devolverá una Serie que contiene los valores de esa columna específica.
print (df['TYPE'][4], end="\n\n") # Mostrar el valor de la columna 'TYPE' en el índice 4. Esto devolverá el valor específico ubicado en ese índice en la columna 'TYPE'.
#método loc
print(df.loc[4, 'TYPE'], end="\n\n") # Mostrar el valor de la columna 'TYPE' en el índice 4 usando el método loc. Esto devolverá el valor específico ubicado en ese índice en la columna 'TYPE'. El método loc se usa para indexación basada en etiquetas, donde se especifican las etiquetas de fila y columna para acceder a datos específicos en el DataFrame.
print(df.loc[4], end="\n\n") # Mostrar la fila completa en el índice 4 usando el método loc. Esto devolverá una Serie que contiene todos los valores para esa fila específica. El método loc se usa para indexación basada en etiquetas, donde se especifica la etiqueta de fila para acceder a toda la fila de datos en el DataFrame.
print(df.iloc[0:2, 0:3], end="\n\n") #Muestra un rango de filas y columnas, en este caso, mostrará las primeras dos filas (índice 0 y 1) y las primeras tres columnas (índice 0, 1 y 2) del DataFrame. El método iloc se usa para indexación basada en enteros, donde se especifican los índices de fila y columna para acceder a datos específicos en el DataFrame.
expensive_articles = df[df['PRICE'] > 400] # Filtrar el DataFrame para incluir solo filas donde la columna 'PRICE' tenga valores mayores que 1000. Esto devolverá un nuevo DataFrame que contiene solo los artículos caros.
print("Mostrar artículos caros", expensive_articles, end="\n\n")
audi_only = df[(df['MANUFACTURER'] == 'Audi') & (df['PRICE'] > 450)] # Filtrar el DataFrame para incluir solo filas donde la columna 'MANUFACTURER' tenga el valor 'Audi' y la columna 'PRICE' tenga valores mayores que 400. Esto devolverá un nuevo DataFrame que contiene solo los artículos fabricados por Audi y con precio superior a 400.
print("Mostrar solo audi y precio mayor que 400USD: \n", audi_only, end="\n\n")
"""MANUPULACION Y LIMPIEZA"""
df["QUANTITY"] = np.random.randint(1, 10, size=len(df)) # Crear una nueva columna 'QUANTITY' en el DataFrame y asignar un valor aleatorio entre 1 y 10 a cada fila utilizando la función randint de NumPy. El argumento size=len(df) asegura que se genere un número aleatorio para cada fila del DataFrame.
print(df.head(), end="\n\n")
# for i in range(len(df)):
# df.loc[i, "QUANTITY"] = np.random.randint(1, 10) # Asignar un valor aleatorio entre 1 y 10 a la columna 'QUANTITY' para cada fila del DataFrame. Esto se hace utilizando un bucle for para iterar a través de cada índice del DataFrame y el método loc para asignar el valor aleatorio a la columna 'QUANTITY' en esa fila específica.
print(df.head(), end="\n\n")
# df['Qty_2'] = [np.random.randint(1, 10) for _ in range(len(df))] # Crear una nueva columna 'Qty_2' en el DataFrame y asignar un valor aleatorio entre 1 y 10 a cada fila utilizando una comprensión de lista. La comprensión de lista itera a través de un rango que coincide con la longitud del DataFrame (len(df)) y genera un número aleatorio para cada fila.
# print(df.head(3), end="\n\n")
# import random
# df["MODEL"] = "A"
# df_tempo = df[df["MANUFACTURER"] == 'BMW']
# for i in range(len(df_tempo)):
# df_tempo.loc[i, "MODEL"] = random.choice(["A", "B", "C"]) # Asignar un valor aleatorio de la lista ["A", "B", "C"] a la columna 'MODEL' para cada fila del DataFrame temporal df_tempo, que contiene solo las filas donde el fabricante es 'BMW'. Esto se hace utilizando un bucle for para iterar a través de cada índice del DataFrame temporal y el método loc para asignar el valor aleatorio a la columna 'MODEL' en esa fila específica.
# print(df_tempo.head(3), end="\n\n")
# df = df[["PART ID", "TYPE", "MANUFACTURER", "YEAR", "QUANTITY", "PRICE"]] # Reorganizar las columnas del DataFrame para que aparezcan en el orden especificado.
# print(df.head(3), end="\n\n")
df.insert(4, "QUANTITY", df.pop("QUANTITY")) # Mover la columna 'QUANTITY' a la posición 4 en el DataFrame. El método pop se usa para eliminar la columna 'QUANTITY' del DataFrame y devolverla, y luego el método insert se usa para insertar esa columna en la posición especificada (índice 4) con el mismo nombre 'QUANTITY'.
print(df.head(), end="\n\n")
df["SUBTOTAL_INVENTORY"] = df["QUANTITY"] * df["PRICE"] # Crear una nueva columna 'SUBTOTAL_INVENTORY' que contiene el resultado de multiplicar la columna 'QUANTITY' por la columna 'PRICE' para cada fila del DataFrame. Esto calculará el subtotal del inventario para cada artículo basado en su cantidad y precio.
print(df.head(), end="\n\n")
df = df.rename(columns={"SUBTOTAL_INVENTORY": "SUBTOTAL"}) # Renombrar la columna 'SUBTOTAL_INVENTORY' a 'SUBTOTAL' en el DataFrame. El método rename se usa para cambiar el nombre de las columnas, donde se proporciona un diccionario que mapea los nombres antiguos a los nuevos.
print(df.head(), end="\n\n")
#NaN representan datos faltantes en el dataSet, este ejemplo se esta agregando para poder demostrar la limpieza del dataSet, para esto hay que ensuciarlo con estos datos
df["ACTIVE"] = [np.random.choice([True, False, np.nan]) for _ in range(len(df))] # Crear una nueva columna 'ACTIVE' y asignar un valor aleatorio de True, False o NaN a cada fila utilizando una comprensión de lista. La función np.random.choice se usa para seleccionar aleatoriamente un valor de la lista [True, False, np.nan] para cada fila del DataFrame, y la comprensión de lista itera a través de un rango que coincide con la longitud del DataFrame (len(df)).
print(df.head(), end="\n\n")
df.loc[len(df)] = ['PARTXXXX', 'Amortiguador', 'Nissan', 2026, np.nan, 100.11, np.nan, True] # Agregar una nueva fila al final del DataFrame con los valores especificados para cada columna. El método loc se usa para acceder a la posición del índice que es igual a la longitud actual del DataFrame (len(df)), lo que permite agregar una nueva fila al final. Los valores proporcionados corresponden a cada columna en el orden del DataFrame.
print(df.iloc[[-1]])
df = df.iloc[:-1] # Eliminar la última fila del DataFrame utilizando iloc para seleccionar todas las filas excepto la última. Esto se hace para limpiar el DataFrame después de agregar una fila con datos faltantes (NaN) para demostración.
print(df.tail(), end="\n\n")
"""Exportacion de resultados"""
df.to_csv("DataSources/automobile_parts_updated.csv", index=False) # Exportar el DataFrame a un archivo CSV llamado "automobile_parts_updated.csv" en la carpeta "DataSources". El argumento index=False se usa para evitar que se exporte el índice del DataFrame al archivo CSV, lo que significa que solo se exportarán las columnas de datos sin incluir el índice.

12
sesion2_3/use_queues.py Normal file
View File

@ -0,0 +1,12 @@
import my_queue
newQueue = my_queue.Queue()
newQueue.enqueue(99)
newQueue.enqueue(55)
newQueue.enqueue(77)
my_queue.Queue.enqueue(newQueue, 88) #Tambien se puede llamar al metodo de esta manera, pero no es lo mas comun, se hace asi para mostrar que el metodo enqueue es un metodo de la clase Queue
# Directo desde el modulo seria Queue.enqueue(self, item)
print(newQueue)

552
sesion4_algebra/algebra.ipynb Normal file
View File

@ -0,0 +1,552 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": 5,
"id": "11c1dcf1",
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import sympy as sp\n"
]
},
{
"cell_type": "markdown",
"id": "bd615dcf",
"metadata": {},
"source": [
">**Caracteristicas basicas de matrices**"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "74203b23",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Orden Matriz A: (2, 3)\n",
"Orden Matriz B: (2, 3)\n",
"A[0, 1]: 4\n",
"B[1, 2]: 1.0\n",
"[[ True True True]\n",
" [ True True True]]\n"
]
}
],
"source": [
"A = np.array([[2, 4, 6], [8, 0 ,1]])\n",
"\n",
"B = np.array([[ -(-2), 16/4, 6],\n",
" [8, 0, -3/-3]])\n",
"\n",
"print(\"Orden Matriz A:\", np.shape(A))\n",
"print(\"Orden Matriz B:\", np.shape(B))\n",
"print(\"A[0, 1]:\", A[0, 1]) # Acceder al elemento en la fila 0, columna 1 de la matriz A\n",
"print(\"B[1, 2]:\", B[1, 2]) # Acceder al elemento en la fila 1, columna 2 de la matriz B\n",
"\n",
"print(np.equal(A, B)) # Verificar si las matrices A y B son iguales"
]
},
{
"cell_type": "markdown",
"id": "f6a8b6ca",
"metadata": {},
"source": [
">**Operaciones Aritmeticas**"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "0c031ae7",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Suma de A y B:\n",
" [[ 7 1]\n",
" [14 19]\n",
" [ 2 14]]\n"
]
}
],
"source": [
"A = np.array([[1, 8], [11, 4], [0, 9]])\n",
"B = np.array([[6, -7], [3, 15], [2, 5]])\n",
"\n",
"escalar = 3\n",
"\n",
"print(\"Suma de A y B:\\n\", A + B) # Sumar las matrices A y B\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "74bbf1c6",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Resta de A y B:\n",
" [[ -5 15]\n",
" [ 8 -11]\n",
" [ -2 4]]\n"
]
}
],
"source": [
"print(\"Resta de A y B:\\n\", A - B) # Restar la matriz B de la matriz A"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "2a68f095",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Multiplicación de A por el escalar:\n",
" [[ 3 24]\n",
" [33 12]\n",
" [ 0 27]]\n"
]
}
],
"source": [
"print(\"Multiplicación de A por el escalar:\\n\", escalar * A) # Multiplicar la matriz A por un escalar"
]
},
{
"cell_type": "markdown",
"id": "01252534",
"metadata": {},
"source": [
">**Transpuesta de una matriz**"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "06ae2d08",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Matriz A:\n",
" [[ 2 0 -1]\n",
" [ 4 6 8]]\n",
"Matriz A transpuesta:\n",
" [[ 2 4]\n",
" [ 0 6]\n",
" [-1 8]]\n"
]
}
],
"source": [
"A = np.array([[2, 0, -1], [4, 6, 8]])\n",
"\n",
"At = np.transpose(A) # Transponer la matriz A\n",
"At = A.T # Otra forma de transponer la matriz A\n",
"\n",
"print (\"Matriz A:\\n\", A) # Imprimir la matriz A\n",
"print(\"Matriz A transpuesta:\\n\", At) # Imprimir la matriz transpuesta de A"
]
},
{
"cell_type": "markdown",
"id": "b0dc6d9a",
"metadata": {},
"source": [
">**Teoremas de la transpuesta**"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "8f63b2fa",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Suma de A y B transpuesta:\n",
" [[ 8 14]\n",
" [10 16]\n",
" [12 18]]\n"
]
}
],
"source": [
"A = np.array([[1, 2, 3], [4, 5, 6]])\n",
"B = np.array([[7, 8, 9], [10, 11, 12]])\n",
"\n",
"print(\"Suma de A y B transpuesta:\\n\", (A+B).T)"
]
},
{
"cell_type": "markdown",
"id": "eaee444d",
"metadata": {},
"source": [
">**Multiplicacion de matrices**"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "6973999a",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Producto de A y B:\n",
" [[ 4 40 42]\n",
" [ 3 27 32]\n",
" [ 8 86 83]]\n",
"Producto de A y B usando @:\n",
" [[ 4 40 42]\n",
" [ 3 27 32]\n",
" [ 8 86 83]]\n"
]
}
],
"source": [
"A = np.array([[2, 4], [1, 3], [5, 8]])\n",
"B = np.array([[0, 6, -1], [1, 7, 11]])\n",
"\n",
"print(\"Producto de A y B:\\n\", np.dot(A, B)) # Multiplicar las matrices A y B, El operador convencional de * no sirve para multiplicar matrices en pyrhon\n",
"\n",
"print(\"Producto de A y B usando @:\\n\", A @ B) # Otra forma de multiplicar las matrices A y B usando el operador @\\"
]
},
{
"cell_type": "markdown",
"id": "d537a13b",
"metadata": {},
"source": [
">**Matriz identidad**"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "787653da",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1. 0. 0.]\n",
" [0. 1. 0.]\n",
" [0. 0. 1.]]\n"
]
}
],
"source": [
"print(np.identity(3)) # Imprimir la matriz identidad de orden 3"
]
},
{
"cell_type": "markdown",
"id": "1c283762",
"metadata": {},
"source": [
"> **Ejercicios de teoremas**"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "2895e041",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"I_2 @ A:\n",
" [[ 2. -5. -9.]\n",
" [ 4. 8. 6.]]\n",
"A @ I_3:\n",
" [[ 2. -5. -9.]\n",
" [ 4. 8. 6.]]\n",
"(3*A)@B:\n",
" [[ -57 -219]\n",
" [ 12 174]]\n",
"3*(A@B):\n",
" [[ -57 -219]\n",
" [ 12 174]]\n"
]
}
],
"source": [
"A = np.array([[2, -5, -9], [4, 8, 6]])\n",
"B = np.array([[1, 0], [-3, 2], [4, 7]])\n",
"C = np.array([[0, 1], [-1, 0], [2, 3]])\n",
"\n",
"I_2 = np.identity(2) \n",
"I_3 = np.identity(3)\n",
"print(\"I_2 @ A:\\n\", I_2 @ A)\n",
"print(\"A @ I_3:\\n\", A @ I_3)\n",
"print(\"(3*A)@B:\\n\", (3 * A) @ B)\n",
"print(\"3*(A@B):\\n\", 3 * (A @ B))"
]
},
{
"cell_type": "markdown",
"id": "036a835e",
"metadata": {},
"source": [
"> **Sistemas de ecuaciones lineales**"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "bdd162f1",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Solución del sistema de ecuaciones lineales Ax = b:\n",
" [-12. -18. -5.]\n"
]
}
],
"source": [
"A = np.array([[2, 10, -40], [-4, -7, 41], [1, 3, -12]])\n",
"b = np.array([-4, -31, -6])\n",
"\n",
"x = np.linalg.solve(A, b) # Resolver el sistema de ecuaciones lineales Ax = b\n",
"\n",
"print(\"Solución del sistema de ecuaciones lineales Ax = b:\\n\", x)"
]
},
{
"cell_type": "markdown",
"id": "a3083315",
"metadata": {},
"source": [
"Teorema (El conjunto generado es un subespacio vectorial): sea v1, v2 ... vk, k son vectores d eun espacio vectorial V entonces gen{ v1, v2, ..., vk} es un subespacio de V "
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "e0ab887e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Solución del sistema de ecuaciones simbólicas:\n",
" {a: b + 2*c, x: b + c, y: c}\n",
"Solución del sistema de ecuaciones simbólicas:\n",
" {x: -a/9 - b/18 + 5*z/6, y: -a/9 + 5*b/72 + 35*z/24}\n",
"Solución del sistema de ecuaciones simbólicas:\n",
" {b: c/3 + d/3, x: -a/40 + 7*c/120 - d/60, y: -a/170 - c/170 + 3*d/85, z: -31*a/680 - 263*c/2040 - 61*d/1020}\n",
"Solución del sistema de ecuaciones simbólicas:\n",
" {a: c/3 + d/3, b: -2*c/3 + 7*d/3, x: -c/41 + d/41 - 32*z/41, y: 7*c/492 + 17*d/246 - 31*z/82}\n"
]
}
],
"source": [
"x, y, z, a, b, c, d = sp.symbols('x y z a b c d') # Definir las variables simbólicas x, y, z, a, b, c\n",
"eq1 = sp.Eq(x + y, a)\n",
"eq2 = sp.Eq(x - y, b)\n",
"eq3 = sp.Eq(y, c)\n",
"\n",
"solution = sp.solve((eq1, eq2, eq3), (x, y, a, b, c)) # Resolver el sistema de ecuaciones simbólicas\n",
"\n",
"print(\"Solución del sistema de ecuaciones simbólicas:\\n\", solution)\n",
"\n",
"eq1 = sp.Eq(-5*x - 4*y + 10*z, a)\n",
"eq2 = sp.Eq(-8*x + 8*y - 5*z, b)\n",
"\n",
"print(\"Solución del sistema de ecuaciones simbólicas:\\n\", sp.solve((eq1, eq2), (x, y, z, a, b))) # Resolver el sistema de ecuaciones simbólicas\n",
"\n",
"eq1 = sp.Eq(-20*x - 23*y - 8*z, a)\n",
"eq2 = sp.Eq(2*x + 7*y - 2*z, b)\n",
"eq3 = sp.Eq(8*x - 3*y - 4*z, c)\n",
"eq4 = sp.Eq(-2*x + 24*y - 2*z, d)\n",
"\n",
"print(\"Solución del sistema de ecuaciones simbólicas:\\n\", sp.solve((eq1, eq2, eq3, eq4), (x, y, z, a, b, c, d))) # Resolver el sistema de ecuaciones simbólicas\n",
"\n",
"eq1 = sp.Eq(-9*x + 8*y - 4*z, a)\n",
"eq2 = sp.Eq(39*x + 20*y + 38*z, b)\n",
"eq3 = sp.Eq(-34*x + 12*y - 22*z, c)\n",
"eq4 = sp.Eq(7*x + 12*y + 10*z, d)\n",
"\n",
"print(\"Solución del sistema de ecuaciones simbólicas:\\n\", sp.solve((eq1, eq2, eq3, eq4), (x, y, z, a, b, c, d))) # Resolver el sistema de ecuaciones simbólicas"
]
},
{
"cell_type": "markdown",
"id": "3e0809fc",
"metadata": {},
"source": [
">**Determinantes**"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cc825dac",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Solucion con numpy\n",
"1.0\n",
"-2.0\n",
"Solucion con sympy\n",
"1\n",
"-2\n"
]
}
],
"source": [
"A = np.array([[1, -2], [-3, 7]])\n",
"B = np.array([[2, 0], [1, -1]])\n",
"\n",
"print(\"Solucion con numpy\")\n",
"print(np.round(np.linalg.det(A), 2)) # Calcular el determinante de la matriz A\n",
"print(np.round(np.linalg.det(B), 2)) # Calcular el determinante de la matriz B\n",
"\n",
"print(\"Solucion con sympy\")\n",
"A_sym = sp.Matrix([[1, -2], [-3, 7]])\n",
"B_sym = sp.Matrix([[2, 0], [1, -1]])\n",
"print(A_sym.det()) # Calcular el determinante de la matriz A usando sympy\n",
"print(B_sym.det()) # Calcular el determinante de la matriz B usando sympy"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "f78d7a6a",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Solución de A\n",
"-8\n",
"Solución de B\n",
"-104\n"
]
}
],
"source": [
"A = sp.Matrix([[1, 5, 2], [2, 0, 1], [1, -1, 1]])\n",
"B = sp.Matrix([[5, -2, 4], [0, 1, 5], [1, 2, -8]])\n",
"\n",
"\n",
"print(\"Solución de A\")\n",
"print(A.det()) # Calcular el determinante de la matriz A usando sympy\n",
"\n",
"\n",
"print(\"Solución de B\")\n",
"print(B.det()) # Calcular el determinante de la matriz B usando sympy"
]
},
{
"cell_type": "markdown",
"id": "120d42b4",
"metadata": {},
"source": [
">**Eigenvalores**"
]
},
{
"cell_type": "code",
"execution_count": 27,
"id": "e067f384",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"PurePoly(λ**2 - 5*λ - 2, λ, domain='ZZ')\n"
]
}
],
"source": [
"A = sp.Matrix([[1, 2], [3, 4]])\n",
"\n",
"print(A.charpoly('λ')) # Calcular el polinomio característico de la matriz A usando sympy"
]
},
{
"cell_type": "code",
"execution_count": 31,
"id": "ae9b370e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"valores propios: {4: 1, -1: 1}\n",
"vectores propios: [(-1, 1, [Matrix([\n",
"[-1/2],\n",
"[ 1]])]), (4, 1, [Matrix([\n",
"[2],\n",
"[1]])])]\n"
]
}
],
"source": [
"A = sp.Matrix([[3, 2], [2, 0]])\n",
"\n",
"print(\"valores propios:\",A.eigenvals(), end=\"\\n\") # Calcular los valores propios de la matriz A usando sympy\n",
"print(\"vectores propios:\",A.eigenvects(), end=\"\\n\") # Calcular los vectores propios de la matriz A usando sympy"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "propedeutico",
"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.10.20"
}
},
"nbformat": 4,
"nbformat_minor": 5
}

0
sesion4_algebra/algebra.py Normal file
View File

2906
sesion5_calculo/calculo.ipynb Normal file
View File

File diff suppressed because one or more lines are too long

77
sesion5_calculo/calculo.py Normal file
View File

@ -0,0 +1,77 @@
import sympy as sp
from IPython.display import display, Markdown, Latex, JSON, IFrame, YouTubeVideo
import pandas as pd
from sympy.abc import y, z
""" Operaciones con valor infinito """
i = float('inf')
print(i + 5) #Representacion nativa de python
print(sp.oo) #Representacion de sympy del infinito
print(sp.oo + sp.oo)
print(sp.oo * 2)
print(sp.oo * -1)
print(5/sp.oo)
print(sp.oo - sp.oo)
"""Operaciones y representacion de los numeros racionales"""
rat = sp.Rational(1,3) #Declaracion de un numero racional
print(sp.pi) #Cada que insertemos nuestras ecuaciones se va a respetar el caracter
print(sp.pi.evalf()) #Cambiamos a la representacion numerica de nuestro racional
print(sp.exp(1), sp.exp(3), sp.exp(1).evalf()) #Numero de euler (e)
numerator = sp.S(-5) + sp.Rational(1, 3) - sp.Rational(9, 7)
display(numerator)
denominator = sp.Rational(16, 3) * (sp.Rational(3, 14) / sp.Rational(2, 7))
display(denominator)
display(numerator/denominator)
result = sp.S(1) + (sp.S(1)/(sp.Rational(7, 3) + sp.Rational(sp.S(1), (sp.S(9) + sp.Rational(1, 2)))))
display("Result: ",result)
expr = sp.S("(-5 + (1/3) - (9/7)) / ((16/3) * (3/14) / (2/7)) ") #Expresion via singelton + un string con la expresion a realizar
print(expr)
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
print(df1)
"""Variables simbolicas"""
x = sp.Symbol('x')
expr = x**2 + 2*x + 1
print(expr)
expr = x**2 + 3*y - 7*x**5
print(expr)
x, y, z = sp.symbols('x y z')
X = sp.symbols('x0:5') #Da una lista de simbolicos de x0 a x4
print(X)
variables = sp.symbols('x_1:4 y_1:4')
print(variables)