{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 2. Control de Flujo\n",
"\n",
"Con el fin de escribir programas útiles, casi siempre necesitamos la capacidad de verificar las condiciones y cambiar el comportamiento del programa. Las declaraciones condicionales nos dan esta habilidad. Para ello usaremos las instrucciones de __control de flujo__.\n",
"\n",
"El control de flujo se refiere al orden en que se ejecutan las instrucciones que tenemos en el programa.\n",
"El orden puede ser ascendente, descendente o podemos ejecutar un conjunto de instrucciones alguna determinada cantidad de veces en donde se modifique algunos valores y hasta que el valor cumple alguna condición se dejen de ejecutar esas instrucciones.\n",
"Determinar el orden de las instrucciones depende primordialmente de el algoritmo que queremos desarrollar en el programa."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"![Alt text](../images/diagram.png \"Optional title\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"En un diagrama de flujo, generalmente hay más de una manera de ir desde el principio hasta el final. Lo mismo ocurre en las líneas de código de un programa de computadora. Los diagramas de flujo representan estos puntos de decision con diamantes, mientras que los otros pasos se representan con rectángulos. Los pasos inicial y final se representan con rectángulos redondeados. Pero antes de aprender sobre las declaraciones de control de flujo, primero debe aprender cómo representar esas opciones de sí y no, y necesita entender cómo escribir esos puntos de ramificación como código de Python."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Antes de empezar recordaremos los valores booleanos y los operadores de comparación"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"a = 2\n",
"b = 10\n",
"c = 6\n",
"d = 4 \n",
"e = 5\n",
"f = 6"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a >= b"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"c == f"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"e != a"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Algo mas hardcore"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"((a == b) and ((d < f) or (e >= c)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Estructuras de seleccion"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"### Sentencia `if`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"El tipo más común de instrucción de control de flujo es la sentencia `if`. Una cláusula `if` statement (es decir, el bloque que sigue a la sentencia `if`) se ejecutará si la condición de la sentencia es `True`. La cláusula se omite si la condición es `False`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Por ejemplo el programa:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Ingrese su nombre: \n",
"Samuel\n",
"Hola samuel\n"
]
}
],
"source": [
"print(\"Ingrese su nombre: \")\n",
"name = input()\n",
"if name == \"Samuel\":\n",
" print(\"Hola samuel\") "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"![Alt text](../images/flujo1.png \"El diagrama de flujo de una sentencia if\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Sentencia `else`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Una cláusula `if` puede ser seguida opcionalmente por una sentencia `else`. La cláusula `else` se ejecuta sólo cuando la condición de la instrucción `if` es `False`. Una instrucción else se podría leer como: \"Si esta condición es verdadera, ejecute este código. O bien, ejecutar ese código. \"Una instrucción else no tiene una condición, y en código, un ejemplo de ello sería:"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Desaprobaste :(\n"
]
}
],
"source": [
"estado = \"F\"\n",
"if estado == \"A\":\n",
" print(\"Aprobaste :D\")\n",
"else:\n",
" print(\"Desaprobaste :(\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"![Alt text](../images/flujo2.png \"El diagrama de flujo de una sentencia if y else\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ahora veamos si un numero es par o impar:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Ingrese un numero: 21\n",
"El numero es impar\n"
]
}
],
"source": [
"num = int(input(\"Ingrese un numero: \"))\n",
"\n",
"if num%2 == 0:\n",
" print(\"El numero es par\")\n",
"else:\n",
" print(\"El numero es impar\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Sentencia `elif`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Mientras que sólo una de las cláusulas `if` o `else` se ejecutará, es posible que tenga un caso en el que desee ejecutar una de las muchas cláusulas posibles. La instrucción `elif` es una instrucción \"`else if`\" que sigue siempre después de una `if` o otra sentencia `elif`. Proporciona otra condición que se comprueba sólo si alguna de las condiciones anteriores eran falsas. Un ejemplo:"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"El pez que compraste es caballa\n"
]
}
],
"source": [
"pez = 'caballa'\n",
"\n",
"if pez == 'atún':\n",
" print(\"El pez que compraste es atún\")\n",
"elif pez == 'caballa':\n",
" print(\"El pez que compraste es caballa\")\n",
"else :\n",
" print(\"¿Qué habrás comprado? D:\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"![Alt text](../images/flujo3.png \"El diagrama de flujo de una sentencia if ,elif,else\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ejemplos de if-elif-else"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Ingrese su promedio: 72\n",
"Grade C\n"
]
}
],
"source": [
"num = int(input(\"Ingrese su promedio: \"))\n",
"\n",
"if num >= 90:\n",
" print(\"Grade A\")\n",
"elif num >= 80:\n",
" print(\"Grade B\")\n",
"elif num >= 70:\n",
" print(\"Grade C\")\n",
"elif num >= 60:\n",
" print(\"Grade D\")\n",
"elif num >= 40:\n",
" print(\"Grade E\")\n",
"else:\n",
" print(\"Grade F\")\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ahora vamos a mostrar un programa que sirve para determinar si un año es bisiesto o no"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Ingrese un año: 1994\n",
"El año 1994 no es bisiesto\n"
]
}
],
"source": [
"anio=input(\"Ingrese un año: \")\n",
"year = int(anio)\n",
"#Un año es bisiesto si es divisible entre 4,\n",
"#excepto aquellos divisibles entre 100 pero no entre 400.\n",
"if year % 4 == 0:\n",
" if year %100 != 0:\n",
" print(\"El año\", year, \"es bisiesto\")\n",
" elif year %400 == 0:\n",
" print(\"El año\", year, \"es bisiesto\")\n",
" else:\n",
" print(\"El año\", year, \"no es bisiesto\") \n",
"else:\n",
" print (\"El año\", year, \"no es bisiesto\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Programa para calcular las raices de una ecuación cuadrática:"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Programa para calcular las raices de una ecuación de la forma ax^2 + bx + c\n",
"Ingrese los coeficientes: \n",
"Coeficiente a: 15\n",
"Coeficiente b: 8\n",
"Coeficiente c: 9\n",
"Las raices imaginarias son: \n",
"x1 = -0.2667+0.7272j\n",
"x1 = -0.2667-0.7272j\n"
]
}
],
"source": [
"print(\"Programa para calcular las raices de una ecuación de la forma ax^2 + bx + c\")\n",
"print(\"Ingrese los coeficientes: \")\n",
"a = int(input(\"Coeficiente a: \"))\n",
"b = int(input(\"Coeficiente b: \"))\n",
"c = int(input(\"Coeficiente c: \"))\n",
"\n",
"d = b**2 - 4*a*c # Discriminante\n",
"e = 2*a #Denominador\n",
"\n",
"if d == 0:\n",
" print(\"Las raices son iguales y x1 = x2 = {}\".format(-b/e))\n",
"else:\n",
" if d>0 :\n",
" print(\"Las raices reales son: \")\n",
" print(\"x1 = {0:.4f}\".format((-b + d**(0.5))/e))\n",
" print(\"x1 = {0:.4f}\".format((-b - d**(0.5))/e))\n",
" else:\n",
" print(\"Las raices imaginarias son: \")\n",
" print(\"x1 = {0:.4f}\".format((-b + d**(0.5))/e))\n",
" print(\"x1 = {0:.4f}\".format((-b - d**(0.5))/e))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Estructuras de control iterativas"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Bucle `while`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Puede hacer que un bloque de código se ejecute una y otra vez con una sentencia `while`. La cláusula de código en un tiempo se ejecutará siempre y cuando la condición de la sentencia `while` sea __`True`__. Un ejemplo:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"No debo escribir código sin documentar\n",
"No debo escribir código sin documentar\n",
"No debo escribir código sin documentar\n",
"No debo escribir código sin documentar\n",
"No debo escribir código sin documentar\n"
]
}
],
"source": [
"cont = 0\n",
"while cont < 5:\n",
" print('No debo escribir código sin documentar')\n",
" cont = cont + 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Puede ver que una sentencia `while` es similar a una sentencia `if`. La diferencia está en cómo se comportan. Al final de una cláusula `if`, la ejecución del programa continúa después de la instrucción `if`. Pero al final de la cláusula `while`, la ejecución del programa vuelve al principio de la sentencia `while`. La cláusula `while` a menudo se denomina __loop `while`__."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"![Alt text](../images/elseIfDiagram.png \"El diagrama de flujo de una sentencia if ,elif,else\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Un bucle infinito... D:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En este ejemplo pediremos al usuario que ingrese su contraseña si es correcta el bucle terminará de lo contrario el bucle continuara, este es un ejemplo de un bucle infinito controlado."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Por favor ingrese su contraseña: \n",
"123\n",
"Por favor ingrese su contraseña: \n",
"12345\n",
"Por fin...!\n"
]
}
],
"source": [
"password = ''\n",
"while password != '12345':\n",
" print('Por favor ingrese su contraseña: ')\n",
" password = input()\n",
"print('Por fin...!')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Sentencia `break`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Hay un atajo para que la ejecución del programa salga de la cláusula de un loop antes. Si en la ejecución del programa encuentra una instrucción `break`, sale inmediatamente de la cláusula `while` loop. En código, una instrucción `break` simplemente contiene la palabra clave `break`.\n",
"Un ejemplo:"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Por favor ingrese su nombre\n",
"Carla\n",
"Por favor ingrese su nombre\n",
"Rose\n",
"Bye! !\n"
]
}
],
"source": [
"while True:\n",
" print('Por favor ingrese su nombre')\n",
" name = input()\n",
" if name == 'Rose':\n",
" break\n",
"print('Bye! !')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Sentencia `continue`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Al igual que las sentencias `break`, las sentencias `continue` se usan dentro de bucles. Cuando la ejecución del programa llega a la instruccion `continue`, la ejecución del programa inmediatamente salta de nuevo al inicio del bucle y reevalúa la condición del bucle. (Esto es también lo que sucede cuando la ejecución llega al final del bucle.)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Ingrese su nombre: Mia\n",
"Ingrese su nombre: Milagros\n",
"Hola Milagros, por favor ingresa tu contraseña: \n",
"test\n",
"Ingrese su nombre: Milagros\n",
"Hola Milagros, por favor ingresa tu contraseña: \n",
"contraseña\n",
"Bienvenido a su cuenta bancaria\n"
]
}
],
"source": [
"while True:\n",
" name = input('Ingrese su nombre: ')\n",
" if name != 'Milagros':\n",
" continue\n",
" print('Hola Milagros, por favor ingresa tu contraseña: ')\n",
" password = input()\n",
" if password == 'contraseña':\n",
" break\n",
"print('Bienvenido a su cuenta bancaria')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Bucle `for`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"El bucle `while` sigue en bucle mientras que su condición sea `True` (que es la razón de su nombre), pero ¿y si quieres ejecutar un bloque de código sólo un cierto número de veces?. Esto se puede hacer haciendo uso del bucle `for`."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"No debo jugar dota (1)\n",
"No debo jugar dota (2)\n",
"No debo jugar dota (3)\n",
"No debo jugar dota (4)\n",
"No debo jugar dota (5)\n",
"No debo jugar dota (6)\n",
"No debo jugar dota (7)\n",
"No debo jugar dota (8)\n"
]
}
],
"source": [
"for i in range(8):\n",
" print('No debo jugar dota (' + str(i+1) + ')')"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"El código en la cláusula del bucle for se ejecuta 8 veces. La primera vez que se ejecuta, la variable i se pone a 0. La llamada print () en la cláusula imprimirá No debo jugar dota (0). Después de que Python termine una iteración a través de todo el código dentro de la cláusula de loop for, la ejecución vuelve a la parte superior del bucle y la instrucción for incrementa i por uno. Esta es la razón por la cual el rango (8) da lugar a 8 iteraciones a través de la cláusula, con i siendo puesto a 0, luego 1, luego 2, etc.... La variable i subirá, pero no incluirá, el entero pasado a range ()."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"![Alt text](../images/flujo5.png \"El diagrama de flujo de una sentencia if ,elif,else\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Función `range()`\n",
"\n",
"La funcion range nos permite crear una secuencia de numeros, tiene por argumentos 3 parametros ( inicio,fin, pasos)"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1 2 3 4 5 6 7 8 9 10 "
]
}
],
"source": [
"# Podemos usar un argumento\n",
"\n",
"for i in range(10):\n",
" print(i + 1, \"\", end=\"\")"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1 2 3 4 5 6 7 8 9 10 "
]
}
],
"source": [
"# Podemos usar 2 para definir el inicio\n",
"\n",
"for i in range(1, 11):\n",
" print(i, \"\", end=\"\")"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2 4 6 8 "
]
}
],
"source": [
"# Podemos usar 3 para definir una secuencia con una razon(en este caso 2)\n",
" \n",
"for i in range (2,10,2):\n",
" print(i, \"\", end=\"\")"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"20 18 16 14 12 10 8 6 4 2 "
]
}
],
"source": [
"for i in range (20,0,-2):\n",
" print(i, \"\", end=\"\")"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"40 35 30 25 20 15 10 5 0 "
]
}
],
"source": [
"for i in range(40, -5, -5):\n",
" print(i, \"\", end=\"\")"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"for i in range(5, -1, 1):\n",
" print(i)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"¿Qué paso? ... el inicio es en 5 y el fin -1 pero como los pasos son crecientes, jamás se cumplirá la condición es decir no se ejecutará el print"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ahora veamos algunos ejemplos"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Hallaremos la suma de valores en un intervalo"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Ingrese el valor inferior: 10\n",
"Ingrese el valor tope: 20\n",
"10\n",
"165\n"
]
}
],
"source": [
"lower_bound = int(input(\"Ingrese el valor inferior: \"))\n",
"upper_bound = int(input(\"Ingrese el valor tope: \"))\n",
"sum = 0\n",
"\n",
"print(lower_bound)\n",
"\n",
"for k in range(lower_bound,upper_bound + 1):\n",
" sum = sum + k\n",
" \n",
"print(sum)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Imprimir que numeros son pares e impares en un rango dado"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Escriba un número entero: 23\n",
"Escriba un número entero mayor o igual que 23: 32\n",
"El número 23 es impar\n",
"El número 24 es par\n",
"El número 25 es impar\n",
"El número 26 es par\n",
"El número 27 es impar\n",
"El número 28 es par\n",
"El número 29 es impar\n",
"El número 30 es par\n",
"El número 31 es impar\n",
"El número 32 es par\n"
]
}
],
"source": [
"numero1 = int(input(\"Escriba un número entero: \"))\n",
"numero2 = int(input(\"Escriba un número entero mayor o igual que \" + str(numero1) + \": \"))\n",
"\n",
"if numero2 < numero1:\n",
" print(\"¡Le he pedido un número entero mayor o igual que\", numero1, \"!\")\n",
"else:\n",
" for i in range(numero1, numero2 + 1):\n",
" if i % 2 == 0:\n",
" print(\"El número\", i, \"es par\")\n",
" else:\n",
" print(\"El número\", i, \"es impar\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Imprime el factorial de un numero"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Escriba un número entero mayor que cero: 10\n",
"El factorial de 10 es 3628800\n"
]
}
],
"source": [
"numero = int(input(\"Escriba un número entero mayor que cero: \"))\n",
"\n",
"if numero <= 0:\n",
" print(\"¡Le he pedido un número entero mayor que cero!\")\n",
"else:\n",
" factorial = 1\n",
" for i in range(1, numero + 1):\n",
" factorial = factorial * i\n",
" print(\"El factorial de\", numero, \"es\", factorial)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Hagamos un ejercicio algo matemático como hallar una serie:\n",
"\n",
"$$ S_{n} = \\sum_{i=1}^{n} \\frac{1}{k^2} $$"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1.6348839001848923\n"
]
}
],
"source": [
"sum = 0\n",
"\n",
"for x in range (1,100):\n",
" sum = sum + (1.0 / (x*x))\n",
"\n",
"print(sum)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Escriba un script que escriba aquellos números entre 1 y 100 que:\n",
"\n",
"- Sean pares\n",
"- No sean múltiplos de 4\n",
"- Tampoco sean múltiplos de 3.\n"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Antes de comenzar tenemos que nuestra condición a evaluar será: \n",
"\n",
"numero % 2 == 0 and numero % 3 != 0 and numero % 4 != 0\n",
"\n",
"# Aunque tambíen sería asi:\n",
"\n",
"numero % 2 == 0 and not (numero % 3 == 0 or numero % 4 ==0)"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2 10 14 22 26 34 38 46 50 58 62 70 74 82 86 94 98 "
]
}
],
"source": [
"#Resolviendo con while\n",
"\n",
"numero = 1\n",
"while numero < 100:\n",
" if numero % 2 == 0 and not (numero % 3 == 0 or numero % 4 == 0):\n",
" print(numero , \"\", end=\"\")\n",
" numero = numero + 1"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2 10 14 22 26 34 38 46 50 58 62 70 74 82 86 94 98 "
]
}
],
"source": [
"# Resolviendo con for\n",
"\n",
"del1al100 = range (1, 101)\n",
"for numero in del1al100:\n",
" if numero % 2 == 0 and not (numero % 3 == 0 or numero % 4 == 0):\n",
" print(numero , \"\", end=\"\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Ahora vamos a imprimir la tabla de multiplicar del 1 al 10"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Tabla de multiplicar del 1\n",
"1 * 1 = 1\n",
"2 * 1 = 2\n",
"3 * 1 = 3\n",
"4 * 1 = 4\n",
"5 * 1 = 5\n",
"6 * 1 = 6\n",
"7 * 1 = 7\n",
"8 * 1 = 8\n",
"9 * 1 = 9\n",
"10 * 1 = 10\n",
"==========================\n",
"\n",
"Tabla de multiplicar del 2\n",
"1 * 2 = 2\n",
"2 * 2 = 4\n",
"3 * 2 = 6\n",
"4 * 2 = 8\n",
"5 * 2 = 10\n",
"6 * 2 = 12\n",
"7 * 2 = 14\n",
"8 * 2 = 16\n",
"9 * 2 = 18\n",
"10 * 2 = 20\n",
"==========================\n",
"\n",
"Tabla de multiplicar del 3\n",
"1 * 3 = 3\n",
"2 * 3 = 6\n",
"3 * 3 = 9\n",
"4 * 3 = 12\n",
"5 * 3 = 15\n",
"6 * 3 = 18\n",
"7 * 3 = 21\n",
"8 * 3 = 24\n",
"9 * 3 = 27\n",
"10 * 3 = 30\n",
"==========================\n",
"\n",
"Tabla de multiplicar del 4\n",
"1 * 4 = 4\n",
"2 * 4 = 8\n",
"3 * 4 = 12\n",
"4 * 4 = 16\n",
"5 * 4 = 20\n",
"6 * 4 = 24\n",
"7 * 4 = 28\n",
"8 * 4 = 32\n",
"9 * 4 = 36\n",
"10 * 4 = 40\n",
"==========================\n",
"\n",
"Tabla de multiplicar del 5\n",
"1 * 5 = 5\n",
"2 * 5 = 10\n",
"3 * 5 = 15\n",
"4 * 5 = 20\n",
"5 * 5 = 25\n",
"6 * 5 = 30\n",
"7 * 5 = 35\n",
"8 * 5 = 40\n",
"9 * 5 = 45\n",
"10 * 5 = 50\n",
"==========================\n",
"\n",
"Tabla de multiplicar del 6\n",
"1 * 6 = 6\n",
"2 * 6 = 12\n",
"3 * 6 = 18\n",
"4 * 6 = 24\n",
"5 * 6 = 30\n",
"6 * 6 = 36\n",
"7 * 6 = 42\n",
"8 * 6 = 48\n",
"9 * 6 = 54\n",
"10 * 6 = 60\n",
"==========================\n",
"\n",
"Tabla de multiplicar del 7\n",
"1 * 7 = 7\n",
"2 * 7 = 14\n",
"3 * 7 = 21\n",
"4 * 7 = 28\n",
"5 * 7 = 35\n",
"6 * 7 = 42\n",
"7 * 7 = 49\n",
"8 * 7 = 56\n",
"9 * 7 = 63\n",
"10 * 7 = 70\n",
"==========================\n",
"\n",
"Tabla de multiplicar del 8\n",
"1 * 8 = 8\n",
"2 * 8 = 16\n",
"3 * 8 = 24\n",
"4 * 8 = 32\n",
"5 * 8 = 40\n",
"6 * 8 = 48\n",
"7 * 8 = 56\n",
"8 * 8 = 64\n",
"9 * 8 = 72\n",
"10 * 8 = 80\n",
"==========================\n",
"\n",
"Tabla de multiplicar del 9\n",
"1 * 9 = 9\n",
"2 * 9 = 18\n",
"3 * 9 = 27\n",
"4 * 9 = 36\n",
"5 * 9 = 45\n",
"6 * 9 = 54\n",
"7 * 9 = 63\n",
"8 * 9 = 72\n",
"9 * 9 = 81\n",
"10 * 9 = 90\n",
"==========================\n",
"\n",
"Tabla de multiplicar del 10\n",
"1 * 10 = 10\n",
"2 * 10 = 20\n",
"3 * 10 = 30\n",
"4 * 10 = 40\n",
"5 * 10 = 50\n",
"6 * 10 = 60\n",
"7 * 10 = 70\n",
"8 * 10 = 80\n",
"9 * 10 = 90\n",
"10 * 10 = 100\n",
"==========================\n",
"\n"
]
}
],
"source": [
"for multiplicador in range (1, 11):\n",
" print(\"Tabla de multiplicar del\", multiplicador)\n",
" for multiplicando in range (1, 11):\n",
" print(multiplicando, \"*\", multiplicador, \"=\", multiplicando*multiplicador)\n",
" print(\"==========================\")\n",
" print() # línea en blanco."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Script para imprimir los divisisores de un numero"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Escriba un número entero mayor que cero: 21\n",
"Los divisores de 21 son 1 3 7 21\n"
]
}
],
"source": [
"numero = int(input(\"Escriba un número entero mayor que cero: \"))\n",
"\n",
"if numero <= 0:\n",
" print(\"¡Le he pedido un número entero mayor que cero!\")\n",
"else:\n",
" print(\"Los divisores de\", numero, \"son \", end=\"\")\n",
" for i in range(1, round(numero/2)+1):\n",
" if numero % i == 0:\n",
" print(i, end=\" \")\n",
" print(numero)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Imprimir si un numero es primo o no"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Escriba un número entero mayor que 1: 10\n",
"10 no es primo\n"
]
}
],
"source": [
"numero = int(input(\"Escriba un número entero mayor que 1: \"))\n",
"\n",
"if numero <= 1:\n",
" print(\"¡Le he pedido un número entero mayor que 1!\")\n",
"else:\n",
" contador = 0\n",
" limite = round(numero ** 0.5)\n",
" for i in range(1, limite + 1):\n",
" if numero % i == 0:\n",
" contador = contador + 1\n",
" if contador == 1:\n",
" print(numero, \"es primo\")\n",
" else:\n",
" print(numero, \"no es primo\")"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Escriba un número entero: 5\n",
"Escriba un número entero mayor o igual que 5: 36\n",
"5\n",
"7\n",
"11\n",
"13\n",
"17\n",
"19\n",
"23\n",
"29\n",
"31\n"
]
}
],
"source": [
"numero1 = int(input(\"Escriba un número entero: \"))\n",
"numero2 = int(input(\"Escriba un número entero mayor o igual que \" + str(numero1) + \": \"))\n",
"\n",
"while numero1 < numero2:\n",
" flag = 0;\n",
" limite = round(numero1**0.5)\n",
" for i in range(2, limite + 1):\n",
" if numero1 % i == 0:\n",
" flag = 1\n",
" break\n",
" \n",
" if flag == 0:\n",
" print(numero1)\n",
" \n",
" numero1 = numero1 + 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Importando Módulos"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Todos los programas de Python pueden llamar a un conjunto básico de funciones llamadas funciones integradas o incorporadas, incluyendo las funciones `print()`, `input()` y `len()` que has visto antes. Python también viene con un conjunto de módulos llamados la biblioteca estándar. Cada módulo es un programa Python que contiene un grupo relacionado de funciones que se pueden usar en los programas. Por ejemplo, el módulo matemático tiene funciones relacionadas con las matemáticas, el módulo aleatorio tiene funciones relacionadas con números aleatorios, y así sucesivamente."
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3.0"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#la función sqrt nos da la raíz cuadrada\n",
"import math\n",
"\n",
"math.sqrt(9)"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"7\n",
"1\n",
"1\n",
"4\n",
"4\n"
]
}
],
"source": [
"# rand.int nos permite generar un numero aleatorio entre 1-10\n",
"import random\n",
"for i in range(5):\n",
" print(random.randint(1, 10))"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Ingrese el valor inferior: 10\n",
"Ingrese el valor tope: 20\n",
"Adivina el numero: 15\n",
"Muy Grande\n",
"Adivina el numero: 13\n",
"Muy pequeño \n",
"Adivina el numero: 14\n",
"Adivinaste! en el intento: 3\n"
]
}
],
"source": [
"# Un juego para adivinar el numero\n",
"import random\n",
"\n",
"lower_bound = int(input(\"Ingrese el valor inferior: \"))\n",
"upper_bound = int(input(\"Ingrese el valor tope: \"))\n",
"\n",
"mi_numero = random.randint(lower_bound,upper_bound)\n",
"count = 0 \n",
"\n",
"while True:\n",
" count +=1\n",
" numeroIngresado = int(input(\"Adivina el numero: \"))\n",
" if numeroIngresado < mi_numero:\n",
" print(\"Muy pequeño \")\n",
" elif numeroIngresado > mi_numero:\n",
" print(\"Muy Grande\")\n",
" else:\n",
" print(\"Adivinaste! en el intento: \" + str(count))\n",
" break"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ahora veamos un ejemplo para calcular la raiz de un número usando el método de Newton"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Ingrese un numero : 36\n",
"El valor estimado de la raiz es: 6.000000005333189\n",
"El valor estimado por python es: 6.0\n"
]
}
],
"source": [
"# Método de newton para calcular la raiz de un numero\n",
"\n",
"import math\n",
"\n",
"x = float(input(\"Ingrese un numero : \"))\n",
"\n",
"tolerancia = 0.0001\n",
"\n",
"estimado = 1.0\n",
"\n",
"while True:\n",
" estimado = (estimado + x / estimado)/2\n",
" diferencia = abs( x - estimado ** 2 )\n",
" if diferencia <= tolerancia:\n",
" break\n",
" \n",
"print(\"El valor estimado de la raiz es: \" + str(estimado))\n",
"print(\"El valor estimado por python es: \" + str(math.sqrt(x)))\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Hallar la siguiente sumatoria:\n",
"\n",
"![Alt text](../images/serie.png \"Hallar el valor de la serie\")"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"77.51389798916522\n"
]
}
],
"source": [
"from math import sqrt,pi,sin\n",
"\n",
"x= 0.0\n",
"s= 0.0\n",
"\n",
"for i in range (101):\n",
" s = s + sqrt(x)*sin(x)\n",
" x = x + 0.01*pi\n",
" \n",
"print(s)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ahora tenemos que hallar el valor de PI usando la serie de Leibniz"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"![Alt text](../images/pi.png \"Hallar el valor de pi\")"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Cuantas iteraciones desea? 100000\n",
"Valor de pi computado: 3.1415826535897198\n",
"error: 1.0000000073340232e-05\n",
"0.07004452 seconds\n"
]
}
],
"source": [
"import time\n",
"import math\n",
"\n",
"n = int(input(\"Cuantas iteraciones desea? \"))\n",
"\n",
"start = time.time()\n",
" \n",
"pi,numer = 0,4.0\n",
"for i in range(n):\n",
" denom = (2*i+1)\n",
" term = numer/denom\n",
" if i%2:\n",
" pi -= term\n",
" else:\n",
" pi += term\n",
"\n",
"end = time.time()\n",
"total_time = (end - start)\n",
"seconds = round(total_time, 8)\n",
"\n",
"\n",
"print(\"Valor de pi computado: \" + str(pi))\n",
"print(\"error: \" + str(math.fabs(math.pi - (pi))))\n",
"print(seconds, \"seconds\")"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"<link href='http://fonts.googleapis.com/css?family=Source+Sans+Pro|Josefin+Sans:400,700,400italic|Ubuntu+Condensed' rel='stylesheet' type='text/css'>\n",
"Estilo aplicado\n",
"<style>\n",
"\n",
"\n",
"\n",
"#notebook_panel { /* main background */\n",
" background: #f7f7f7;\n",
"}\n",
"\n",
"div.cell { /* set cell width */\n",
" width: 1000px;\n",
"}\n",
"\n",
"div #notebook { /* centre the content */\n",
" background: #fff; /* white background for content */\n",
" width: 1100px;\n",
" margin: auto;\n",
" padding-left: 0em;\n",
"}\n",
"\n",
"#notebook li { /* More space between bullet points */\n",
" margin-top:0.6em;\n",
"}\n",
"\n",
"/* draw border around running cells */\n",
"div.cell.border-box-sizing.code_cell.running { \n",
" border: 1px solid #111;\n",
"}\n",
"\n",
"/* Put a solid color box around each cell and its output, visually linking them*/\n",
"div.cell.code_cell {\n",
" font-family: 'Source Sans Pro', sans-serif;\n",
" background-color: rgb(256,256,256);\n",
" font-size: 110%;\n",
" border-radius: 0px; \n",
" padding: 0.5em;\n",
" margin-left:1em;\n",
" margin-top: 1em;\n",
"}\n",
"\n",
"div.text_cell_render{\n",
" font-family: 'Josefin Sans', serif;\n",
" line-height: 145%;\n",
" font-size: 125%;\n",
" font-weight: 500;\n",
" width:850px;\n",
" margin-left:auto;\n",
" margin-right:auto;\n",
"}\n",
"\n",
"\n",
"/* Formatting for header cells */\n",
".text_cell_render h1, .text_cell_render h2, .text_cell_render h3,\n",
".text_cell_render h4, .text_cell_render h5 {\n",
" font-family: 'Ubuntu Condensed', sans-serif;\n",
"}\n",
"/*\n",
".text_cell_render h1 {\n",
" font-family: Flux, 'Ubuntu Condensed', serif;\n",
" font-style:regular;\n",
" font-weight: 400; \n",
" font-size: 30pt;\n",
" text-align: center;\n",
" line-height: 100%;\n",
" color: #335082;\n",
" margin-bottom: 0.5em;\n",
" margin-top: 0.5em;\n",
" display: block;\n",
"}\n",
"*/\n",
".text_cell_render h1 {\n",
"\tfont-family: Flux, 'Ubuntu Condensed', serif;\n",
" font-style:regular;\n",
" font-weight: 600;\n",
" font-size: 35pt;\n",
"\ttext-align: center;\n",
" line-height: 100%;\n",
" color: #2c7638;\n",
" margin-bottom: 0.2em;\n",
" margin-top: 0.3em;\n",
" display: block;\n",
"}\n",
"\n",
".text_cell_render h2 {\n",
" margin-top:16px;\n",
" font-size: 27pt;\n",
" font-weight: 550;\n",
" margin-bottom: 0.1em;\n",
" margin-top: 0.3em;\n",
" font-style: regular;\n",
" color: #498550\t;\n",
"}\t\n",
"\n",
".text_cell_render h3 {\n",
" font-size: 20pt;\n",
" font-weight: 550\n",
" text-align: left;\n",
" margin-bottom: 0.1em;\n",
" margin-top: 0.3em;\n",
" font-style: regular;\n",
" color: #1a66ab;\n",
"}\n",
"\n",
".text_cell_render h4 { /*Use this for captions*/\n",
" font-size: 18pt;\n",
" font-weight: 450\n",
" text-align: left;\n",
" margin-bottom: 0.1em;\n",
" margin-top: 0.3em;\n",
" font-style: regular;\n",
" color: #578cb4;\n",
"}\n",
"\n",
".text_cell_render h5 { /*Use this for small titles*/\n",
" font-size: 18pt;\n",
" font-weight: 550;\n",
" color: rgb(163,0,0);\n",
" font-style: italic;\n",
" margin-bottom: .1em;\n",
" margin-top: 0.8em;\n",
" display: block;\n",
" color: #b21c0d;\n",
"}\n",
"\n",
".text_cell_render h6 { /*use this for copyright note*/\n",
" font-family: 'Ubuntu Condensed', sans-serif;\n",
" font-weight: 300;\n",
" font-size: 14pt;\n",
" line-height: 100%;\n",
" color: #252525;\n",
" text-align: right;\n",
" margin-bottom: 1px;\n",
" margin-top: 1px;\n",
"}\n",
"\n",
".CodeMirror{\n",
" font-family: 'Duru Sans', sans-serif;\n",
" font-size: 100%;\n",
"}\n",
"\n",
"</style>\n",
"<script>\n",
" MathJax.Hub.Config({\n",
" TeX: {\n",
" extensions: [\"AMSmath.js\"],\n",
" equationNumbers: { autoNumber: \"AMS\", useLabelIds: true}\n",
" },\n",
" tex2jax: {\n",
" inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
" displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
" },\n",
" displayAlign: 'center', // Change this to 'center' to center equations.\n",
" \"HTML-CSS\": {\n",
" styles: {'.MathJax_Display': {\"margin\": 4}}\n",
" }\n",
" });\n",
"</script>\n"
],
"text/plain": [
"<IPython.core.display.HTML object>"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Esta celda da el estilo al notebook\n",
"from IPython.core.display import HTML\n",
"css_file = '../styles/StyleCursoPython.css'\n",
"HTML(open(css_file, \"r\").read())"
]
}
],
"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.6.5"
}
},
"nbformat": 4,
"nbformat_minor": 1
}