"<h1><center>Tópicos Avanzados de Programación</center></h1>\n",
print("1.5.1 Imprimir todos los numeros pares entre 0 y 20 usando for o while.")
"\n",
"# 1. Python \n",
for i in range(21):
"## 1.1 Introduccion"
print(i)
]
},
{
print("1.5.2 Imprimir todos los numeros mayores a 10 de la lista A")
"cell_type": "markdown",
"metadata": {},
a = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
"source": [
"Python fue creado en 1991 por Guido van Rossum, con la filosofia de crear codigo legible, por lo que la identacion es obligatoria. Su desarrollo esta administrado por **Python Software Foundation** (python.org).\n",
for i in a:
"\n",
if (i>10):
"\n",
print(i)
"Caracteristicas:\n",
"* Alto Nivel\n",
print("1.5.3 Dadas dos listas A y B, obten una lista con sus elementos comunes (A∩B).")
"* Interpretado (Se ejecuta sin compilación previa)\n",
a = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
"* Tipificación Dinamica (Se realiza durante en tiempo de ejecución)\n",
b = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
"* Multiparadigma\n",
"* Interactivo (con ipython)\n"
for i in a:
]
for j in b:
},
if(i==j):
{
print(i)
"cell_type": "markdown",
"metadata": {},
print(" 1.5.4 Pregunta al usario cuantos numeros de la secuancia Fibonacci quiere calcular y escribe una funcion que calcule la secuencia e imprima el resultado.")
"source": [
"## 1.2 Tipos de Datos\n",
terminos=10
"#### Numericos\n",
"* int\n",
#línea para preguntar cuantos números de fibonacci se deben imprimir
"* float\n",
#terminos = int(input("Cuantos números? "))
"* complex"
]
num1 = 0
},
num2 = 1
{
contador = 0
"cell_type": "code",
"execution_count": 1,
if terminos <= 0:
"metadata": {},
print("El número seleccionado debe ser mayor a cero")
"outputs": [
elif terminos == 1:
{
print("Fibonacci con ",terminos," valores :")
"data": {
print(num1)
"text/plain": [
else:
"int"
print("Fibonacci con ",terminos," valores :")
]
while contador < terminos:
},
print(num1)
"execution_count": 1,
nth = num1 + num2
"metadata": {},
num1 = num2
"output_type": "execute_result"
num2 = nth
}
contador += 1
],
"source": [
print("1.5.5 Escribe una funcion que sume todos los uneros en una lista.")
"type (1)"
]
a = [8, 2, 3, 0, 7]
},
suma=0
{
"cell_type": "code",
for i in a:
"execution_count": 2,
suma=suma+i
"metadata": {},
"outputs": [
print("la suma es de ", suma)
{
"data": {
print("1.5.6 Escribe una funcion que tome una lista y regrese los elementos unicos en la lista.")
"text/plain": [
"float"
a = [1,2,2,3,3,3,3,4,5,5]
]
},
for i in a:
"execution_count": 2,
print(i)
"metadata": {},
"output_type": "execute_result"
print("1.5.7 Escribe una funcion que indique si un numero es o no perfecto.")
}
],
#ent=int(input("Inserte el número para calcular si es perfecto: "))
"source": [
ent=6 #valor mientras
"type (1.)"
b=0
]
checker=0
},
for j in range(1, (ent//2)+1):
{
if((ent%j)==0):
"cell_type": "code",
b= b+j;
"execution_count": 3,
if(b==ent):
"metadata": {},
checker=1
"outputs": [
else:
{
checker=0
"data": {
if(checker==1):
"text/plain": [
print(ent," es perfecto")
"complex"
else:
]
print(ent,"no es perfecto")
},
"execution_count": 3,
print("1.5.8 Escribe una funcion que imprima las prieras n filas del triangulo de Pascal.")
"metadata": {},
"output_type": "execute_result"
print("1.5.9 Escribe una funcion que indique si una frase es un panagrama.")
}
],
print("1.5.10 Escribe un programa que imprima el siguiente un for anidado.")
"source": [
"type ((1+2j))"
ent=int(input("Inser el número de filas de la figura: "))
]
for i in range(1,ent+1):
},
print(i)
{
\ No newline at end of file
"cell_type": "markdown",
"metadata": {},
"source": [
"### Secuencias\n",
"* list\n",
"* tuple \n",
"* range\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"list"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type([1,2,3])"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"tuple"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type((1,2))"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"range"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type(range(1))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Texto\n",
"* str\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"str"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type(\"Hola\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Mapeo\n",
"* dict"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"dict"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type({\"mensaje\":\"hola mundo\"})"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Conjuntos\n",
"* set\n",
"* frozenset"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{1, 2, 3, 5, 6}"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"set([1,2,3,1,5,2,6])\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1.2 Operadores\n",
"### Comparación \n",
"| Simbolo | Operador |\n",
"|---------|----------|\n",
"| < | menor que |\n",
"| <= | Menor o igual que |\n",
"| >\t| Mayor que |Mayor o igual que | \n",
"| == | Igual |\n",
"| != | Desigual |\n",
"| is | Identidad de Objetos |\n",
"| is not | Identidad Negada de Objetos|\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"6 < 9"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"6 > 9"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"6 == 9"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"6 != 9"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"6 is float(6)\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"6 is int(6)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Operaciones\n",
"| Operacion\t| Result |\n",
"|-----------|--------|\n",
"| x + y\t| Suma |\n",
"| x - y\t| Resta |\n",
"| x * y\t| Multiplicacion |\n",
"| x / y\t| Division |\n",
"| x // y | Division (Parte entera) |\n",
"| x % y\t| Modulo|\n",
"| x ** y | x a la potencia y |\n",
"\n",
"### Operador a nivel de bits\n",
"| Operation | Result |\n",
"|-----------|--------|\n",
"| x | y\t| x OR y |\n",
"| x ^ y\t| x XOR y |\n",
"| x & y\t| x AND y |\n",
"| x << n | x desplazado n bits a la izquierda |\n",
"| x >> n | x desplazado n bits a la derecha |\n",
"| ~x | x Negado |\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1.3 Control de Flujo\n",
"Las estructuruas de control de flijo permiten modificar el flujo de ejecución de las instrucciones de un programa mediante el valor binario de una condicion. Python cuenta con las siguientes estructuras de control:\n",
"\n",
"* if, elif\n",
"* else\n",
"* for\n",
"* while\n",
"* continue\n",
"* break\n",
"* pass\n",
"* try, exeption\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"if True:\n",
" print(\"True\")\n",
"else:\n",
" print(\"False\")"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n",
"2\n",
"3\n",
"4\n"
]
}
],
"source": [
"for i in range(5):\n",
" print(i)"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Vacio\n"
]
}
],
"source": [
"for i in range(0):\n",
" print(i)\n",
"else:\n",
" print(\"Vacio\")"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n",
"3\n",
"4\n",
"5\n"
]
}
],
"source": [
"i = 0\n",
"while i < 5:\n",
" i+=1\n",
" print(i)"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n",
"3\n",
"4\n"
]
}
],
"source": [
"for i in range(5):\n",
" if(i==2):\n",
" continue\n",
" print(i)"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n"
]
}
],
"source": [
"for i in range(5):\n",
" if(i==2):\n",
" break\n",
" print(i)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n",
"2\n",
"3\n",
"4\n"
]
}
],
"source": [
"for i in range(5):\n",
" if(i==2):\n",
" pass\n",
" print(i)"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.5\n",
"0.6666666666666666\n",
"1.0\n",
"2.0\n",
"ERROR\n"
]
}
],
"source": [
"for i in reversed(range(5)):\n",
" try:\n",
" print(2/i)\n",
" except:\n",
" print(\"ERROR\")\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Todos los objetos de python son considerados verdaders (True) exepto los siguintes:\n",
"* Constantes definidas como: None o False.\n",
"* Cero de cualquier tipo numerico: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)\n",
"Una función es un conjunto de setencias que pueden ser invocadas varias veces durante la ejecución de un programa. Permiten minimizar el codigo, amuentar su legibilidad y permiten reutilizar código. En python las funciones son definida por la palabra reservada **def**. \n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello World\n"
]
}
],
"source": [
"def HelloWorld():\n",
" print(\"Hello World\")\n",
"\n",
"HelloWorld()\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.4.1 Parametros\n",
"La funciones pueden aceptar arguentos de entrada y devoler resultados."
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello Mario\n"
]
}
],
"source": [
"def Hello(name):\n",
" print(\"Hello \"+name)\n",
"Hello(\"Mario\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.4.2 Parametros Opcionales\n",
"Las funciones tampien pueden aceptar parametros opcionales, los cuales toman en valor indicado por defecto si no son pasados a la funcion."
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello Mario!!!\n",
"Hello Mario?\n",
"Hello Mario!\n",
"Hello Alex!!\n"
]
},
{
"data": {
"text/plain": [
"[1]"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def Hello(name, x=\"!!!\"):\n",
" print(\"Hello \" + name + x)\n",
"Hello(\"Mario\")\n",
"Hello(\"Mario\",\"?\")\n",
"Hello(x=\"!\", name=\"Mario\")\n",
"p = {\"name\":\"Alex\", \"x\":\"!!\"}\n",
"Hello(**p)\n",
"[1,]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.4.3 Desempaquetado"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0 1 2\n",
"0 4 5\n",
"[6, 7, 8] 1 2\n",
"6 7 8\n",
"{'a': 9, 'b': 10, 'c': 11} 1 2\n",
"9 10 11\n"
]
}
],
"source": [
"def unpack(a,b=1,c=2):\n",
" print(a,b,c)\n",
"\n",
"l = [6,7,8] \n",
"d = {\"a\":9,\"b\":10,\"c\":11} \n",
"unpack(0)\n",
"unpack(0, 4, 5)\n",
"unpack(l)\n",
"unpack(*l)\n",
"unpack(d)\n",
"unpack(**d)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1.5 Ejercicios\n",
"### 1.5.1 Imprimir todos los numeros pares entre 0 y 20 usando *for* o *while*."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.5.2 Imprimir todos los numeros mayores a 10 de la lista A"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
"A = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.5.3 Dadas dos listas A y B, obten una lista con sus elementos comunes (A∩B)."
"### 1.5.4 Pregunta al usario cuantos numeros de la secuancia Fibonacci quiere calcular y escribe una funcion que calcule la secuencia e imprima el resultado."
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [],
"source": [
"def fibonacci(n):\n",
" pass"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.5.5 Escribe una funcion que sume todos los uneros en una lista."
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [],
"source": [
"a = [8, 2, 3, 0, 7]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.5.6 Escribe una funcion que tome una lista y regrese los elementos unicos en la lista.\n"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [],
"source": [
"a = [1,2,2,3,3,3,3,4,5,5]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.5.7 Escribe una funcion que indique si un numero es o no perfecto.\n",
"[Wikipedia:](https://es.wikipedia.org/wiki/N%C3%BAmero_perfecto) *Un número perfecto es un número natural que es igual a la suma de sus divisores propios positivos. Dicho de otra forma, un número perfecto es aquel que es amigo de sí mismo.\n",
"Así, 6 es un número perfecto porque sus divisores propios son 1, 2 y 3; y 6 = 1 + 2 + 3. Los siguientes números perfectos son 28, 496 y 8128.*\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Escribe un nuemero:8\n"
]
}
],
"source": [
"def perfect(x):\n",
" pass\n",
"numero = input(\"Escribe un nuemero:\")\n",
"perfect(numero)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.5.8 Escribe una funcion que imprima las prieras *n* filas del triangulo de Pascal.\n",
"El triángulo de Pascal es un triángulo numérico con números dispuestos en filas escalonadas de manera tal que:\n",
"$a_{nr}=\\frac{n!}{r!(n-r)!}=\\binom{n}{r}$\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def pascal(n):\n",
" pass\n",
"numero = input(\"Indica el numero de filas:\")\n",
"pascal(numero)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.5.9 Escribe una funcion que indique si una frase es un panagrama.\n",
"[Wikipedia](https://es.wikipedia.org/wiki/Pangrama):Un pangrama (del griego: παν γραμμα, «todas las letras») o frase holoalfabética es un texto que usa todas las letras posibles del alfabeto de un idioma. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1.5.10 Escribe un programa que imprima el siguiente un **for** anidado.\n",
