1.2.-Practica con un lenguaje

1.2. Practica con un lenguaje

Idea principal

En el apartado 1.1 analizamos qué es un programa y en 1.1.1 describimos algoritmos con pseudocódigo. Ahora daremos el siguiente paso: traduciremos esas ideas a Python y aprenderemos a ejecutar y revisar un programa real.

Python será nuestro primer lenguaje porque permite centrarnos en la lógica sin que la sintaxis o la configuración oculten las ideas fundamentales. Lo aprendido se podrá aplicar después a Kotlin y a otros lenguajes.

Este contenido trabaja el RA 1 del módulo de Programación, especialmente los criterios relacionados con la estructura del programa, los tipos de datos, las variables, los operadores, las conversiones y los comentarios.

Código	Descripción
RA 1	Reconoce la estructura de un programa informático, identificando y relacionando los elementos propios del lenguaje de programación utilizado.
CE a	Se han identificado los bloques que componen la estructura de un programa informático.
CE b	Se han creado proyectos de desarrollo de aplicaciones.
CE c	Se han utilizado entornos integrados de desarrollo.
CE d	Se han identificado los distintos tipos de variables y la utilidad específica de cada uno.
CE e	Se ha modificado el código de un programa para crear y utilizar variables.
CE f	Se han creado y utilizado constantes y literales.
CE g	Se han clasificado, reconocido y utilizado en expresiones los operadores del lenguaje.
CE h	Se ha comprobado el funcionamiento de las conversiones de tipo explícitas e implícitas.
CE i	Se han introducido comentarios en el código.

Qué deberías saber al terminar

Al acabar este apartado deberías poder:

• explicar los bloques básicos de un programa Python;
• ejecutar instrucciones en el intérprete y programas guardados en .py;
• usar literales, variables, constantes por convención y tipos básicos;
• construir expresiones con operadores y respetar su precedencia;
• leer datos del teclado, convertirlos y mostrar resultados;
• reconocer errores frecuentes y escribir comentarios útiles.

Mapa del tema

Seguiremos esta secuencia:

1. estructura de un programa en Kotlin y Python;
2. intérprete y primer programa ejecutable;
3. valores, variables, tipos y constantes;
4. operadores, expresiones, sentencias y bloques;
5. entrada, comentarios, nombres y depuración.

1. Bloques de un programa

Un programa se construye combinando bloques con responsabilidades diferentes. Reconocerlos ayuda a leer código ajeno y a localizar los errores.

1.1. Bloques habituales en Kotlin

En Kotlin encontramos, entre otros, estos elementos:

Los bloques organizan el código y definen el flujo del programa.

• Punto de entrada main: marca el comienzo habitual de la ejecución.
• Paquetes e importaciones: organizan el código e incorporan clases o funciones que ya existen.
• Funciones: agrupan instrucciones con un nombre para poder reutilizarlas.

Consulta la sintaxis básica de Kotlin si quieres comparar esta estructura con la de Python.

1.2. Bloques habituales en Python

En Python, un programa suele organizarse en módulos. Un módulo es un archivo .py que puede contener variables, funciones, clases e instrucciones ejecutables. También puede importar código de otros módulos.

# Importación de una función definida en otro módulo
from file_two import function_three

def main():
    """Ejecuta la tarea principal del programa."""
    print("Cuerpo principal")


if __name__ == "__main__":
    # Solo se ejecuta al lanzar directamente este archivo.
    main()
else:
    # El módulo también puede ser importado por otro programa.
    print("Módulo importado")

La condición __name__ == "__main__" permite que un archivo tenga código reutilizable y, al mismo tiempo, un punto de entrada cuando se ejecuta como programa.

2. Comenzar con Python

Python es un lenguaje de alto nivel, multiparadigma y multiplataforma. Se usa en automatización, desarrollo web, ciencia de datos y muchas otras áreas.

• Es multiparadigma: permite programación imperativa, orientada a objetos y funcional.
• Tiene tipado dinámico: el tipo se asocia al valor durante la ejecución y no se declara de forma obligatoria al crear cada variable.
• Tiene tipado fuerte: no mezcla automáticamente valores incompatibles, como un número y una cadena, en todas las operaciones.
• Se ejecuta mediante un intérprete. En la práctica, Python transforma el código en bytecode y lo ejecuta en su máquina virtual; por eso decir que es “interpretado” es una simplificación útil para empezar, no que cada línea se traduzca directamente a lenguaje máquina.

