Hasta este punto del curso, todos tus programas han sido “sordos”: ejecutaban operaciones con datos fijos (literales) que tú escribías directamente en el código, pero no tenían la capacidad de reaccionar a lo que un usuario real quisiera decirles. En el desarrollo real, prácticamente cualquier software necesita leer y procesar datos del exterior.
Para solucionar esto, Python nos presenta una función completamente nueva que actúa como el reflejo exacto en un espejo de nuestra vieja conocida print():
print() toma datos desde el interior del programa y los envía hacia la consola. No genera ningún resultado matemático almacenable (devuelve None).
input() hace el viaje inverso: detiene el programa y extrae datos desde la consola para introducirlos al código en ejecución, devolviendo un resultado sumamente útil.
La función input() es capaz de capturar lo que el usuario teclee y entregárselo directamente a tu programa, logrando que el código sea verdaderamente interactivo. Analicemos detenidamente el flujo de este programa básico:
print("Dime lo que sea...")anything =input()print("Hmm...", anything, "... ¿En serio?")
Al ejecutar este bloque en tu entorno de desarrollo, el intérprete realizará las siguientes acciones secuenciales:
print("Dime lo que sea..."): Lanza un mensaje en la pantalla para indicarle al usuario que el sistema está esperando una interacción (esto se conoce técnicamente como un prompt).
anything = input(): Python invoca a la función input(). En este momento, el programa se congela por completo. La consola cambia a “modo entrada”, verás un cursor parpadeando y el sistema se quedará esperando a que el usuario presione teclas y finalice la instrucción pulsando la tecla Enter.
El almacenamiento obligatorio: Cuando el usuario presiona Enter, todo el texto digitado viaja hacia el programa como resultado de la función. Es absolutamente crucial asignar este resultado a una variable (como hicimos con anything =). Si olvidas este paso, los datos introducidos por el usuario caerán al vacío y se perderán para siempre en la memoria.
print("Hmm...", anything, ...): El script se reanuda, toma el contenido guardado en la variable y lo proyecta combinado con otros textos.
La función input() con argumentos y su tipo de dato nativo
La función input() es más versátil de lo que parece a simple vista. Tiene la capacidad de interactuar con el usuario de forma directa, eliminando la necesidad de usar una función print() previa para lanzar el mensaje de aviso (prompt).
anything =input("Dime lo que sea...")print("Hmm...", anything, "... ¿En serio?")
¿Cómo funciona esta variante?
Invocamos a la función input() pasándole un único argumento: una cadena de texto con nuestro mensaje.
Python muestra ese mensaje en la consola de inmediato, antes de abrir el modo de espera.
El cursor se queda parpadeando justo al lado del texto, esperando las pulsaciones del teclado y el Enter del usuario.
Esta técnica simplifica notablemente la estructura de tu script, reduciendo líneas de código y haciéndolo mucho más limpio y legible.
El Experimento del Colapso
Debido a esto, tienes estrictamente prohibido usar el resultado directo de un input() para realizar operaciones aritméticas. Mira lo que sucede en este fragmento propuesto por el curso:
anything =input("Introduce un número: ")something = anything **2.0print(anything, "elevado a la potencia de 2 es", something)
Si ejecutas este código e introduces el número 4, el programa no calculará. En la segunda línea, el script se interrumpirá bruscamente y arrojará un error fatal de tipo en la consola:
TypeError: unsupported operand type(s) for **: 'str' and 'float'
Python te está diciendo con toda claridad: “No puedo elevar una palabra (un str) a una potencia matemática”. Para el intérprete, estás intentando multiplicar letras por números.
El Resultado de input():
Debemos establecer una regla absoluta y sin excepciones que el Python Institute evalúa bajo máxima presión en sus exámenes:
Regla de Oro (PCEP): El resultado de la función input() es SIEMPRE una cadena de texto (str).
No importa si el usuario teclea un entero como 5, un flotante como 3.14, o letras; Python empaquetará absolutamente todos esos caracteres dentro de un tipo str (es decir, el sistema leerá "5" o "3.14" con comillas invisibles).
Operaciones Prohibidas con input() y la Anatomía del Error
Si ejecutamos el código anterior e introducimos, por ejemplo, el número 5, la consola no nos da un resultado; nos arroja un reporte de colapso técnico llamado Traceback:
¿Cómo se lee este reporte de error? (Enfoque PCEP)
Cuando tu programa falle en los laboratorios o en los exámenes de simulación, no te asustes. Léelo de abajo hacia arriba:
La última línea (TypeError): Te da el diagnóstico de la enfermedad. Te dice que estás usando tipos de datos incompatibles (str y float) para el operador de potencia ().
La línea del medio (something = ...): Te muestra el fragmento exacto de código que causó el colapso.
La primera línea (File "main.py", line 4): Te indica en qué archivo y en qué número de línea exacta ocurrió el accidente.
La Lógica de Python
Este comportamiento es completamente lógico. Piensa en esto: ¿cuál sería el resultado matemático de elevar la frase “Ser o no ser” a la potencia de 2? No tiene ningún sentido. No podemos calcularlo nosotros, y Python tampoco puede.
Moldeo de Tipos (Type Casting): La Solución Definitiva
Python ofrece dos funciones extremadamente simples y directas para tomar un dato de un tipo y forzarlo a convertirse en otro. Estas funciones son int() y float().
Sus nombres, al igual que los de las variables bien estructuradas, son autodocumentados:
La función int(): Toma un único argumento (por ejemplo, una cadena de texto: int(cadena)) e intenta transformar esos caracteres en un número entero. Si lo que está dentro de la cadena no parece un número entero (por ejemplo, int("hola") o int("3.14")), el programa fallará con un error.
La función float(): Hace exactamente lo mismo, pero intenta convertir el argumento en un número flotante (con punto decimal).
Esto es tan simple como efectivo. Al proceso de transformar un tipo de dato en otro de forma explícita se le conoce en programación como moldeo de tipos o type casting.
El Flujo de Datos Sincronizado
La ventaja de estas funciones es que no necesitas crear variables intermedias para hacer la conversión. Puedes anidar las funciones, pasando el resultado de un input()directamente como argumento de tu función de moldeo.
anything =float(input("Introduce un número: "))something = anything **2.0print(anything, "elevado a la potencia de 2 es", something)
¿Cómo viaja la información en la primera línea?
Para entender cómo fluyen los datos desde el teclado hasta la pantalla, imagina que Python resuelve esta línea desde el núcleo hacia afuera, como las capas de una cebolla:
input(...) entra en acción: Muestra el prompt en la pantalla y congela el script. El usuario teclea, por ejemplo, el número 5 y presiona Enter.
Nace el texto: La función input() extrae ese dato de la consola y lo convierte en el literal de cadena "5" (con comillas).
El relevo de float(): De inmediato, esa cadena "5" es succionada por la función exterior float(). Esta función toma las letras, borra las comillas invisibles, le añade el formato decimal y lo transforma en el número real 5.0.
La caja de almacenamiento: El número flotante 5.0 se deposita finalmente dentro de la variable anything.
La matemática despierta: En la segunda línea, anything 2.0 se ejecuta sin problemas porque ahora Python está multiplicando un float por otro float ($5.0^2$).
Si corres este código en tu entorno e introduces un 0, un número negativo como -3 o un número gigante, el programa calculará la potencia perfectamente y la consola proyectará el resultado sin colapsar.
El Trío Dinámico en Acción: Pitágoras Interactivo
Tener en tu equipo de desarrollo la combinación de input() – int() – float() te abre un abono infinito de nuevas posibilidades. A partir de ahora, puedes escribir programas completos que acepten datos numéricos del exterior, los procesen matemáticamente y proyecten el resultado final en la pantalla.
Es cierto que, por ahora, estos programas son lineales y algo primitivos; no pueden tomar decisiones de forma autónoma ni reaccionar de manera diferente ante situaciones imprevistas (como cuando un usuario introduce datos incoherentes). Sin embargo, eso lo solucionaremos muy pronto en los siguientes módulos.
Evolución del Programa: Leyendo Catetos desde la Consola
Vamos a reescribir el script que calcula la hipotenusa, pero esta vez, en lugar de usar valores fijos en el código (3.0 y 4.0), permitiremos que el usuario introduzca las longitudes de los catetos directamente por el teclado.
leg_a =float(input("Ingresa la longitud del primer cateto: "))leg_b =float(input("Ingresa la longitud del segundo cateto: "))hypo = (leg_a**2+ leg_b**2) **.5print("La longitud de la hipotenusa es", hypo)
🔍 Análisis de Ejecución:
El programa solicita dos veces consecutivas las medidas en la consola.
Convierte de inmediato las entradas de texto en números flotantes (float) mediante el moldeo de tipos.
Evalúa la fórmula matemática y almacena el resultado en la variable intermedia hypo.
⚠️ La debilidad del programa: Si ejecutas este código e introduces valores negativos (como -3 o -4), notarás que el programa calcula el resultado igualmente sin quejarse (5.0). Esto pasa porque cualquier número negativo elevado al cuadrado se vuelve positivo. Python no entiende de geometría del mundo real, solo obedece la aritmética. Ignoraremos esta flaqueza por ahora; aprenderemos a controlarla cuando veamos condicionales.
Optimización de Código: Eliminando Variables Redundantes
En el bloque de código del Sandbox, la variable hypo se utiliza con un único propósito: guardar el valor calculado para poder pasárselo a la función print() en la línea inmediatamente posterior.
Dado que la función print() tiene la capacidad de aceptar expresiones matemáticas complejas directamente como argumentos, podemos deshacernos de esa variable intermedia. Esto limpia el script y reduce el uso innecesario de etiquetas en la memoria de la computadora. El código optimizado y ultra-compacto queda de esta manera:
leg_a =float(input("Ingresa la longitud del primer cateto: "))leg_b =float(input("Ingresa la longitud del segundo cateto: "))# Pasamos la fórmula matemática directamente como argumento dentro de print()print("La longitud de la hipotenusa es", (leg_a**2+ leg_b**2) **.5)
¿Qué ganamos con esto?
El código es más corto y directo.
Evitamos crear un espacio en memoria (hypo) que solo íbamos a usar una vez.
Cuando escribes código, tarde o temprano sentirás la necesidad de incluir algunas palabras dirigidas no a Python, sino a los humanos. Ya sea para explicarle a otro programador cómo funciona un truco complejo en el script, detallar el propósito de una variable, o dejar registro de quién es el autor y cuándo se escribió el programa.
Una anotación insertada en el código fuente que el intérprete ignora por completo en tiempo de ejecución se conoce formalmente como comentario.
¿Cómo se escribe un comentario en Python?
Para evitar que Python intente interpretar tus notas humanas como órdenes o comandos, debes usar el símbolo # (almohadilla, hash o gato).
Cada vez que Python se topa con un signo # en el programa, todo lo que esté escrito a la derecha de ese símbolo se vuelve completamente invisible y transparente para él. Desde el punto de vista técnico del intérprete, un comentario equivale simplemente a un espacio en blanco, sin importar lo largo que sea.
Comentarios de una o varias líneas
Un comentario en Python se extiende estrictamente desde el signo # hasta el final de la línea actual. Si necesitas redactar un comentario que abarque varios renglones, debes colocar un signo # al inicio de cada uno de ellos.
# Este programa calcula la hipotenusa c.# a y b son las longitudes de los catetos.a =3.0b =4.0c = (a **2+ b **2) **0.5# Usamos ** en lugar de una función de raíz raíz.print("c =", c)
Como ves en el ejemplo, existen dos formas de colocar comentarios:
Bloque independiente: Ocupando líneas completas al inicio para dar contexto.
Línea interna (inline comment): Colocado a la derecha de una instrucción de código (c = ... # Usamos ). Python ejecuta la matemática de la izquierda e ignora la nota de la derecha.
El Código Autodocumentado: La Mejor Práctica
Los desarrolladores profesionales y responsables acostumbran a describir los fragmentos importantes de sus sistemas. Sin embargo, la comunidad de Python defiende una regla de oro: la mejor manera de comentar una variable es asignándole un nombre que no deje lugar a dudas.
Si creas una variable diseñada para almacenar el área de un terreno, el nombre area_terreno es infinitamente superior a ponerle caja_1 o tia_juana. Un nombre bien elegido se considera autodocumentado (self-commenting), lo que reduce drásticamente la necesidad de llenar tu archivo de textos explicativos redundantes.
Comentarios como Herramienta de Depuración (Testing)
Los comentarios tienen otra utilidad estratégica vital: te permiten “desactivar” temporalmente líneas de código que no necesitas en un momento dado o que sospechas que están provocando un fallo.
# Este es un programa de prueba.x =1y =2# y = y + xprint(x + y)
Truco Pro de Productividad (Atajo de Teclado)
Escribir el signo # línea por línea en bloques largos de código puede ser tedioso. Los editores de código modernos y los entornos de desarrollo (IDEs) incluyen un atajo universal sumamente útil:
Windows / Linux: Selecciona las líneas que deseas modificar y presiona CTRL + /
Mac OS: Selecciona las líneas y presiona CMD + /
Este comando funciona como un interruptor (toggle): si las líneas no tienen comentario, les añade el # automáticamente; si ya están comentadas, les quita el signo de inmediato.
Es evidente que Python te permite codificar literales con valores numéricos y de texto, y ya has aprendido a realizar operaciones aritméticas con ellos. Sin embargo, en cualquier desarrollo real surge una pregunta inevitable: ¿Cómo guardamos los resultados de esas operaciones para usarlos en cálculos posteriores?
Si no tuviéramos una forma de almacenar esos resultados intermedios, tendríamos que escribir expresiones infinitas y redundantes. Para resolver esto, Python nos ofrece “cajas” o contenedores especiales llamados variables. El nombre mismo lo dice todo: el contenido de estos contenedores puede variar en casi cualquier momento del programa.
Toda variable en Python consta obligatoriamente de dos elementos esenciales:
Un nombre: El identificador único que usas para llamar a la caja.
Un valor: El contenido o dato que está guardado dentro de la caja.
Las variables no aparecen de la nada de forma automática. Como desarrollador, tú debes decidir cuántas variables necesitas y qué nombres estratégicos les vas a asignar.
Reglas Estrictas para Nombrar Variables
Para que el intérprete de Python acepte el nombre de una variable sin arrojar un SyntaxError, debes seguir estas cinco reglas obligatorias:
1. Caracteres permitidos
El nombre solo puede estar compuesto por letras mayúsculas o minúsculas (de la A a la Z), dígitos (del 0 al 9) y el carácter de guion bajo o underscore (_). No se permiten espacios, eñes, acentos ni símbolos especiales ($, @, -, etc.).
2. El primer carácter es clave
El nombre de una variable debe comenzar obligatoriamente con una letra o con un guion bajo (_). Jamás puede empezar con un número.
mi_variable_1 ➔ Válido
_contador ➔ Válido
1_variable ➔ Inválido (Provoca error por empezar con dígito).
3. El guion bajo es considerado una letra
Para efectos sintácticos, Python trata al carácter _ con el mismo estatus que una letra. Puedes usarlo al inicio o entre palabras para mejorar la legibilidad (estilo conocido como snake_case).
4. Sensibilidad a mayúsculas y minúsculas (Case-Sensitivity)
En el mundo real, “Pedro” y “pedro” representan el mismo nombre propio. En Python no es así. Las mayúsculas y minúsculas crean variables completamente distintas.
Si en tu código escribes Alice = 10 y luego intentas llamarla como print(alice), Python arrojará un error porque Alice y alice son dos cajas diferentes en la memoria.
5. Prohibido usar palabras reservadas (Keywords)
El nombre de la variable no puede coincidir con ninguna de las palabras clave que Python ya utiliza para sus propias funciones internas o estructuras de control (como True, False, print, None, etc.).
Aquí tienes la adaptación de esta sección fundamental sobre la creación y asignación dinámicas de variables. Aquí es donde Python demuestra por qué es un lenguaje tan ágil en comparación con alternativas más rígidas como C++ o Java.
Creación de Variables y el Operador de Asignación (=)
¿Qué puedes meter dentro de una variable? Lo que sea. Puedes utilizar una variable para almacenar cualquier tipo de dato de los que ya hemos estudiado (enteros, flotantes, cadenas, booleanos o None) y muchos otros tipos avanzados que analizaremos más adelante. El valor de una variable es, literalmente, el dato que decides depositar en ella. Y, haciendo honor a su nombre, puede cambiar tantas veces como quieras: puede ser un entero en un instante, transformarse en un flotante un segundo después y terminar convertida en una cadena de texto.
El Milagro de la Asignación Dinámica
En Python, una variable nace y cobra existencia en el instante exacto en el que le asignas un valor por primera vez.
A diferencia de otros lenguajes tradicionales de programación, en Python no necesitas declarar la variable de forma previa (no tienes que avisarle al sistema “Oye, voy a crear una caja para guardar un entero”). Si intentas inyectar un dato dentro de una variable que no existía, Python la creará automáticamente tras bambalinas. No requieres de ninguna configuración extra.
La sintaxis para dar vida a una variable es extraordinariamente sencilla: escribes el nombre que has elegido, colocas el signo de igual (=) y finalmente escribes el valor o expresión que deseas almacenar.
El Operador de Asignación en Acción
var =1print(var)
Este script ejecuta dos instrucciones secuenciales muy claras:
var = 1: El signo = aquí no significa “igualdad matemática”, sino asignación. Toma el literal entero 1 de la derecha y lo deposita dentro de la variable llamada var. Como var no existía en la memoria, Python la crea en ese mismo milisegundo.
print(var): Aquí descubrimos otra faceta imprescindible de la función print(). No solo procesa textos o cálculos directos; también puede recibir variables como argumentos.
Resumen de Control
Las variables se crean automáticamente al recibir su primer valor.
El signo = es el operador de asignación (mueve los datos de derecha a izquierda).
print(variable) muestra el contenido de la caja; print("variable") muestra el nombre textual de la caja.
Aquí tienes la adaptación de la sección sobre el uso práctico de variables. Aquí analizaremos cómo manipular múltiples contenedores a la vez, el peligro de llamar a variables inexistentes y una técnica muy útil para el examen: la concatenación de texto con variables.
Combinando Texto y Variables: La Concatenación
Una de las operaciones más comunes en programación es fusionar cadenas de texto estáticas con los valores almacenados dentro de nuestras variables.
var ="3.8.5"print("Python version: "+ var)
Cuando el operador + se coloca entre dos datos de tipo cadena de texto (str), su función cambia por completo: ya no realiza una suma aritmética, sino que ejecuta una concatenación (une los textos uno detrás del otro como si fueran vagones de un tren).
Python version: 3.8.5
Advertencia : La concatenación con el signo +solo funciona si ambos lados son cadenas de texto (str). Si intentas hacer "Edad: " + 25 (un texto más un entero), Python arrojará un error de tipo (TypeError). Para que funcione con números usando el signo +, el número tendría que estar entre comillas ("25").
Aquí tienes la adaptación de esta sección fundamental sobre la reasignación de variables. Aquí analizaremos cómo una variable puede cambiar su contenido a lo largo del tiempo y cómo resolver esa clásica línea de código (var = var + 1) que suele escandalizar a los matemáticos pero que es el pan de cada día en la programación.
Reasignación de Variables y el Secreto de var = var + 1
¿Cómo se le asigna un nuevo valor a una variable que ya ha sido creada? Exactamente de la misma manera: volviendo a utilizar el signo de igual (=).
Como ya hemos mencionado, el signo de igual no representa una igualdad matemática, sino que es el operador de asignación. Su mecánica es directa y libre de ambigüedades: toma el valor o el resultado del argumento de la derecha y lo deposita en la variable de la izquierda. El argumento de la derecha puede ser desde un literal simple hasta una expresión arbitrariamente compleja llena de operadores, otras variables y cálculos.
var =1print(var)var = var +1print(var)
Al ejecutar este script, la consola proyectará dos líneas:
12
En efecto, lo que hemos hecho es incrementar el valor de la variable en uno. No estamos comparando nada, estamos destruyendo el pasado de la variable para actualizarla con su nuevo presente.
Resumen de Control
Las variables solo pueden guardar un valor a la vez. Cada nueva asignación destruye el valor anterior.
En instrucciones como var = var + 1, Python siempre resuelve primero el cálculo matemático del extremo derecho usando los valores actuales antes de modificar la variable de la izquierda.
Operadores de Asignación Compuesta (Shortcut Operators)
En la programación real, es extremadamente común querer usar una misma variable tanto a la izquierda como a la derecha del operador de asignación =. Por ejemplo, si estás calculando una serie de potencias sucesivas de 2, escribirías algo como esto:
x = x *2
Python ofrece una forma abreviada y elegante de escribir exactamente estas mismas operaciones, ahorrándote repetir el nombre de la variable:
x *=2sheep +=1
La Regla General de Simplificación (Enfoque PCEP)
Podemos definir una regla matemática y sintáctica universal para estas abreviaciones. Si llamamos op a cualquier operador binario (es decir, que requiere obligatoriamente dos argumentos), y dicho operador se usa en el siguiente contexto:
Analiza detenidamente la siguiente tabla de equivalencias. En el examen de certificación PCEP es muy común que te pidan “traducir” una forma larga a una corta o viceversa:
Forma Tradicional (Larga)
Forma Compacta (Shortcut)
Operación Ejecutada
i = i + 2 * j
i += 2 * j
Suma combinada
var = var / 2
var /= 2
División (Resultado float)
rem = rem % 10
rem %= 10
Residuo o Módulo
j = j - (i + var + rem)
j -= (i + var + rem)
Resta de una subexpresión
x = x ** 2
x **= 2
Exponenciación o Potencia
La Gran Trampa de Prioridad en los Shortcuts
Cuando usas un operador compuesto como += o *=, toda la expresión que se encuentra a la derecha del signo se calcula PRIMERO, como si estuviera metida dentro de un paréntesis imaginario, sin importar qué operadores tenga.
x =2x *=3+5
Comportamiento real de Python: Primero se resuelve toda la derecha: 3 + 5 = 8. Después se aplica el shortcut: x = x * 8 \(\rightarrow\) 2 * 8. El resultado final en la consola será 16.
Resumen
Los shortcut operators (+=, -=, *=, /=, //=, %=, =) fusionan la operación matemática con la asignación.
El operando de la derecha se evalúa por completo antes de que el operador compuesto actúe.
Un operador es un símbolo reservado del lenguaje de programación que tiene la capacidad de realizar una acción o cálculo específico sobre uno o más valores (datos).
El ejemplo más intuitivo es el signo + (más), el cual, exactamente igual que en la aritmética tradicional, toma dos números a sus lados, los suma y devuelve el resultado de dicha adición. Los valores sobre los cuales actúa un operador reciben el nombre técnico de operandos.
+ (Suma)
- (Resta)
* (Multiplicación)
/ (División tradicional)
// (División de piso o entera)
% (Módulo o residuo)
**(Exponenciación o potencia)
El orden en el que aparecen listados estos operadores no es casualidad; responde a sus reglas jerárquicas de prioridad.
El Concepto de Expresión
Para comunicarte con Python de forma efectiva, necesitas estructurar tus instrucciones en forma de expresiones. Una expresión es la combinación e interconexión de datos (literales o variables) y operadores. Al ser evaluada por el intérprete, una expresión siempre se reduce a un único valor final.
Bajo esta regla, debes saber que el literal más simple por sí solo ya constituye una expresión (por ejemplo, el número 5 es una expresión cuyo valor es 5). Si conectas varios elementos mediante operadores (5 + 3 * 2), estás construyendo una expresión compleja que Python resolverá paso a paso siguiendo las leyes de la matemática.
Resumen de Terminología
Operador: El símbolo que ejecuta la acción (+, -, *).
Operando: El dato que sufre la acción del operador.
Expresión: El conjunto unificado de operandos y operadores (2 + 2).
Aquí tienes la adaptación de esta sección, enfocada en el operador de exponenciación (), introduciendo una de las reglas de tipado más importantes para el examen de certificación PCEP: cómo interactúan los tipos de datos en una operación aritmética.
La Exponenciación
El símbolo (doble asterisco) es el operador de exponenciación o potencia en Python. Su argumento de la izquierda actúa como la base, mientras que el argumento de la derecha es el exponente.
La matemática clásica prefiere la notación con superíndices (como \(2^3\)). Dado que los editores de texto plano no permiten escribir caracteres elevados de forma nativa, Python adoptó el doble asterisco para lograr el mismo efecto matemático:
print(2**3)
La Regla de Propagación de Tipos
Si ejecutas diferentes combinaciones de números utilizando la exponenciación, notarás un comportamiento sumamente regular y predecible en las salidas de la consola. Este experimento nos permite formular la regla de oro de los operadores numéricos en Python:
Entero puro: Cuando ambos argumentos del operador son números enteros (int), el resultado final será obligatoriamente otro número entero.
Contaminación por flotante: Cuando al menos uno de los argumentos del operador es un número de punto flotante (float), el resultado final se convertirá automáticamente en un flotante, sin importar que el resultado matemático sea exacto.
Aquí tienes la adaptación de estas dos secciones fundamentales. Analizaremos el operador de multiplicación y entraremos de lleno en la primera gran excepción del tipado aritmético en Python: la división tradicional.
Multiplicación (*)
El símbolo * (asterisco de forma individual) es el operador de multiplicación. Pongamos a prueba el bloque de código sugerido por el curso para comprobar si la regla de propagación de tipos que aprendimos con la exponenciación se sigue manteniendo:
La regla funciona a la perfección y de manera idéntica. Multiplicar enteros puros (int * int) produce un entero (6). En el momento en que introduces un punto decimal en cualquiera de los operandos, el resultado se convierte automáticamente en un flotante (6.0).
División Tradicional (/)
El símbolo / (barra diagonal o slash) representa el operador de división estándar. El valor situado a la izquierda es el dividendo y el de la derecha es el divisor.
El resultado producido por el operador de división tradicional (/) SIEMPRE, sin excepción, será un número de punto flotante (float).
¿Por qué esto representa un problema?
En el desarrollo de software (y especialmente en algoritmos de ciencia de datos, machine learning o control de bucles), existen situaciones críticas donde necesitas estrictamente un número entero como resultado de una división (por ejemplo, si estás calculando el índice de una lista o una posición en una matriz). Un número con punto decimal provocaría un error de sintaxis en esos contextos.
División Entera (//)
Para solucionar la necesidad de obtener resultados numéricos sin decimales, Python incorpora el operador // (doble barra diagonal). Este operador se conoce formalmente como división entera o, de manera más precisa en ciencias de la computación, división de piso (floor division). Este difiere de la división estándar en dos características sintácticas y semánticas cruciales:
Elimina la parte fraccionaria: El resultado carece por completo de decimales (si operas enteros) o su parte decimal es forzada a ser siempre cero (si operas flotantes).
Cumple estrictamente la regla de propagación de tipos (int vs float).
La Regla del “Piso”: Redondeo hacia el Entero Menor
Llevemos el análisis a un nivel más avanzado. ¿Qué ocurre cuando el resultado matemático real no es exacto?
print(6//4)print(6. //4)
Si estuviéramos utilizando la división tradicional (/), el resultado matemático exacto sería 1.5. Sin embargo, al ejecutar este código con //, obtenemos:
11.0
Regla Crítica de Redondeo (PCEP)
El resultado de la división de piso siempre se redondea al número entero más cercano que sea MENOR o IGUAL al resultado real (no redondeado). No se trata de un truncamiento simple, sino de un desplazamiento hacia la izquierda en la recta numérica (hacia el valor más pequeño).
El resultado real es 1.5.
El entero menor más cercano a 1.5 es 1. Por lo tanto, el resultado es 1 (o 1.0 si hay un float).
El Peligro de los Números Negativos
Donde la mayoría de los estudiantes comete errores en el examen PCEP es al aplicar la división de piso con operandos negativos. Intenta predecir el resultado del siguiente bloque:
print(-6//4)print(6. //-4)
A primera vista, podrías pensar: “Si en el caso anterior dio 1, aquí debería dar -1”. Vamos a ejecutarlo y observar la consola:
-2-2.0
¿Por qué da -2 en lugar de -1?
Apliquemos estrictamente la regla del piso matemática:
El resultado matemático real (exacto) de -6 / 4 es -1.5.
La regla exige redondear hacia el entero menor en la recta numérica (moverse hacia la izquierda).
En el universo de los números negativos, -2 es menor que -1 (está más alejado del cero).
Por esta razón, Python redondea hacia abajo, alcanzando el -2 (o -2.0).
Resumen
Definición:// calcula la división y aplica la función suelo (floor).
Positivos:6 // 4 da 1 (el entero menor cercano a 1.5).
Negativos:-6 // 4 da -2 (el entero menor cercano a -1.5).
Tipado:int // int = int. Si hay algún float involucrado, el resultado será float (ej. 1.0 o -2.0).
Aquí tienes la adaptación de la sección sobre el operador de módulo o residuo (%) y las restricciones absolutas de la división en Python. Este es un concepto de gran peso en la lógica de programación y un blanco frecuente de preguntas en el PCEP.
El Residuo o Módulo (%)
El siguiente operador es bastante peculiar porque no tiene un símbolo equivalente directo en la aritmética tradicional de la escuela. En Python se representa con el signo de porcentaje (%).
Para que no te confunda su diseño, un buen truco visual es imaginarlo como la barra de la división (/) acompañada por dos pequeños círculos. Su función es crucial: devolver el residuo (lo que sobra) de una división entera.
En otras palabras, es el valor que queda remanente tras intentar encajar un número entero dentro de otro tantas veces como sea posible. En muchos otros lenguajes de programación se le conoce formalmente con el nombre de módulo.
Anatomía del Cálculo del Módulo
Analicemos el primer ejemplo básico propuesto por el curso. Intenta predecir el resultado antes de mirar la explicación:
print(14%4)
Al ejecutarlo, la consola nos devuelve un 2. ¿Por qué? El proceso matemático interno que sigue Python se divide en tres pasos automáticos:
Realiza una división de piso para hallar el cociente entero: 14 // 4 da 3 (el 4 cabe 3 veces enteras en el 14).
Multiplica ese cociente por el divisor original: 3 * 4 da 12.
Resta ese valor intermedio al dividendo original para hallar el residuo: 14 - 12 da 2.
Elevando la Dificultad: Módulo con Flotantes
El operador % también cumple de forma estricta la regla de propagación de tipos (int vs float). Observa este caso más complejo:
print(12%4.5)
¿Cuál es el resultado?
Si hacemos el mismo desglose algorítmico:
12 // 4.5 da como resultado 2.0 (el 4.5 cabe dos veces enteras en el 12, acumulando 9.0).
Multiplicamos el cociente por el divisor: 2.0 * 4.5 nos da 9.0.
Restamos el dividendo original menos el resultado intermedio: 12 - 9.0 da 3.0.
Dado que uno de los operandos era un flotante (4.5), todo el resultado se “contamina”, devolviendo en la consola 3.0 en lugar de un 3 entero.
Operadores: Cómo NO debes dividir (Límites de la Máquina)
Existe una regla matemática universal que las computadoras defienden de forma agresiva debido a limitaciones físicas en la unidad de procesamiento aritmético: la división por cero es imposible.
En tus programas de Python, jamás debes intentar:
Realizar una división tradicional por cero (6 / 0).
Realizar una división de piso o entera por cero (6 // 0).
Encontrar el residuo de una división por cero (6 % 0).
Si el intérprete de Python topa con cualquiera de estas tres operaciones durante la ejecución de tu script, detendrá el programa de golpe y arrojará un error en tiempo de ejecución muy específico: ZeroDivisionError: integer division or modulo by zero.
Resumen
% extrae únicamente el residuo de una división.
Sigue las reglas de tipado: int % int da int. Si hay un float, devuelve float.
Cualquier variante de división donde el divisor sea 0 provocará un colapso del programa (ZeroDivisionError).
Aquí tienes la adaptación de esta sección, donde cerramos el catálogo de operadores básicos con la suma y la resta, e introducimos una distinción conceptual teórica que es pregunta de examen obligatoria en el PCEP: la diferencia entre operadores unarios y binarios.
El Operador de Suma (+)
El signo más (+) actúa como el operador de adición propagando el punto flotante en caso de que haya.
print(-4+4)print(-4. +8)
04.0
En la primera línea, int + int produce el entero 0.
En la segunda línea, la presencia del punto decimal en el -4. propaga el tipo flotante, devolviendo 4.0.
Operadores Binarios vs. Operadores Unarios
El signo menos (-) tiene una naturaleza dual en programación. Puede actuar de dos formas completamente distintas dependiendo de cuántos argumentos (operandos) lo acompañen. Esto nos permite clasificar los operadores en dos familias:
Operadores Binarios (Requieren DOS operandos)
Cuando utilizas el signo - para realizar una resta tradicional, el operador espera obligatoriamente dos argumentos: uno a la izquierda (el minuendo) y otro a la derecha (el sustraendo). Por esta razón, la resta es un operador binario, exactamente igual que la suma (+), la multiplicación (*) y la división (/).
Operadores Unarios (Requieren UN solo operando)
El signo menos también puede utilizarse para cambiar o invertir el signo de un número. Cuando escribes -4, el operador no está restando nada; simplemente está modificando la polaridad del operando que tiene a su derecha. Al actuar sobre un único argumento, se le considera un operador unario.
Aquí tienes la adaptación de esta sección fundamental sobre la prioridad (precedencia) y asociatividad (bindings) de los operadores. Estos conceptos matemáticos abstractos determinan el orden exacto en el que Python desglosa expresiones complejas y son una fuente garantizada de preguntas capciosas en el examen PCEP.
Jerarquía de Operadores: Prioridad y Asociatividad
Hasta ahora hemos analizado cada operador de forma aislada, como si no tuvieran relación entre sí. Sin embargo, en la programación real, lo habitual es encontrar expresiones complejas donde conviven múltiples operadores al mismo tiempo.
El fenómeno que provoca que algunos operadores actúen antes que otros se conoce formalmente como la jerarquía de prioridades o precedencia de operadores. Python define con precisión matemática el nivel de prioridad de cada símbolo, asegurando que los operadores con mayor prioridad tomen el control de los operandos antes que los de menor prioridad.
Asociatividad de Operadores (Bindings)
¿Qué sucede cuando en una misma expresión se encuentran dos operadores pegados que tienen exactamente la misma prioridad? Aquí es donde entra en juego la asociatividad (binding), la cual determina el orden de evaluación de izquierda a derecha o viceversa.
La gran mayoría de los operadores en Python tienen asociatividad a la izquierda (left-sided binding). Esto significa que el cálculo de la expresión se ejecuta estrictamente de izquierda a derecha. Analicemos este ejemplo con el operador de módulo:
Tabla de Precedencia y Asociatividad (De Mayor a Menor)
Nivel de Prioridad
Operador
Descripción
Asociatividad (Binding)
1 (Máxima)
**
Exponenciación (Potencia)
Derecha a Izquierda (La gran excepción)
2
+, -
Operadores Unarios (Signo positivo/negativo)
Izquierda a Derecha
3
*, /, //, %
Multiplicación, División, División de piso y Módulo
Izquierda a Derecha
4 (Mínima)
+, -
Operadores Binarios (Suma y Resta)
Izquierda a Derecha
Unarios vs. Binarios
Un signo menos unario (-5) tiene más prioridad que una multiplicación o una división, pero un signo menos binario (5 - 2) tiene menos prioridad que ellas. Observa cómo cambia el orden en este ejemplo:
print(-3**2)
Aquí, la potencia tiene un nivel de prioridad (1) más alto que el menos unario (2). Por lo tanto, Python calcula primero $3^2 = 9$, y después el menos unario entra en acción para cambiarle el signo, dando como resultado -9 (y no 9 positivo, como ocurriría si el menos operara primero). Si quisieras elevar el número negativo completo, estarías obligado a usar paréntesis: (-3) 2.
Operadores y Paréntesis: Rompiendo las Reglas Naturales
Por supuesto, no estás atado a las prioridades por defecto de Python. Tienes permitido utilizar paréntesis () en cualquier momento para alterar el orden natural de un cálculo. En perfecta sintonía con las reglas aritméticas universales, las subexpresiones que se encuentran dentro de los paréntesis siempre se calculan primero.
Puedes anidar tantos paréntesis como necesites. De hecho, muchos desarrolladores los utilizan incluso cuando no alteran el orden, simplemente para que el código sea más legible y fácil de entender para otros humanos.
Reto: El Desafío de los Paréntesis Anidados
Intenta resolver paso a paso la siguiente expresión compleja antes de mirar la solución. Es un excelente ejercicio de rastreo mental para el PCEP:
print((5* ((25%13) +100) / (2*13)) //2)
El flujo va estrictamente desde adentro hacia afuera. Python no puede resolver el contenedor exterior sin saber primero qué valor numérico esconde el contenedor más interno.
Cuando tienes bloques independientes de paréntesis que no dependen el uno del otro, la regla que aplica Python es procesar de izquierda a derecha.
Desglose paso a paso desde el interior hacia el exterior:
Primer bloque interno (25 % 13): El 13 cabe una sola vez en el 25 y genera un residuo de 12.
Segundo bloque interno (12 + 100): Sumamos el residuo anterior, lo que nos da 112.
Bloque del divisor (2 * 13): Resolvemos el paréntesis del extremo derecho, obteniendo 26.
Multiplicación izquierda (5 * 112): Multiplicamos el resultado del segundo paso, lo que nos da 560.
División tradicional (560 / 26): Al usar la barra diagonal /, el resultado se transforma obligatoriamente en un número flotante: 21.53846153846154.
División de piso final (21.53846153846154 // 2): Aplicamos la división entera sobre el flotante. El 2 cabe exactamente 10 veces en el 21. Al haber un flotante involucrado, la parte decimal se fuerza a cero.
El resultado final que verás en la consola es 10.0.
A nivel teórico, un literal se define como un dato cuyo valor está determinado única y exclusivamente por su propia representación literal. Como esta definición formal puede resultar un tanto abstracta y difícil de asimilar al principio, recurramos a un ejemplo práctico para entenderlo a la perfección.
El Experimento de la Identificación
Analicemos detenidamente los dos elementos siguientes:
Caso 1: Una secuencia numérica
123
Si miras este conjunto de dígitos, ¿puedes deducir qué valor representa? La respuesta es inmediata: representa el número ciento veintitrés. No hay espacio para la duda ni la libre interpretación; su valor es fijo y evidente.
Caso 2: Una sola letra
c
Si miras esta letra de forma aislada, ¿sabrías decir con certeza qué valor representa? Aquí la situación cambia. Podría ser el símbolo físico de la velocidad de la luz, la constante de integración en una fórmula de cálculo matemático, o la longitud de la hipotenusa en el teorema de Pitágoras. Las posibilidades son infinitas.
Sin información o contexto adicional (como una línea de código previa que defina su significado), es imposible saber qué representa exactamente esa c.
La Clave de la Distinción
123 es un literal: Su valor es inmutable y obvio desde el momento en que se escribe. No necesita un contexto para “significar” ciento veintitrés; se explica por sí mismo.
c no es un literal: Es un símbolo (en programación, habitualmente una variable). Su valor es abstracto y puede cambiar o asignarse dinámicamente a lo largo del programa.
¿Para qué sirven los literales en el código?
En el desarrollo de software, utilizas los literales constantemente para codificar datos duros y fijos directamente dentro de tu código fuente (por ejemplo, cuando escribes el mensaje "Hello, World!", el número de iteraciones de un bucle como 10, o una tasa de interés fija como 0.16).
Sin embargo, para que el intérprete de Python no confunda tus literales con variables u otras instrucciones, el lenguaje exige respetar una serie de convenciones y reglas de escritura muy estrictas según el tipo de dato que estés manejando (enteros, decimales, textos o booleanos).
Aquí tienes la adaptación de esta sección, enfocada en la diferencia fundamental entre cómo procesa la computadora un string frente a un número entero, un concepto clave para entender el manejo de memoria en Python y preparar tu examen PCEP.
Detrás de la Pantalla: Strings vs. Números Enteros
Para entender cómo maneja Python los datos internamente, analicemos el siguiente experimento mental con dos líneas de código muy similares pero con una diferencia crítica:
print("2026")print(2026)
A primera vista, la primera línea te resultará completamente familiar (un string delimitado por comillas). La segunda línea podría parecer un error debido a la total ausencia de comillas. Sin embargo, si ejecutas este código, el intérprete no protestará. Al contrario, verás dos líneas exactamente idénticas en tu pantalla:
20262026
¿Qué pasó realmente? Dos Tipos de Literals
Aunque el resultado visual en la consola sea idéntico, semánticamente estás lidiando con dos especies de datos completamente diferentes:
Un String ("2026"): Una cadena de caracteres que ya dominas.
Un Número Entero (2026): Un literal de tipo numérico entero (integer), algo totalmente nuevo en nuestro recorrido.
La función print() se encarga de traducir ambos a una forma legible para los humanos, y dado que la representación visual de ambos es la misma, en la pantalla se ven igual. Pero dentro de la memoria de la computadora, sus vidas son radicalmente distintas.
La Vida Interna en la Memoria del Computador
El almacenamiento de estos dos literales sigue caminos opuestos en el hardware:
El String ("2026"): Para la computadora, este dato no tiene ningún valor matemático. Existe en la memoria simplemente como una secuencia de caracteres o letras independientes (el carácter ‘2’, seguido del ‘0’, luego el ‘2’ y finalmente el ‘6’). La máquina no sabe qué número es, solo guarda los dibujos de los caracteres alineados.
El Número Entero (2026): Cuando Python ve los dígitos directos sin comillas, sabe que se trata de una cantidad matemática. El intérprete toma el número y lo convierte directamente en código máquina, es decir, en una representación binaria pura (un conjunto de bits, ceros y unos) dentro de los circuitos del procesador.
Gracias a esta conversión, la computadora puede usar ese 2026 para realizar operaciones aritméticas reales (sumar, restar, multiplicar), algo que sería imposible de hacer directamente con el string "2026".
Aquí tienes la adaptación de esta sección clave sobre los números enteros, estructurada con la claridad conceptual necesaria para asentar las bases del tipado de datos en Python y asegurar puntos en el examen PCEP.
Literales Numéricos: El Tipo Entero (Integer)
Los números que manejan las computadoras modernas se dividen principalmente en dos grandes mundos:
Enteros (Integers / int): Números que carecen por completo de parte fraccionaria o decimal (por ejemplo, 4, -15, 0).
Números de Punto Flotante (Floats / float): Números que contienen (o pueden contener) una parte fraccionaria o decimal (por ejemplo, 3.14, -0.5).
Esta distinción es crítica. La frontera entre ambos es sumamente estricta porque difieren radicalmente en cómo se almacenan en la memoria física del ordenador y en el rango de valores que pueden adoptar.
A la característica que determina la naturaleza de un valor, su rango admisible y sus aplicaciones permitidas se le conoce formalmente como Tipo de Dato (Data Type). En Python, la estructura física de tu literal le indica automáticamente al intérprete qué tipo de dato debe asignarle en memoria.
¿Cómo reconoce Python un número entero?
El proceso es muy intuitivo y se parece a cómo escribes un número con lápiz en papel: es simplemente una secuencia continua de dígitos. Sin embargo, existe una restricción absoluta: no puedes intercalar ningún carácter que no sea un dígito dentro del número.
Tomemos como ejemplo el número once millones ciento once mil ciento once. En el mundo real, para facilitar la lectura de tantas cifras, usarías alguna de estas notaciones:
11,111,111 (Notación anglosajona)
11.111.111 (Notación europea)
11 111 111 (Separación por espacios)
Python prohíbe terminantemente el uso de comas, puntos o espacios en blanco dentro de un entero. Si pones un punto, Python pensará que es un decimal (float); si pones una coma o un espacio, arrojará un error de sintaxis inmediato.
La solución: El uso de guiones bajos (_)
Para resolver este problema de legibilidad en números grandes, Python introdujo una regla especial: permite el uso de guiones bajos individuales como separadores visuales. El intérprete ignora por completo estos guiones bajos al procesar el valor. Por lo tanto, puedes escribir legítimamente ese número de dos formas:
numero_1 =11111111# Válido, pero difícil de leer a simple vistanumero_2 =11_111_111# Válido, limpio y perfectamente legible
Gestión de Signos: Números Positivos y Negativos
La codificación de la polaridad numérica en Python sigue las convenciones matemáticas universales:
Números Negativos: Se configuran anteponiendo de forma obligatoria el operador menos (-) al literal.Pythonprint(-11111111) print(-11_111_111)
Números Positivos: No requieren ningún signo que los preceda de forma obligatoria; la ausencia de signo le indica a Python que el número es positivo. Sin embargo, es completamente permisible añadir un signo más (+) si deseas hacerlo explícito en tu código. Las siguientes dos líneas producen exactamente el mismo valor semántico.
Aquí tienes la adaptación de esta sección avanzada sobre los sistemas numéricos alternativos, un tema recurrente y crítico en el examen de certificación PCEP para evaluar tu comprensión profunda de los literales enteros.
Sistemas Numéricos Alternativos: Octal y Hexadecimal
En el mundo de las matemáticas convencionales y en nuestro día a día, estamos acostumbrados a utilizar el sistema decimal (base 10), que emplea los dígitos del 0 al 9. Sin embargo, en el desarrollo de software y en la arquitectura de sistemas, trabajar con otras bases numéricas resulta sumamente eficiente.
Python ofrece dos convenciones especiales para codificar números enteros utilizando sistemas de numeración que no usamos en la vida cotidiana: el sistema octal y el sistema hexadecimal.
El Sistema Octal (Base 8)
Si necesitas representar un número en formato octal, Python exige que utilices un prefijo específico inmediatamente antes de los dígitos: 0o o 0O (el número cero seguido de la letra “o”, ya sea minúscula o mayúscula).
Debido a que el sistema octal funciona en base 8, los literales que utilices después del prefijo deben contener única y exclusivamente dígitos dentro del rango del 0 al 7. Si intentas usar un 8 o un 9 con este prefijo, Python arrojará un error de sintaxis inmediato.
print(0o123)
Al ejecutarla, la consola no mostrará 0o123. Como ya aprendimos, la función print() realiza la conversión de forma automática a nuestra base humana estándar. El resultado en la pantalla será:
83
El Sistema Hexadecimal (Base 16)
La segunda convención nos permite trabajar con el sistema hexadecimal, ampliamente utilizado en informática para representar direcciones de memoria, configuraciones de red (direcciones MAC) o códigos de color.
Para indicarle a Python que estás escribiendo un literal en base 16, debes anteponer el prefijo 0x o 0X (el número cero seguido de la letra “x”).
El sistema hexadecimal utiliza dieciséis caracteres para contar: los dígitos del 0 al 9 y las letras de la A a la F (donde A=10, B=11, C=12, D=13, E=14, F=15), las cuales pueden escribirse indistintamente en mayúsculas o minúsculas.
print(0x123)
La función print() gestionará el valor binario interno y proyectará en la consola su equivalente decimal exacto:
291
Aquí tienes la adaptación de esta sección, enfocada en la sintaxis y las reglas estrictas de los números de punto flotante (floats), un componente vital para el manejo de datos precisos y una pregunta fija en el examen PCEP.
Literales Numéricos: El Tipo Punto Flotante (Float)
Es momento de explorar el segundo gran tipo numérico en Python, diseñado específicamente para representar y almacenar lo que en matemáticas se conoce como números con una fracción decimal no vacía.
Hablamos de los números que tienen (o son capaces de tener) una parte fraccionaria después del punto decimal. Cada vez que piensas en un valor como dos y medio o menos cero coma cuatro, estás ante datos que el intérprete de Python clasifica como números de punto flotante (floating-point numbers o simplemente floats):
2.5-0.4
La Regla de Oro: El Punto vs. La Coma
Si en tu país natal (como en España o gran parte de Latinoamérica) estás acostumbrado a escribir los decimales utilizando una coma (ej. 2,5), debes prestar mucha atención y cambiar ese hábito al programar: Python utiliza estrictamente el punto (.) como separador decimal.
Asegúrate de que tus números decimales no contengan comas en absoluto. Si intentas escribir algo como print(2,5), Python no lo interpretará como “dos y medio”. Para el intérprete, la coma tiene un significado reservado (separar argumentos), por lo que pensará que le estás pasando dos números enteros independientes (el 2 y el 5) en lugar de un único decimal.
La Regla de la Omisión del Cero (Abreviación)
Cuando escribes un número flotante en Python y el número 0 es el único dígito que se encuentra inmediatamente antes o después del punto decimal, tienes permitido omitirlo por completo. Esto no alterará en absoluto ni el valor matemático ni el tipo de dato del número.
Veamos cómo funciona esta regla de abreviación:
Omitir el cero inicial: El valor cero punto cuatro (0.4) se puede escribir simplemente omitiendo el cero antes del punto (.4):
Omitir el cero final: El valor cuatro punto cero (4.0) se puede escribir omitiendo el cero que va después del punto:
Ambas formas son completamente válidas y equivalentes en Python. De hecho, ver un número escrito simplemente como 4. es una de las “trampas” visuales más comunes en las preguntas del examen PCEP para comprobar si sabes distinguir un entero de un flotante.
Aquí tienes la adaptación de esta sección, donde se profundiza en el impacto que tiene el punto decimal y se introduce la notación científica mediante la letra e, un recurso indispensable para simplificar números colosales o microscópicos en Python.
Ints vs. Floats y la Notación Científica (e)
Como acabamos de ver, el punto decimal es el factor fundamental que utiliza Python para reconocer un número de punto flotante. Analicemos detenidamente este par de números:
44.0
Desde una perspectiva puramente matemática, ambos representan exactamente la misma cantidad. Sin embargo, Python los ve y los procesa de formas completamente distintas:
4 es un número entero (int).
4.0 es un número de punto flotante (float).
La simple presencia del punto cambia las reglas del juego en la memoria de la computadora. Pero el punto no es la única vía para dar vida a un float. Existe otra herramienta matemática clave: la letra e.
La Notación Científica para Números Extremos
Cuando necesitas manipular datos que involucran números extremadamente grandes (como distancias astronómicas) o ridículamente pequeños (como medidas a nivel cuántico), escribir todos los ceros en el editor de código resulta ineficiente y propenso a errores. Para solucionar esto, Python adopta la notación científica.
Pensemos, por ejemplo, en la velocidad de la luz expresada en metros por segundo. Si la escribimos de forma directa y tradicional, se vería así: 300000000
Para evitar saturar el texto con tantos ceros, los libros de física recurren a una abreviación abreviada que seguro te resulta familiar: \(3 \times 10^8\) (tres multiplicado por diez a la potencia de ocho).
En Python, logramos exactamente ese mismo efecto semántico de una manera muy compacta utilizando la letra E (o su versión en minúscula, e):
3e8
Anatomía de la Notación Científica en Python
La letra e proviene de la palabra exponent (exponente) y funciona en el código como un registro abreviado que significa literalmente: “multiplicado por diez a la potencia de”.
Para que Python acepte esta estructura sin protestar, debes memorizar dos reglas sintácticas estrictas para el examen PCEP:
El Exponente (el valor después de la E): Tiene que ser obligatoriamente un número entero. Puede ser positivo (para números grandes) o negativo (para números pequeños), pero nunca decimal.
La Base (el valor delante de la E): Puede ser tanto un número entero como un decimal.
⚠️ Efecto colateral importante: Cualquier número escrito con notación científica (E), independientemente de si la base es un entero, se convertirá automáticamente en un tipo de dato flotante (float) dentro de la memoria de Python.
Por ejemplo, si ejecutas print(3E8), la consola te devolverá 300000000.0, demostrando con ese punto final que el dato ha sido catalogado como un float.
Aquí tienes la adaptación de esta sección, enfocada en cómo codificar números extremadamente pequeños mediante exponentes negativos y cómo Python optimiza automáticamente la representación visual de los floats en la consola.
Codificación de Floats: Exponentes Negativos y la Ley de Economía
En la sección anterior aprendimos a condensar números colosales usando la notación científica con exponentes positivos. Ahora analizaremos cómo aplicar esta misma convención para registrar números que son extremadamente pequeños (aquellos cuyo valor absoluto es ridículamente cercano a cero).
Un ejemplo clásico de la física es la constante de Planck (denotada como \(h\)), cuyo valor en los libros de texto es \(6.62607 \times 10^{-34}\).
Si necesitaras introducir esta constante matemática en un flujo de datos dentro de tu programa, la sintaxis correcta en Python sería:
6.62607e-34
El signo menos (-) colocado inmediatamente después de la E le indica al intérprete que el punto decimal debe desplazarse 34 posiciones hacia la izquierda, dando como resultado un número microscópico.
La Ley de la Presentación Económica de Python
Existe un detalle crítico que suele desconcertar a los programadores principiantes y que es una pregunta recurrente en el examen PCEP: El hecho de que tú elijas una forma específica de escribir un literal flotante no garantiza que Python lo muestre exactamente igual en la pantalla.
Python cuenta con un algoritmo interno diseñado para elegir siempre la forma más económica y compacta de presentar un número en la consola. Imagina que decides escribir un literal flotante repleto de ceros de forma manual en tu editor:
print(0.0000000000000000000001)
Al ejecutar esta instrucción, Python evalúa la cantidad de caracteres. En lugar de ensuciar la terminal imprimiendo una fila interminable de ceros que dificulta la lectura, el intérprete optimiza la salida y te devuelve esto:
1e-22
¿Por qué hace esto Python?
Porque escribir y leer 1e-22 consume muchísimos menos recursos visuales y espacio que su contraparte extendida. El valor matemático interno en la memoria sigue siendo exactamente el mismo, pero la semántica de su presentación se transforma en pro de la legibilidad y la eficiencia.
Aquí tienes la adaptación de esta sección fundamental sobre las cadenas de texto (strings), enfocada en cómo resolver uno de los desafíos sintácticos más comunes en el código: cómo introducir comillas dentro de un texto sin romper las fronteras del propio string.
Literales de Cadena: El Tipo String y el Dilema de las Comillas
Las cadenas de texto o strings se utilizan en programación cuando necesitas procesar texto (como nombres, direcciones, mensajes o párrafos completos) en lugar de cantidades matemáticas. Como ya hemos establecido, los strings necesitan comillas de la misma manera que los floats necesitan un punto decimal. Un literal de cadena estándar se ve así:
"I am a string."
Sin embargo, aquí se presenta un dilema clásico: ¿Cómo podemos introducir una comilla dentro de un texto que ya está delimitado por comillas?
Imagina que necesitas proyectar en la consola este mensaje exacto, incluyendo las comillas internas: I like "Monty Python" . Si intentas escribirlo de forma ingenua como print("I like "Monty Python""), Python se confundirá de inmediato, asumirá que el string termina justo antes de la letra M, y arrojará un error de sintaxis. Para solucionar este problema, el lenguaje nos ofrece dos caminos muy elegantes.
Solución 1: El Carácter de Escape (\)
La primera alternativa se basa en un concepto que ya conocemos: el carácter de escape representado por la barra invertida (\). Así como la barra invertida altera el significado de la letra n para crear un salto de línea (\n), también puede escapar el significado de las comillas. Cuando colocas una barra invertida inmediatamente antes de una comilla, esta cambia su rol semántico: deja de ser interpretada como una frontera o delimitador de código y pasa a ser un simple carácter textual de datos.
print("I like \"Monty Python\"")
Si te fijas bien, hay dos comillas escapadas (\") envolviendo la frase. Al ejecutarse, Python ignorará las barras invertidas en la consola y mostrará las comillas de manera literal.
Solución 2: Alternancia de Delimitadores (Comillas Simples)
La segunda solución suele resultar muy sorprendente y cómoda para los desarrolladores. Python te permite definir un string utilizando tanto comillas dobles (") como comillas simples o apóstrofes ('). Aprovechando esta flexibilidad, si necesitas que tu texto contenga comillas dobles en su interior, puedes delimitar externamente todo el string usando comillas simples:
print('I like "Monty Python"')
Aquí tienes la adaptación de la sección final sobre los literales de Python, enfocada en los valores booleanos, su origen lógico y la resolución del reto interactivo.
Valores Booleanos: El Tipo Lógico (Boolean)
Para concluir el estudio de los literales en Python, debemos analizar los dos últimos elementos del catálogo. A diferencia de los números o los textos, estos dos literales no representan objetos tangibles o cantidades contables, sino un concepto abstracto fundamental: la veracidad.
Cada vez que le pides a Python que compare si un número es mayor que otro o si una contraseña es correcta, esa evaluación genera un tipo de dato específico: un valor booleano (Boolean o bool).
El nombre rinde homenaje a George Boole (1815-1864), un matemático británico que definió el álgebra booleana, una estructura lógica basada exclusivamente en dos estados distintos: Verdadero y Falso, representados matemáticamente como 1 y 0.
El Intérprete Binario: Respuestas sin Matices
En el desarrollo de software, tú escribes el código y el programa le hace preguntas al sistema operativo o a los datos. Python ejecuta esas instrucciones y devuelve las respuestas. Para que una computadora pueda tomar decisiones automatizadas, necesita respuestas absolutas.
Por suerte, los ordenadores solo contemplan dos tipos de contestaciones:
Sí, esto es verdadero (True)
No, esto es falso (False)
El Desafío: ¿Qué imprimen estas líneas?
Analicemos el reto propuesto por el curso. Si pones a prueba este bloque de código en tu entorno:
print(True>False)print(True<False)
El Resultado en la Consola:
TrueFalse
Explicación Semántica: ¿Por qué ocurre esto?
Este comportamiento se debe directamente a la herencia del álgebra de George Boole en la arquitectura de computadores. Tras bambalinas, Python asigna un valor numérico intrínseco a los estados lógicos para poder operar con ellos a nivel de bits:
True equivale aritméticamente a 1
False equivale aritméticamente a 0
Por lo tanto, cuando le pides a Python que evalúe si True > False, el procesador traduce internamente la pregunta a términos matemáticos básicos: ¿Es 1 > 0? Como la respuesta a esa pregunta es afirmativa, la primera instrucción imprime True.
Aquí tienes la adaptación y estructuración de la sección de puntos clave (Key Takeaways) de este módulo, un resumen ideal para repasar antes de realizar los test de práctica del PCEP. He incluido el concepto extra de None de forma muy visual.
Resumen del Módulo: Conceptos Clave (Key Takeaways)
Para consolidar los conocimientos de este capítulo antes de avanzar, repasemos los pilares fundamentales sobre los literales y los tipos de datos en Python:
1. ¿Qué es un Literal?
Los literales son notaciones específicas utilizadas en el código fuente para representar valores fijos e inmutables. Python cuenta con varias familias de ellos:
Literales numéricos: Por ejemplo, el entero 123.
Literales de cadena (strings): Por ejemplo, "I am a literal.".
2. Sistemas de Numeración Computacional
Sistema Binario: Utiliza el 2 como base, lo que significa que se compone únicamente de ceros y unos (0 y 1). Por ejemplo, el binario 1010 equivale al número 10 en nuestro sistema decimal.
Sistemas Octal y Hexadecimal: Utilizan el 8 y el 16 como bases, respectivamente. El sistema hexadecimal (0x) se apoya en los números decimales del 0 al 9 y añade seis letras (A a la F) para completar sus dieciséis valores posicionales.
3. Números Enteros (Integers / int)
Son uno de los tipos numéricos nativos de Python. Se caracterizan por escribirse sin ninguna parte fraccionaria o decimal. Pueden ser tanto positivos (256) como negativos (-1).
4. Números de Punto Flotante (Floats / float)
Es el tipo numérico diseñado para almacenar valores continuos que contienen (o tienen la capacidad de contener) un componente fraccionario o decimal separado estrictamente por un punto. Ejemplo: 1.27.
5. El Dilema de las Comillas en los Strings
Para incrustar un apóstrofe o una comilla dentro de un texto sin romper la sintaxis del lenguaje, dispones de dos estrategias:
Uso del carácter de escape: Anteponer una barra invertida (\), por ejemplo: 'I\'m happy.'.
Alternancia de símbolos: Envolver el texto con los delimitadores opuestos a los que deseas mostrar. Usas comillas dobles externas para proteger un apóstrofe interno ("I'm happy.") o comillas simples externas para proteger comillas dobles internas ('He said "Python"').
6. Valores Booleanos (bool)
Son dos objetos constantes, True (Verdadero) y False (Falso), que se utilizan para representar estados lógicos de veracidad. En contextos puramente numéricos o aritméticos, True se comporta como un 1, mientras que False equivale a un 0.
🌟 Contenido Extra: El Literal Especial None
Existe un último literal altamente especializado en el ecosistema de Python que debes conocer: None.
¿Qué es? Es un objeto único que pertenece a su propio tipo de dato llamado NoneType.
¿Para qué sirve? Se utiliza de forma explícita para denotar la ausencia total de un valor o un estado “vacío”. No equivale al número cero (0), ni a un string vacío (""), ni a False; es simplemente la representación formal de que un contenedor no tiene datos o de que una función no devolvió nada (como el caso de print()).
Si hay una instrucción que todo programador conoce al iniciar su camino en un nuevo lenguaje, es la encargada de mostrar datos en la pantalla. En Python, esa herramienta es la función print(). Analicemos la línea de código más famosa de la informática:
print("Hello, World!")
A simple vista parece sencillo, pero detrás de esta línea se esconden los principios fundamentales de cómo interactuamos con el lenguaje.
¿Qué es una función en programación?
La palabra print es el nombre de una función. Sin embargo, esto no significa que cada vez que aparezca esta palabra en un script actúe como tal; su significado depende estrictamente del contexto en el que se utilice (como veremos más adelante al hablar de variables o texto).
En el contexto del software, una función es un bloque de código separado e independiente que posee la capacidad de realizar dos tareas (ya sea de forma individual o conjunta):
Efectuar un efecto secundario (Efecto): Consiste en provocar un cambio perceptible en el sistema. Por ejemplo: mostrar un texto en la terminal, crear un archivo en el disco, dibujar una gráfica en la pantalla o reproducir un sonido. Esto es algo que no existe en el mundo de las matemáticas puras.
Evaluar y devolver un valor (Resultado): Al igual que en matemáticas, toma un dato de entrada, realiza un cálculo (como calcular una raíz cuadrada o medir la longitud de un texto) y devuelve el resultado final al programa.
La función print() se enfoca principalmente en la primera tarea: su objetivo y efecto principal es enviar texto a la consola.
¿De dónde provienen las funciones en Python?
A medida que avances en el curso, notarás que no todas las funciones se invocan ni se configuran de la misma manera. En Python, las funciones pueden tener tres orígenes distintos:
1. Funciones Integradas (Built-in Functions)
Vienen incorporadas de forma nativa en el núcleo de Python. La función print() pertenece a este grupo. Están disponibles desde el primer segundo en que instalas el entorno; no necesitas realizar ninguna configuración, descarga o importación especial para utilizarlas.
2. Funciones de Módulos (Modules)
Son herramientas que se encuentran organizadas en “paquetes” o complementos externos llamados módulos. Algunos de estos módulos vienen preinstalados con Python (la librería estándar) y otros requieren una instalación independiente desde internet. Para poder usar sus funciones, debes conectarlas explícitamente a tu código usando la instrucción import.
3. Funciones Propias (Definidas por el usuario)
Tú tienes el poder de escribir tus propias funciones. Puedes diseñar bloques de código personalizados e insertar tantos como necesites dentro de tu programa para que este sea más organizado, limpio, reutilizable y elegante.
La Importancia de un Buen Nombre
El nombre de una función debe ser significativo y autoexplicativo. El nombre de la función print (imprimir) cumple esto a la perfección, ya que describe de inmediato su propósito operativo.
Cuando utilizas funciones integradas o de módulos existentes, no tienes control sobre sus nombres. Sin embargo, cuando llegue el momento de desarrollar tus propias funciones, elegir nombres claros y descriptivos será una de tus responsabilidades más importantes como programador para mantener el código legible.
Los Componentes de una Función: Argumentos y Sintaxis
Previamente establecimos que una función en Python puede generar un efecto y devolver un resultado. Sin embargo, existe un tercer componente fundamental que determina cómo interactuamos con ellas y cómo procesan la información: los argumentos.
¿Qué es un Argumento?
En el ámbito de la programación, un argumento es el dato (o conjunto de datos) que le proporcionas a una función para que pueda realizar su trabajo. Es la materia prima que la función necesita procesar.
Si volvemos a la analogía matemática, una función como \(sin(x)\) requiere obligatoriamente un argumento (\(x\)), que representa la medida de un ángulo. Sin ese valor, la función no tiene nada que calcular.
Las funciones de Python son sustancialmente más versátiles. Dependiendo de su diseño y de las necesidades del script, pueden aceptar cualquier número de argumentos: tantos como sean necesarios para cumplir su tarea.
💡 Nota clave: “Cualquier número” incluye también el cero. Algunas funciones de Python están diseñadas para ejecutarse de forma autosuficiente y no requieren que les pases ningún dato.
La Sintaxis Obligatoria: El Rol de los Paréntesis
Independientemente de cuántos argumentos necesite o reciba una función, Python exige estrictamente la presencia de un par de paréntesis: uno de apertura ( y uno de cierre ).
Con argumentos: Si deseas enviar uno o más datos a la función, debes colocarlos ordenadamente dentro de los paréntesis.
Sin argumentos: Si vas a invocar una función que no requiere parámetros, los paréntesis deben permanecer vacíos, pero siguen siendo obligatorios.
📝 Convención de lectura: Para distinguir visualmente una palabra común (como una variable) del nombre de una función en la documentación, artículos o apuntes, se acostumbra escribir un par de paréntesis vacíos inmediatamente después del nombre. Por ello, a partir de ahora, nos referiremos a ella formalmente como print().
Anatomía de nuestra primera línea de código
Analicemos minuciosamente nuestro ejemplo inicial bajo estos nuevos conceptos:
print("Hello, World!")
Si desglosamos esta instrucción en sus componentes anatómicos básicos, encontramos la siguiente estructura estándar:
print ( "Hello, World!" ) │ │ │ │ ┌─┴───────┴┐ ┌─┴───────┐ ┌┴─────────┐ │ Nombre │ │Argumento│ │Paréntesis│ │ de la │ │ (Texto) │ │de cierre │ │ función │ └─────────┘ └──────────┘ │ y Paren- │ │ tesis de │ │ apertura │ └──────────┘
¿Tiene argumentos la función print() en este ejemplo?
Por supuesto que sí. En este escenario específico, el argumento es la cadena de texto "Hello, World!". Al colocar esa frase entre comillas dentro de los paréntesis, le estamos indicando a la función print() exactamente qué información queremos que procese y proyecte como efecto secundario en la terminal.
Aquí tienes la adaptación de esta sección, enfocada en el concepto de las cadenas de texto (strings) y la transición fundamental entre la sintaxis y la semántica en la programación.
El Tipo de Dato String: Delimitando Código y Datos
En nuestro ejemplo fundamental, el único argumento que le pasamos a la función print() es una cadena de caracteres o string:
print("Hello, World!")
Como puedes observar, este texto está delimitado por comillas. En Python, las comillas no son un simple adorno: son las que transforman el texto en un string. Su función principal es aislar una parte del archivo y asignarle un significado completamente diferente al del resto del programa.
El Propósito de las Comillas: “Esto no es código”
Puedes imaginar las comillas como una frontera que le dice al intérprete de Python:
“Todo lo que esté atrapado entre nosotros no es código ejecutable. No intentes analizarlo como una orden, simplemente tómalo tal cual es: como datos”.
Casi cualquier carácter que coloques dentro de las comillas será tomado de forma literal. El intérprete no intentará buscar una función llamada Hello o una variable llamada World; simplemente imprimirá esos caracteres en la pantalla uno a uno.
Sintaxis vs. Semántica: Una Distinción Vital
Hasta este punto del curso hemos analizado la función print() desde el punto de vista de la sintaxis, pero para ser un programador profesional, debes entender la diferencia entre dos conceptos lingüísticos fundamentales:
Concepto
¿Qué significa en programación?
Ejemplo en nuestro código
Sintaxis
Las reglas gramaticales y de estructura. Cómo se escribe correctamente el código para que el intérprete lo acepte.
Saber que print lleva paréntesis () y que el texto debe ir entre comillas " ".
Semántica
El significado real, el propósito y el efecto que produce ese código al ejecutarse.
Entender que invocar esa instrucción provocará que un mensaje aparezca en la terminal del usuario.
Un código puede ser sintácticamente perfecto (no tener errores de escritura) pero carecer de sentido semántico (hacer algo completamente diferente a lo que el programador planeaba). Dominar ambos lados es lo que te permitirá escribir software robusto y sin errores.
Aquí tienes la adaptación de esta sección fundamental, donde se explica paso a paso el mecanismo interno de una invocación de función. He estructurado el contenido de manera muy visual y secuencial para facilitar el aprendizaje y la preparación del PCEP.
¿Qué ocurre cuando ejecutamos una función?
El conjunto formado por el nombre de la función, los paréntesis y los argumentos se conoce formalmente como invocación de función o llamada a una función (function invocation). Tomemos de nuevo nuestra línea de referencia:
print("Hello, World!")
Para comprender cómo procesa Python esta instrucción, analicemos el modelo abstracto de cualquier llamada a una función:
Cuando el intérprete se topa con una estructura como esta, detiene el flujo lineal de tu script e inicia un proceso interno sumamente estricto que consta de 5 etapas consecutivas:
1. Validación del Nombre (Control de Legalidad)
Python examina el nombre de la función que intentas usar. El intérprete busca en sus datos internos si existe una función registrada con ese nombre exacto (ya sea integrada, de un módulo importado o definida por ti).
Punto de quiebre: Si la búsqueda falla (por ejemplo, si escribiste prnt), Python aborta el programa inmediatamente y arroja un error (NameError).
2. Verificación de los Argumentos (Control de Requisitos)
Python comprueba si el número de argumentos que has colocado dentro de los paréntesis coincide con lo que la función exige para trabajar.
Punto de quiebre: Si una función específica exige exactamente dos argumentos y tú solo le proporcionas uno, el intérprete considerará que la invocación es errónea, detendrá la ejecución del código y lanzará un error (TypeError).
3. El Salto al Código de la Función
Si el nombre es legal y los argumentos son correctos, Python hace una pausa en tu script. El intérprete “abandona” temporalmente tu línea de código y da un salto hacia el lugar de la memoria donde están almacenadas las instrucciones internas de la función invocada, llevando consigo los argumentos que le pasaste.
4. Ejecución y Efecto
Una vez dentro de la función, esta toma los argumentos, ejecuta su propio código interno, provoca el efecto secundario diseñado (en el caso de print(), enviar los caracteres a la terminal), calcula los resultados necesarios y finaliza su tarea.
5. El Retorno al Flujo Principal
Finalmente, una vez que la función ha terminado de procesar todo, Python realiza un salto de regreso a tu código fuente, exactamente al punto que se encuentra justo después de la invocación, y reanuda la ejecución normal del script.
Resumen para el Desarrollador
Este ciclo de “pausa, salto, ejecución y retorno” ocurre en milisegundos cada vez que llamas a una función en Python. Comprender este mecanismo te permitirá prever el comportamiento de tu software y entender con precisión los flujos de trabajo con datos estructurados y automatizaciones.
Aquí tienes la adaptación de esta sección, enfocada en uno de los conceptos más importantes de la manipulación de texto en Python: los caracteres de escape y el salto de línea. Lo he estructurado con un enfoque didáctico y limpio para tus apuntes o artículos.
Caracteres de Escape y Salto de Línea
Si modificamos nuestro código e introducimos un par de caracteres extraños dentro de una cadena de texto, podemos cambiar por completo la forma en que se muestra la información. Observa con atención el siguiente patrón: \n.
A nivel visual, tú puedes ver claramente dos caracteres distintos (una barra invertida y una letra “n”). Sin embargo, para Python, esto representa un solo carácter especial.
El rol de la barra invertida (\) como carácter de escape
La barra invertida o backslash (\) tiene un significado sumamente especial cuando se utiliza dentro de las cadenas de texto (strings): se le conoce como el carácter de escape (escape character).
El término “escape” debe entenderse de una manera muy específica en programación: significa que la secuencia de caracteres del texto “escapa” por un breve momento de su comportamiento habitual para introducir una función o instrucción especial.
En otras palabras:
La barra invertida no significa nada por sí misma ni se mostrará en la pantalla de forma directa.
Funciona como un anuncio o advertencia para el intérprete, indicándole que el carácter que viene inmediatamente después de ella cambia por completo su significado ordinario.
El Símbolo \n (Newline)
La letra n colocada justo después de la barra invertida proviene de la palabra inglesa newline (nueva línea). Juntos, la barra invertida y la “n” (\n) forman un símbolo único y especial llamado carácter de salto de línea. Cuando el intérprete de Python envía el texto a la consola y tropieza con este símbolo, no imprime las letras \ ni n; en su lugar, le ordena firmemente a la consola que rompa la línea actual y comience una nueva línea de salida.
Aquí tienes la adaptación de esta sección, donde se introduce el concepto técnico fundamental de los argumentos posicionales, un pilar indispensable para el examen PCEP.
Aquí tienes la adaptación de esta sección, enfocada en cómo gestiona la función print() la recepción de múltiples argumentos y el comportamiento automático que añade entre ellos.
La Función print() con Múltiples Argumentos
Hasta este punto del curso, hemos analizado cómo se comporta la función print() cuando no recibe argumentos o cuando recibe un único argumento. Ahora es momento de explorar una de sus capacidades más útiles: procesar más de un argumento a la vez.
print("The itsy bitsy spider", "climbed up", "the waterspout.")
El Rol de la Coma
Para pasar más de un argumento a cualquier función en Python, debemos utilizar commas (,) como separadores. La función print() inserta un espacio en blanco entre los argumentos por iniciativa propia de forma predeterminada. Actúa como un separador automático para que los datos no se muestren pegados.
La Función print() y los argumentos posicionales
Antes de ejecutar cualquier código en tu editor, un buen programador debe ser capaz de predecir el resultado analizando la estructura de la instrucción.
¿Qué significa el “Enfoque Posicional”?
La manera en la que hemos estado pasando los argumentos dentro de la función print() es la más común y utilizada en el universo de Python. Técnicamente se le conoce como el enfoque posicional (positional way).
Este nombre proviene de un hecho lógico: el significado y el orden de aparición de un argumento están determinados estrictamente por la posición física que ocupa dentro de los paréntesis.
Por lo tanto, bajo este modelo:
El primer argumento de la izquierda será el primero en procesarse y mostrarse en la consola.
El segundo argumento se imprimirá inmediatamente después del primero.
El tercer argumento irá al final, y así sucesivamente.
Python jamás alterará este orden de forma autónoma; respeta fielmente la secuencia posicional que tú hayas escrito de izquierda a derecha.
Aquí tienes la adaptación de esta sección, donde se introduce el concepto técnico de los argumentos de palabra clave (keyword arguments), una de las herramientas más potentes para personalizar el comportamiento de print() y un tema clave para el examen PCEP.
Keywords: modificando el comportamiento de print()
Python ofrece otro mecanismo muy útil cuando queremos convencer a una función de que altere sus costumbres nativas: los argumentos de palabra clave (keyword arguments).
A diferencia de los posicionales, el significado de estos argumentos no depende de la posición en la que los escribas, sino de una palabra especial (clave) que los identifica unívocamente.
La función print() cuenta con dos argumentos de palabra clave fundamentales. En esta sección nos enfocaremos en el primero de ellos: end.
Reglas de Sintaxis para los Keyword Arguments
Para utilizar correctamente un argumento de palabra clave, es obligatorio seguir una estructura estricta de tres elementos:
[ Palabra clave ] ──> [ Signo igual (=) ] ──> [ Valor asignado ]
Además, existe una regla de oro en la sintaxis de Python que jamás debes romper:
⚠️ Regla Crítica (PCEP): Todos los argumentos de palabra clave deben colocarse obligatoriamente después del último argumento posicional. Si intentas poner un keyword argument antes de un argumento común, Python abortará la ejecución y arroja un error de sintaxis.
El Argumento end: Controlando el Final de la Línea
Por defecto, cada vez que la función print() termina de mostrar sus argumentos, salta automáticamente al siguiente renglón. Esto ocurre porque, “tras bambalinas”, Python aplica un valor predeterminado equivalente a escribir: end="\n" (un salto de línea).
Sin embargo, tú puedes modificar este carácter de finalización. Imagina que ejecutas el siguiente código en tu editor:
print("My name is", end=" ")print("Python.")
¿Qué ocurre aquí?
Al configurar end=" " (un string con un solo espacio en blanco), le estás ordenando a la función print() que, cuando termine de procesar el texto "My name is", no realice un salto de línea, sino que coloque un espacio y mantenga el cursor en la misma fila.
Cuando se ejecuta la segunda línea (print("Python.")), el texto se imprime inmediatamente a continuación. Por lo tanto, el resultado unificado en la consola será:
My name is Python.
Aquí tienes la siguiente sección del curso, enfocada en el segundo argumento de palabra clave fundamental de la función print(): sep (el separador). Está adaptada con un tono educativo, profesional y estructurada metódicamente para tus apuntes o artículos.
El Argumento de Palabra Clave sep: Personalizando los Espacios
El argumento de palabra clave sep sirve para modificar el comportamiento de print al añadir espacios entre argumentos. Al igual que end, el argumento sep debe respetar la regla de oro: colocarse estrictamente al final de la instrucción, después de todos tus argumentos posicionales.
Su estructura es la misma: sep="valor". El valor que pongas entre las comillas sustituirá al espacio en blanco automático que Python introduce entre argumento y argumento.
Las computadoras no entienden los lenguajes de programación de alto nivel; solo procesan código binario (ceros y unos). Para transformar nuestras instrucciones en algo que el procesador pueda ejecutar, existen dos estrategias fundamentales: la compilación y la interpretación.
A continuación, analizaremos a fondo ambos enfoques, cómo funciona el ciclo de vida de un programa interpretado y qué implicaciones tiene esto al programar en Python.
El Enfoque de la Compilación
En los lenguajes compilados (como C, C++ o Go), el código fuente se traduce por completo una sola vez antes de que el programa pueda ejecutarse. El software encargado de realizar este proceso se denomina compilador.
El Resultado: El compilador genera un archivo binario independiente y cerrado (por ejemplo, un archivo .exe en Windows).
Ventajas:
Mayor velocidad: La ejecución es directa y extremadamente rápida porque la traducción ya se hizo de antemano.
Distribución independiente: Puedes enviar el archivo ejecutable final a cualquier usuario sin necesidad de compartir tu código fuente original ni obligarlo a instalar herramientas adicionales.
Protección intelectual: Al estar almacenado en lenguaje máquina, es muy difícil de comprender o revertir, protegiendo tus algoritmos y trucos de programación.
Desventajas:
Desarrollo más lento: El proceso de traducción es rígido. Cualquier modificación en el código fuente, por mínima que sea, te obliga a compilar todo el proyecto de nuevo para ver los cambios.
Dependencia del hardware: El archivo generado está limitado a una arquitectura específica. Necesitas tantos compiladores como plataformas de hardware quieras soportar.
El Enfoque de la Interpretación
En este esquema —bajo el cual opera Python— no se genera un archivo ejecutable previo. El código fuente se distribuye tal cual y se traduce de forma dinámica en cada sesión de ejecución mediante un programa llamado intérprete.
El Intérprete en Acción: Su función es leer, verificar y ejecutar el código línea por línea, de arriba hacia abajo y “al vuelo”, justo en el momento en que se corre el programa.
Ventajas:
Inmediación y flexibilidad: Puedes probar el código de forma instantánea tan pronto como terminas de escribirlo, lo que agiliza las correcciones y experimentos.
Portabilidad multiplataforma: Como el código se almacena en el lenguaje original, puede ejecutarse en diferentes arquitecturas de computadora sin necesidad de adaptarlo o compilarlo por separado.
Desventajas:
Menor rendimiento: El código comparte la potencia de procesamiento de la computadora con el propio intérprete en tiempo real, lo que reduce la velocidad general.
Dependencia del entorno: No puedes enviar un ejecutable aislado. Para que el programa funcione, el usuario final debe tener instalado el intérprete correspondiente en su máquina.
El Ciclo de Vida de la Ejecución en Lenguajes Interpretados
Para escribir scripts estables y entender cómo se procesan tus flujos de trabajo, es vital comprender qué ocurre “tras bambalinas” cuando ejecutas un archivo de texto plano con tu código fuente.
El intérprete sigue un patrón de lectura estándar (de arriba hacia abajo y de izquierda a derecha). Aunque ciertas estructuras como las funciones o los bucles pueden alterar este orden, el flujo inicial siempre es lineal y se basa en un ciclo continuo de tres pasos por cada línea:
[ Leer ] ──> [ Verificar ] ──> [ Ejecutar ]
Paso 1: Lectura y Análisis
El intérprete toma la línea de código correspondiente para procesar sus componentes.
Paso 2: Verificación y Manejo de Errores (Tiempo de Ejecución)
Antes de realizar cualquier acción, el intérprete comprueba si la línea es sintácticamente correcta bajo reglas muy estrictas:
Parada Inmediata: Si encuentra un fallo, detiene su trabajo por completo en ese preciso instante. El programa aborta y muestra un mensaje en la consola.
Diagnóstico Limitado: El sistema te informará la línea y la causa estimada del fallo. Sin embargo, como el intérprete no conoce tu intención original, el mensaje puede ser engañoso e identificar el error a cierta distancia de la causa real.
Paso 3: Ejecución y el Fenómeno del “Éxito Parcial”
Si la línea no presenta anomalías, el intérprete la ejecuta. Debido a que cada línea se procesa de forma aislada, el ciclo puede repetirse miles de veces en secciones específicas (como un bucle que procesa filas de un dataset).
Este comportamiento produce una consecuencia directa: el éxito parcial. Es perfectamente normal que una parte significativa de tu programa corra correctamente, realice cálculos e incluso guarde datos en el disco antes de tropezar con un error en las líneas finales y detenerse por completo.
Comparativa Directa
Característica
Compilación
Interpretación
Momento de traducción
Antes de la ejecución (todo el bloque).
Durante la ejecución (línea por línea).
Velocidad de ejecución
Alta.
Moderada / Baja.
Portabilidad del código
Limitada a la arquitectura compilada.
Alta (multiplataforma).
Requisito del usuario
Solo el archivo ejecutable.
Requiere el intérprete instalado.
Flujo ante errores
No genera el ejecutable si hay errores.
Ejecuta el código previo al error (Éxito parcial).
Entendiendo la Consola de Errores (Traceback)
Cuando cometes un error en un entorno como IDLE, la ventana del editor no te dirá mucho, pero la consola (Shell) se teñirá de letras rojas. Esas líneas de texto son tu mapa para solucionar el problema.
Un mensaje de error estándar en Python se compone de las siguientes partes (leídas de arriba hacia abajo):
El Traceback (Rastreo): Es la ruta que siguió el intérprete a través de las diferentes partes del programa antes de fallar. En scripts simples de una sola línea estará vacío, pero en programas complejos te dice exactamente qué función llamó a qué otra función.
La Ubicación del Error: Te indica el nombre del archivo, el número de línea y el módulo donde ocurrió el fallo.⚠️ ¡Cuidado! El número de línea puede ser engañoso. Python muestra el lugar donde notó por primera vez el efecto del error, que no siempre es el lugar exacto donde lo cometiste (por ejemplo, un paréntesis abierto unas líneas más arriba).
El Contenido de la Línea: El intérprete te muestra un duplicado exacto de la línea de código que causó el colapso para que puedas examinarla visualmente.
El Nombre del Error y la Explicación: La última línea es la más crucial. Te da el diagnóstico técnico (por ejemplo, SyntaxError, NameError) seguido de una breve explicación en inglés de lo que salió mal.
Las expresiones regulares son una herramienta esencial en Python para buscar, validar y transformar texto. Se implementan a través del módulo estándar re, que proporciona funciones como search(), match(), findall(), split() o sub().
Puedes experimentar tus expresiones directamente en regex101.com seleccionando el motor Python.
Clases de Caracteres
Expresión
Descripción
[ABC]
Coincide con cualquiera de los caracteres dentro de los corchetes.
[^ABC]
Coincide con cualquier carácter que no esté en el conjunto.
[A-Z]
Coincide con un carácter dentro del rango especificado (inclusive).
.
Coincide con cualquier carácter, excepto el salto de línea (\n). Puede incluirlo si se usa la bandera re.S.
\w
Coincide con un carácter de palabra (letra, número o guion bajo). Equivalente a [A-Za-z0-9_].
\W
Coincide con cualquier carácter que no sea de palabra.
\d
Coincide con un dígito (0–9).
\D
Coincide con cualquier carácter que no sea un dígito.
\s
Coincide con un carácter de espacio en blanco (espacio, tab, salto de línea, retorno de carro, etc.).
\S
Coincide con cualquier carácter que no sea espacio en blanco.
\n, \r, \t, \f, \v
Coinciden con salto de línea, retorno de carro, tabulación, salto de página y tabulación vertical, respectivamente.
\xFF
Coincide con el carácter cuyo valor hexadecimal es FF.
\uFFFF
Coincide con el carácter Unicode especificado (por ejemplo \u00F1 → ñ).
Anclas
Expresión
Descripción
^
Coincide con el inicio de la cadena o de una línea (si se usa re.M).
$
Coincide con el final de la cadena o de una línea (si se usa re.M).
\b
Coincide con un límite de palabra (entre un carácter de palabra y uno que no lo es).
\B
Coincide con una posición que no sea límite de palabra.
\A
Coincide solo al inicio de toda la cadena (no afectado por re.M).
\Z
Coincide solo al final de toda la cadena (no afectado por re.M).
Grupos de Captura
Expresión
Descripción
(ABC)
Agrupa tokens y crea un grupo de captura.
(?P<nombre>ABC)
Grupo de captura con nombre, referenciable como (?P=nombre) o \g<nombre> en reemplazos.
\1, \2, \3
Referencias a grupos de captura por número.
(?:ABC)
Grupo no capturante: agrupa sin guardar coincidencias.
Lookaround (búsquedas anticipadas y retrospectivas)
Expresión
Descripción
(?=ABC)
Lookahead positivo: coincide si después del patrón actual está ABC.
(?!ABC)
Lookahead negativo: coincide si no hay ABC después.
(?<=ABC)
Lookbehind positivo: coincide si antes del patrón está ABC.
(?<!ABC)
Lookbehind negativo: coincide si no hay ABC antes.
Cuantificadores y Alternancia
Expresión
Descripción
+
1 o más repeticiones del token anterior.
*
0 o más repeticiones del token anterior.
?
0 o 1 del token anterior (opcional).
{n}
Exactamente n repeticiones.
{n,}
n o más repeticiones.
{n,m}
Entre n y m repeticiones.
+?, *?, ??, {n,m}?
Cuantificadores no codiciosos (buscan la menor coincidencia posible).
`
`
Sustitución (Reemplazo en re.sub())
Expresión
Descripción
\1, \2, …
Inserta el texto del grupo de captura correspondiente.
\g<nombre>
Inserta el texto del grupo con nombre.
\\
Inserta un carácter \ literal.
\n, \r, \t
Caracteres de escape comunes.
Banderas en Python (re)
Bandera
Descripción
re.I o re.IGNORECASE
Ignora mayúsculas y minúsculas.
re.M o re.MULTILINE
^ y $ coinciden al inicio y final de cada línea.
re.S o re.DOTALL
Hace que . coincida también con saltos de línea.
re.U o re.UNICODE
Interpreta \w, \W, \b y \B según Unicode (activado por defecto en Python 3).
re.X o re.VERBOSE
Permite escribir expresiones legibles con espacios y comentarios.
re.A o re.ASCII
Hace que \w, \b, \d y \s solo reconozcan caracteres ASCII.