Tutorial Python

Ing. Juventino Israel García Andrade

TUTORIAL
LENGUAJE DE PROGRAMACIÓN PYTHON

Ing. Juventino Israel García Andrade

Email: [Link]@[Link]
© 2025

1
 Tutorial Python
Ing. Juventino Israel García Andrade

Contenido

INTRODUCCIÓN ................................................................................................................................................. 1
¿QUE ES PYTHON? ............................................................................................................................................. 2
DESCARGA E INSTALACIÓN DE PYTHON ............................................................................................................. 4
¿CÓMO USAR EL EDITOR IDLE DE PYTHON? ....................................................................................................... 7
MI PRIMER PROGRAMA EN PYTHON .................................................................................................................. 9
VARIABLES EN PYTHON .................................................................................................................................... 12
OPERADORES ................................................................................................................................................... 17
INTERACCIÓN CON EL USUARIO (ENTRADAS) ................................................................................................... 21
EJERCICIOS CON OPERADORES ARITMÉTICOS .................................................................................................. 23
FUNCIONES MATEMÁTICAS ............................................................................................................................. 26
ESTRUCTURAS DE CONTROL ............................................................................................................................ 31
ESTRUCTURAS CONDICIONALES (TOMA DE DECISIONES) ................................................................................. 31
ESTRUCTURAS ITERATIVAS (BUCLES) ................................................................................................................ 40
ESTRUCTURAS DE DATOS ................................................................................................................................. 45
FUNCIONES...................................................................................................................................................... 52
UTILIZAR VARIABLES LOCALES Y GLOBALES ...................................................................................................... 61
LECTURA Y ESCRITURA DE ARCHIVOS ............................................................................................................... 62
MÓDULOS ....................................................................................................................................................... 65
CONVERTIR UN ARCHIVO .PY A .EXE................................................................................................................. 75
INTERFAZ DE COMUNICACIÓN SERIE EN PYTHON............................................................................................. 79
CONTROL DE RELÉ USB LCUS-1 CON PYTHON ................................................................................................... 79
CONTROL DE RELÉ USB LCUS-2 CON PYTHON ................................................................................................... 89
COMUNICACIÓN ARDUINO CON PYTHON ........................................................................................................ 96
CONTROL DE SERVOMOTORES CON ARDUINO Y PYFIRMATA2 ....................................................................... 110
CONCLUSIÓN ................................................................................................................................................. 119

1
 Tutorial Python
Ing. Juventino Israel García Andrade

INTRODUCCIÓN

Bienvenido al fascinante mundo de la programación con Python, uno de los lenguajes más
poderosos, versátiles y, sobre todo, amigables que existen en la actualidad. Si alguna vez has
sentido curiosidad por cómo se construyen las aplicaciones que usas a diario, cómo se
automatizan tareas repetitivas o cómo las máquinas aprenden a tomar decisiones, has llegado
al lugar indicado. Este tutorial ha sido diseñado específicamente para guiarte desde tus
primeros pasos, eliminando la frustración técnica y enfocándonos en lo que realmente importa:
desarrollar tu capacidad de resolver problemas mediante el código.

En las siguientes secciones, exploraremos los cimientos que sostienen cualquier programa
exitoso. Comenzaremos desde lo más elemental —la instalación del entorno y tu primer "Hola
Mundo"— para luego adentrarnos en el manejo de variables, tipos de datos, estructuras de
control, módulos y control de hardware. No se trata simplemente de memorizar comandos,
sino de entender la lógica detrás de ellos. Aprenderás a pensar de forma algorítmica,
descomponiendo grandes desafíos en pequeñas instrucciones que una computadora puede
ejecutar con precisión matemática.

Este tutorial no requiere que seas un genio de las matemáticas ni que tengas experiencia
previa en computación. Solo necesitas curiosidad, paciencia y ganas de experimentar. La
programación es, en esencia, un arte creativo donde el error no es un fracaso, sino una pista
hacia la solución correcta. Al finalizar este recorrido, no solo habrás escrito tus primeras líneas
de código funcional, sino que habrás adquirido una herramienta transformadora que te abrirá
puertas en cualquier ámbito profesional que te propongas. ¡Es hora de encender el editor de
texto y comenzar a crear!

1
 Tutorial Python
Ing. Juventino Israel García Andrade

¿QUE ES PYTHON?

Python se ha consolidado como el lenguaje de programación más popular del mundo gracias
a su sintaxis clara, legible y cercana al lenguaje humano. A diferencia de otros lenguajes que
requieren estructuras complejas y reglas rígidas desde la primera línea, Python permite que
tanto principiantes como expertos se enfoquen en resolver problemas reales en lugar de luchar
con la complejidad del código. Su versatilidad es asombrosa: desde el desarrollo de
aplicaciones web y la automatización de tareas cotidianas hasta campos avanzados como la
inteligencia artificial, la ciencia de datos y la robótica, Python es la herramienta predilecta de
las empresas líderes en tecnología.

Python fue creado por Guido van Rossum, un programador holandés, a finales de los años 80
y principios de los 90. La primera versión pública de Python, la 0.9.0, fue lanzada en 1991.

Python se diseñó con el objetivo de ser un lenguaje fácil de leer y escribir, con una sintaxis
clara y concisa. A lo largo de los años, ha evolucionado y ganado popularidad hasta convertirse
en uno de los lenguajes de programación más utilizados en el mundo.

Características

Python tiene varias características que lo hacen atractivo tanto para principiantes como para
programadores experimentados:

Legibilidad: Python utiliza una sintaxis clara y sencilla, lo que facilita la lectura y comprensión
del código. Utiliza indentación (espacios o tabulaciones) para delimitar bloques de código, lo
que promueve un estilo de programación estructurado y legible. A diferencia de otros lenguajes
de programación que usan llaves { }.

Tipado dinámico: En Python, no es necesario declarar explícitamente el tipo de datos de las

variables. Python infiere automáticamente el tipo de datos en función del valor asignado a una
variable, lo que simplifica la escritura de código.

Interpretado: Python es un lenguaje interpretado, lo que significa que el código se ejecuta

línea por línea en tiempo real. Esto permite un ciclo de desarrollo rápido y facilita la depuración
del código.

Multiplataforma: Python se puede ejecutar en diferentes sistemas operativos, como Windows,

macOS y Linux, sin necesidad de modificar el código. Esto lo convierte en un lenguaje versátil
y portátil.

2
 Tutorial Python
Ing. Juventino Israel García Andrade

Amplia biblioteca estándar: Python viene con una extensa biblioteca estándar que
proporciona una gran cantidad de módulos y funciones para realizar diversas tareas, como
manipulación de archivos, conexión a bases de datos, procesamiento de texto, entre otros.

Áreas principales

 Desarrollo Web.
Se usa para crear la parte "invisible" de las páginas web (el backend), como el manejo de
usuarios o bases de datos. Los marcos de trabajo más famosos son Django y Flask.
 Ciencia de Datos.
Es el rey en esta área. Sirve para analizar grandes cantidades de información y crear
gráficas. Usa herramientas como Pandas y Matplotlib.
 Inteligencia Artificial.
Python es la base para crear sistemas que "aprenden" solos, como los chats inteligentes o
el reconocimiento de rostros, usando bibliotecas como TensorFlow.
 Automatización.
Sirve para que la computadora haga tareas aburridas por ti, como organizar miles de
archivos, extraer datos de sitios web (scraping) o probar software automáticamente.
 Videojuegos.
Aunque no es para juegos de súper alta resolución como Call of Duty, es excelente para
aprender lógica de videojuegos y crear juegos sencillos con Pygame.

3
 Tutorial Python
Ing. Juventino Israel García Andrade

DESCARGA E INSTALACIÓN DE PYTHON

Visita el sitio web oficial de Python: [Link]

En el apartado de Downloads descarga la versión más actual.

Guarda el instalador en tu PC, en la mayoría de navegadores de internet por predeterminado el archivo

se guarda en la carpeta “Descargas”.

Abre la carpeta donde fue descargado.

Localiza el archivo ejecutable para proceder con la instalación.

4
 Tutorial Python
Ing. Juventino Israel García Andrade

Instalación de Python

- En el sistema Operativo Windows:

1. Ejecuta el instalador: Haz doble clic en el archivo descargado para iniciar la
instalación.

2. Marca la casilla "Add [Link] to PATH": Antes de hacer clic en "Install Now",
Es importante seleccionar que Python se incluya en el path para facilitar la ejecución
de módulos desde consola.

3. Haz clic en "Install Now": Sigue las indicaciones para completar la instalación.
Cuando finalice, puedes hacer clic en "Close".

5
 Tutorial Python
Ing. Juventino Israel García Andrade

De esta forma se ha instalado el intérprete de Python y el IDE simple IDLE, el cual permite
realizar los primeros programas en Python.

Para verificar que la instalación fue un éxito, en Windows busca “Símbolo del sistema” y ejecuta
el siguiente comando: python –version

Al dar “Enter” deberá aparecer la versión instalada en tu equipo.

Con estos pasos tu sistema operativo está listo para comenzar a programar en Python.

6
 Tutorial Python
Ing. Juventino Israel García Andrade

¿CÓMO USAR EL EDITOR IDLE DE PYTHON?

IDLE es el entorno de desarrollo y aprendizaje integrado (Integrated Development and
Learning Environment) básico y gratuito que viene incluido por defecto al instalar Python. Es
ideal para principiantes, ya que ofrece un intérprete interactivo (shell) y un editor de texto con
coloreado de sintaxis, sangría inteligente y depurador.

Primeros pasos con Python IDLE.

En Windows, Abre el menú Inicio y haz clic en Todos los programas o Todas las aplicaciones.
Debería aparecer un icono de programa llamado IDLE (Python 3.14 o versión Instalada). Esto
puede variar ligeramente según la versión de Windows. El IDLE también podría estar en una
carpeta de programa llamada Python 3.14 o la versión que se instaló.

También puedes encontrar el programa IDLE usando la función de búsqueda de Windows en

el menú Inicio y escribiendo IDLE. Haz clic en el icono para iniciar el programa.

7
 Tutorial Python
Ing. Juventino Israel García Andrade

Al abrir IDLE de Python, se abrirá la ventana principal de IDLE, como se muestra en la siguiente
imagen.

La ventana principal de IDLE Shell es siempre el entorno interactivo, es la ventana donde se

ejecutarán los resultados de nuestros programas.

Para crear un nuevo archivo de programa Python con IDLE, abra una nueva ventana mediante
el menú File > New File (o el atajo de teclado Ctrl+N). Al elegir esta opción se abrirá una nueva
ventana como se muestra en la imagen.

Esta ventana blanca es el editor de archivos de Python IDLE, donde comenzaremos a codificar
todos nuestros programas.

8
 Tutorial Python
Ing. Juventino Israel García Andrade

MI PRIMER PROGRAMA EN PYTHON

Es una tradición en el mundo de la programación comenzar con un programa simple llamado

"Hola Mundo". Este programa simplemente muestra el mensaje "Hola Mundo" en la pantalla.
Pasos:

1. Abre el editor de archivos de Python IDLE.

2. En el archivo, escribe el siguiente código: print("¡Hola Mundo!")

3. Dirigirte al Menú Run – Run Module.

4. Aparecerá la siguiente ventana para guardar los cambios. Seleccionar Aceptar.

9
 Tutorial Python
Ing. Juventino Israel García Andrade

5. La primera vez que ejecutes el programa, se te solicitará nombrar el archivo y

seleccionar la carpeta donde deseas almacenarlo.

6. Al hacer clic en Guardar, la consola de Python (IDLE) ejecutará el código y mostrará el

resultado.

Si ves el mensaje “¡Hola Mundo!” en la consola, el programa ha funcionado

correctamente.