Python 3 y el comando de ejecución

Según el sistema operativo, el comando puede ser python, python3 o el lanzador py. En los ejemplos usaremos python3; comprueba cuál está instalado en tu equipo con python3 --version.

2.1. El intérprete interactivo

El intérprete permite probar expresiones de forma inmediata. El indicador >>> señala que está esperando una instrucción:

Para entrar en el intérprete, abre un terminal y ejecuta el comando de Python disponible en tu sistema:

$ python3

En Windows puede ser necesario utilizar python o el lanzador py:

> python
> py

Si Python está instalado correctamente, aparecerá información sobre su versión y el indicador >>>. A partir de ese momento puedes escribir instrucciones y confirmarlas con Enter:

>>> 2 + 3
5
>>> print("¡Hola, mundo!")
¡Hola, mundo!

Para salir se puede utilizar quit() o la combinación de teclas correspondiente al sistema. Esta modalidad es útil para experimentar, pero un programa real se guarda en un archivo para poder repetirlo y versionarlo.

2.2. Primer programa en Python

Crea un archivo llamado suma.py:

resultado = 2 + 3
print(resultado)

Desde un terminal situado en esa carpeta, ejecútalo:

$ python3 suma.py
5

El intérprete lee el archivo, evalúa la expresión, guarda el resultado en la variable resultado y muestra su valor. Esta es la conexión práctica entre el algoritmo de entrada → procesamiento → salida y el código Python.

3. Valores, variables y constantes

Un literal es un valor escrito directamente en el código, como 17, 3.14 o "Hola". Una variable es un nombre que permite referirse a un valor y puede asociarse después a otro valor.

>>> mensaje = "Hola"
>>> intentos = 3
>>> precio = 3.14
>>> print(mensaje, intentos, precio)
Hola 3 3.14
>>> type(mensaje)
<class 'str'>
>>> type(intentos)
<class 'int'>

La asignación se realiza con =. No significa “son iguales” como en una ecuación matemática, sino “asocia a la izquierda el resultado de la derecha”.

3.1. Valores, variables y tipos

Un literal es un valor escrito directamente en el código, como 17, 3.14 o "Hola". Una variable es un nombre que permite referirse a un valor y puede asociarse después a otro valor.

Todo valor tiene un tipo, que indica qué clase de dato representa y qué operaciones se pueden realizar con él. En Python el tipo se asocia al valor durante la ejecución, por lo que no es obligatorio declararlo al crear cada variable. La explicación detallada de los tipos, sus operaciones y sus conversiones se desarrolla en 1.3. Tipos de datos.

Tipo	Uso	Ejemplos
int	Números enteros	0, -1, 20
float	Números con parte decimal	3.14, -0.5
str	Texto	"Python", '123'
bool	Verdad o falsedad	True, False
NoneType	Ausencia de valor, representada por None	resultado = None

El texto '17' es una cadena, no un entero. Las comillas cambian el tipo y, por tanto, también las operaciones que se pueden realizar. Es importante conocer el tipo de cada dato para evitar errores y elegir las operaciones adecuadas.

>>> type(17)
<class 'int'>
>>> type("17")
<class 'str'>
>>> type(3.2)
<class 'float'>

3.2. Constantes por convención

Python no impone constantes inmutables como otros lenguajes. Por convención, se escriben en mayúsculas los nombres cuyo valor no debería cambiar:

IVA = 0.21
MAX_INTENTOS = 3

El intérprete permite reasignarlos; es responsabilidad del equipo respetar la convención. True, False y None son valores predefinidos del lenguaje.

4. Operadores, expresiones y sentencias

Un operador actúa sobre uno o varios operandos. Una expresión combina operandos y operadores y produce un valor. Una sentencia es una instrucción que realiza una acción, como asignar, imprimir o controlar el flujo.

total = precio * cantidad  # sentencia de asignación; contiene una expresión
print(total)               # llamada que muestra el resultado

4.1. Operadores aritméticos y de asignación

Operador	Significado	Ejemplo
+, -, *	suma, resta y producto	a + b
/	división real	5 / 2 == 2.5
//	cociente entero	5 // 2 == 2
%	resto	5 % 2 == 1
**	potencia	2 ** 3 == 8
+=, -=, *=, /=, %=, //=, **=	operación y asignación	contador += 1

