Fundamentos de Python: valores, variables y expresiones

Un programa es una secuencia de instrucciones. El intérprete de Python lee el código Python y ejecuta esas instrucciones. Usa Python 3, donde una llamada como print("Hello") lleva paréntesis.

Prueba una línea en la consola

La consola interactiva, o REPL (bucle de lectura, evaluación e impresión), muestra >>> cuando está lista para recibir código Python. Escribe una sentencia después del indicador y pulsa Intro. No escribas tú el >>>.

>>> 3 + 4
7
>>> "hi"
'hi'

La consola muestra automáticamente el valor de una expresión. Pone comillas alrededor de una cadena para identificarla como texto. El indicador ... significa que una sentencia está incompleta y Python espera más. Por ejemplo, puede faltar el paréntesis de cierre de uno que se ha abierto. Escribe exit() cuando la consola esté lista para salir de ella.

La consola sirve para probar una expresión. Puede conservar un historial de comandos, pero ese historial no es un programa guardado. Pon las instrucciones que quieras volver a ejecutar juntas en un archivo de programa.

Guarda y ejecuta un archivo de programa

Un archivo de programa es un archivo de texto sin formato que contiene código y tiene la extensión .py. Usa un editor de código como IDLE, Thonny o VS Code. IDLE viene con la distribución estándar de Python. Un procesador de textos puede cambiar las comillas rectas por comillas tipográficas; estas últimas no pueden delimitar cadenas en Python.

Introduce estas líneas en el editor y guarda el archivo de programa:

print("Hello, world!")
print("Welcome to Python.")

En IDLE, elige Ejecutar → Ejecutar módulo o pulsa F5. La salida es:

Hello, world!
Welcome to Python.

Python ejecuta estas sentencias de arriba abajo. Cada print() muestra su texto y pasa a una línea nueva. Invertir el orden de las sentencias invierte el de la salida.

También puedes ejecutar un archivo de programa guardado desde una terminal. Abre la carpeta que lo contiene y después introduce el comando del intérprete seguido del nombre con el que guardaste el archivo. En macOS o Linux, el comando suele ser python3 seguido del nombre del archivo; Windows suele usar python o py. El comando de la terminal inicia el intérprete y le indica qué archivo ejecutar. Ese comando se escribe en la terminal, no después del >>> de Python. Un editor en línea puede ofrecer un botón Ejecutar.

Decide qué necesitas mostrar con print

Un archivo de programa que solo contiene 3 + 4 calcula un valor, pero no muestra nada. Escribe print(3 + 4) para mostrar 7. Del mismo modo, print("hi") muestra el texto sin las comillas que lo rodean. Las comillas pertenecen al código; marcan el principio y el final del texto.

Python distingue entre mayúsculas y minúsculas. print y Print son nombres distintos, así que Print("hi") produce un NameError a menos que se haya definido ese otro nombre. Mantén la escritura y las mayúsculas de los nombres incorporados exactamente como se muestran.

Los espacios iniciales también tienen significado. En estas secuencias sencillas de sentencias, empieza cada una en el margen izquierdo. Una sangría sobrante antes de print("hi") puede causar IndentationError: unexpected indent. Los espacios dentro del texto entre comillas son diferentes: Python los muestra como parte del mensaje.

Un fallo en un programa es un error de programación. Detectarlo y corregirlo es depuración. Primero identifica qué clase de problema tienes: código que Python no puede leer, una operación que falla durante la ejecución o un resultado que simplemente es incorrecto.

Tres clases de problemas

Python comprueba la sintaxis de todo el archivo de programa antes de ejecutarlo. Un error de sintaxis cerca del final impide que se ejecute incluso la primera línea. Un error de ejecución es diferente: las sentencias anteriores ya se han ejecutado y su salida permanece visible.

En la media, la división se realiza antes que la suma. Python calcula 92 / 2 como 46.0 y después suma 88 para obtener 134.0. La expresión buscada es (88 + 92) / 2, que da 90.0. No hay mensaje de error porque ambas expresiones están permitidas. Un cálculo a mano te da un resultado con el que comparar el del programa.

Lee una traza de excepción desde abajo

Supón que el código es:

name = "Ada"
print("Hello", nme)

La traza de la excepción termina con un mensaje como NameError: name 'nme' is not defined. La última línea nombra el error y explica qué ha fallado. Encima, Python muestra la ubicación, el número de línea y el código. Compara nme con el nombre al que se asignó un valor antes: name. Corregir esa escritura hace que la salida sea Hello Ada.

La ubicación indicada es donde Python detectó el problema. Si una línea parece correcta, revisa también la anterior. Una comilla o un paréntesis sin cerrar en una línea anterior puede impedir que Python interprete lo que sigue. Las versiones recientes suelen señalar directamente el paréntesis de apertura sin pareja.

Usa el tipo de error para orientar la búsqueda

• NameError: Python no encuentra un nombre, como ocurre con pirnt, Print o una variable usada antes de asignarle un valor. Revisa la escritura, las mayúsculas y el orden de las líneas.
• TypeError: la operación no funciona con esos tipos. "5" + 5 intenta unir texto y un número.
• ValueError: una conversión recibe un contenido que no sirve. int("abc") recibe texto, pero ese texto no representa un entero.
• ZeroDivisionError: un divisor es cero. Revisa el valor usado después de /, // o %.