¡Felicidades! Has escrito y ejecutado tu primer programa en Python.

10
 Tutorial Python
Ing. Juventino Israel García Andrade

Para mostrar en pantalla el texto en varias líneas, ten en cuenta que la función print() añade,
por defecto, un salto de línea al final de cada ejecución.

Ejemplo:

RESULTADO

Además, tienes dos opciones principales:

1. Carácter de escape \n: Es la forma estándar. Al insertar \n dentro de una cadena, Python
lo interpreta como el fin de una línea y el inicio de otra.

Ejemplo:

RESULTADO

2. Triples comillas (""" o '''): Permiten escribir bloques de texto respetando los saltos de
línea físicos que hagas directamente en el editor.

Ejemplo:

RESULTADO

11
 Tutorial Python
Ing. Juventino Israel García Andrade

VARIABLES EN PYTHON

Las variables son contenedores que nos permiten almacenar y manipular datos en nuestros
programas. Imagina que una variable es una caja donde puedes almacenar un dato numérico,
un decimal, un carácter, o cadenas de texto.

Tipos de datos.

En Python, los tipos de datos básicos son las categorías en las que se pueden clasificar los
valores que utilizamos en nuestros programas. Comprender los diferentes tipos de datos es
fundamental para trabajar con variables y realizar operaciones en Python. Los tipos de datos
básicos incluyen:

Enteros (int). Los números enteros son aquellos que no tienen parte decimal.

Ejemplo: edad = 25

Flotantes (float). Los números flotantes, también conocidos como números de punto flotante,
son aquellos que tienen una parte decimal.

Ejemplo: calificacion = 9.5

Cadenas de texto (strings). Las cadenas de texto, o simplemente cadenas, son secuencias
de caracteres encerradas entre comillas simples ('...') o dobles ("..."). Se utilizan para
representar texto en Python.

Ejemplo: nombre = “Rosario”

Booleanos. Los valores booleanos representan los valores de verdad: True (verdadero) y
False (falso). Se utilizan comúnmente en expresiones condicionales y operaciones lógicas.

Ejemplo: es_de_dia = True

tiene_hambre = False
12
 Tutorial Python
Ing. Juventino Israel García Andrade

En Python, no es necesario declarar explícitamente el tipo de dato de las variables como se

realiza en otros lenguajes. Python infiere automáticamente el tipo de dato en función del valor
asignado a una variable, lo que simplifica la escritura de código.

Declaración de variables con su tipo de dato en otros lenguajes Declaración de variables en Python

Para declarar y asignar un valor a una variable en Python, utilizamos el operador de asignación
=. El nombre de la variable va a la izquierda del operador =, y el valor que deseas asignar va
a la derecha. Para asignar valores como cadenas de texto se debe colocar la frase entre
comillas, cuando se desea asignar valores numéricos, decimales o booleanos estos van sin
comillas. Por ejemplo:

En la imagen anterior, Python automáticamente detecta que la variable nombre tendrá un tipo
de dato (String) que almacena una cadena de texto, la variable edad tendrá un tipo de dato
entero (int), altura tipo de dato decimal (float) y es_estudiante almacena un tipo de dato
booleano (boolean) como verdadero.

La forma de dar valor a una variable se realiza por asignaciones y en Python pueden ser
simples o múltiples.

Asignaciones simples
Edad=10

Asignaciones múltiples
Edad1, Edad2, Edad3 = 14,16,20
a = b = c = 10
nombre1, nombre2 = "Israel", "Alondra"
13
 Tutorial Python
Ing. Juventino Israel García Andrade

Reglas para nombrar una variable.

Para crear una variable existen algunas reglas para nombrarlas y así evitar errores.

 Los nombres de las variables solo pueden contener letras (a-z, A-Z), números (0-9) y
guiones bajos (_). No pueden comenzar con un número.
 Python distingue entre mayúsculas y minúsculas, por lo que nombre y Nombre son
variables diferentes.
 Las variables no pueden tener espacios en sus caracteres o entre palabras.
 No pueden iniciar con un valor numérico, pero si con un guion bajo _
 No se pueden utilizar palabras clave reservadas de Python como nombres de variables
(por ejemplo, if, else, for, while, etc.).
 Se recomienda utilizar nombres descriptivos para las variables, que indiquen claramente
su propósito: nombre, edad, total_ventas, etc.

Ejemplo:

Variables declaradas de forma correcta. ✅ Variables declaradas de forma incorrecta. ❌

nombre1 1nombre (no puede iniciar con valor numérico)
Apellido_paterno Apellido paterno (No puede tener espacios)
_edad if (es una palabra reservada de Python)

Para mostrar en pantalla el contenido de una variable se utiliza la función print()

1. Usando el método básico.

Simplemente pasa el nombre de la variable entre los paréntesis.

RESULTADO

14
 Tutorial Python
Ing. Juventino Israel García Andrade

2. Usando F-Strings (Recomendado).

Es la forma más moderna y limpia de mezclar texto y variables. Solo pon una f antes de las
comillas y la variable entre llaves {}.

RESULTADO

3. Separando con comas.

Es la forma clásica donde todo texto que se desea mostrar en pantalla se coloca en comillas y
se separa de la variable mediante una coma. Recuerda que las variables no llevan comillas
para que el sistema muestre su contenido y no su nombre.

RESULTADO

15
 Tutorial Python
Ing. Juventino Israel García Andrade

PRACTICA:
 Elabora un programa en Python que muestre una lista de 10 variables que almacene
diferentes tipos de datos y muéstralos en pantalla utilizando print(). Coloca el resultado que
se mostraría en la consola.

RESULTADO

16
 Tutorial Python
Ing. Juventino Israel García Andrade

OPERADORES

Los operadores son símbolos especiales que nos permiten realizar operaciones en variables
y valores. Python proporciona diferentes tipos de operadores para realizar operaciones
aritméticas, comparaciones y operaciones lógicas.

Operadores Aritméticos.

Los operadores aritméticos se utilizan para realizar operaciones matemáticas básicas. Los
principales operadores aritméticos en Python son:

Ejemplo:

a=4
b=2

suma = a + b
resta = a - b
multiplicacion = a * b
division = a / b
división_entera = a // b
modulo = a % b
exponenciacion = a ** b

17
 Tutorial Python
Ing. Juventino Israel García Andrade

PRACTICA:
 Del ejemplo del cuadro anterior muestra en pantalla los resultados de cada operación
utilizando print(). Coloca el resultado que se mostraría en la consola.
Ejemplo:

RESULTADO

RESULTADO

18
 Tutorial Python
Ing. Juventino Israel García Andrade

Operadores de comparación.

Los operadores de comparación se utilizan para comparar dos valores y devuelven un valor
booleano (True o False) según el resultado de la comparación. Los operadores de
comparación en Python son:

Ejemplo:

a = 15
b=5

igual = a == b # False
diferente = a != b # True
mayor que = a > b # True
menor que = a < b # False
mayor o igual = a >= b # True
menor o igual = a <= b # False

En Python, estos operadores son fundamentales para la toma de decisiones, ya que permiten
comparar valores y determinar el flujo del programa. Exploraremos este tema con mayor
profundidad más adelante.

19
 Tutorial Python
Ing. Juventino Israel García Andrade

Operadores Lógicos.

Los operadores lógicos se utilizan para combinar expresiones condicionales y evaluar múltiples
condiciones. Los operadores lógicos en Python son:

Ejemplo:

a = 15
b=4

resultado_and = (a > 5) and (b < 5) # True

resultado_or = (a > 15) or (b < 5) # True
resultado_not = not (a > 5) # False

En Python, estos operadores son esenciales para la toma de decisiones que involucra
múltiples condiciones, permitiendo construir lógicas más complejas. Exploraremos este tema
con mayor profundidad más adelante.

20
 Tutorial Python
Ing. Juventino Israel García Andrade

INTERACCIÓN CON EL USUARIO (ENTRADAS)

En Python, la forma principal de recibir datos del usuario es mediante la función input().

Ejemplo:

RESULTADO

Por defecto, input() siempre devuelve una cadena de texto (string), incluso si el usuario escribe
un número, por lo que ese número no servirá para realizar operación aritméticas. Si necesitas
hacer cálculos, debes convertir el dato a un valor numérico:

int() para números enteros.

float() para números con decimales.

Ejemplo: Si el usuario inserta la edad y se desea realizar un cálculo con esa edad insertada,
deberá convertirlo a un valor numérico de la siguiente manera:

RESULTADO

21
 Tutorial Python
Ing. Juventino Israel García Andrade

En el ejemplo anterior, la primera línea solicita la edad del usuario y la almacena como una
cadena de texto en la variable edad, Debido a que input() siempre recibe texto, la segunda
línea utiliza la función int() para convertir ese valor en un número entero, guardándolo en
edadNumerica. Posteriormente, se suman 20 a dicho valor y el resultado se almacena en la
variable resultado, la cual se imprime finalmente en pantalla. Aunque este es el proceso paso
a paso, Python permite optimizar el código mediante la anidación, colocando la función input()
directamente dentro de int().

Ejemplo: De esta forma, optimizamos el código reduciendo el uso de variables intermedias.

Aunque el proceso puede comprimirse en una sola línea, no se recomienda abusar de esta
práctica, ya que puede dificultar la comprensión del código para los programadores.

Ejemplo:

22
 Tutorial Python
Ing. Juventino Israel García Andrade

EJERCICIOS CON OPERADORES ARITMÉTICOS

En el siguiente ejemplo, se muestra un programa diseñado para sumar dos números. El

sistema solicita al usuario el ingreso de ambos valores, tras procesar la operación, despliega
el resultado final de forma clara en la pantalla.

RESULTADO

23
 Tutorial Python
Ing. Juventino Israel García Andrade

En el siguiente ejemplo, se muestra un programa diseñado para calcular el área de un

triángulo. El sistema solicita al usuario que ingrese la base y la altura, ya que son los datos
que se requieren para obtener el área, tras procesar la operación, despliega el resultado final
de forma clara en la pantalla.

RESULTADO

24
 Tutorial Python
Ing. Juventino Israel García Andrade

PRACTICA:
 Elabora un programa en Python para obtener el promedio académico de cinco asignaturas.
El programa solicita al usuario que inserte cada una de las calificaciones. Coloca el
resultado que se mostraría en la consola.

RESULTADO

25
 Tutorial Python
Ing. Juventino Israel García Andrade

FUNCIONES MATEMÁTICAS

En Python, el manejo de funciones matemáticas se divide principalmente en tres categorías:

operadores básicos, funciones integradas (built-in) y el módulo especializado math.

1. Operadores Aritméticos Básicos.

Son los símbolos fundamentales para realizar cálculos rápidos sin necesidad de importar
librerías adicionales:

 Suma (+) y Resta (-).

 Multiplicación (*) y División (/) (siempre devuelve un número flotante).
 División Entera (//): Devuelve solo la parte entera del cociente.
 Módulo (%): Devuelve el residuo de una división.
 Exponente (**): Eleva un número a la potencia de otro.

2. Funciones Integradas (Built-in Functions).

Python incluye funciones directas que no requieren ninguna importación previa:

 abs(x): Calcula el valor absoluto de un número.

 round(x, n): Redondea un número real x a n decimales.
 pow(base, exp): Equivalente a base ** exp.
 max(x) y min(x): Encuentran el valor máximo o mínimo en una serie de números.
 sum(x): Suma los elementos de una lista o iterable.
 len(x): Sirve para contar elementos.

3. El Módulo math.

Se utiliza para cálculos más avanzados (trigonometría, logaritmos, constantes), permite

realizar operaciones matemáticas avanzadas que no se pueden hacer con los operadores
básicos, para utilizarlo se debe importar el módulo math mediante “import math”.

26
 Tutorial Python
Ing. Juventino Israel García Andrade

FUNCIONES DEL MÓDULO MATH.

27
 Tutorial Python
Ing. Juventino Israel García Andrade

Ejemplo: Cómo obtener la raíz cuadrada de un número.

Este programa solicita un número al usuario y utiliza la función [Link]() para calcular su raíz
cuadrada. Para que esta función sea accesible, es necesario importar previamente el módulo
math. Una vez realizado el cálculo, el sistema muestra el resultado final en pantalla.

RESULTADO

28
 Tutorial Python
Ing. Juventino Israel García Andrade

PRACTICA:
 Desarrolla un programa en Python que calcule la hipotenusa de un triángulo rectángulo. El
sistema debe solicitar al usuario las medidas del cateto opuesto y del cateto adyacente,
realizar el cálculo correspondiente y mostrar el resultado final en la consola.

Antes de iniciar la codificación, es fundamental comprender el procedimiento matemático. Para

resolver este problema, seguiremos los siguientes pasos:

1. Elevar al cuadrado el valor del cateto opuesto.

2. Elevar al cuadrado el valor del cateto adyacente.
3. Sumar los resultados.
4. Sacar raíz de la suma.

Ejemplo: si el usuario coloca el en cateto opuesto el valor de 4 y en el cateto adyacente el valor

de 3.

1. 42 = 16
2. 32 = 9
3. 16 + 9 = 25
4. √25 = 5

Codifica el problema utilizando las funciones necesarias para su correcta solución.

29
 Tutorial Python
Ing. Juventino Israel García Andrade

RESULTADO

30
 Tutorial Python
Ing. Juventino Israel García Andrade

ESTRUCTURAS DE CONTROL

Las estructuras de control son herramientas que te permiten romper la lectura lineal de un
código. En lugar de que Python lea todo de arriba abajo, estas estructuras deciden qué partes
se ejecutan y cuántas veces.

Se dividen principalmente en dos tipos:

1. Estructuras Condicionales (Toma de Decisiones).

2. Estructuras Iterativas (Bucles).

ESTRUCTURAS CONDICIONALES (TOMA DE DECISIONES)

Sirven para ejecutar un bloque de código solo si se cumple una condición.

if: Ejecuta el código si la condición es verdadera.

elif: (Abreviatura de else if) Se usa para evaluar una segunda condición si la primera falló.
else: Se ejecuta cuando ninguna de las condiciones anteriores fue verdadera.

La estructura if se compone de tres elementos principales: la variable, el operador de

comparación y el valor o dato a comparar.

Ejemplo:

En el ejemplo anterior la estructura if se compone de:

Variable: edad
Operador: >= (mayor o igual que)
Dato: 18
Finalizando con dos puntos (:)
31
 Tutorial Python
Ing. Juventino Israel García Andrade

¿Cómo funciona?

Si se cumple la condición (la edad es 18 o más), el programa ejecuta el bloque de código bajo
el if y muestra: "Eres mayor de edad". De lo contrario (else), se ejecuta la instrucción
alternativa y muestra: "Eres menor de edad".

En Python, la indentación (o sangría) no es solo una cuestión de orden o estética; es una regla
sintáctica obligatoria.

A diferencia de otros lenguajes (como C++, Java o JavaScript) que usan llaves { } para delimitar
dónde empieza y termina un bloque de código, Python utiliza espacios en blanco. La
indentación le dice al intérprete: "Todo lo que tenga este mismo nivel de espacio pertenece a
este if".

En Python, la indentación es el espacio en

blanco que se deja al principio de una línea de
código para indicar que esa instrucción
pertenece a un bloque específico (como un if,
un for o una función).

La palabra clave elif es una abreviatura de "else if". Se utiliza en Python para encadenar
múltiples condiciones de forma secuencial dentro de una misma estructura de control.

¿Para qué sirve exactamente?

Evalúa condiciones en orden, Python revisa la condición del if inicial. Si es falsa, pasa al primer
elif; si esa también es falsa, pasa al siguiente, y así sucesivamente. En cuanto el programa
encuentra un elif cuya condición sea verdadera, ejecuta su bloque de código y salta el resto
de las condiciones (elif o else posteriores).

32
 Tutorial Python
Ing. Juventino Israel García Andrade

Ejemplo:

RESULTADO

33
 Tutorial Python
Ing. Juventino Israel García Andrade

PRACTICA:
 Elabora un programa en Python que determina el nivel de batería de un celular y envía una
alerta, el usuario inserta un valor entero de 0 a 100. Si la cantidad insertada es 100 mostrar
el mensaje “Carga completa”, si la cantidad es mayor o igual a 40 mostrar “Batería
normal”, si la cantidad es mayor a 10 mostrar “Batería baja: Conecte el cargador”, si es
mayor a 0 mostrar “Atería crítica: El teléfono se apagará pronto” de lo contrario mostrar
el mensaje “Teléfono apagado”.

RESULTADO

34
 Tutorial Python
Ing. Juventino Israel García Andrade

Operadores lógicos en un if.

Para usar operadores lógicos en un if, combinamos dos o más condiciones en una sola línea.
Los más usados en Python son and, or y not.

1. Operador and (Y).

Ambas condiciones deben ser verdaderas para que se ejecute el código.

Ejemplo: Para entrar a una montaña rusa debes medir más de 1.40m Y tener más de 10 años.
RESULTADO

En el primer ejemplo, el usuario ingresa una altura de 1.60 m y una edad de 11 años. Como
cumple con ambas condiciones, aparece el mensaje: '¡Puedes subir a la atracción!'. En la
segunda prueba, aunque el usuario tiene 18 años, su altura es de solo 1.30 m; al no alcanzar
el mínimo requerido, el sistema muestra: 'No cumples con los requisitos de seguridad'.
35
 Tutorial Python
Ing. Juventino Israel García Andrade

PRACTICA:
 Elabora un programa en Python que solicite un nombre de usuario y una contraseña. Si
ambos datos son correctos, debe mostrar el mensaje: 'Datos correctos, bienvenido'; de
lo contrario, debe mostrar: 'Intenta nuevamente'.

RESULTADO

36
 Tutorial Python
Ing. Juventino Israel García Andrade

2. Operador or (O).

El operador lógico or funciona de forma opuesta al and: la condición es verdadera si al menos

una de las partes se cumple. Solo es falso si todas las condiciones fallan.

Ejemplo: Una persona recibe un descuento si es estudiante O si es mayor de 60 años.

RESULTADO

El método .lower() se usa para

convertir cualquier texto
(string) a letras minúsculas.

En el primer ejemplo, el usuario indica que es estudiante, pero tiene 40 años. Aunque no
cumple la condición de edad, se muestra el mensaje '¡Felicidades! Tienes derecho al
descuento' porque basta con ser estudiante. En la segunda prueba, el usuario no es
estudiante y tiene 50 años; al no cumplirse ninguna de las dos condiciones, aparece: 'Lo
sentimos, debes pagar el precio completo'.

37
 Tutorial Python
Ing. Juventino Israel García Andrade

PRACTICA:
 Elabora un programa en Python que pregunte qué día es hoy. Si el usuario ingresa 'sábado'
o 'domingo', el sistema debe mostrar: '¡A descansar! Es fin de semana'. Para cualquier
otro día, debe mostrar: 'A trabajar, aún es día de semana'.

RESULTADO

38
 Tutorial Python
Ing. Juventino Israel García Andrade

3. Operador not (NO).

Invierte el valor lógico (lo que es verdadero lo hace falso y viceversa).

Ejemplo: Si el sistema NO está bloqueado, puedes entrar.

RESULTADO

RESULTADO

Este código muestra cómo funciona el operador lógico not para invertir un valor booleano (True
o False). Es como un interruptor: si algo es falso, el not lo vuelve verdadero.

En el primer ejemplo el estado de la variable dice que el sistema no está bloqueado (False).
La condición: if not devuelve (True) mostrando el mensaje “Acceso permitido.”.

En el segundo ejemplo el estado de la variable dice que el sistema sí está bloqueado (True).
La condición: if not devuelve (False) mostrando el mensaje “Acceso denegado.”.

39
 Tutorial Python
Ing. Juventino Israel García Andrade

ESTRUCTURAS ITERATIVAS (BUCLES)

Sirven para repetir una tarea varias veces sin escribir el código una y otra vez.

En Python, los bucles más comunes son for y while:

for: Se usa para indicar cuantas veces repetir algo (recorrer una lista, un rango de números,
etc.).
while: Repite el código mientras una condición sea verdadera. Es útil cuando no sabes cuántas
vueltas dará el ciclo.

Ciclo for.

El ciclo for (o bucle para) es una estructura de control en programación que se utiliza para
repetir un bloque de instrucciones un número determinado de veces. Su principal ventaja es
que permite automatizar tareas repetitivas de forma eficiente, especialmente cuando ya sabes
de antemano cuántas veces necesitas que se ejecute la acción.

La sintaxis básica es la siguiente:

for variable in secuencia:

instrucciones

Dentro del ciclo for, la variable i comienza desde 0. Con cada vuelta o iteración, el valor
aumenta y se imprime el mensaje 'HOLA'. El proceso se detiene cuando se alcanza el límite
establecido en el rango.

También es posible definir el valor inicial del ciclo y realizar las iteraciones correspondientes
hasta alcanzar el límite final.

RESULTADO

40
 Tutorial Python
Ing. Juventino Israel García Andrade

Ejemplo: mostrar los números del 0 al 5.

RESULTADO

En el ejemplo anterior se muestra un ciclo que incrementa la variable i en cada iteración. El

proceso finaliza automáticamente al alcanzar el límite definido en el rango. Sin este ciclo, el
programador tendría que escribir una instrucción para imprimir cada número de forma manual.
Ejemplo: mostrar los números del 0 al número que indique el usuario.

RESULTADO

En el ejemplo anterior se muestra un ciclo que incrementa la variable i en cada iteración. El

proceso finaliza automáticamente al alcanzar el límite definido por el usuario. A la variable
límite se le suma 1 para que el ciclo sea inclusivo y muestre el valor final, ya que en Python el
rango termina una unidad antes del número indicado puesto que arranca desde el valor 0.

41
 Tutorial Python
Ing. Juventino Israel García Andrade

Ciclo While.

El bucle while se utiliza para repetir un bloque de código mientras una condición sea verdadera.

La sintaxis básica es la siguiente:

variable_control = valor_inicial
while variable_control < valor_limite:
Bloque de instrucciones
Actualización

Ejemplo: mostrar los números del 0 al 5.

RESULTADO

La estructura del ciclo while se compone de los siguientes elementos fundamentales:

Inicialización: contador = 0 define el punto de partida del ciclo.

Condición: Se conforma por la variable de control (contador), un operador de comparación

(<=) y un valor límite (5), finalizando siempre con dos puntos (:).

Actualización: Es indispensable incrementar manualmente la variable en cada iteración

mediante contador += 1 (que equivale a contador = contador + 1). Esto permite que el ciclo
avance y evita que se vuelva infinito.

Para crear un ciclo infinito en Python se puede utilizar while True, Como la condición siempre
es True (verdadera), el código dentro del ciclo se ejecutará para siempre, a menos que se
incluya una instrucción para salir.

42
 Tutorial Python
Ing. Juventino Israel García Andrade

Ejemplo:

RESULTADO

Para evitar que el programa entre en un bucle infinito y se bloquee, se utiliza la sentencia de
control break. Esta instrucción permite finalizar la ejecución del ciclo inmediatamente cuando
se cumple una condición específica dentro del bloque de código.

Ejemplo:

RESULTADO

El programa se ejecutará de forma indefinida hasta que contador sea igual a 8.

RESULTADO

El programa se ejecutará de forma indefinida hasta que el usuario introduzca la palabra 'salir',
lo que activa la sentencia break y finaliza el ciclo.

43
 Tutorial Python
Ing. Juventino Israel García Andrade

PRACTICA:
 Elabora un programa en Python que muestre los números del 1 al 10 de tres formas
distintas: utilizando un ciclo for, un ciclo while y la estructura while True con su respectiva
interrupción.

RESULTADO

44
 Tutorial Python
Ing. Juventino Israel García Andrade

ESTRUCTURAS DE DATOS

Las estructuras de datos nos permiten organizar y almacenar datos de manera eficiente en
nuestros programas. Python proporciona varias estructuras de datos integradas, como listas,
tuplas, diccionarios y conjuntos, cada una con sus propias características y usos.

Listas.

Una lista es una estructura de datos mutable y ordenada que permite almacenar una colección
de elementos. Los elementos de una lista pueden ser de diferentes tipos de datos y se
encierran entre corchetes [ ], separados por comas.

Para crear una lista, simplemente encierra los elementos entre corchetes:

nombres = ["Israel", "Rosario", "Alondra"]

Para acceder a los elementos de una lista, utiliza el índice del elemento entre corchetes. Los
índices comienzan desde 0.

print(nombres [0]) # Imprime "Israel"

print(nombres [1]) # Imprime "Rosario"
print(nombres [2]) # Imprime "Alondra"

También puedes acceder a los elementos desde el final de la lista utilizando índices negativos.
El índice -1 representa el último elemento, -2 representa el penúltimo, y así sucesivamente.

print(nombres [-1]) # Imprime "Alondra"

print(nombres [-2]) # Imprime "Rosario"
print(nombres [-3]) # Imprime "Israel"

Ejemplo:

RESULTADO

45
 Tutorial Python
Ing. Juventino Israel García Andrade

RESULTADO

Métodos de listas.

Las listas en Python tienen varios métodos incorporados que nos permiten manipular y
modificar los elementos de la lista. Algunos métodos comunes son:

 append(elemento): agrega un elemento al final de la lista.

 insert(indice, elemento): inserta un elemento en una posición específica de la lista.
 remove(elemento): elimina la primera aparición de un elemento en la lista.
 pop(indice): elimina y devuelve el elemento en una posición específica de la lista.
 sort(): ordena los elementos de la lista en orden ascendente.
 reverse(): invierte el orden de los elementos en la lista.

Ejemplo:

nombres = ["Israel", "Rosario", "Alondra"]

[Link]("Juventino")
print(nombres) # Imprime ['Israel', 'Rosario', 'Alondra', 'Juventino']

[Link](1, "María")
print(nombres) # Imprime ['Israel', 'María', 'Rosario', 'Alondra', 'Juventino']

[Link]("Israel")
print(nombres) # Imprime ['María', 'Rosario', 'Alondra', 'Juventino']

nombres_eliminados = [Link](2)
print(nombres) # Imprime ['María', 'Rosario', 'Juventino']
print(nombres_eliminados) # Imprime Alondra

[Link]()
print(nombres) # Imprime ['Juventino', 'María', 'Rosario']

[Link]()
print(nombres) # Imprime ['Rosario', 'María', 'Juventino']

46
 Tutorial Python
Ing. Juventino Israel García Andrade

Tuplas.

En Python, una tupla es una estructura de datos diseñada para almacenar colecciones de
elementos de forma ordenada e inmutable. Su sintaxis se define mediante el uso de paréntesis
( ), dentro de los cuales los elementos se organizan separados por comas.

Para crear una tupla, se encierran los elementos entre paréntesis:

edad = (15, 30)

print(edad [0]) # Imprime 15

print(edad [1]) # Imprime 30

A diferencia de las listas, las tuplas son inmutables, lo que significa que no se pueden modificar
una vez creadas. No se pueden agregar, eliminar o cambiar elementos en una tupla.
existente.

Diccionarios.

Un diccionario es una estructura de datos mutable y no ordenada que permite almacenar pares
de clave-valor. Cada elemento en un diccionario consiste en una clave única y su valor
correspondiente. Los diccionarios se encierran entre llaves {}, y los pares clave-valor se
separan por comas.

Para crear un diccionario, utiliza llaves y separa las claves y valores con dos puntos.

persona1 = {"nombre": "Israel", "edad": 40, "ciudad": "México"}

persona2 = {"nombre": "María", "edad": 33, "ciudad": "Coahula"}

Para acceder a los valores de un diccionario, utiliza la clave correspondiente entre corchetes:

print(persona1["nombre"]) # Imprime "Israel"

print(persona2["edad"]) # Imprime 33
print(persona1["ciudad"]) # Imprime "México"
print(persona2["nombre"]) # Imprime "María"

47
 Tutorial Python
Ing. Juventino Israel García Andrade

Métodos de diccionarios.

Los diccionarios en Python tienen varios métodos incorporados para manipular y acceder a los
elementos. Algunos métodos comunes son:

keys(): devuelve una vista de todas las claves del diccionario.

values(): devuelve una vista de todos los valores del diccionario.
items(): devuelve una vista de todos los pares clave-valor del diccionario.
update(otro_diccionario): actualiza el diccionario con los pares clave-valor de otro
diccionario.

Ejemplo:

persona1 = {"nombre": "Israel", "edad": 40, "ciudad": "México"}

print([Link]()) # Imprime dict_keys(['nombre', 'edad', 'ciudad'])

print([Link]()) # Imprime dict_values(['Israel', 40, 'México'])
print([Link]()) # Imprime dict_items([('nombre', 'Israel'), ('edad', 40), ('ciudad', 'México')])
[Link]({"profesion": "Ingeniero"})
print(persona1) # Imprime {'nombre': 'Israel', 'edad': 11, 'ciudad': 'México', 'profesion': 'Ingeniero'}
RESULTADO

48
 Tutorial Python
Ing. Juventino Israel García Andrade

Conjuntos.

Un conjunto es una estructura de datos mutable y desordenada diseñada para almacenar

elementos únicos. En Python, se definen utilizando llaves { } o mediante el constructor set( ).

diagrama de Venn

Usando llaves:
frutas = {"manzana", "naranja", "plátano", "uva"}
print(frutas)

Usando el constructor set():

numeros = set([1,2,3,4,5,6,7])
print(numeros)

Los conjuntos admiten operaciones matemáticas de conjuntos, como la unión (|), la

intersección (&), la diferencia (-) y la diferencia simétrica (^).

EJEMPLO:

conjunto1 = {1,3,5,7,9}
conjunto2 = {3,5,7,2}

union = conjunto1 | conjunto2

print(union) # Imprime {1, 2, 3, 5, 7, 9}

49
 Tutorial Python
Ing. Juventino Israel García Andrade

interseccion = conjunto1 & conjunto2

print(interseccion) # Imprime {3, 5, 7}

diferencia = conjunto1 - conjunto2

print(diferencia) # Imprime {1, 9}

diferencia_simetrica = conjunto1 ^ conjunto2

print(diferencia_simetrica) # Imprime {1, 2, 9}

Métodos de conjuntos.

Los conjuntos en Python tienen varios métodos incorporados para manipular y acceder a los
elementos. Algunos métodos comunes son:

add(elemento): agrega un elemento al conjunto.

remove(elemento): elimina un elemento del conjunto. Si el elemento no existe, genera un error.
discard(elemento): elimina un elemento del conjunto si está presente. Si el elemento no existe, no
hace nada.
clear(): elimina todos los elementos del conjunto.

Ejemplo:

frutas = {"manzana", "naranja", "plátano", "uva"}

[Link]("fresa")
print(frutas) # Imprime {'plátano', 'manzana', 'fresa', 'naranja', 'uva'}

[Link]("naranja")
print(frutas) # Imprime {'pera', 'plátano', 'manzana', 'uva'}

[Link]("uva")
print(frutas) # Imprime {'plátano', 'manzana', 'pera'}

[Link]()
print(frutas) # Imprime set()
50
 Tutorial Python
Ing. Juventino Israel García Andrade

PRACTICA:
 Elabora un programa en Python que muestre los resultados de las operaciones de unión,
intersección, diferencia y diferencia simétrica entre los conjuntos representados en el
siguiente diagrama de Venn.

RESULTADO

51
 Tutorial Python
Ing. Juventino Israel García Andrade

FUNCIONES
Una función en Python es un bloque de código reutilizable que solo se ejecuta cuando se le
llama. Su objetivo principal es agrupar tareas específicas para evitar repetir código y hacer que
los programas sean más organizados y fáciles de entender.

¿Cómo definir y llamar a una función?

Para definir una función se utiliza los siguientes componentes de la sintaxis:

def: Indica que estás iniciando una definición de función.

nombre_de_la_funcion: Debe ser descriptivo, en minúsculas, no usar espacios entre
palabras en su lugar usar guiones bajos, no iniciar con valores numéricos.
Parentesis (): Dentro de ellos se colocan los parámetros (variables locales que recibirán los
datos). Si hay varios, se separan por comas.
Dos puntos : “:” Obligatorios al final de la línea de definición.
Indentación (Sangría): Todo el código que pertenece a la función debe estar desplazado a la
derecha (normalmente 4 espacios).
return: Palabra clave para enviar un resultado de vuelta al lugar donde se llamó la función.

Sintaxis:

def mi_funcion(parametro1,parametro2):
contenido de la función

Funciones sin argumentos:

Las funciones sin argumentos son aquellas que no necesitan recibir ningún dato externo para
realizar su tarea. Se definen con los paréntesis vacíos () y siempre ejecutan la misma lógica
interna cada vez que las llamas.

Al nombrar una función en Python, al igual que con las variables, es fundamental seguir las
reglas de sintaxis: los nombres no deben contener espacios ni comenzar con valores
numéricos, entre otras restricciones.

52
 Tutorial Python
Ing. Juventino Israel García Andrade

Ejemplo:

RESULTADO

En el ejemplo anterior, se define la función saludar() sin argumentos. Su estructura incluye la

instrucción print, que muestra en pantalla el mensaje '¡Hola, mundo!'. Finalmente, se invoca la
función por su nombre para ejecutar el código. Cabe destacar la importancia de respetar la
indentación para que el programa funcione correctamente.

Ejemplo 2:

RESULTADO

En este segundo ejemplo, se crean las funciones edad y sumar2numeros. Aunque ambas
están declaradas, el programa solo ejecuta sumar2numeros() porque es la única que ha sido
llamada. Por esta razón, el programa comienza directamente con la solicitud de los números.

53
 Tutorial Python
Ing. Juventino Israel García Andrade

Imagina que cada función es una cápsula con un nombre propio que guarda código en su
interior. El programador solo tiene que llamar a la cápsula que necesita en cada momento; esto
permite reutilizar código y mantener el proyecto mucho más limpio y ordenado.

Funciones con parámetros y argumentos:

Las funciones con argumentos son aquellas que necesitan recibir información externa para
poder trabajar.

Para definir una función con argumentos en Python, se utiliza la palabra clave def seguida del
nombre de la función y los nombres de los parámetros entre paréntesis.

Sintaxis:

def mi_funcion(parametro1,parametro2, …):

contenido de la función
valores a enviar

Los argumentos son los valores específicos que se envían a la función al momento de
invocarla.

Ejemplo con un solo argumento:

RESULTADO

54
 Tutorial Python
Ing. Juventino Israel García Andrade

En el ejemplo anterior, la función se define con el parámetro nombre. Esto indica que la función
requiere un dato externo para procesar la información, el cual se proporciona mediante un
argumento al momento de invocarla.

Ese valor específico que le enviamos al llamarla es lo que conocemos como argumento.

Ejemplo 2 con un solo argumento:

RESULTADO

En este ejemplo, se solicita al usuario que ingrese su nombre. Dicho valor se almacena en la
variable minombre para, posteriormente, ser enviado como argumento al invocar la función
saludar.

Valores de retorno (return).

Los valores de retorno sirven para que una función pueda "devolver" el resultado de su trabajo
al lugar donde fue llamada. Sin un retorno, la función realiza una tarea (como imprimir algo),
pero el resto de tu programa no puede usar el dato que generó.

Las funciones pueden devolver valores utilizando la palabra clave return.

Sintaxis:
def mi_funcion(parametro1,parametro2, …):
contenido de la función
return dato que se devuelve.

55
 Tutorial Python
Ing. Juventino Israel García Andrade

Ejemplo:

RESULTADO

En el ejemplo anterior, la función se define con los parámetros a y b realizando un proceso de

suma, donde el resultado lo retorna en la variable c para que pueda ser aprovechado fuera de
la función. Al llamarla con los valores 8 y 9, el dato devuelto (variable c) se asigna a la variable
resultado, la cual se muestra finalmente en la consola.

Ejemplo 2:

RESULTADO

En este ejemplo, el programa solicita al usuario que ingrese dos valores mediante la consola.
Estos datos se pasan como argumentos al invocar la función suma. La función procesa la
adición y retorna el valor de la variable c, permitiendo que el resultado se almacene
externamente en la variable resultado para su posterior impresión.

56
 Tutorial Python
Ing. Juventino Israel García Andrade

Ejemplo 3:

En este ejemplo, se envían cinco calificaciones a la función promedio. Normalmente, para

procesar esta cantidad de datos, habríamos tenido que definir una función con cinco
parámetros individuales.

def promedio(a,b,c,d,e):

El asterisco (*) en el parámetro calificaciones, indica que la función puede recibir una cantidad
arbitraria de argumentos. Sin importar si se pasan 2, 10 o 100 valores, Python los agrupa
automáticamente en una tupla denominada calificaciones. Esto elimina la rigidez de tener que
predefinir un número exacto de parámetros (como def promedio(a, b, c, d, e)), otorgando total
flexibilidad a la función.

57
 Tutorial Python
Ing. Juventino Israel García Andrade

Función lambda.

Una función lambda en Python (también conocida como función anónima) es una función
pequeña que se define sin nombre y en una sola línea de código. A diferencia de las funciones
normales que usan def, las lambdas están diseñadas para tareas sencillas y rápidas que no
requieren una estructura compleja.

Sintaxis:

Se utiliza la palabra clave lambda, seguida de los argumentos y una expresión:

lambda argumentos: expresión

Así es como se define una función estándar para sumar dos números:

def suma(a, b):

return a + b

utilizando lambda:

suma = lambda a, b: a + b

Desglose de la función Lambda:

suma: Es el Identificador (el nombre que le damos a la función).

lambda a, b: Indica que es una función lambda y que toma los Argumentos 'a' y 'b'.
a + b: Es la Expresión que se ejecuta y cuyo resultado se devuelve.

58
 Tutorial Python
Ing. Juventino Israel García Andrade

Ejemplo:

RESULTADO

PRACTICA:
 Elabora un programa en Python que presente un menú interactivo con cinco opciones para
resolver diversos problemas matemáticos. El sistema deberá invocar la función
correspondiente según la selección del usuario, empleando estructuras de control de
decisión. Para los problemas planteados, es obligatorio implementar y poner en práctica
los distintos tipos de funciones estudiados: sin argumentos, con argumentos y expresiones
lambda.

Ejemplo:

59
 Tutorial Python
Ing. Juventino Israel García Andrade

RESULTADO

60
 Tutorial Python
Ing. Juventino Israel García Andrade

UTILIZAR VARIABLES LOCALES Y GLOBALES

Las variables definidas dentro de una función tienen un alcance local, lo que significa que solo
son accesibles dentro de la función. Por otro lado, las variables definidas fuera de cualquier
función tienen un alcance global y pueden ser accedidas desde cualquier parte del programa.

Ejemplo:

RESULTADO

En este ejemplo, la variable local solo es accesible dentro de su propia función; intentar
utilizarla en otros bloques de código provocaría un error. Por el contrario, cuando se requiere
que un dato esté disponible en múltiples funciones o en el cuerpo principal del programa, lo
correcto es definir una variable global.

PRACTICA:
 Elabora un programa en Python que implemente el uso de variables locales y globales para
la resolución de un problema específico.

RESULTADO

61
 Tutorial Python
Ing. Juventino Israel García Andrade

LECTURA Y ESCRITURA DE ARCHIVOS

Python nos permite leer y escribir datos en archivos externos. Podemos abrir archivos en
diferentes modos, como lectura ("r"), escritura ("w") o anexar ("a"), y realizar operaciones de
lectura y escritura.

Lectura de archivos.

Para leer el contenido de un archivo, asegúrate de que este se encuentre en el mismo directorio que el
archivo de Python; de lo contrario, deberá especificar la ruta completa de donde se encuentra. Primero
debemos abrirlo utilizando la función open() en modo de lectura ("r"). Luego, podemos leer el contenido
del archivo utilizando métodos como read() o readlines().

Ejemplo:

RESULTADO

Escritura de archivos.

Para escribir datos en un archivo, lo abrimos en modo de escritura ("w") utilizando la función
open(). Si el archivo no existe, se creará automáticamente. Si el archivo ya existe, su contenido
se sobrescribirá.

RESULTADO

62
 Tutorial Python
Ing. Juventino Israel García Andrade

Sin embargo, sobre escribe la información anterior. Para agregar información a un archivo sin borrar lo
que ya contiene, se debe cambiar el modo de apertura de la función open(). En lugar de usar el modo
de lectura ("r") o el de escritura convencional ("w", que sobrescribe todo), debes usar el modo Append
(Anexar), representado por la letra "a".

RESULTADO

También puedes utilizar la declaración with para manejar la apertura y cierre de archivos de manera
automática.
RESULTADO

Se recomienda usar
encoding="utf-8" para evitar
problemas con acentos.

pa

En este ejemplo, el archivo se gestiona mediante la declaración with, la cual garantiza el cierre
automático del flujo de datos al finalizar el bloque de código. Esta práctica es fundamental, ya
que asegura la integridad del archivo incluso si ocurre una excepción o error durante la
ejecución.

63
 Tutorial Python
Ing. Juventino Israel García Andrade

PRACTICA:
 Elabora un programa en Python que permita leer un [Link] que contenga una lista de
10 nombres. Posteriormente, implemente la función de escritura para anexar 5 nombres
adicionales al final del documento, asegurando la integridad de los datos previos.

RESULTADO

64
 Tutorial Python
Ing. Juventino Israel García Andrade

MÓDULOS

En Python, un módulo es simplemente un archivo con extensión .py que contiene código
(funciones, variables o clases) diseñado para ser reutilizado en otros programas.

La biblioteca estándar de Python incluye una vasta colección de módulos con funciones y
clases listas para usar. Por ejemplo, el módulo random permite generar valores aleatorios y
datetime permite gestionar fechas de forma sencilla:

RESULTADO

65
 Tutorial Python
Ing. Juventino Israel García Andrade

Módulo os.

El módulo os de Python es una herramienta de la biblioteca estándar que permite interactuar

con el sistema operativo de manera portátil.

Para utilizarlo se requiere importar el módulo “import os” y así, poder utilizar las funciones que
nos permitirán comunicarnos directamente con el sistema operativo.

Ejemplo: Crear un programa que muestre un menú de opciones que permita abrir las
siguientes aplicaciones de Windows: Bloc de Notas, Calculadora, Paint.

RESULTADO

66
 Tutorial Python
Ing. Juventino Israel García Andrade

En programas de consola podemos utilizar [Link]("pause") esto permite esperar a que

presiones una tecla y así la aplicación no se cierre automáticamente.

Ejemplo:

RESULTADO

Mantiene la ventana abierta hasta que presiones una tecla.

Tabla con algunos de los comandos más útiles de la terminal (CMD) de Windows:

No. COMANDO DESCRIPCIÓN

1 CALC Abre la calculadora de Windows
2 NOTEPAD Abre el bloc de notas de Windows
3 MSPAINT Abre Paint de Windows
4 CHARMAP Abre el mapa de caracteres de Windows
5 CLEANMGR Liberar memoria
6 SHUTDOWN /S /T 15 Apaga Windows en un tiempo de 15segundos
7 SHUTDOWN /R /T 8 Reinicia Windows en un tiempo de 8 segundos
8 SHUTDOWN /L Cierra Sesión
9 SHUTDOWN /A Cancela un proceso de apagado o reinicio
10 EXPLORER Abre el explorador de Windows
11 MAGNIFY Abre la Lupa de Windows

Estos son solo algunos ejemplos del potencial de la biblioteca estándar. Para explorar todas
las herramientas disponibles, te recomendamos consultar la documentación oficial de Python.

67
 Tutorial Python
Ing. Juventino Israel García Andrade

PRACTICA:
 Elabora un programa en Python que implemente un menú interactivo. Este debe permitir al
usuario seleccionar y ejecutar, mediante el módulo os, al menos 7 comandos de Windows
extraídos de la tabla de referencia proporcionada anteriormente.

RESULTADO

68
 Tutorial Python
Ing. Juventino Israel García Andrade

Creación de módulos propios.

Para crear un módulo personalizado, basta con generar un nuevo archivo Python con el nombre
deseado y definir en él las funciones, clases y variables necesarias.

Ejemplo:

En una carpeta de Windows creamos nuestro primer módulo llamado modulo_operaciones.py con
las siguientes funciones:

Posteriormente, lo ejecutamos para verificar que no existan errores y sean guardados los cambios. En
la imagen de consola no se muestra nada puesto que ninguna función es mandada a llamar.

Luego, podemos importar y utilizar las funciones definidas en “modulo_operaciones.py” en otro

archivo Python. Creamos un nuevo archivo con el siguiente contenido:

RESULTADO

69
 Tutorial Python
Ing. Juventino Israel García Andrade

En este ejemplo, la primera línea importa el módulo “modulo_operaciones”, permitiendo acceder a

todas sus funciones. Tras mostrar un mensaje de bienvenida, se invocan las funciones suma y
multiplicacion enviando los argumentos (6, 4). Los valores retornados se almacenan en las variables
result_sum y result_multip, para finalmente desplegar los resultados en la consola.

Para este ejemplo utilizamos dos archivos: el módulo que contiene las funciones (modulo_operaciones)
y el archivo principal desde donde se invocan.

Paquetes.

Un paquete es una forma de organizar módulos relacionados en una estructura jerárquica de

directorios. Los paquetes nos permiten agrupar módulos relacionados y evitar conflictos de
nombres entre módulos.

Crear y utilizar paquetes.

Para crear un paquete, se crea un directorio con el nombre deseado por ejemplo (mi_paquete)
y un archivo especial llamado __init__.py dentro del directorio. Este archivo puede estar vacío
o contener código de inicialización del paquete.

La siguiente imagen muestra la estructura de directorios y archivos típica de un proyecto de

programación en Python, organizado como un paquete.

70
 Tutorial Python
Ing. Juventino Israel García Andrade

Explicación de los directorios y archivos:

1. Directorio Raíz (MI PROYECTO): Es la carpeta principal que contiene todo tu trabajo. Es
el contenedor de nivel superior de tu aplicación.

2. Archivo Principal ([Link]): Es el punto de entrada del programa; el archivo que ejecutas
para que todo el proyecto empiece a funcionar. Suele importar funciones o clases de las
otras carpetas.

3. El Paquete (mi_paquete): Es una subcarpeta que agrupa módulos relacionados. Para que
Python la reconozca como un "paquete" y no como una carpeta normal, contiene archivos
específicos:

 __init__.py: Es un archivo fundamental (aunque a menudo esté vacío). Indica a

Python que la carpeta mi_paquete puede ser importada como un paquete. Sin él, no
podrías hacer algo como: from mi_paquete import modulo_operaciones.

Archivo sin código.

71
 Tutorial Python
Ing. Juventino Israel García Andrade

 modulo_operaciones.py: Contiene funciones matemáticas (sumas, resta,

multiplicación, división).

 modulo_persona.py: Define la función persona(nombre): espera recibir un dato (

nombre) para poder ejecutar la frase.

Esta estructura permite que tu código esté ordenado y sea reutilizable. En lugar de tener mil
líneas de código en un solo archivo, separas las responsabilidades: la lógica va en los
"módulos" dentro del "paquete", y el archivo "main" se encarga de coordinarlo todo.

Código del archivo [Link]:

72
 Tutorial Python
Ing. Juventino Israel García Andrade

La primera línea de código significa: “Que debe ir a la carpeta mi_paquete y traer todo lo que
hay en modulo_persona y modulo_operaciones”. Esto permite usar las funciones definidas
en esos archivos.

from mi_paquete import modulo_persona, modulo_operaciones

En la siguiente línea, Se invoca la función persona definida dentro del módulo

“modulo_persona”. Al pasarle el argumento "JUVENTINO", el programa ejecuta la instrucción
interna del módulo para mostrar en consola el saludo personalizado: ¡Hola, JUVENTINO!

modulo_persona.persona(“Juventino”) Archivo modulo_personas.py

En la siguiente línea, se imprime en pantalla: BIENVENIDO AL PROGRAMA DE

OPERACIONES BÁSICAS.

print("BIENVENIDO AL PROGRAMA DE OPERACIONES BÁSICAS")

En la siguiente línea, se envían los valores numéricos 6 y 4 a la función resta del

“modulo_operaciones”. El valor devuelto (10) se almacena en la variable result_resta, para
posteriormente mandar el resultado en pantalla.

result_resta = modulo_operaciones.suma(6,4)

print(f"LA RESTA ES {result_resta}")

73
 Tutorial Python
Ing. Juventino Israel García Andrade

PRACTICA:
 A partir del programa en Python que muestra un menú interactivo con cinco opciones para
resolver diversos problemas matemáticos. Modifícalo para que cada función esté en un
módulo independiente y en un paquete para organizar todos los módulos. El objetivo es
que estas funciones sean llamadas desde el archivo principal (main).

Estructura sugerida:

74
 Tutorial Python
Ing. Juventino Israel García Andrade

CONVERTIR UN ARCHIVO .PY A .EXE

Pasos para convertir un archivo .py a .exe:

Método 1:

Instalar PyInstaller: Abre tu terminal Símbolo del Sistema (CMD) y ejecuta:

pip install pyinstaller

75
 Tutorial Python
Ing. Juventino Israel García Andrade

Generar el ejecutable: Navega a la carpeta de tu proyecto desde el Símbolo del Sistema y

ejecuta:

Ruta del proyecto

pyinstaller --onefile nombre_de_tu_proyecto.py

Usa --onefile para empaquetar todo en un solo archivo .exe.

Usa --windowed si tu archivo no necesita una consola (interfaz gráfica).

Localizar el archivo: Una vez termine, busca tu archivo .exe dentro de la carpeta dist que se
ha creado.

Archivo ejecutable .exe

76
 Tutorial Python
Ing. Juventino Israel García Andrade

Método 2:

Instalar auto-py-to-exe: Abre tu terminal Símbolo del Sistema (CMD) y ejecuta:

pip install auto-py-to-exe

Ejecutar: Escribir auto-py-to-exe en la terminal.

77
 Tutorial Python
Ing. Juventino Israel García Andrade

Se abrirá la siguiente ventana. Cargue su archivo .py en la sección 'Script Location' y haga clic
en el botón 'CONVERT .PY TO .EXE'. El proceso comenzará automáticamente y se le
notificará cuando finalice.

Puedes abrir el directorio donde se generó el archivo “.exe” dando clic el botón “OPEN
OUTPUT FOLDER”.

Archivo .exe

78
 Tutorial Python
Ing. Juventino Israel García Andrade

INTERFAZ DE COMUNICACIÓN SERIE EN PYTHON

Una interfaz de comunicación serie en Python es una herramienta que permite a un programa
escrito en este lenguaje intercambiar datos con dispositivos externos (como sensores,
microcontroladores como Arduino o equipos industriales) de manera secuencial, enviando la
información bit a bit. Para lograr esto, la biblioteca estándar de facto es PySerial, la cual
proporciona el soporte necesario para acceder a los puertos serie (COM en Windows o /dev/tty
en Linux/macOS).

CONTROL DE RELÉ USB LCUS-1 CON PYTHON

Para controlar un módulo de relé USB LCUS-1 con Python, debes comunicarte con él a través
de un puerto serie (COM en Windows o ttyUSB en Linux/Mac). Este dispositivo utiliza el chip
CH340, por lo que el sistema operativo lo reconocerá como un puerto serie estándar.

La función principal del Módulo de Relé USB LCUS-1 es actuar como un interruptor inteligente
que permite controlar el encendido y apagado de dispositivos eléctricos externos directamente
desde una computadora.

A diferencia de los relés convencionales que requieren señales de microcontroladores (como

Arduino), este módulo integra un chip de comunicación que facilita su uso mediante comandos
de puerto serie (Serial).

Características y Funciones:

 Control mediante Comandos Seriales: Utiliza un chip CH340 (USB a Serie) que permite enviar
instrucciones desde software de depuración serial o scripts personalizados a una tasa de 9600 BPS.

 Capacidad de Carga: Puede manejar cargas de hasta 10A / 250VCA o 10A / 30VCC, lo que lo
hace apto para controlar electrodomésticos, luces o motores pequeños.

 Protección Integrada: Incluye protección contra sobre corriente y un diodo de protección (flyback)
para evitar daños al circuito por picos de voltaje al conmutar la bobina.

79
 Tutorial Python
Ing. Juventino Israel García Andrade

 Indicadores Visuales: Cuenta con dos LEDs integrados; uno para confirmar que el módulo recibe
energía y otro que indica si el relé está activado o desactivado.

 Aislamiento Eléctrico: Permite que circuitos de baja potencia (como el puerto USB de tu PC)
controlen dispositivos de alto voltaje de forma segura, separando físicamente ambos sistemas.

Ejemplo de Aplicación.

Es ideal para proyectos de domótica o automatización industrial simple, como programar una
computadora para que encienda un ventilador, un motor, etc.

EJEMPLO:

Proyecto para encender y apagar un foco de 110V - 127VCA.

En los relés, las siglas (NO, COM, NC) describen los tres terminales o contactos de salida que
determinan cómo se comportará el interruptor.

NO (Normally Open - Normalmente Abierto).

 Estado: En reposo (sin energía en la bobina), el circuito está abierto o interrumpido.

 Función: La corriente no pasa hacia el dispositivo. Solo se cierra y deja pasar la electricidad
cuando activas el relé mediante el comando USB.
 Uso común: Es el más usado. Se conecta aquí si quieres que el dispositivo esté apagado
por defecto y solo se encienda cuando tú lo mandes.

NC (Normally Closed - Normalmente Cerrado).

 Estado: En reposo, el circuito está cerrado o conectado.

 Función: La corriente pasa constantemente hacia el dispositivo. Cuando activas el relé, el
circuito se abre y corta la energía.
 Uso común: Se usa para dispositivos que deben estar encendidos siempre, como una
alarma o un sistema de refrigeración, y que solo quieres apagar en momentos específicos.
80
 Tutorial Python
Ing. Juventino Israel García Andrade

COM (Common - Común).

 Estado: Es el terminal central o de entrada.

 Función: Es donde conectas la línea de fase (en AC) o el positivo (en DC) que quieres
controlar.

¿Qué es un relé?

Un relé (o relevador) es un interruptor electromagnético que permite abrir o cerrar circuitos

eléctricos de alta potencia mediante una señal eléctrica de baja potencia (como la de un
Arduino o un sensor). Actúa como un interruptor automático que separa el circuito de control
del circuito de carga.

Diagrama de un relé o relevador.

81
 Tutorial Python
Ing. Juventino Israel García Andrade

Material para armar el proyecto:

 Relé USB Programable LCUS-1, 1 Foco y Socket 110 – 120v, cable con clavija.

Diagrama de conexión:

Ten en cuenta que la terminal central del

Socket corresponde a la Fase de corriente.

Conectar a la
Corriente eléctrica

Conecte la Fase a la terminal “COM”. Utilice la terminal “NO” para la salida hacia la parte
central del Socket; de esta forma, el circuito permanecerá abierto en la terminal “NO
(Normalmente Abierto)” y solo se cerrará para permitir el paso de corriente cuando se envíe la
instrucción vía USB. Posteriormente conecte el cable Neutro directamente al Socket.

Una vez finalizado el montaje físico del proyecto, se procede con el diseño del software.

82
 Tutorial Python
Ing. Juventino Israel García Andrade

DISEÑO DEL SOFTWARE.

Requisitos: Instalar el módulo estándar pyserial

Abre tu terminal Símbolo del Sistema (CMD) y ejecuta: pip install pyserial

Una vez instalado “pyserial” se procede a crear un nuevo archivo en Python utilizando el IDLE.

83
 Tutorial Python
Ing. Juventino Israel García Andrade

Para controlar un módulo de relé USB LCUS-1 con Python y "mandar" 5V a una carga, Sse
necesita utilizar el módulo pyserial. Este módulo utiliza un chip CH340 que crea un puerto COM
virtual en tu computadora, permitiéndo enviar comandos hexadecimales para activar o
desactivar el relé.

Identifica el puerto: Conecta el dispositivo y busca en el "Administrador de dispositivos"

(Windows).

Pasos para identificar el puerto:

Para identificar el puerto COM en Windows y asegurarte de que el relé LCUS-1 esté conectado
a la computadora y sea reconocido correctamente, sigue estos pasos:

1. Abre el Administrador de dispositivos:

o Presiona la tecla Windows + X y selecciona Administrador de dispositivos.

o bien, presiona Windows + R, escribe [Link] y pulsa Enter.

2. Localiza la sección de Puertos: Busca en la lista el apartado llamado Puertos (COM y LPT)
y haz clic en la flecha para desplegarlo.

3. Identifica tu puerto: Deberías ver algo como USB-SERIAL CH340 (COMX). El número que
aparece después de "COM" (por ejemplo, COM3 o COM5) es el que deberás usar en tu
código de Python.

84
 Tutorial Python
Ing. Juventino Israel García Andrade

CÓDIGO EN PYTHON:

Este código permite controlar el módulo de relé a través de comandos serie.

Explicación de las líneas de código:

1. El módulo “import serial” permite carga la librería pySerial para permitir que Python se
comunique con el puerto USB (convertido a serie).

2. El módulo “import time” se usa para generar pausas (retardos) entre las acciones.

3. Configuración del Puerto:

o puerto = 'COM9': Define la dirección donde está conectado el dispositivo.

o ser = [Link](puerto, 9600, timeout=1): Abre la comunicación.
9600 es la velocidad (baudios) que requiere el chip CH340.
timeout=1 evita que el programa se congele si no recibe respuesta.

4. La función controlar_rele:

def controlar_rele(comando_hex):
[Link]([Link](comando_hex))

o La función está en espera de recibir el dato en el parámetro (comando_hex)

o [Link](): Convierte la cadena de texto (ej. "A0 01 01 A2") en bytes reales que el
hardware puede procesar.
85
 Tutorial Python
Ing. Juventino Israel García Andrade

5. Se muestra en pantalla el mensaje: Activando Canal 1...

print("Activando Canal 1...")

6. Se envía los datos al parámetro (comando_hex) de la función controlar_rele para abrir el

canal 1 del relé:

controlar_rele("A0 01 01 A2")

Los comandos hexadecimales (Protocolo LCUS-1)

A0: Byte de inicio.
01: Dirección del relé.
01 / 00: El estado (01 encendido / 00 apagado).
A2 / A1: Es el Checksum (la suma para verificar que el mensaje llegó sin errores).

POR LO TANTO:

7. Mantiene el relé encendido durante 5 segundos.

[Link](5)

8. Se muestra en pantalla el mensaje: Desactivando Canal 1...

print("Desactivando Canal 1...")

9. Se envía los datos al parámetro (comando_hex) de la función controlar_rele para cerrar el

canal 1 del relé:

controlar_rele("A0 01 00 A1")

10. Por último, se coloca la instrucción que finaliza la comunicación entre tu programa de
Python y el puerto USB.

[Link]()

86
 Tutorial Python
Ing. Juventino Israel García Andrade

RESULTADO

Resultado:

Activando Canal 1…

Tiempo 5 segundos.
Desactivado Canal 1…

87
 Tutorial Python
Ing. Juventino Israel García Andrade

PRACTICA:
 Codifica un programa en Python para encender y apagar un foco cada 3 segundos de
manera cíclica utilizando “while”, si deseas elaborarlo de manera física utiliza los
componentes mencionados en la sección anterior.
Además, puedes programar para que el usuario inserte el tiempo de encendido y apagado.

RESULTADO

88
 Tutorial Python
Ing. Juventino Israel García Andrade

CONTROL DE RELÉ USB LCUS-2 CON PYTHON

El Relé USB LCUS-2 es un módulo de control inteligente que te permite activar o desactivar
dos interruptores electrónicos (relés) de forma independiente desde una computadora a través
de un puerto USB.

A diferencia del modelo LCUS-1, que solo tiene un canal, el LCUS-2 cuenta con dos canales,
lo que te permite controlar dos dispositivos distintos simultáneamente.

EJEMPLO:

Desarrollo de un sistema de evaluación de 2 preguntas que proporcione

retroalimentación visual inmediata: se encenderá un indicador verde ante cada
respuesta correcta y un indicador rojo ante cada respuesta incorrecta.

Material para armar el proyecto:

 Relé USB Programable LCUS-2, 2 Foco y Socket 110 – 120v, cable con clavija.

89
 Tutorial Python
Ing. Juventino Israel García Andrade

Diagrama de conexión:

Conecte el cable neutro directamente a cada socket. Posteriormente, lleve la fase a la entrada
COM de cada relé y utilice las salidas para retornar la corriente hacia el contacto de fase en
cada socket.

Una vez finalizado el montaje físico del proyecto, se procede con el diseño del software.

DISEÑO DEL SOFTWARE.

Recuerda que, para controlar los módulos Relé USB LCUS-2 desde Python, es necesario
instalar “pyserial”. El proceso de instalación y pasos para identificar el puerto se detalla en la
práctica anterior.

90
 Tutorial Python
Ing. Juventino Israel García Andrade

CÓDIGO EN PYTHON.

91
 Tutorial Python
Ing. Juventino Israel García Andrade

Explicación de las líneas de código:

1. El módulo “import serial” permite carga la librería pySerial para permitir que Python se
comunique con el puerto USB (convertido a serie).

2. El módulo “import time” se usa para generar pausas (retardos) entre las acciones.

3. El módulo “import os” se usa para el comando final de pausa en consola.

4. Configuración del Puerto:

o puerto = 'COM9': Define la dirección donde está conectado el dispositivo.

o ser = [Link](puerto, 9600, timeout=1): Abre la comunicación.
9600 es la velocidad (baudios) que requiere el chip CH340.
timeout=1 evita que el programa se congele si no recibe respuesta.

5. La función controlar_rele:

def controlar_rele(comando_hex):
[Link]([Link](comando_hex))

o La función está en espera de recibir el dato en el parámetro (comando_hex)

o [Link](): Convierte la cadena de texto (ej. "A0 01 01 A2") en bytes reales que el
hardware puede procesar.

6. La función apagar_todo(): Envía los comandos A0 01 00 A1 (Apaga Canal 1) y A0 02 00

A2 (Apaga Canal 2). Es muy útil para "limpiar" el estado de los focos antes de empezar o
después de cada respuesta.

92
 Tutorial Python
Ing. Juventino Israel García Andrade

7. Se manda a llamar a la función apagar_todo() y se declara una variable llamada aciertos

que inicie desde 0.

8. Da la bienvenida y muestra la pregunta 1 con las opciones (a, b, c). se le pide al usuario
que capture su respuesta: Usa input().lower() para que no importe si el usuario escribe la
letra en mayúscula todo lo pasa a minúscula.

9. Si la respuesta es correcta “a”: Suma un punto a la variable aciertos, imprime un mensaje

de ¡CORRECTO!... y envía el comando A0 01 01 A2 para encender el Canal 1 (el foco
verde).

93
 Tutorial Python
Ing. Juventino Israel García Andrade

10. Si la respuesta es incorrecta: Imprime el mensaje de INCORRECTO y envía A0 02 01 A3

para encender el Canal 2 (el foco rojo).

11. Se inserta un temporizador de 3 segundos para mantener el foco encendido por 3 segundos
([Link](3)) y luego apaga ambos mediante apagar_todo().

12. Posteriormente pasa a la siguiente pregunta siguiendo el mismo proceso.

13. Finalmente, el programa calcula la calificación multiplicando los aciertos por cinco. De esta
manera, al tratarse de solo dos preguntas, se obtiene un puntaje basado en una escala del
0 al 10.

14. Se muestra en pantalla el puntaje total de aciertos y calificación obtenida.

15. Si la calificación es 6 o más, imprime un mensaje de "APROBASTE EL EXAMEN"; de lo

contrario, muestra "REPROBASTE EL EXAMEN".

94
 Tutorial Python
Ing. Juventino Israel García Andrade

16. Se utiliza “[Link]()” para cerrar la comunicación con el USB para que el puerto quede
libre.

17. Por último se utiliza “[Link]("pause")” para evita que la ventana de la consola se cierre
inmediatamente, permitiendo al usuario leer su resultado final.

RESULTADO:

Se enciende
el foco rojo
del montaje
físico.

Se enciende
el foco verde
del montaje
físico.

PRACTICA PROYECTO:
 Codifica un sistema de evaluación de 10 preguntas que proporcione retroalimentación
visual inmediata: se encenderá un indicador verde ante cada respuesta correcta y un
indicador rojo ante cada respuesta incorrecta.
95
 Tutorial Python
Ing. Juventino Israel García Andrade

COMUNICACIÓN ARDUINO CON PYTHON

¿Qué es Arduino?

Arduino es una plataforma de creación electrónica de código abierto (open-source) que

combina hardware y software fáciles de usar para crear proyectos interactivos.

Los pines de Arduino más utilizados para mandar voltajes se dividen principalmente en pines
de alimentación (voltaje constante) y pines de entrada/salida (I/O) (voltaje controlado por
código).

Los Pines Digitales (0 al 13): Envían un voltaje "ALTO" (5V en la mayoría de placas como Uno
o Nano) o "BAJO" (0V).

Para estos proyectos se utilizarán los pines de alimentación que incluyen un puerto USB (para
programar y dar energía), un conector para batería externa (7-12V) y pines de salida de voltaje
(5V, 3.3V y GND/Tierra) y los pines digitales (0-13) que se usan para señales de "encendido"
o "apagado" (0 o 5V). Algunos incluyen PWM (marcados con ~) para simular señales
analógicas, como variar la intensidad de un LED.

96
 Tutorial Python
Ing. Juventino Israel García Andrade

Interfaz de comunicación: Cómo conectar Arduino con Python.

pyFirmata2 es una biblioteca de Python diseñada para controlar placas Arduino desde una
computadora, permitiendo leer y escribir en pines digitales y analógicos sin necesidad de
escribir código C++ en el IDE de Arduino. Convierte Arduino en un dispositivo de adquisición
de datos en tiempo real mediante el protocolo Firmata.

Para comunicar Arduino con Python usando el módulo pyFirmata2 se debe cargar el sketch
"StandardFirmata" en la placa y usar la biblioteca en Python para enviar comandos serie,
siendo ideal para automatización y adquisición de datos rápida.

Pasos para cargar el sketch "StandardFirmata" a la placa Arduino:

1. Descarga e instala la aplicación Arduino.

Sitio de descarga: [Link]

97
 Tutorial Python
Ing. Juventino Israel García Andrade

2. Una vez instalado abre la aplicación:

Se mostrará la interfaz del IDE de Arduino (Entorno de Desarrollo Integrado). Este es el

programa oficial que se utiliza para escribir código y cargarlo a las placas de
microcontroladores Arduino (como el Arduino Uno, Nano, etc.).

3. Conecta tu placa Arduino a la computadora utilizando el puerto USB.

4. Verificar que la placa fue reconocida por el IDE en la aplicación Arduino, ve al menú Tools—
Port y selecciona el puerto donde se encuentra la placa Arduino conectada.

98
 Tutorial Python
Ing. Juventino Israel García Andrade

5. Selecciona la placa Arduino.

6. Cargar StandardFirmata a la placa Arduino.

En la aplicación Arduino, abre Archivo(File) --> Ejemplos(Examples) --> Firmata -->
FirmataEstándar(StandardFirmata).

99
 Tutorial Python
Ing. Juventino Israel García Andrade

Se Visualiza el código "C" de StandardFirmata. No necesitas entender el código para

usarlo.

7. Ahora, en la parte superior izquierda de la ventana del editor de texto, haga clic en el botón
“Subir(Upload)”, como se muestra en la imagen.

En la parte inferior de la ventana, verá una pequeña ventana de estado que indica el
progreso de la compilación y la carga del código en la placa Arduino. Mientras se carga el
código, verá pequeños indicadores LED (de transmisión (TX) y recepción (RX))
parpadeando en su placa Arduino a medida que se transfieren los datos.

100
 Tutorial Python
Ing. Juventino Israel García Andrade

Cuando el proceso finalice, verá el mensaje "Carga completada" en la ventana de estado, en

la parte inferior del editor. Si aparece un mensaje de error, continúe con el siguiente paso sobre
"Solución de problemas". De lo contrario, omita el siguiente paso.

Con estos pasos ya tenemos cargado el StandardFirmata en la placa Arduino para habilitar la
comunicación.

Existen diversos paquetes de software que utilizan StandardFirmata, entre ellos Processing,
Python pyFirmata, HyperStudio, HyperDuino y muchos otros.

Instalar pyfirmata2 en Python.

Para instalar pyFirmata2, Abre tu terminal Símbolo del Sistema (CMD) en Windows y ejecuta:
pip install pyfirmata2

Una vez instalado “pyfirmata2” se procede a crear un nuevo archivo en Python utilizando el
IDLE.

Con estos pasos tenemos preparado todo para realizar nuestro primer proyecto.
101
 Tutorial Python
Ing. Juventino Israel García Andrade

EJEMPLO:

Proyecto para encender y apagar un led en la placa Arduino con Python.

Material para armar el proyecto:

 Placa “Arduino Uno” con cable de datos, LEDs con resistencias de 220Ω, ProtoBoard,
cable Dupont (macho-macho).

102
 Tutorial Python
Ing. Juventino Israel García Andrade

Diagrama de conexión:

Conecta el cable negro a cualquier pin GND de la sección POWER de la placa Arduino. Luego,
lleva este cable a la línea negativa de la protoboard (bus azul). Desde esa línea, conecta la
resistencia de 220Ω hacia el cátodo (pata corta) del LED. Finalmente, conecta el cable rojo
desde el pin digital 2 hasta el ánodo (pata larga) del LED.

103
 Tutorial Python
Ing. Juventino Israel García Andrade

¿Qué función tiene la resistencia 220 Ω?

Evita que el LED se queme, los LEDs tienen muy poca resistencia interna. Si lo conectas
directamente a los 5V del Arduino, pasaría demasiada corriente eléctrica, lo que
sobrecalentaría el componente y lo fundiría en segundos.

Los pines de Arduino tienen un límite de corriente que pueden entregar (generalmente 20mA)
Sin la resistencia, el pin intentaría entregar demasiada energía y podría dañarse
permanentemente.

Para elegir la resistencia adecuada, lo más común es usar una de 220Ω o 330Ω si estás
usando un Arduino (5V), ya que funcionan de forma segura para casi cualquier color.

Sin embargo, si quieres ser exacto, el valor depende del color del LED, porque cada color
requiere un voltaje distinto. Aquí tienes una guía rápida usando la Ley de Ohm:

Otra manera de conectar el LED.

104
 Tutorial Python
Ing. Juventino Israel García Andrade

Una vez finalizado el montaje físico del proyecto, se procede con el diseño del software.

DISEÑO DEL SOFTWARE.

Crear un nuevo archivo en Python utilizando el IDLE.

CÓDIGO EN PYTHON:

105
 Tutorial Python
Ing. Juventino Israel García Andrade

Explicación de las líneas de código:

1. El código “import pyfirmata2 as pyfirmata”, importa el módulo necesario para

comunicarse con Arduino. El as pyfirmata es un alias para escribir menos código después.

El código “import time”, importa el módulo que permite manejar pausas o retardos de
tiempo.

2. El código “board = [Link]('COM10')”, establece la comunicación.'COM10' es

el puerto USB donde está conectado tu Arduino.

Pasos para identificar el puerto:

Para identificar el puerto COM en Windows y asegurarte de que Arduino esté conectado a
la computadora y sea reconocido correctamente, sigue estos pasos:

1. Abre el Administrador de dispositivos:

o Presiona la tecla Windows + X y selecciona Administrador de dispositivos.

o bien, presiona Windows + R, escribe [Link] y pulsa Enter.

2. Localiza la sección de Puertos: Busca en la lista el apartado llamado Puertos (COM y

LPT) y haz clic en la flecha para desplegarlo.

3. Identifica tu puerto: Deberías ver algo como Arduino Uno (COMX). El número que
aparece después de "COM" (por ejemplo, COM3 o COM5) es el que deberás usar en
tu código de Python.

106
 Tutorial Python
Ing. Juventino Israel García Andrade

3. El código “[Link][2].write(1)”, envía una señal digital de "alto" (5V) al pin 2. Esto
hace que el LED se encienda.

4. El código “print("LED Encendido")”, muestra el mensaje “LED Encendido” en la pantalla

de la computadora para que sepas qué se está realizando este proceso.

5. El código “[Link](10)”, hace una espera de 10 segundos. Durante este tiempo, el LED
permanece encendido.

6. El código “[Link][2].write(0)”, envía una señal digital de "bajo" (0V) al pin 2. Esto
hace que el LED se apage.

7. El código “print("LED Apagado")”, muestra el mensaje “LED Apadado” en la pantalla de

la computadora para que sepas qué se está realizando este proceso.

8. El código “[Link](10)”, hace una espera de 10 segundos. Durante este tiempo, el LED
permanece apagado.

9. El código “[Link]()”, cierra de forma segura la conexión entre Python y el Arduino.

107
 Tutorial Python
Ing. Juventino Israel García Andrade

RESULTADO:

Se mantiene encendido por 10 segundos.

Se mantiene apagado por 10 segundos.

Finaliza el programa.

108
 Tutorial Python
Ing. Juventino Israel García Andrade

PRACTICA PROYECTO:
 Desarrolla un sistema utilizando Python y Arduino para simular un semáforo. El programa
debe realizar una transición de colores cada 3 segundos y emplear un ciclo while True
para garantizar un funcionamiento continuo y automático.

 Diseña un sistema mediante Python y Arduino que controle 4 LEDs de distintos colores,
permitiendo al usuario seleccionar el LED que desea encender a través de la entrada de
un valor numérico.

109
 Tutorial Python
Ing. Juventino Israel García Andrade

CONTROL DE SERVOMOTORES CON ARDUINO Y PYFIRMATA2

¿Qué es un servomotor?

Un servomotor (o simplemente "servo") es un motor eléctrico que permite controlar con

extrema precisión la posición, velocidad y aceleración de su eje. A diferencia de un motor
convencional que gira libremente mientras recibe energía, un servomotor puede moverse a un
ángulo exacto (como 45° o 90°) y mantenerse firme en esa posición.

EJEMPLO:

Proyecto: Diseño de un indicador dinámico de Índice de Masa Corporal

controlado por servomotor.

110
 Tutorial Python
Ing. Juventino Israel García Andrade

Material para armar el proyecto:

1 Arduino Uno.
1 Servomotor SG90.
3 Cables tipo Dupont (macho-macho).
1 Impresión de Imagen (IMC)

111
 Tutorial Python
Ing. Juventino Israel García Andrade

Diagrama de conexión:

Una vez finalizado el montaje físico del proyecto, se procede con el diseño del software.

DISEÑO DEL SOFTWARE.

Para establecer la comunicación entre Arduino y Python, es indispensable cargar el protocolo

StandardFirmata en la placa y realizar la instalación de la librería pyfirmata2 en el entorno de
Python. El proceso de instalación y pasos para cargar el protocolo “StandardFirmata” se
detalla en la práctica anterior; sin embargo, se muestran a continuación de manera general.

Pasos Generales para la comunicación:

1. Preparación del Arduino.

 Abre el IDE de Arduino.
 Ve a Archivo > Ejemplos > Firmata > StandardFirmata.
 Sube el código a la placa Arduino.
112
 Tutorial Python
Ing. Juventino Israel García Andrade

2. Instalación de la librería.
 Desde la terminal o consola de comandos, instala la versión actualizada:
pip install pyfirmata2

Posteriormente crear un nuevo archivo en Python utilizando el IDLE.

CÓDIGO EN PYTHON PARA EL FUNCIONAMIENTO DEL SERVOMOTOR:

Mandar señal al servomotor:

113
 Tutorial Python
Ing. Juventino Israel García Andrade

Explicación de las líneas de código:

1. El código “import pyfirmata2 as pyfirmata”, importa el módulo necesario para

comunicarse con Arduino. El as pyfirmata es un alias para escribir menos código después.

El código “import time”, importa el módulo que permite manejar pausas o retardos de
tiempo.

2. El código “board = [Link]('COM10')”, establece la comunicación.'COM10' es

el puerto USB donde está conectado tu Arduino.

3. El código “servo = board.get_pin('d:9:s')”:

d: Digital.
9: El número del pin físico donde conectaste el cable de señal del servo (usualmente el
cable naranja o amarillo).
s: Servo (indica que debe enviar pulsos PWM específicos para servomotores).

4. El código “[Link](180) y [Link](2)”, envía la señal de 180° y detiene el programa

Python por 2 segundos. El servo llega rápido y se queda "bloqueado" ahí.

Esto se repite para los 90°, 0° y vuelve a 180°. Es útil para probar que el servo funciona en
todo su rango.

114
 Tutorial Python
Ing. Juventino Israel García Andrade

5. Posteriormente Ciclo for realiza un movimiento controlado. En lugar de saltar de 180 a 0 de

golpe, lo hace "pasito a pasito":

El código “range(180, -1, -1)” del ciclo for, genera una lista de números: 180, 179, 178...
hasta llegar al 0. En el contexto el ciclo for, la función range(180, -1, -1) funciona como una
cuenta regresiva de 180 hasta 0.

El primer número (180). Indica que el ciclo comenzará con la variable “angulo” valiendo
180.
El segundo número (-1). Indica hasta dónde llegará la cuenta, pero sin incluirlo. Como se
quiere llegar hasta el 0, se pone -1 para que el ciclo se detenga justo después de procesar
el cero.
El tercer número (-1). Indica cuánto se suma o resta en cada vuelta. Al ser -1, le dice a
Python: "resta uno en cada paso".

Por cada vuelta del ciclo toma cada uno de esos números, uno por uno, y los guarda en la
variable [Link](angulo) para enviar ese valor específico al servo.

El código “[Link](0.02)”, espera 20 milisegundos entre cada vuelta. Como el ojo

humano percibe fluidez a partir de ciertos milisegundos, se observará que el brazo del servo
baja suavemente.

6. El código “[Link]()”, cierra de forma segura la conexión entre Python y el Arduino.

Ejecuta el programa y visualiza el resultado en el servomotor.

115
 Tutorial Python
Ing. Juventino Israel García Andrade

Para calcular el IMC (Índice de Masa Corporal), la fórmula es la siguiente:

CÓDIGO EN PYTHON PARA CALCULAR EL IMC:

116
 Tutorial Python
Ing. Juventino Israel García Andrade

Este programa contiene una estructura de control (if - elif) que compara el resultado obtenido
(24.91) con los rangos establecidos por la OMS.

Menor a 18.5: Bajo peso.

Entre 18.5 y 24.9: Peso normal.
Entre 25 y 29.9: Sobrepeso.
Entre 30 y 34.9: Obesidad grado I.
Entre 35 y 39.9: Obesidad grado II.
Mayor igual a 40: Obesidad grado III.

PRACTICA PROYECTO:

Diseñar e implementar un sistema que integre Python y Arduino para controlar un indicador
físico de IMC. El dispositivo utilizará un servomotor que deberá girar a un ángulo específico
según el rango de masa corporal obtenido en el cálculo.

117
 Tutorial Python
Ing. Juventino Israel García Andrade

EJEMPLO:

Cuando el cálculo del IMC arroje un valor de 24.91, el sistema lo clasificará como 'Peso normal'.
Simultáneamente, el servomotor deberá desplazarse hacia el ángulo correspondiente en el
indicador físico, tal como se ilustra en la imagen.

Cuando el cálculo del IMC arroje un valor de 28.37, el sistema lo clasificará como “Sobrepeso”.
Simultáneamente, el servomotor deberá desplazarse hacia el ángulo correspondiente en el
indicador físico, tal como se ilustra en la imagen.

118
 Tutorial Python
Ing. Juventino Israel García Andrade

CONCLUSIÓN

Este tutorial fue diseñado con un objetivo claro: demostrar que la programación y la electrónica
no son disciplinas exclusivas para expertos, sino herramientas accesibles para cualquier
persona con curiosidad. Al elaborar este material, mi intención fue guiar a quienes tienen pocos
conocimientos previos a través de un viaje lógico que comienza con lo más elemental, para
que comprendieran que el código es, ante todo, un lenguaje de comunicación claro y
estructurado. La intención fue que el lector no solo memorizara comandos, sino que
desarrollara un pensamiento algorítmico capaz de resolver problemas reales.

El panorama se amplía significativamente cuando el software se encuentra con el hardware.

Al integrar módulos específicos de Python con la placa Arduino, este tutorial eliminó la barrera
entre lo digital y lo físico. Pasar de imprimir texto en una pantalla a controlar un LED y,
finalmente, gestionar la potencia de un relé, permite que el principiante visualice el potencial
infinito de estas herramientas. No se trata solo de encender una luz, sino de entender que, con
estas bases, cualquiera puede comenzar a construir proyectos de automatización, domótica o
robótica desde cero.

Espero que este recorrido les haya servido para perderle el miedo al código y para visualizar
todo lo que son capaces de construir combinando software y hardware. Recuerden que todo
gran proyecto comienza con un simple 'Hola Mundo'. ¡Mucho éxito en sus futuras creaciones!

Atentamente,
Juventino Israel García Andrade.

119