contador += 1 equivale a contador = contador + 1. Para separar miles no se usan puntos ni comas como en la escritura cotidiana; 1_000_000 sí es un literal entero válido y legible.

Las comas no separan millares

La expresión 1,000,000 no representa un millón en Python. Las comas separan valores:

>>> print(1,000,000)
1 0 0
>>> 1_000_000
1000000

Para escribir un entero grande usa guiones bajos, como en 1_000_000, o deja que el programa lo formatee al mostrarlo.

Las formas compuestas también existen para el resto de operadores habituales:

Operador	Equivalencia
x -= 2	x = x - 2
x *= 2	x = x * 2
x /= 2	x = x / 2
x %= 2	x = x % 2
x //= 2	x = x // 2
x **= 2	x = x ** 2
x &= 2, x |= 2, x ^= 2	Aplican la operación bit a bit y asignan el resultado.
x <<= 2, x >>= 2	Desplazan bits y asignan el resultado.

4.2. Cadenas de texto

El operador + concatena cadenas y * repite una cadena un número entero de veces:

>>> "Hola, " + "Python"
'Hola, Python'
>>> "Py" * 3
'PyPyPy'

No se puede concatenar directamente un número con texto; hay que convertirlo o usar una cadena formateada:

edad = 20
print("Edad: " + str(edad))
print(f"Edad: {edad}")

4.3. Comparación, pertenencia e identidad

• Comparación: ==, !=, >, <, >= y <=; devuelven True o False.
• Pertenencia: in y not in; comprueban si un valor aparece en una cadena o colección.
• Identidad: is y is not; comprueban si dos referencias apuntan al mismo objeto. Para comparar valores se debe usar ==, no is.

>>> 9 > 1
True
>>> "py" in "Python".lower()
True
>>> resultado = None
>>> resultado is None
True

4.4. Operadores lógicos

and exige que se cumplan ambas condiciones, or que se cumpla al menos una y not invierte el resultado. Python aplica evaluación perezosa y puede devolver uno de los operandos, no siempre un bool:

>>> edad = 20
>>> tiene_autorizacion = False
>>> edad >= 18 and tiene_autorizacion
False
>>> True or False
True
>>> not False
True
>>> 0 or 10
10

4.5. Precedencia

Python evalúa primero los paréntesis, después la potencia, los operadores aritméticos, las comparaciones y, finalmente, los operadores lógicos. Dentro de un mismo nivel suele avanzar de izquierda a derecha. Usa paréntesis cuando mejoren la claridad:

>>> 5 + 3 * 2
11
>>> (5 + 3) * 2
16

También existen operadores bit a bit (&, |, ^, ~, <<, >>), que actúan sobre la representación binaria de enteros. Por ejemplo, 2 | 7 produce 7, 2 ^ 7 produce 5, 2 & 7 produce 2, 2 << 1 produce 4, 2 >> 1 produce 1 y ~2 produce -3. Son útiles en casos concretos de sistemas y rendimiento, pero no deben confundirse con and y or.

5. Sentencias y bloques de código

Las sentencias normalmente ocupan una línea. Una expresión entre paréntesis, corchetes o llaves puede continuar en varias líneas; también existe la barra invertida \, aunque se recomienda preferir los delimitadores:

total = (
    precio
    * cantidad
    * (1 + IVA)
)

Python delimita los bloques mediante indentación, no mediante llaves. La convención PEP 8 recomienda cuatro espacios:

def sumar(numeros):
    suma = 0
    for numero in numeros:
        suma += numero
    return suma

La indentación forma parte de la sintaxis

No mezcles tabuladores y espacios. Configura el IDE para insertar cuatro espacios y mantén la misma sangría en cada bloque.

6. Entrada de datos y conversiones

input() detiene el programa, muestra opcionalmente un mensaje y devuelve siempre una cadena. Si se espera un número, hay que convertirlo:

nombre = input("¿Cómo te llamas? ")
edad = int(input("¿Qué edad tienes? "))
print(f"{nombre} tiene {edad} años")

Las conversiones explícitas las solicita quien programa:

int("12")      # 12
float("3.14")  # 3.14
str(42)         # "42"
bool("")       # False
bool("0")      # True: una cadena no vacía es verdadera