Para un SyntaxError, comprueba que cada comilla y paréntesis de apertura tenga su cierre. print('It's late') cierra la cadena en el apóstrofo de «It's»; usa print("It's late"). El código de Python 2 como print "hi" necesita los paréntesis de Python 3: print("hi"). Vuelve a escribir las comillas tipográficas como comillas rectas. Si hay una sangría inesperada, elimina los espacios iniciales sobrantes.

Corrige un problema y después vuelve a ejecutar el programa. El primer fallo puede haber impedido que Python llegue a un segundo. Construye el programa unas pocas líneas cada vez para que cada fallo nuevo deje una zona pequeña que revisar.

El código le dice a Python qué hacer. Un comentario le dice a una persona por qué lo hace o qué significa un valor. Python ignora los comentarios al ejecutar el programa.

Marca el comentario con claridad

Un comentario empieza con # fuera de una cadena y continúa hasta el final de esa línea. Puede ocupar su propia línea o aparecer después de una sentencia:

# Convert a temperature from Fahrenheit to Celsius.
fahrenheit = 68
celsius = (fahrenheit - 32) * 5 / 9
print(celsius)  # Show the converted temperature.

El comentario de línea completa explica el propósito del programa. El comentario en línea aparece después del código en la misma línea. PEP 8, la guía de estilo de Python, recomienda al menos dos espacios antes de un # en línea y un espacio después. Esa separación permite ver fácilmente el límite.

Una almohadilla dentro de comillas es texto normal:

print("#1 is not a comment")  # This part is a comment.

La salida es #1 is not a comment. Python lee toda la cadena entre comillas, incluida su almohadilla, como datos. Ignora el texto después del segundo # porque ese signo está fuera de las comillas.

Explica el significado, no los pasos evidentes

Compara estos comentarios:

count = count + 1  # Add 1 to count.
attempts = attempts + 1  # One more failed login.

El primer comentario repite una operación que ya se ve en el código. El segundo añade una razón para el cambio. Ahora quien lo lee sabe qué cuenta un intento. Un nombre claro como attempts también hace parte del trabajo que un nombre vago dejaría a los comentarios.

Los comentarios útiles explican una unidad, una decisión o un propósito que el código por sí solo no deja claro. Por ejemplo, tax_rate = 0.08 # 8% sales tax relaciona una tasa decimal con su significado. Si después cambias esa tasa, revisa también el comentario. Un comentario desactualizado puede llevar a quien lo lee por el camino equivocado incluso cuando el código funciona.

Impide temporalmente que se ejecute una línea

Para desactivar una sentencia mediante un comentario, pon # delante:

print("Start")
# print("Checking this step")
print("Finish")

Solo aparecen Start y Finish. Desactivar una línea mediante un comentario la mantiene disponible mientras pruebas el programa sin ella. Elimina el código antiguo desactivado cuando ya no ayude; de lo contrario, quien lo lea después tendrá que adivinar si aún hace falta.

Para una nota que abarque varias líneas, empieza cada línea con #:

# Read the temperature in degrees Fahrenheit.
# Keep the calculation in Celsius for the next step.

El texto entre comillas triples es diferente. Una línea como """Convert a temperature.""" es una expresión de cadena, no un comentario. Estas cadenas pueden servir como documentación, llamada cadena de documentación, en posiciones concretas. Usa # cuando quieras escribir un comentario normal. Una cadena que nada utiliza puede quedar invisible en un archivo de programa, lo que puede hacer que parezca un comentario aunque Python la lea como un valor.

Un valor es un dato, como 42, 3.5 o "Ada". Cada valor tiene un tipo, que indica a Python qué clase de dato es. Un literal es un valor escrito directamente en el código. Su forma de escritura importa: 7, 7.0 y "7" tienen tipos distintos.

Cuatro tipos básicos

El punto decimal hace que 2.0 sea de coma flotante aunque su valor numérico sea igual al entero 2. Las comillas hacen que "42" sea texto aunque los caracteres parezcan un número. El tipo depende del valor escrito, no del uso que una persona pueda darle.

Los literales booleanos llevan la primera letra en mayúscula y no llevan comillas. True es un booleano; "True" es una cadena. true en minúsculas es un nombre, y usarlo sin definirlo produce NameError. Una comparación puede producir un booleano: 3 < 5 se evalúa como True.

Pregunta a Python por el tipo

La función incorporada type() indica el tipo de su argumento. En la consola, estas llamadas muestran:

>>> type(7)
<class 'int'>
>>> type(7.0)
<class 'float'>
>>> type("7")
<class 'str'>
>>> type(True)
<class 'bool'>

En un archivo de programa, usa print() para ver esos resultados:

print(type(42), type("42"))

Esto muestra <class 'int'> <class 'str'>. La palabra class forma parte de la respuesta de Python; los nombres int y str identifican los tipos.

Los tipos cambian el significado de los operadores

Con números, + suma. Con dos cadenas, une texto:

print(5 + 3)
print("5" + "3")

La primera línea muestra 8. La segunda muestra 53. La segunda expresión tiene dos valores de texto, así que Python une sus caracteres. No examina los caracteres de los dígitos y decide sumarlos.

"5" + 5 lanza TypeError: un operando es texto y el otro es un entero. Comprueba los tipos cuando una operación se comporte de forma distinta a la que esperas. En particular, que aparezcan dígitos en la pantalla no demuestra que el valor almacenado sea numérico.

Elige un tipo según el significado

Usa un entero para un conteo y un número de coma flotante para una medida que pueda incluir una fracción. Mantén como texto un identificador, como un código postal de EE. UU. La cadena "02134" conserva el cero inicial; ese cero forma parte de la identidad del código, no de un cálculo. Los números de teléfono también pueden contener signos de puntuación que conviene conservar.

La consola puede mostrar 'Ada', mientras que print("Ada") muestra Ada. Ambos se refieren al mismo texto. Las comillas de la consola identifican una cadena; print() presenta los caracteres para quien los lee. Ninguna de las dos formas de mostrarlos cambia el tipo almacenado.

Python tiene tipos distintos para los números enteros y los números de coma flotante. Escribirlos con claridad evita tanto errores de sintaxis como cambios menos evidentes en los datos.

Escribe los conteos como enteros

Un número entero no tiene parte fraccionaria. Escribe un int sin punto decimal, como en 42, 0 o -7. Los enteros de Python pueden crecer tanto como permita la memoria disponible, sin un límite fijo de bits. La suma, la resta y la multiplicación de enteros son exactas. Por ejemplo, 2 ** 100 da el entero exacto 1267650600228229401496703205376.

No uses comas para agrupar los miles. Escribe 1000000 o usa guiones bajos para facilitar la lectura: 1_000_000. Los guiones bajos no cambian el valor.

Un literal entero decimal distinto de cero no puede empezar con cero. Escribir 02134 es un error de sintaxis. Si esos dígitos son un identificador cuyo cero inicial importa, escribe "02134" como texto.

Escribe las cantidades fraccionarias como números de coma flotante

Un número de coma flotante usa un punto decimal o notación con exponente. 3.5, 2.0 y -0.25 son números de coma flotante. Python también acepta .5 y 5., que significan 0.5 y 5.0; escribir el cero adicional suele facilitar su lectura. Usa números de coma flotante para medidas como la temperatura o la distancia y para cálculos introductorios con precios que tengan parte fraccionaria.

El código Python usa punto decimal. La coma separa valores; nunca marca la parte fraccionaria. Por ejemplo:

x = 3.5
print(x)

muestra 3.5, mientras que x = 3,5 crea un par de valores que se muestra como (3, 5). Del mismo modo, x = 1,000 crea (1, 0), no mil. Estas sentencias pueden ejecutarse, así que la ausencia de un mensaje de error no significa que el número se haya escrito correctamente.

Usa la notación científica

La letra e significa «por diez elevado a» en un literal numérico:

Un literal con exponente es de coma flotante incluso cuando su valor es un número entero. El signo negativo después de e hace que el exponente sea negativo, así que 2.5e-3 significa 2,5 dividido entre 1000.

Ten en cuenta la precisión limitada

Los números de coma flotante se almacenan en binario con precisión limitada, normalmente unas 15–17 cifras decimales significativas. Muchas fracciones decimales, incluida 0.1, no tienen una representación exacta en ese almacenamiento. Como resultado:

print(0.1 + 0.2)
print(round(0.1 + 0.2, 2))

muestra 0.30000000000000004 y después 0.3. La pequeña diferencia procede de las aproximaciones almacenadas. round(..., 2) redondea el resultado a dos decimales para mostrarlo; no cambia cómo se almacenan los valores de coma flotante. Mantén el cálculo original hasta el final y después redondea el resultado que se muestra.

Un signo también puede ser un operador. El menos unario cambia el signo de un valor: -7 es menos siete. En 5 - -3, el primer menos resta y el segundo forma menos tres, así que el resultado es 8. Distingue este signo del exponente negativo en un literal como 2.5e-3.

Una cadena de caracteres es una secuencia de caracteres: letras, dígitos, espacios, signos de puntuación y otros símbolos. Las comillas indican a Python dónde empieza y termina esa secuencia. Los caracteres del interior son datos, aunque parezcan código Python.

Elige comillas que coincidan

Las comillas simples y las dobles crean el mismo tipo, str. Tanto 'Ada' como "Ada" contienen los mismos tres caracteres. Empieza y termina una cadena con el mismo tipo de comillas.

Elige las comillas exteriores para que resulte fácil escribir una comilla interior:

print("It's late")
print('She said "hi"')

La salida es:

It's late
She said "hi"

En print('It's late'), el apóstrofo después de It cierra la cadena antes de tiempo. Python ya no puede leer el resto de la sentencia. Usar comillas dobles exteriores mantiene el apóstrofo dentro del texto.

Usa una secuencia de escape

Una barra invertida inicia una secuencia de escape. Cada una de estas secuencias habituales representa un carácter:

Por ejemplo, print("Line 1\nLine 2") muestra dos líneas. La barra invertida y la n del código representan juntas un salto de línea, no una letra n visible. Del mismo modo, print('It\'s late') muestra It's late: la comilla escapada se convierte en un carácter sin terminar la cadena.

Para mostrar una barra invertida literal seguida de una letra, escribe la barra invertida dos veces. print("A\\B") muestra A\B. La primera barra invertida indica que la siguiente debe ser un carácter.

Conserva saltos de línea o ningún carácter

Las comillas triples permiten que una cadena abarque varias líneas físicas. Los saltos de línea pasan a formar parte de su valor:

print("""Line one
Line two""")

Esto muestra Line one y Line two en líneas distintas. Las comillas simples triples también sirven. Las comillas triples siguen creando una cadena; no crean un comentario con #.

La cadena vacía, "", no tiene caracteres. Es distinta de " ", que contiene un espacio. Ese espacio puede ser difícil de ver en la salida, pero sigue formando parte de los datos.

Distingue el texto de una expresión o un nombre

Compara estas sentencias:

name = "Ada"
print("3 + 4")
print(3 + 4)
print("name")
print(name)

La salida es 3 + 4, después 7, después name y después Ada. Las comillas convierten el primer y el tercer argumento en texto literal. Sin comillas, Python evalúa un cálculo o consulta una variable.

Olvidar las comillas alrededor de un mensaje como Hello hace que Python busque un nombre. Si no se ha definido Hello, print(Hello) lanza NameError. Escribe print("Hello") cuando quieras esa palabra.

Las cadenas pueden contener caracteres de muchos idiomas y símbolos, como "café", "naïve" y "°F". También pueden aparecer dígitos junto a ellos: "Room 101" es texto en su totalidad. Un carácter de dígito entre comillas no se convierte en un entero.

Una variable es un nombre que hace referencia a un valor en la memoria. Una sentencia de asignación conecta un nombre a la izquierda de = con el valor de una expresión a la derecha.

Lee primero el lado derecho

En age = 30, Python evalúa 30 y después hace que age se refiera a ese entero. El lado izquierdo debe ser un destino válido para asignar un valor. 30 = age es un error de sintaxis: no puedes asignar un valor nuevo al literal 30.

El signo = significa «asignar». No pregunta si dos valores son iguales. La comprobación de igualdad usa ==. Leer la asignación como una dirección de trabajo permite entender sentencias como x = x + 1: usa el valor anterior de x a la derecha, calcula el valor nuevo y después asígnalo a x a la izquierda.

Considera un rectángulo:

width = 4
height = 2.5
area = width * height
print(area)

Después de la primera línea, width se refiere a 4. Después de la segunda, height se refiere a 2.5. En la tercera línea, Python consulta ambos valores actuales y evalúa 4 * 2.5, lo que produce 10.0. Asigna ese resultado a area. La última línea muestra 10.0.

La asignación por sí sola no muestra el valor. Usa el nombre en una llamada posterior a print() cuando quieras mostrarlo.

Asigna un valor antes de usar un nombre

Python sigue el orden de las sentencias. Este código falla en la primera línea:

print(total)
total = 10

En ese momento, total no tiene valor. La asignación posterior no puede proporcionar un valor a una sentencia anterior. Mueve total = 10 antes de print(total).

Una consola puede conservar nombres de pruebas anteriores. Un programa guardado debe incluir las asignaciones que necesita en su propio orden de ejecución, para que su resultado no dependa de recordar qué escribiste antes.

Reasigna un nombre existente

La reasignación hace que un nombre se refiera a un valor nuevo:

score = 10
score = 15

Ahora score es 15; el 10 anterior ya no es accesible a través de ese nombre. Para una actualización basada en el valor anterior:

x = 3
x = x + 1

La segunda línea evalúa 3 + 1 y después asigna 4 a x. No hay ninguna ecuación que resolver ni ninguna contradicción.

El tipo pertenece al valor, no de forma permanente al nombre de la variable. Python permite temp = 3 seguido de temp = "three"; después, type(temp) indica str. Mantener coherentes el significado y el tipo esperado de un nombre suele facilitar el seguimiento del programa.

Un valor copiado no crea un vínculo futuro

a = 5
b = a
a = 10
print(a, b)

Esto muestra 10 5. En b = a, ambos nombres se refieren al entero actual 5. Reasignar a cambia el valor al que se refiere a; deja b haciendo referencia a 5. Del mismo modo, almacenar width * height guarda su resultado, no una fórmula que se actualice sola cuando cambie width.

Una sentencia puede asignar valores a varios nombres. a = b = 0 da a ambos nombres el valor 0. En x, y = 1, 2, los valores se emparejan con los nombres por su posición, de modo que x es igual a 1 e y es igual a 2.

Un nombre debe cumplir la gramática de Python y ayudar a una persona a entender el programa. Son dos comprobaciones distintas: Python puede aceptar un nombre que aun así dificulte la lectura del código.

Sigue las reglas de los nombres

Un nombre de variable puede contener letras, dígitos y guiones bajos. No puede empezar con un dígito, contener un espacio ni usar signos de puntuación como un guion.

Python también acepta letras de otros alfabetos. Las letras del alfabeto inglés son una opción habitual para los identificadores. Elijas las letras que elijas, mantén la escritura coherente: age, Age y AGE son tres nombres distintos. Asignar age = 30 no define Age.

Distingue las palabras reservadas de los nombres incorporados

Una palabra reservada está reservada para la gramática de Python. No puedes usarla como nombre de variable. Las palabras que siempre están reservadas son:

False None True and as assert async await break class
continue def del elif else except finally for from
global if import in is lambda nonlocal not or pass
raise return try while with yield

No necesitas memorizar la lista antes de escribir un programa. Por ahora, reconoce que un nombre como class no está disponible: class = 3 es un error de sintaxis. Los editores suelen mostrar las palabras reservadas con un color especial.

Los nombres de funciones incorporadas, incluidos print, input, int, str, type, sum y max, no son palabras reservadas. Python permite asignarles valores, pero esa asignación oculta la función original:

print = 5
print("hi")

La segunda línea intenta llamar al entero 5 y lanza TypeError. Elige un nombre que describa tus datos, como total, para que la función incorporada siga disponible. Reiniciar la consola elimina las sustituciones accidentales hechas durante las pruebas.

Escribe los nombres con un estilo coherente

PEP 8 recomienda snake_case para los nombres de variables: palabras en minúsculas unidas por guiones bajos, como en hourly_rate y first_name. El guion bajo mantiene unido un nombre de varias palabras sin espacios.

Una constante es un valor que quieres mantener sin cambios. Por convención, su nombre usa mayúsculas:

SALES_TAX_RATE = 0.08

Python no bloquea ese nombre. Una asignación posterior puede cambiarlo; las mayúsculas comunican una intención a quien lo lee.

Incluye el significado y las unidades

hours_worked = 38 te dice más que h = 38. Un nombre como distance_miles o temp_f también identifica la unidad, lo que reduce la posibilidad de usar millas como si fueran kilómetros o grados Fahrenheit como si fueran grados Celsius. Los nombres cortos como x e y funcionan bien para coordenadas o una fórmula breve en la que sus significados ya están claros.

Evita nombres casi idénticos como total y totl. Un error al escribirlos puede producir un NameError o usar por accidente otra variable existente. PEP 8 también desaconseja las letras sueltas l, O e I, que pueden parecer dígitos. Unas pocas letras más pueden hacer que un cálculo sea mucho más fácil de revisar.

Una actualización usa el valor actual de una variable para calcular el siguiente. Seguir cada actualización en orden te permite predecir la salida y detectar errores lógicos antes de ejecutar el programa.

Asigna un valor inicial antes de actualizarlo

count = count + 1 suma uno al conteo anterior. Ese cambio es un incremento. Una variable que mantiene una suma acumulada es un acumulador; dale un valor inicial como total = 0 antes de añadir cantidades.

La asignación aumentada combina una operación con una asignación. Con números, x += 3 tiene el mismo efecto que x = x + 3. Las formas disponibles incluyen +=, -=, *=, /=, //=, %= y **=.

score = 10
score -= 3
score **= 2
print(score)

La resta cambia score a 7. La potenciación lo cambia después a 49, que se muestra. Sin la asignación inicial, una actualización intentaría usar un nombre no definido y lanzaría NameError.

El operador elegido también afecta al tipo. Partiendo de n = 7, n /= 2 produce el número de coma flotante 3.5. Partiendo de nuevo de n = 7, n //= 2 produce el entero 3. Python no tiene un operador de incremento ++: x++ no es válido. Escribir ++x aplica dos veces el más unario y no actualiza x; usa x += 1.

Sigue una sentencia cada vez

Una tabla de seguimiento registra los valores de las variables después de cada sentencia. Escribe una columna por variable y una fila por paso:

price = 20
quantity = 3
total = price * quantity
price = 25
total += 5
print(total, price)

La salida es 65 25. Cambiar price no repitió la multiplicación anterior. La variable total contenía el valor calculado 60; no era una fórmula de hoja de cálculo vinculada a price. Solo su propia actualización posterior lo cambió a 65.

Para seguir la ejecución a mano, evalúa el lado derecho usando la fila inmediatamente anterior y después actualiza el nombre al que se asigna el valor. Deja las demás columnas sin cambios. Compara la predicción con la salida real del programa.

Conserva ambos valores al intercambiarlos

Supón que a = 1 y b = 2. El intento a = b seguido de b = a da 2 2. La primera asignación hace que se pierda el acceso al valor original de a mediante ese nombre, así que la segunda línea copia de vuelta el valor nuevo.

Una variable temporal mantiene disponible el valor original:

a = 1
b = 2
temp = a
a = b
b = temp
print(a, b)

Esto muestra 2 1. También puedes escribir a, b = b, a. Python evalúa ambos valores de la derecha antes de asignarlos a cualquiera de los nombres de la izquierda, así que ambos valores originales están disponibles para el intercambio. Sigue la versión con variable temporal cuando quieras ver exactamente dónde se conserva cada valor original.

Una expresión se evalúa para obtener un valor. Puede ser un literal, una variable o una combinación como 2 + 3. El + es un operador; los valores sobre los que actúa son sus operandos.

Elige el operador

Los operadores aritméticos de Python funcionan así:

Escribe la multiplicación explícitamente con *. La notación matemática como 2x no funciona como multiplicación en Python. Escribe 2 * x o 2 * (x + 1). Con x = 1, 2(x + 1) intenta llamar al entero 2 como si fuera una función y lanza TypeError.

El operador de potenciación es **, no ^. Por ejemplo, 7 ** 2 es 49, mientras que 7 ^ 2 es 5 porque el acento circunflejo realiza otra operación. Por tanto, un programa puede ejecutarse y calcular un resultado que no buscabas.

Predice tanto el tipo como el número

La división con / da un número de coma flotante con operandos enteros, incluso cuando la división es exacta: 6 / 2 es 3.0. Para obtener un conteo entero de grupos completos, usa //: 6 // 2 es 3.

Con dos operandos enteros, la suma, la resta, la multiplicación, la división entera con redondeo hacia abajo y el resto dan resultados enteros. Las potencias con exponentes enteros no negativos también: 2 ** 10 da el entero exacto 1024. Un exponente negativo cambia esto: 2 ** -1 da el número de coma flotante 0.5.

En la aritmética habitual con un entero y un número de coma flotante, el cálculo usa valores de coma flotante. 3 + 4.0 da 7.0; 7.0 // 2 da 3.0. La división entera con redondeo hacia abajo describe cómo se redondea el cociente, no garantiza que su tipo sea siempre int.

Un exponente fraccionario puede calcular una raíz de un número positivo. 4 ** 0.5 da 2.0, y 2 ** 0.5 da aproximadamente 1.4142135623730951.

Construye un cálculo con valores que tengan nombre

Un automóvil recorre 287 millas usando 10,25 galones:

miles = 287
gallons = 10.25
mpg = miles / gallons
print("Miles per gallon:", mpg)

La división calcula 28.0, así que la salida es Miles per gallon: 28.0. Los nombres identifican las cantidades, y la etiqueta mostrada identifica la unidad del resultado. Multiplicar 28.0 * 10.25 recupera las 287 millas, lo que permite comprobar la división.

Un divisor cero hace fallar /, // y %. Por ejemplo, 10 / 0 lanza ZeroDivisionError. Revisa la variable usada como divisor cuando aparezca ese error.

Los espacios alrededor de los operadores no cambian su significado: 2+3 y 2 + 3 dan 5. Los espacios alrededor de = y de la mayoría de los operadores facilitan la lectura de las partes. No pueden sustituir un operador; 2 x sigue sin significar multiplicación.

Python no calcula una expresión simplemente desde su extremo izquierdo hasta el derecho. La precedencia establece qué operaciones se realizan primero. Los paréntesis te permiten elegir otra agrupación o aclarar la agrupación buscada.

Aplica los niveles en orden

Para los operadores presentados aquí, usa este orden:

1. Expresiones entre paréntesis.
2. Potencias, **.
3. Signos unarios, como el menos de -x.
4. Operaciones de multiplicación y división: *, /, //, %.
5. Suma y resta: +, -.

En 3 + 4 * 2 ** 2, evalúa 2 ** 2 para obtener 4. La expresión se convierte en 3 + 4 * 4. La multiplicación da 16, y la suma da 19. Con (3 + 4) * 2 ** 2, la suma entre paréntesis es 7; la potencia es 4; el producto es 28.

Los operadores del nivel de multiplicación y división tienen la misma prioridad. Avanza de izquierda a derecha: 8 / 2 * 4 significa (8 / 2) * 4, lo que da 16.0. La multiplicación no se adelanta a la división. Del mismo modo, 100 / 10 / 5 da 2.0, y 10 - 4 - 3 da 3.

Trata con cuidado las potencias y los signos

Las potencias repetidas se agrupan de derecha a izquierda. 2 ** 3 ** 2 significa 2 ** (3 ** 2). Primero, 3 ** 2 da 9; después, 2 ** 9 da 512. Agrupar desde la izquierda daría 64, un resultado distinto.

Un signo menos inicial se aplica después de la potencia que le sigue: -2 ** 2 significa -(2 ** 2) y da -4. En (-2) ** 2, los paréntesis hacen que menos dos sea la base, así que el resultado es 4. Un menos después de ** puede pertenecer al exponente: 2 ** -1 da 0.5.

Traslada toda la agrupación de una fórmula

Una media requiere sumar ambos valores antes de dividir entre dos:

average = (88 + 92) / 2

La suma es 180, y después la división da 90.0. Sin paréntesis, 88 + 92 / 2 solo divide 92 y da 134.0.

Una barra de fracción también agrupa todo lo que tiene encima y debajo. Un numerador que contiene a + b y un denominador que contiene c + d se convierten en (a + b) / (c + d). Omitir cualquiera de los dos pares puede cambiar qué términos se dividen.

El mismo problema aparece en una conversión de temperatura:

celsius = (98.6 - 32) * 5 / 9

La resta da 66.6, la multiplicación da 333.0 y la división da 37.0. Sin la agrupación, 98.6 - 32 * 5 / 9 da 80.82222222222222.

Usa los signos de agrupación adecuados

Los paréntesis agrupan una expresión. Los corchetes y las llaves tienen otros significados en Python. Por ejemplo, [2 + 3] * 4 produce [5, 5, 5, 5], no 20.

Los paréntesis alrededor de una operación que se realizaría primero de todos modos dejan el resultado sin cambios: (2 * 3) + 1 y 2 * 3 + 1 dan 7. Los paréntesis que cambian la agrupación pueden cambiar el valor: 2 * (3 + 1) da 8. Añade agrupaciones cuando faciliten ver el significado del cálculo.

La división entera con redondeo hacia abajo y el resto responden a dos preguntas relacionadas: cuántos grupos completos caben y qué queda después de formar esos grupos. Para cantidades enteras no negativas, esta pareja resulta útil con el tiempo, el dinero, el empaquetado y los dígitos.

Obtén el cociente y el resto juntos

17 // 5 da 3, el número de grupos completos de cinco. 17 % 5 da 2, la cantidad sobrante. Los dos resultados reconstruyen la cantidad inicial:

print((17 // 5) * 5 + 17 % 5)

La expresión da 17: tres grupos de cinco más dos. En general, para enteros y un divisor distinto de cero, (a // b) * b + a % b es igual a a. Usa esa relación para comprobar ambas respuestas.

Reparte cantidades reales

Para 135 minutos:

hours = 135 // 60
minutes = 135 % 60

Hay 2 horas completas y sobran 15 minutos. El divisor es 60 porque una hora contiene 60 minutos. Dividir con / da 2.25, que expresa horas con parte fraccionaria; no da por separado los minutos sobrantes.

La misma estructura funciona con otro tamaño de grupo:

El conteo de cajas indica el número de cajas completas. Si también necesitas un recipiente para los huevos sobrantes, esa es una pregunta distinta de cuántos grupos completos caben.

Usa el valor posicional y la paridad

Para un entero positivo, dividir entre diez separa su último dígito. 1234 % 10 da 4, y 1234 // 10 da 123. Volver a combinar 123 * 10 + 4 recupera 1234.

Para cualquier entero n, n % 2 es 0 cuando es par y 1 cuando es impar. Esto también funciona con negativos: -7 % 2 es 1. Para enteros y un divisor positivo b, el resto está entre 0 y b - 1, ambos incluidos.

Comprende la división con negativos

La división entera con redondeo hacia abajo redondea hacia menos infinito, no hacia cero. Como menos siete dividido entre dos es menos 3,5, -7 // 2 da -4. El resto es entonces 1, porque -4 * 2 + 1 es igual a -7.

Un resto distinto de cero tiene el signo del divisor. Con un divisor negativo, 7 % -2 da -1, y 7 // -2 da -4. Estos resultados siguen reconstruyendo el original: -4 * -2 + -1 es 7.

Esto difiere de convertir un cociente con int(): int(-7 / 2) da -3 porque la conversión trunca hacia cero.

Ambos operadores también aceptan números de coma flotante. 7.5 // 2 es 3.0, y 7.5 % 2 es 1.5. Comparten el nivel de precedencia de * y /, así que 5 * 3 + 17 % 5 da 17. Aquí el operador % significa resto, no porcentaje: calcula el 8 por ciento de un precio con price * 0.08 o price * 8 / 100.

El símbolo de un operador es solo una parte de su significado. Python también usa los tipos de sus operandos. Los operadores + y * funcionan con cadenas, pero en ellas realizan operaciones de texto.

Une cadenas con el signo más

La concatenación une una cadena al final de otra:

print("ab" + "cd")
print("Hello" + "Ada")
print("Hello " + "Ada")

Estas líneas muestran abcd, HelloAda y Hello Ada. La concatenación no añade espacios por sí sola. El espacio del tercer resultado procede del último carácter de "Hello ".

Los caracteres de dígitos siguen la misma regla: "5" + "3" da la cadena "53". Sin comillas, 5 + 3 da el entero 8. Elige valores numéricos cuando quieras hacer aritmética y cadenas cuando quieras texto.

Repite una cadena con la multiplicación

Una cadena multiplicada por un entero repite sus caracteres. "3" * 2 da "33", mientras que 3 * 2 da 6. El número de repeticiones puede ir a cualquiera de los dos lados: 3 * "ab" da "ababab". Repetir cero veces da la cadena vacía, así que "ab" * 0 es "".

El número de repeticiones debe ser un entero. "ab" * 2.5 lanza TypeError, al igual que "ab" * "cd". En esta operación no hay un número fraccionario de copias.

Combina las operaciones en orden

La multiplicación también tiene mayor precedencia que la suma en estas expresiones:

print("-" * 4 + "Menu" + "-" * 4)

Primero, cada repetición crea "----". Después, las sumas unen las tres cadenas y producen ----Menu----. El orden de las uniones conserva el orden de sus caracteres.

Para un cálculo que pasa a formar parte de una cadena:

print("7" + str(3 * 2))

La operación aritmética interior da el entero 6. str(6) crea la cadena "6". Por último, la concatenación produce "76". No produce 13, porque el + final tiene dos cadenas como operandos.

Resuelve los tipos incompatibles de forma explícita

"Age: " + 30 lanza TypeError. Convierte el entero antes de concatenar:

print("Age: " + str(30))

Esto produce Age: 30. Como alternativa, print("Age:", 30) muestra los dos valores con un espacio entre ellos. Ese es el comportamiento de print() con argumentos separados, no una suma de texto.

Los enteros y los números de coma flotante pueden mezclarse en la aritmética habitual: 2 * 3.0 da el número de coma flotante 6.0. Python no convierte de forma similar una cadena numérica en un número durante +. Si necesitas calcular con "30", conviértela primero a un tipo numérico.

La resta no funciona con estos operandos de cadena. "10" - 3 lanza TypeError, aunque los caracteres 10 puedan representar un número. Para predecir una expresión con tipos mixtos, identifica el tipo de cada operando, evalúa las operaciones de mayor prioridad y vuelve a comprobar los tipos en la siguiente operación. Una conversión puede cambiar la regla que sigue el siguiente operador.

La conversión de tipos crea un valor de un tipo distinto. Las funciones int(), float() y str() te permiten elegir la forma que necesita la siguiente operación.

Conserva el resultado de la conversión

x = "42"
int(x)
print(type(x))

Esto sigue mostrando <class 'str'>. La conversión creó un entero, pero ninguna asignación lo conservó. Escribe x = int(x) para que x se refiera a ese entero, o asígnalo a otro nombre cuando quieras conservar ambas formas.

Elige una conversión numérica

int() acepta una cadena que represente un número entero, con un signo opcional y espacios alrededor. int("42"), int("-12") e int(" 42 ") producen 42, -12 y 42.

Un punto decimal en una cadena impide la conversión directa a entero. int("3.5") e int("4.0") lanzan ValueError; también lo hacen int("abc") e int(""). Que 4,0 sea matemáticamente entero no convierte "4.0" en una cadena con formato de entero.

float() acepta texto decimal y notación con exponente. float("3.5") da 3.5, float("3") da 3.0, y float("1e3") da 1000.0. También convierte enteros: float(7) da 7.0. Una coma decimal falla: float("3,5") lanza ValueError.

Decide si necesitas truncar o redondear

Convertir un número de coma flotante a int elimina su parte fraccionaria hacia cero. int(3.99) da 3, e int(-3.99) da -3. No elige el entero más cercano. Para convertir texto decimal y después truncar, usa int(float("3.5")), que da 3.

round() elige el valor más cercano. round(3.7) da el entero 4; round(3.14159, 2) da el número de coma flotante 3.14. El segundo argumento establece el número de decimales.

En un punto exactamente intermedio, Python elige el vecino par: round(2.5) da 2, mientras que round(3.5) da 4. Las fracciones decimales almacenadas en coma flotante pueden no ser valores exactamente intermedios. round(2.675, 2) da 2.67 debido a su representación binaria.

Estas operaciones responden a preguntas distintas. Elige la operación que corresponda al resultado buscado, especialmente cuando pueda haber valores negativos.

Convierte a texto para unir cadenas

str(42) produce "42", y str(3.0) produce "3.0". Después de la conversión, + une sus caracteres:

print("7" + "3")
print(int("7") + int("3"))
print(str(7) + str(3))
print(float("7") + 3)

Las salidas son 73, 10, 73 y 10.0. Las conversiones determinan si el + final recibe texto o números.

Un ValueError señala un contenido inadecuado para una conversión, como int("abc"). Un TypeError señala una operación incompatible con sus operandos, como "5" + 5. Usa esa diferencia para decidir si debes revisar el texto de entrada o cambiar la operación.

print() muestra valores para que una persona los lea. Sus argumentos son los valores o expresiones dentro de sus paréntesis. Las comas separan los argumentos; Python los evalúa antes de mostrar sus resultados.

Muestra valores con etiquetas útiles

print("Total:", 5)
print(3 + 4)
print("3 + 4")

Las líneas muestran Total: 5, 7 y 3 + 4. Una etiqueta indica a quien lee qué significa un valor. Un cálculo sin comillas se evalúa; una expresión entre comillas se muestra como texto.

Por defecto, print() pone un espacio entre argumentos y termina con un salto de línea. Convierte cada valor para mostrarlo, así que print("Total:", 5) puede mezclar texto y un entero sin un str() explícito.

Compáralo con print("Total:" + str(5)), que muestra Total:5. Aquí, + construye una cadena antes de que print() la reciba. La concatenación no aporta espacios automáticos, y solo hay un argumento que mostrar.

Establece el separador

El argumento con nombre sep establece el texto que se coloca entre los argumentos:

print("a", "b", sep="-")
print(1, 2, 3, sep=", ")
print("A", 12, sep="")

La salida es:

a-b
1, 2, 3
A12

Usa el nombre sep. Escribir print("a", "b", "-") proporciona un tercer valor, así que el resultado es a b -. Un separador vacío une directamente los argumentos mostrados; no elimina los espacios que ya están dentro de sus cadenas.

Establece el terminador

El argumento con nombre end cambia lo que sigue al último valor. Por defecto es un salto de línea. Un terminador vacío mantiene la siguiente salida en la misma línea:

print("a", end="")
print("b")

Esto muestra ab en una sola línea. Puedes incluir signos de puntuación y un salto de línea juntos:

print("Hello,", "Ada", end="!\n")

La salida es Hello, Ada! seguida de un salto de línea. sep se aplica entre los argumentos de una misma llamada; end se aplica después del último argumento de esa llamada. Controlan posiciones distintas.

Añade saltos de línea y elige la precisión mostrada

Llamar a print() sin argumentos muestra una línea vacía. Un \n dentro de una cadena crea un salto de línea en esa cadena, como en print("Line 1\nLine 2"). El texto repetido puede formar un separador: print("=" * 20) muestra veinte signos igual.

Python muestra un número de coma flotante con una forma breve que representa su valor almacenado. print(1 / 3) muestra 0.3333333333333333. Para mostrar un valor redondeado, calcúlalo primero dentro de la llamada: print(round(1 / 3, 2)) muestra 0.33.

El redondeo no garantiza un número fijo de decimales visibles. round(2.50, 2) se muestra como 2.5, porque el número de coma flotante no almacena ceros finales como una instrucción de presentación. Usa la salida exactamente como la produce Python al comprobar un programa.

input() muestra un mensaje de solicitud de datos, espera a que alguien escriba y pulse Intro, y después devuelve el texto escrito como una cadena sin el salto de línea de Intro. Un programa breve y completo lee los datos necesarios, los procesa y muestra un resultado.

Lee texto y convierte números

name = input("What is your name? ")
print("Hello", name)

El espacio al final del mensaje separa la respuesta escrita de la pregunta. La variable almacena texto como texto, incluso cuando el usuario escribe dígitos. Escribir 30 en input() produce "30", no el entero 30.

Elige una conversión antes de hacer operaciones aritméticas:

age = int(input("Age in whole years: "))
print("Next year:", age + 1)

El input() interior se ejecuta primero. Si el usuario escribe 30, devuelve "30"; int() lo convierte en 30; la asignación conserva el entero. Después, la suma produce 31.

Usa float(input(...)) cuando se permitan valores fraccionarios. Un mensaje debe indicar qué clase de respuesta se espera. Introducir 2.5 o thirty para una conversión con int() lanza ValueError. Introducir 98,6 para una conversión con float() también falla; el separador decimal debe ser un punto.

Omitir la conversión no siempre lanza un error. Si dos llamadas a input reciben 5 y 3, sus valores sin convertir se suman como cadenas y producen 53. Ambos operandos tienen un tipo que admite +, pero es la operación incorrecta para sumar cantidades.

Sigue un cálculo completo

El patrón entrada–proceso–salida facilita revisar las etapas principales:

# Convert a temperature from Fahrenheit to Celsius.
fahrenheit = float(input("Temperature in °F: "))
celsius = (fahrenheit - 32) * 5 / 9
print(fahrenheit, "°F is", round(celsius, 1), "°C")

Con la entrada 98.6, el programa lee el número de coma flotante 98.6. Resta 32 para obtener 66.6, multiplica por 5 para obtener 333.0 y divide entre 9 para obtener 37.0. La línea mostrada es 98.6 °F is 37.0 °C. La entrada 50 se convierte en 50.0, así que la línea es 50.0 °F is 10.0 °C.

Aquí tienes un programa con datos enteros:

total_minutes = int(input("Enter a whole number of minutes: "))
hours = total_minutes // 60
minutes = total_minutes % 60
print("Hours:", hours, "Minutes:", minutes)

La entrada 135 produce Hours: 2 Minutes: 15. Las etiquetas sirven para cero, uno y resultados mayores sin cambiar el texto. Las dos líneas de procesamiento usan el mismo total original; asignar un valor a hours no quita nada de total_minutes.

Prueba valores habituales y valores límite

Elige entradas cuyas respuestas puedas calcular a mano. En el programa de temperatura, 32 debería producir 0.0 °C y 212 debería producir 100.0 °C. Para los minutos, prueba 0, 59 y 60: comprueban el valor inicial y el paso de ninguna hora completa a una hora completa.

Prueba también un valor habitual como 135. Compara las etiquetas exactas, los espacios, los resultados numéricos y los tipos con tu predicción. Si el código se ejecuta, pero el resultado es incorrecto, sigue los valores almacenados y el orden de las operaciones. Si falla una conversión, revisa el texto escrito y el tipo que solicita tu mensaje.