├── LICENSE ├── README.md ├── codigo ├── adivina_el_numero.py ├── adivina_el_numero_esqueleto.py ├── animacion.py ├── audio.py ├── bucles.py ├── funciones.py ├── hello_world.py ├── onda_magica.py ├── pinta_circunferencia.py ├── pinta_parabola.py ├── pinta_recta.py ├── quetepillo.py ├── tortuga_1_movimiento.py ├── variables_0_intro.py ├── variables_1_con_lectura.py ├── variables_2_listas.py └── variables_3_booleanas.py └── slides ├── python_elemental_slides.pdf ├── python_elemental_slides.pptx └── ~$python_elemental_slides.pptx /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2017 Javier García-Algarra 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Introducción a la programación con Python 2 | Este repositorio es un curso de iniciación a la programación para alumnos sin conocimientos previos. Está diseñado para ser impartido en dos sesiones presenciales de cuatro horas cada una. 3 | 4 | Se trata de una actividad voluntaria, no evaluable, y el objetivo es despertar la curiosidad por el desarrollo software en estudiantes de disciplinas no STEM, así como en alumnos de enseñanza secundaria. 5 | 6 | El material original se preparó para la comunidad de desarrollo del Centro Universitario de Tecnología y Arte Digital, España (www.u-tad.com). Se comparte bajo una licencia CC 4.0 con reconocimiento internacional 7 | -------------------------------------------------------------------------------- /codigo/adivina_el_numero.py: -------------------------------------------------------------------------------- 1 | # Archivo: adivina_el_numero.py 2 | # Autor: Javier Garcia Algarra 3 | # Fecha: 27 de diciembre de 2017 4 | # Descripción: Juego para adivinar un número secreto 5 | 6 | import random # Este paquete es necesario para generar números aleatorios 7 | 8 | print("Hola, vamos a jugar a adivinar un número secreto entre 1 y 100") 9 | 10 | # Elegir al azar un número entero entre 1 y 100 11 | numero_secreto = random.randrange(1,101) 12 | 13 | print("Ya lo he pensado, podemos empezar") 14 | intentos = 1 # Contador de intentos. Empieza en uno 15 | 16 | # Esta funcion pide al usuario un número. Si es igual devolverá el valor True, el usuario 17 | # acertó. Si no, dará una pista indicando si el número secreto es mayor o menor que el que 18 | # escribió el jugador. 19 | def adivinalo(numintentos, numsec): 20 | numero_humano = int(input("¿Qué numero has pensado?: ")) 21 | if (numero_humano == numsec): 22 | print("¡Enhorabuena, has acertado!. Número de intentos:",numintentos) 23 | acierto = True 24 | else: 25 | acierto = False 26 | if (numero_humano < numsec): 27 | print("El número que pensé es mayor que el tuyo") 28 | else: 29 | print("El número que pensé es menor que el tuyo") 30 | print("Has utilizado",intentos,"intentos") 31 | return(acierto) 32 | 33 | # Bucle principal del programa. Mientras el usuario no adivine el número repetimos 34 | # la jugada e incrementamos el número de intentos 35 | while not(adivinalo(intentos, numero_secreto)): 36 | intentos = intentos + 1 37 | 38 | 39 | -------------------------------------------------------------------------------- /codigo/adivina_el_numero_esqueleto.py: -------------------------------------------------------------------------------- 1 | # Archivo: adivina_el_numero.py 2 | # Autor: Javier Garcia Algarra 3 | # Fecha: 27 de diciembre de 2017 4 | # Descripción: Juego para adivinar un número secreto 5 | 6 | import random # Este paquete es necesario para generar números aleatorios 7 | 8 | print("Hola, vamos a jugar a adivinar un número secreto entre 1 y 100") 9 | 10 | # Elegir al azar un número entero entre 1 y 100 11 | numero_secreto = random.randrange(...) 12 | 13 | print("Ya lo he pensado, podemos empezar") 14 | intentos = 1 # Contador de intentos. Empieza en uno 15 | 16 | # Esta funcion pide al usuario un número. Si es igual devolverá el valor True, el usuario 17 | # acertó. Si no, dará una pista indicando si el número secreto es mayor o menor que el que 18 | # escribió el jugador. 19 | def adivinalo(numintentos, numsec): 20 | # Leer el numero del jugador 21 | 22 | # Si el numero leido es el mismo decir que ha adivinado en n intentos 23 | # y devolver la variable acierto a True 24 | if (numero_humano == numsec): 25 | acierto = True 26 | 27 | # En caso contrario 28 | else: 29 | # La variable acierto es False 30 | acierto = False 31 | # Si el numero es menor decírselo al jugador 32 | 33 | # Si no indicar que es mayor 34 | 35 | # Indicar el 36 | return(acierto) 37 | 38 | # Bucle principal del programa. Mientras el usuario no adivine el número repetimos 39 | # la jugada e incrementamos el número de intentos 40 | while not(adivinalo(intentos, numero_secreto)): 41 | intentos = intentos + 1 42 | 43 | 44 | -------------------------------------------------------------------------------- /codigo/animacion.py: -------------------------------------------------------------------------------- 1 | # Archivo: animaciones.py 2 | # Basado en https://matplotlib.org/examples/animation/simple_anim.html 3 | # Autor: Javier Garcia Algarra 4 | # Fecha: 28 de diciembre de 2017 5 | # Descripción: Ejemplo de animacion 6 | 7 | import numpy as np 8 | import matplotlib.pyplot as plt 9 | import matplotlib.animation as animation 10 | import random 11 | 12 | PI = 3.1416 13 | fig, ax = plt.subplots() 14 | 15 | x = np.arange(0, 4*PI, 0.01) 16 | line, = ax.plot(x, np.sin(x)) 17 | 18 | 19 | # Init only required for blitting to give a clean slate. 20 | def init(): 21 | line.set_ydata(np.ma.array(x, mask=True)) 22 | return line, 23 | 24 | 25 | def animate_sin_wave(i): 26 | line.set_ydata(np.sin(x+ i/10.0)) # update the data 27 | return line, 28 | 29 | def animate_square_wave(i): 30 | line.set_ydata(0.5*((4/PI)*np.sin(x+ i/10.0)+(4/(3*PI))*np.sin(3*(x+ i/10.0))+(4/(5*PI))*np.sin(5*(x+ i/10.0)))) # update the data 31 | return line, 32 | 33 | def animate_noisy_wave(i): 34 | line.set_ydata(0.5*(np.sin(x+ i/10.0)+0.4*np.random.random(size=len(x)))) # update the data 35 | return line, 36 | 37 | speed = 20 38 | frames = 200 39 | 40 | # Quitar el comentario de ls función de onda que se representa: seno, seno con ruido gaussiano o 'cuadrada' 41 | #funcion = animate_sin_wave 42 | #funcion = animate_noisy_wave 43 | funcion = animate_square_wave 44 | 45 | ani = animation.FuncAnimation(fig, funcion, np.arange(1, frames), init_func=init, 46 | interval=speed, blit=True) 47 | plt.show() 48 | 49 | -------------------------------------------------------------------------------- /codigo/audio.py: -------------------------------------------------------------------------------- 1 | # Archivo: audio.py 2 | # Autor: Javier Garcia Algarra 3 | # Fecha: 24 de diciembre de 2017 4 | # Descripción: Producimos sonidos 5 | 6 | import winsound 7 | do = 262 8 | re = 294 9 | mi = 330 10 | fa = 349 11 | sol = 393 12 | la = 440 13 | si = 494 14 | do_5 = 523 15 | duration = 600 # millisecond 16 | 17 | winsound.Beep(do, duration) 18 | winsound.Beep(re, duration) 19 | winsound.Beep(mi, duration) 20 | winsound.Beep(fa, duration) 21 | winsound.Beep(sol, duration) 22 | winsound.Beep(la, duration) 23 | winsound.Beep(si, duration) 24 | winsound.Beep(do_5, duration) 25 | winsound.Beep(si, duration) 26 | winsound.Beep(la, duration) 27 | winsound.Beep(sol, duration) 28 | winsound.Beep(fa, duration) 29 | winsound.Beep(mi, duration) 30 | winsound.Beep(re, duration) 31 | winsound.Beep(do, duration) 32 | 33 | 34 | dummy = input("Cuando pulses cualquier tecla escucharás una melodía conocida") 35 | 36 | winsound.Beep(do, 2*duration) 37 | winsound.Beep(sol,2* duration) 38 | winsound.Beep(fa, int(duration/2)) 39 | winsound.Beep(mi, int(duration/2)) 40 | winsound.Beep(re, int(duration/2)) 41 | winsound.Beep(do_5, 2*duration) 42 | winsound.Beep(sol, 2*duration) 43 | winsound.Beep(fa, int(duration/2)) 44 | winsound.Beep(mi, int(duration/2)) 45 | winsound.Beep(re, int(duration/2)) 46 | winsound.Beep(do_5, 2*duration) 47 | winsound.Beep(sol, 2*duration) 48 | winsound.Beep(fa, int(duration/2)) 49 | winsound.Beep(mi, int(duration/2)) 50 | winsound.Beep(fa, int(duration/2)) 51 | winsound.Beep(re, 2*duration) 52 | 53 | -------------------------------------------------------------------------------- /codigo/bucles.py: -------------------------------------------------------------------------------- 1 | # Archivo: bucles.py 2 | # Autor: Javier Garcia Algarra 3 | # Fecha: 27 de diciembre de 2017 4 | # Descripción: Variables booleanas 5 | 6 | 7 | # El bucle while se ejecuta mientras la condición sea verdad 8 | 9 | variable_a = 1 10 | 11 | while (variable_a < 7): 12 | print("El valor de variable_a es",variable_a,"y como es menor que 7 entramos en el bucle") 13 | variable_a = variable_a + 1 14 | 15 | print("Cuando la variable_a vale",variable_a,"salimos del bucle") 16 | 17 | # Espera 18 | dummy = input() 19 | 20 | print("Bucle for") 21 | # La instrucción for repite el código para todos los elementos de la lista 22 | for i in [9,8,5]: 23 | print("El valor de i es",i) 24 | 25 | # Espera 26 | dummy = input() 27 | 28 | # Una forma muy habitual de usar el bucle for es con una secuencia de números 29 | # La función range() devuelve una lista entre dos números o entre 0 y n-1 si solo 30 | # indicamos un número. Veamos su utilidad 31 | 32 | print() # Linea en blanco 33 | print("Queremos repetir un bucle 7 veces") 34 | veces = 0 35 | for i in range(7): 36 | veces = veces + 1 37 | print("Veces que he pasado por el bucle",veces,"y el valor de i es",i) 38 | 39 | # Espera 40 | dummy = input() 41 | 42 | print() # Linea en blanco 43 | print("Vamos a calcular la suma de los números 1 al 10") 44 | suma = 0 45 | for i in range(1,11): # Cuando pones dos números range genera desde el mínimo hasta el máximo menos 1 46 | suma = suma + i 47 | print("El valor de i es",i) 48 | print("La suma de los 10 primeros números enteros vale",suma) 49 | -------------------------------------------------------------------------------- /codigo/funciones.py: -------------------------------------------------------------------------------- 1 | # Archivo: funciones.py 2 | # Autor: Javier Garcia Algarra 3 | # Fecha: 27 de diciembre de 2017 4 | # Descripción: Manejo simple de funciones 5 | 6 | 7 | # En programación no es buena práctica repetir código 8 | # Volvamos al ejemplo del bucle for. Queremos calcular la suma de los 10 primeros enteros 9 | 10 | print("Vamos a calcular la suma de los números 1 al 10") 11 | suma = 0 12 | for i in range(1,11): # Cuando pones dos números range genera desde el mínimo hasta el máximo menos 1 13 | suma = suma + i 14 | print("La suma de los 10 primeros números enteros vale",suma) 15 | 16 | # Espera 17 | dummy = input() 18 | 19 | # Imagina que ahora quieres calcular la suma de los 8 primeros enteros. Podemos repetir el código 20 | # y cambiar el límite 21 | 22 | print("Vamos a calcular la suma de los números 1 al 8") 23 | suma = 0 24 | for i in range(1,9): # Cuando pones dos números range genera desde el mínimo hasta el máximo menos 1 25 | suma = suma + i 26 | print("La suma de los 8 primeros números enteros vale",suma) 27 | 28 | # Esto queda muy feo, hay una manera de hacerlo mejor, con funciones 29 | 30 | def suma_primeros_enteros(hasta_que_numero): # hasta_que_numero es un parámetro de entrada 31 | suma = 0 32 | for i in range(1,hasta_que_numero+1): # Cuando pones dos números, range genera una lista de números desde el mínimo hasta el máximo menos 1 33 | suma = suma + i 34 | return(suma) # Valor que devuelve la función 35 | 36 | print() 37 | print("La suma de los primeros 5 números enteros vale",suma_primeros_enteros(5)) 38 | print("La suma de los primeros 12 números enteros vale",suma_primeros_enteros(12)) 39 | 40 | # Espera 41 | dummy = input() 42 | 43 | # Vamos a jugar poniendo junto todo lo que ya sabemos. 44 | # ¿Qué crees que sucederá con este trozo de código? 45 | 46 | valor_suma = 0 47 | while (valor_suma < 500): 48 | num_enteros = int(input("¿Cuántos de los primeros enteros quieres que sume? ")) 49 | valor_suma = suma_primeros_enteros(num_enteros) 50 | print("El valor de la suma de los",num_enteros,"primeros enteros es",valor_suma) 51 | print() 52 | -------------------------------------------------------------------------------- /codigo/hello_world.py: -------------------------------------------------------------------------------- 1 | # Archivo: hello_world.py 2 | # Autor: Javier Garcia Algarra 3 | # Fecha: 24 de diciembre de 2017 4 | # Descripción: Primer programa del curso de introducción a Python para 5 | # no programadores 6 | 7 | print("¡Hola mundo!") -------------------------------------------------------------------------------- /codigo/onda_magica.py: -------------------------------------------------------------------------------- 1 | # Archivo: onda_magica.py 2 | # Autor: Javier Garcia Algarra 3 | # Fecha: 28 de diciembre de 2017 4 | # Descripción: Ejemplo de suma de series de Fourier 5 | 6 | import matplotlib.pyplot as plt 7 | import math # importamos la librería matemática que sabe calcular el seno 8 | 9 | PI = 3.1416 # definimos la constante PI 10 | 11 | # Funcion para crear una lista de numeros que empieza en inferior y termina en superior con un paso no entero 12 | def crealistadevaloresreales(inferior, superior, paso): 13 | listadevalores = [] # Creamos una lista vacia 14 | j = inferior 15 | while (j < superior): 16 | listadevalores.append(j) # Cada valor de la variable j se añade a la lista 17 | j = j + paso 18 | return(listadevalores) # Se devuelve la lista completa 19 | 20 | # Crear una lista de números entre 0 y 4*PI 21 | x_valores = crealistadevaloresreales(0,4*PI,0.1) 22 | 23 | # Ahora vamos a crear los valores y. 24 | 25 | y_sin = [] 26 | 27 | for k in x_valores: 28 | y_sin.append((4/PI)*math.sin(k)) 29 | 30 | # Parte del programa que pinta la gráfica. Pasamos a la funcion plt.plot las listas de valores x e y 31 | plt.plot(x_valores, y_sin) 32 | plt.axis('equal') 33 | plt.ylabel('y') # Etiqueta del eje y. Podriamos no ponerla 34 | plt.xlabel('x') # Etiqueta del eje x 35 | plt.show() # Esta función ordena mostrar la imagen en una ventanita nueva 36 | 37 | dummy = input("Muy hermosa la función sen(x), ahora vamos a ver como es sen(3x)") 38 | y_3sin = [] 39 | 40 | for k in x_valores: 41 | y_3sin.append((4/(3*PI))*math.sin(3*k)) 42 | plt.plot(x_valores, y_sin, '--') 43 | plt.plot(x_valores, y_3sin, color = 'red') 44 | plt.axis('equal') 45 | plt.ylabel('y') # Etiqueta del eje y. Podriamos no ponerla 46 | plt.xlabel('x') # Etiqueta del eje x 47 | plt.show() # Esta función ordena mostrar la imagen en una ventanita nueva 48 | 49 | print("") 50 | dummy = input("Muy hermosa la función sen(3x), ahora vamos a ver como es sen(5x)") 51 | y_5sin = [] 52 | 53 | for k in x_valores: 54 | y_5sin.append((4/(5*PI))*math.sin(5*k)) 55 | plt.plot(x_valores, y_sin,'--') 56 | plt.plot(x_valores, y_3sin,'--', color = 'red') 57 | plt.plot(x_valores, y_5sin, color = 'green') 58 | plt.axis('equal') 59 | plt.ylabel('y') # Etiqueta del eje y. Podriamos no ponerla 60 | plt.xlabel('x') # Etiqueta del eje x 61 | plt.show() # Esta función ordena mostrar la imagen en una ventanita nueva 62 | 63 | print("") 64 | dummy = input("¿Qué crees que pasa si sumamos las tres ondas?") 65 | 66 | y_suma = [] 67 | for i in range(len(x_valores)): 68 | y_suma.append(y_sin[i] + y_3sin[i] + y_5sin[i], ) 69 | plt.plot(x_valores, y_sin,'--') 70 | plt.plot(x_valores, y_3sin,'--', color = 'red') 71 | plt.plot(x_valores, y_5sin,'--', color = 'green') 72 | plt.plot(x_valores, y_suma, color = 'black',lw=3) 73 | plt.axis('equal') 74 | plt.ylabel('y') # Etiqueta del eje y. Podriamos no ponerla 75 | plt.xlabel('x') # Etiqueta del eje x 76 | plt.show() # Esta función ordena mostrar la imagen en una ventanita nueva 77 | -------------------------------------------------------------------------------- /codigo/pinta_circunferencia.py: -------------------------------------------------------------------------------- 1 | # Archivo: pinta_parabola.py 2 | # Autor: Javier Garcia Algarra 3 | # Fecha: 24 de diciembre de 2017 4 | # Descripción: Dibujamos una circunferencia 5 | 6 | import matplotlib.pyplot as plt 7 | import math # importamos la librería matemática que sabe hacer raíces cuadradas 8 | 9 | # Funcion para crear una lista de numeros que empieza en inferior y termina en superior 10 | def crea_lista_de_valores(inferior, superior): 11 | listadevalores = [] # Creamos una lista vacia 12 | for j in range(inferior,superior+1): # La variable j va tomando los valores del rango inferior a superior 13 | listadevalores.append(j) # Cada valor de la variable j se añade a la lista 14 | return(listadevalores) # Se devuelve la lista completa 15 | 16 | # Crear una lista de números naturales, del -9 al 9 17 | x_valores = crea_lista_de_valores(-9,9) 18 | 19 | # Ahora vamos a crear los valores y. La formula de la circunferencia es y**2 + x**2 = radio**2 20 | # Recorremos los valores de x para crear otra lista de valores y 21 | # pero para cada valor de x hay dos valores de y, el positivo y el negativo de la raiz cuadrada. 22 | # Para solucionarlo creamos dos listas de valores y, una positiva y otra negativa 23 | 24 | radio = 9 25 | y_valores_pos = [] 26 | y_valores_neg = [] 27 | 28 | for k in x_valores: 29 | y_valores_pos.append(math.sqrt(radio**2 - k**2)) 30 | y_valores_neg.append(-math.sqrt(radio**2 - k**2)) 31 | 32 | # Parte del programa que pinta la gráfica. Pasamos a la funcion plt.plot las listas de valores x e y 33 | plt.plot(x_valores, y_valores_pos, ".") 34 | plt.plot(x_valores, y_valores_neg, ".") # Añadimos la lista de valores y negativos al gráfico 35 | plt.axis('equal') 36 | plt.ylabel('y') # Etiqueta del eje y. Podriamos no ponerla 37 | plt.xlabel('x') # Etiqueta del eje x 38 | plt.show() # Esta función ordena mostrar la imagen en una ventanita nueva 39 | -------------------------------------------------------------------------------- /codigo/pinta_parabola.py: -------------------------------------------------------------------------------- 1 | # Archivo: pinta_parabola.py 2 | # Autor: Javier Garcia Algarra 3 | # Fecha: 24 de diciembre de 2017 4 | # Descripción: Dibujamos una parábola 5 | 6 | import matplotlib.pyplot as plt 7 | 8 | # Funcion para crear una lista de numeros que empieza en inferior y termina en superior 9 | def crea_lista_de_valores(inferior, superior): 10 | listadevalores = [] # Creamos una lista vacia 11 | for j in range(inferior,superior+1): # La variable j va tomando los valores del rango inferior a superior 12 | listadevalores.append(j) # Cada valor de la variable j se añade a la lista 13 | return(listadevalores) # Se devuelve la lista completa 14 | 15 | # Crear una lista de números naturales, del -15 al 15 16 | x_valores = crea_lista_de_valores(-15,15) 17 | 18 | # Ahora vamos a crear los valores y. La formula de la parábola es y = x ^ 2 19 | # Recorremos los valores de x para crear otra lista de valores y 20 | # La lista de valores x es [-15, ..., -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, ..., 15] 21 | 22 | 23 | y_valores = [] 24 | for k in x_valores: 25 | y_valores.append(k ** 2) 26 | 27 | # Parte del programa que pinta la gráfica. Pasamos a la funcion plt.plot las listas de valores x e y 28 | plt.plot(x_valores, y_valores) 29 | plt.ylabel('y') # Etiqueta del eje y. Podriamos no ponerla 30 | plt.xlabel('x') # Etiqueta del eje x 31 | plt.show() # Esta función ordena mostrar la imagen en una ventanita nueva -------------------------------------------------------------------------------- /codigo/pinta_recta.py: -------------------------------------------------------------------------------- 1 | # Archivo: pinta_recta.py 2 | # Autor: Javier Garcia Algarra 3 | # Fecha: 24 de diciembre de 2017 4 | # Descripción: Dibujamos una linea recta 5 | 6 | import matplotlib.pyplot as plt 7 | 8 | # Funcion para crear una lista de numeros que empieza en inferior y termina en superior 9 | def crea_lista_de_valores(inferior, superior): 10 | listadevalores = [] # Creamos una lista vacia 11 | for j in range(inferior,superior+1): # La variable j va tomando los valores del rango inferior a superior 12 | listadevalores.append(j) # Cada valor de la variable j se añade a la lista 13 | return(listadevalores) # Se devuelve la lista completa 14 | 15 | # Crear una lista de números enteros, del 1 al 10 16 | x_valores = crea_lista_de_valores(1,10) 17 | 18 | # Ahora vamos a crear los valores y. La formula de la recta es y = 2 * x 19 | # Recorremos los valores de x para crear otra lista de valores y 20 | # La lista de valores x es [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 21 | # y la lista de valores y será [2, 4, 6, 8, 10, 12, 14, 16, 18, 20] 22 | 23 | y_valores = [] 24 | for k in x_valores: 25 | y_valores.append(2 * k) 26 | 27 | # Parte del programa que pinta la gráfica. Pasamos a la funcion plt.plot las listas de valores x e y 28 | plt.plot(x_valores, y_valores, ".") 29 | plt.ylabel('y') # Etiqueta del eje y. Podriamos no ponerla 30 | plt.xlabel('x') # Etiqueta del eje x 31 | plt.show() # Esta función ordena mostrar la imagen en una ventanita nueva 32 | -------------------------------------------------------------------------------- /codigo/quetepillo.py: -------------------------------------------------------------------------------- 1 | # Archivo: quetepillo.py 2 | # Autor: Javier Garcia Algarra 3 | # Fecha: 27 de diciembre de 2017 4 | # Descripción: Juego de la presa y el cazador 5 | # 6 | # La tortuga naranja se mueve al azar. El cazador es la tortuga negra. 7 | # Podemos controlar su dirección haciendo que gire con las flechas izquierda 8 | # y derecha. Si pulsamos la flecha hacia arriba el cazador acelera el paso 9 | # El juego termina cuando el cazador alcanza a la presa 10 | 11 | from turtle import * 12 | import random 13 | import math 14 | 15 | # Creacion de la pantalla 16 | dimension = 500 17 | setup(dimension, dimension) 18 | salto = int(dimension/50) 19 | wn = Screen() 20 | se_acabo = False 21 | title("Que te pillo") 22 | 23 | # La presa de color naranja se coloca en el centro 24 | presa = Turtle() 25 | presa.penup() 26 | presa.setpos(0,0) 27 | presa.color("orange") 28 | presa.showturtle() 29 | 30 | # El cazador empieza en una posición aleatoria 31 | mitortuga = Turtle() 32 | mitortuga.penup() 33 | mitortuga.setpos(random.randrange(-int(dimension/3)-50,int(dimension/3)+50),random.randrange(-int(dimension/3),int(dimension/3))) 34 | mitortuga.showturtle() 35 | 36 | # Cálculo de la distancia entre la presa y el cazador 37 | def calc_distancia(posA,posB): 38 | distancia =math.sqrt( (posA[0]-posB[0])**2+(posA[1]-posB[1])**2 ) 39 | return(distancia) 40 | 41 | # Funciones para controlar el movimiento del cazador 42 | def k1(): # Flecha superior 43 | if not(se_acabo): 44 | mitortuga.penup() 45 | mitortuga.forward(salto) 46 | def k2(): # Flecha izquierda 47 | mitortuga.left(45) 48 | 49 | def k3(): 50 | mitortuga.right(45) # Flecha derecha 51 | 52 | def movepresa(): # Movimiento de la presa 53 | # Esta función se ejecuta cada vez que vence el temporizador de 0.1 segundos 54 | global contador, se_acabo 55 | if not(se_acabo): 56 | contador = contador + 1 57 | mitortuga.penup() 58 | mitortuga.forward(salto/4) # Movimiento lento del cazador 59 | dist = calc_distancia(mitortuga.pos(),presa.pos()) # Calcular la distancia 60 | if dist <= 6: # Condición de caza 61 | print("¡¡¡Te pillé!!!. Has necesitado",contador/10,"segundos.") 62 | se_acabo = True 63 | done() 64 | if not(contador % 10): # Imprimir el tiempo cada segunfo 65 | print("Segundos: ",contador / 10) 66 | random_walk = random.randrange(4) # Movimiento aleatorio de la presa 67 | if random_walk < 2: # Si es 0 ó 1 saltar 68 | presa.forward(salto) 69 | if random_walk == 2: # Girar a la izquierda 70 | presa.left(random.randrange(90)) 71 | if random_walk == 3: # Girar a la derecha 72 | presa.right(random.randrange(90)) 73 | wn.ontimer(movepresa, periodo) # Reiniciar el contador 74 | 75 | onkey(k1, "Up") 76 | onkey(k2, "Left") 77 | onkey(k3, "Right") 78 | periodo = 100 79 | contador = 0 80 | wn.ontimer(movepresa, periodo) 81 | listen() 82 | 83 | mainloop() 84 | -------------------------------------------------------------------------------- /codigo/tortuga_1_movimiento.py: -------------------------------------------------------------------------------- 1 | # Archivo: tortuga_1_movimiento.py 2 | # Autor: Javier Garcia Algarra 3 | # Fecha: 27 de diciembre de 2017 4 | # Descripción: Ejemplo de uso de la tortuga gráfica 5 | 6 | import turtle 7 | import random 8 | 9 | print("Vamos a dibujar un cuadrado") 10 | # Dibujamos un rectángulo de lado 200 11 | lado = 200 12 | for i in range(4): 13 | turtle.forward(lado) 14 | turtle.left(90) 15 | 16 | print("Impresionante, ¿no?") 17 | print("Ahora voy a dibujar otro de color rojo") 18 | dummy = input("Pulsa cualquier tecla para que comience") 19 | 20 | turtle.penup() # Levanta la pluma del papel 21 | turtle.setpos(-lado,-lado) # Muevete a esta posicion 22 | turtle.pendown() # Vuelve a poner la pluma en el papel 23 | turtle.color("red") 24 | for i in range(4): 25 | turtle.forward(lado) 26 | turtle.left(90) 27 | 28 | print("Ahora vamos a hacer que el ratón se mueva al azar (random walk)") 29 | dummy = input("Pulsa cualquier tecla para que comience ") 30 | turtle.clear() 31 | turtle.penup() 32 | turtle.setpos(0,0) 33 | turtle.pendown() 34 | saltos = 0 35 | while (saltos < 20): 36 | turtle.forward(25) 37 | angulo_al_azar = random.randrange(0,360) 38 | turtle.left(angulo_al_azar) 39 | saltos = saltos + 1 40 | 41 | print("Una estrella...") 42 | dummy = input("Pulsa cualquier tecla para que comience ") 43 | turtle.clear() 44 | turtle.penup() 45 | turtle.setpos(-100,-100) 46 | turtle.pendown() 47 | puntas = 0 48 | while (puntas < 8): 49 | turtle.forward(200) 50 | turtle.left(135) 51 | puntas = puntas + 1 52 | 53 | print("Para el final dejamos lo mejor...") 54 | dummy = input("Pulsa cualquier tecla para que comience ") 55 | turtle.penup() 56 | turtle.setpos(100,100) 57 | turtle.pendown() 58 | turtle.color('red', 'yellow') 59 | turtle.begin_fill() 60 | puntas = 0 61 | while (puntas < 36): 62 | turtle.forward(200) 63 | turtle.left(170) 64 | puntas = puntas + 1 65 | 66 | turtle.end_fill() 67 | turtle.done() -------------------------------------------------------------------------------- /codigo/variables_0_intro.py: -------------------------------------------------------------------------------- 1 | # Archivo: variables_0_intro.py 2 | # Autor: Javier Garcia Algarra 3 | # Fecha: 27 de diciembre de 2017 4 | # Descripción: Manejo elemental de variables 5 | 6 | 7 | # Variables numéricas enteras (sin decimales). En python se llaman del tipo int 8 | 9 | a = 3 # Esta instrucción ordena cargar el número 3 en la variable a 10 | b = 7 # Esta instrucción ordena cargar el número 7 en b 11 | c = a + b # Esta instrucción ordena cargar la suma de a y b en la variable c 12 | print("El valor de a es ",a) 13 | print("El valor de b es ",b) 14 | print("La suma de a y b es ",c) 15 | 16 | 17 | # Variables con valores reales (decimales). Se llaman float 18 | peso = 76.5 19 | altura = 179.5 20 | 21 | print("Peso (Kg): ",peso) 22 | print("Altura (cm): ",altura) 23 | 24 | # En programación se llama string a una cadena de caracteres, y se indica escribiéndola entre 25 | # comillas. En python son del tipo char 26 | 27 | mi_nombre = "Javier" 28 | print("Mi nombre es ",mi_nombre) 29 | -------------------------------------------------------------------------------- /codigo/variables_1_con_lectura.py: -------------------------------------------------------------------------------- 1 | # Archivo: variables_1_con_lectura.py 2 | # Autor: Javier Garcia Algarra 3 | # Fecha: 27 de diciembre de 2017 4 | # Descripción: Lectura de variables desde el teclado 5 | 6 | # Primero preguntamos al usuario cual es su nombre 7 | print("Dime tu nombre, por favor: ") 8 | nombre = input() # Esta función lee la variable nombre desde el teclado 9 | # Repetimos la operación para saber la edad, el peso y la altura 10 | print("¿Cuál es tu edad?: ") 11 | edad = input() 12 | print("¿Cuántos kilos pesas?: ") 13 | peso = input() 14 | print("¿Cuántos centímetros mides?: ") 15 | estatura = input() 16 | 17 | # Este programa tan simple lo único que hace es construir un mensaje con la información que 18 | # nos dió el usuario 19 | print("Hola",nombre,". Tu edad son",edad,"años, pesas",peso,"kilos y mides",estatura," cm") 20 | 21 | # Hay otra manera más compacta de escribir el mensaje y leer la variable de entrada 22 | tu_ciudad = input("¿En qué ciudad vives?: ") 23 | print(tu_ciudad,"es un lugar muy agradable para vivir,",nombre) 24 | 25 | # También podemos indicar a Python de qué tipo es la variable que se desea leer. Por ejemplo 26 | # queremos que la edad sea un número y no una cadena de caracteres 27 | edad = int(input("¿Puedes repetirme la edad, por favor?: ")) 28 | print("Nadie diría que tienes",edad,"años. Pareces más joven :)") 29 | 30 | -------------------------------------------------------------------------------- /codigo/variables_2_listas.py: -------------------------------------------------------------------------------- 1 | # Archivo: variables_2_listas.py 2 | # Autor: Javier Garcia Algarra 3 | # Fecha: 27 de diciembre de 2017 4 | # Descripción: Manejo de listas 5 | 6 | 7 | # En una lista podemos incluir diferentes valores 8 | 9 | lista_a = ["hola","mundo","hasta","luego"] 10 | 11 | # Si imprimimos la lista por la pantalla aparecerán los elementos individuales 12 | print(lista_a) 13 | 14 | # La longitud de una lista y de cualquier variable se puede saber con la función len 15 | print("La lista tiene",len(lista_a),"elementos") 16 | 17 | # Los elementos de una lista pueden conocerse de manera individual. Python cuenta 18 | # desde 0 hasta longitud de la lista - 1 19 | print("El primer elemento de la lista es",lista_a[0]) 20 | print("El último elemento es",lista_a[len(lista_a)-1]) 21 | 22 | # Podemos agregar elementos al final de una lista con el método append. Es muy 23 | # sencillo 24 | otro_elemento = input("Escribe el valor de un nuevo elemento para la lista: ") 25 | lista_a.append(otro_elemento) 26 | print("Ahora la longitud de la lista es",len(lista_a)) 27 | print("Puedes comprobarlo tú mismo") 28 | print(lista_a) 29 | 30 | # Si queremos que el programa se detenga hasta que el usuario pulse cualquier tecla 31 | # podemos usar una variable 'tonta' que no haga nada, solo esperar 32 | 33 | dummy = input() 34 | 35 | print("Ahora vamos a ver cómo funcionan las listas de números") 36 | # También podemos tener listas de números 37 | lista_b = [8, 9, 10, 4] 38 | # Python es muy inteligente y puede sumar todos los elementos de una vez 39 | suma_lista_b = sum(lista_b) 40 | print("Los valores de la lista numérica son ",lista_b,"y su suma es",suma_lista_b) 41 | # También sabe hallar el máximo y el mínimo 42 | maximo = max(lista_b) 43 | minimo = min(lista_b) 44 | print("El valor máximo es",maximo,"y el mínimo es",minimo) 45 | -------------------------------------------------------------------------------- /codigo/variables_3_booleanas.py: -------------------------------------------------------------------------------- 1 | # Archivo: variables_3_booleanas.py 2 | # Autor: Javier Garcia Algarra 3 | # Fecha: 27 de diciembre de 2017 4 | # Descripción: Variables booleanas 5 | 6 | 7 | # Las variables booleanas son muy útiles. Sólo pueden tomar dos variables True (Verdadero) o False (Falso) 8 | 9 | booleana_1 = True 10 | booleana_2 = False 11 | 12 | print("La variable booleana_1 es",booleana_1,"y la variable 2 es",booleana_2) 13 | 14 | # Espera 15 | dummy = input() 16 | 17 | # Cuando hacemos comparaciones el resultado es una variable booleana 18 | a = 6 19 | b = 5 20 | a_mayor_que_b = (a > b) 21 | a_menor_que_b = (a < b) 22 | print("La variable a vale",a,"y la variable b vale",b) 23 | print("Si digo que a es mayor que b, es",a_mayor_que_b) 24 | print("Si digo que a es menor que b, es",a_menor_que_b) 25 | 26 | # Espera 27 | dummy = input() 28 | 29 | # Para saber si dos valores son iguales usamos el operador == 30 | # ¡Cuidado! si pones solo = es el operador de asignación y 31 | 32 | d = 5 33 | e = 5 34 | f = 7 35 | 36 | print("Las variables d, e y f valen",d,",",e,",",f) 37 | print("Si digo que d y e valen lo mismo es", d == e) 38 | print("Si digo que e y f valen lo mismo es", e == f) 39 | 40 | # Espera 41 | dummy = input() 42 | 43 | # Con las variables booleanas podemos tomar decisiones usando 44 | # la expresión if 45 | if (5 > 3): 46 | print("La condición 5 > 3 se cumple") 47 | 48 | # Espera 49 | dummy = input() 50 | 51 | # ¿Qué sucede si queremos hacer una cosa si la condición se cumple y 52 | # otra diferente si no se cumple? Para eso usamos la expresión completa if ... else 53 | 54 | y = 7 55 | x = 9 56 | 57 | print("Las variables x, y valen",x,",",y) 58 | if (x == y): 59 | print("Esto es lo sucede si las variables x e y son iguales") 60 | else: 61 | print("Y esto es lo que sucede si las variables x e y no son iguales") 62 | 63 | 64 | # Espera 65 | dummy = input() 66 | 67 | # Ahora vamos a ver un ejemplo muy sencillo. Luego lo haremos un poco más divertido con un juego 68 | numero_secreto = 7 # OK, no es muy secreto porque ya sabes programar en Python, pero lo es para alguien que solo use el programa 69 | num_del_usuario = int(input("He pensado un número secreto del 1 al 10. A ver si lo adivinas: ")) 70 | 71 | if (num_del_usuario == numero_secreto): 72 | print("¡Impresionante!, lo adivinaste") 73 | else: 74 | print("No acertaste, mi número secreto era el ",numero_secreto) 75 | -------------------------------------------------------------------------------- /slides/python_elemental_slides.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jgalgarra/introprogpython/890e28fb109cfd1cb77e8348ebbd59e74c0c10b8/slides/python_elemental_slides.pdf -------------------------------------------------------------------------------- /slides/python_elemental_slides.pptx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jgalgarra/introprogpython/890e28fb109cfd1cb77e8348ebbd59e74c0c10b8/slides/python_elemental_slides.pptx -------------------------------------------------------------------------------- /slides/~$python_elemental_slides.pptx: -------------------------------------------------------------------------------- 1 | yo yo --------------------------------------------------------------------------------