Si el texto no representa un número válido, int() o float() producen ValueError. Python también convierte implícitamente un int a float en una operación numérica, pero no convierte automáticamente una cadena en número ni un número en texto para concatenarlo.

7. Comentarios y documentación

Los comentarios empiezan por # y el intérprete los ignora. Deben explicar una decisión o una intención, no repetir literalmente el código:

# Aplicamos el IVA solo después de calcular el subtotal.
total = subtotal * (1 + IVA)

Los docstrings documentan módulos, funciones, clases o métodos y se escriben como primera sentencia con tres comillas:

def calcular_total(precio, cantidad):
    """Devuelve el importe de una línea de pedido."""
    return precio * cantidad

8. Palabras reservadas y nombres

Las palabras reservadas forman parte de la sintaxis y no pueden usarse como identificadores. En Python 3 se encuentran, entre otras: and, as, assert, async, await, break, case, class, continue, def, del, elif, else, False, finally, for, from, global, if, import, in, is, lambda, None, nonlocal, not, or, pass, raise, return, True, try, while, with y yield.

En cuanto a los nombres, estas son las reglas y recomendaciones principales:

• puede contener letras, dígitos y _, pero no comenzar por un dígito;
• Python distingue mayúsculas y minúsculas: dato y Dato son nombres distintos;
• usa snake_case para variables, funciones y módulos (numero_intentos);
• usa PascalCase para clases (CuentaBancaria);
• escribe las constantes por convención en MAYUSCULAS_CON_GUION_BAJO;
• elige nombres expresivos: contador comunica más que c.

busca información sobre aquellos términos que no conozcas

snake_case y PascalCase son convenciones de nomenclatura usadas en programación. También se conocen como lower_case_with_underscores y UpperCamelCase, respectivamente.

9. Errores y depuración inicial

Los errores más frecuentes en este punto son:

Tipo de error	Ejemplo	Qué revisar
Sintaxis	bad name = 5	Nombres, dos puntos, paréntesis e indentación.
Ejecución	int("abc")	Datos recibidos y conversiones válidas.
Nombre	print(principle) sin definirlo	Ortografía y orden de las asignaciones.
Semántica	1 / 2 * pi cuando se quería 1 / (2 * pi)	Precedencia y resultado esperado.

>>> bad name = 5
  File "<stdin>", line 1
    bad name = 5
        ^
SyntaxError: invalid syntax

Depurar consiste en reproducir el problema, leer el mensaje, aislar la causa, corregir una cosa cada vez y volver a probar. El intérprete no puede adivinar la intención: un programa puede ejecutarse sin errores y producir un resultado incorrecto.

Comprueba tu comprensión

¿Qué ocurre al ejecutar input() y sumar directamente el resultado a 2? ¿Qué conversión necesitas si la persona usuaria ha escrito un entero?

10. Buenas prácticas

• Comienza con un algoritmo claro y traduce una parte cada vez.
• Ejecuta ejemplos pequeños en el intérprete antes de crear un programa grande.
• Usa nombres expresivos, cuatro espacios y comentarios que aporten contexto.
• Revisa tipos con type() cuando no tengas claro qué dato manejas.
• Convierte las entradas en el punto donde las recibes y valida los casos problemáticos.
• Prueba valores normales, extremos e inesperados.

11. Resumen

• Un módulo Python puede contener importaciones, variables, funciones, clases y un punto de entrada.
• El intérprete permite experimentar y los archivos .py permiten guardar y repetir programas.
• Las variables asocian nombres a valores; los literales son valores escritos directamente y las constantes se expresan mediante una convención.
• Las expresiones usan operadores y respetan una precedencia que puede hacerse explícita con paréntesis.
• input() devuelve texto, por lo que las entradas numéricas suelen requerir int() o float().
• La indentación, los nombres y los comentarios forman parte de un código legible y mantenible.

Conexión con el siguiente apartado

Ya podemos escribir programas sencillos en Python. En 1.3. Tipos de datos estudiaremos con más detalle números, cadenas, booleanos y contenedores, y aprenderemos qué operaciones son adecuadas para cada tipo.

Bibliografía y fuentes

• Python Software Foundation: documentación de Python.
• Tutorial de Python.
• Elementos de un programa de Python.
• PEP 8: guía de estilo para código Python.
• Documentación básica de Kotlin.

Presentación

• PR-U1.2. Práctica con un lenguaje