1. Primeros pasos con Python

Bienvenido a tu viaje en la programación con Python. Este capítulo te guiará por los primeros pasos esenciales: entender qué es Python, instalarlo en tu computadora y ejecutar tu primer código Python. Al final de este capítulo, te sentirás cómodo usando la consola interactiva de Python, creando y ejecutando archivos de script y entendiendo los mensajes de error básicos que te muestra Python.

1.1) Qué es un programa y qué hace Python

Antes de entrar en Python específicamente, entendamos qué es un programa y qué papel juega Python en la creación de programas.

1.1.1) Comprender los programas

Un programa es un conjunto de instrucciones que le dice a una computadora qué hacer. Igual que una receta te indica paso a paso cómo hornear un pastel, un programa le indica a la computadora paso a paso cómo realizar una tarea. Estas tareas pueden ir desde cálculos simples hasta operaciones complejas como mostrar páginas web, procesar imágenes o controlar robots.

Las computadoras no entienden directamente lenguajes humanos como el inglés o el español. Solo entienden código máquina: secuencias de números binarios (0s y 1s) que representan operaciones muy básicas. Escribir programas directamente en código máquina sería extremadamente difícil y propenso a errores para los humanos.

Aquí es donde entran los lenguajes de programación. Un lenguaje de programación es una forma legible por humanos de escribir instrucciones que se pueden traducir a código máquina. Python es uno de esos lenguajes de programación, diseñado para ser particularmente fácil de leer y escribir para las personas.

1.1.2) Qué hace especial a Python

Python es un lenguaje de programación de alto nivel, lo que significa que oculta muchos de los detalles complejos que tendrías que manejar en lenguajes de más bajo nivel. Esto es lo que hace que Python sea especialmente atractivo tanto para principiantes como para profesionales:

Sintaxis legible: El código Python se lee casi como inglés. Por ejemplo, para imprimir "Hello, World!" en Python, escribes:

# hello_simple.py
print("Hello, World!")

Salida:

Hello, World!

Compáralo con lenguajes como C o Java, que requieren mucho más código “boilerplate” para hacer lo mismo.

Lenguaje interpretado: Python es un lenguaje interpretado. Esto significa que no necesitas compilar tu código a código máquina antes de ejecutarlo. En su lugar, un programa llamado intérprete de Python lee tu código y lo ejecuta línea por línea. Esto hace que el desarrollo sea más rápido porque puedes ver inmediatamente los resultados de tus cambios.

Versátil y potente: A pesar de ser amigable para principiantes, Python se usa en entornos profesionales para:

• Desarrollo web (sitios y aplicaciones web)
• Análisis y visualización de datos
• Aprendizaje automático e inteligencia artificial
• Computación científica
• Automatización y scripting
• Desarrollo de videojuegos
• Y mucho más

Gran comunidad y bibliotecas: Python tiene una comunidad enorme de usuarios y miles de bibliotecas de código ya escrito que amplían sus capacidades. Esto significa que las soluciones a problemas comunes suelen estar a solo un import de distancia.

1.1.3) Cómo ejecuta Python tu código

Cuando escribes código Python y lo ejecutas, esto es lo que ocurre por debajo:

1. Escribes código: Creas un archivo que contiene instrucciones Python o las escribes directamente en la consola interactiva de Python.

2. El intérprete lee tu código: El intérprete de Python revisa tu código en busca de errores de sintaxis (fallos en cómo has escrito el código).

3. Traducción a bytecode: Si no hay errores de sintaxis, Python traduce tu código a una forma intermedia llamada bytecode. El bytecode es una forma intermedia de tu código: una traducción a un lenguaje que está a medio camino entre Python y el código máquina. Es más simple que Python para que la computadora lo ejecute, pero más abstracto que el código máquina puro.

4. Ejecución: La Máquina Virtual de Python (PVM) ejecuta el bytecode, realizando las operaciones que especificaste.

5. Salida: Ves los resultados de tu programa, ya sea texto en pantalla, un archivo creado o cualquier otra acción.

La belleza de este proceso es que no necesitas preocuparte por la mayoría de estos pasos. Escribes código, lo ejecutas y ves resultados. El intérprete se encarga del resto.

1.2) Instalación de Python y ejecución del intérprete

Para empezar a programar en Python, primero necesitas instalar Python en tu computadora. Esta sección te guiará por el proceso de instalación y verificará que todo funcione correctamente.

1.2.1) Comprobar si Python ya está instalado

Algunos sistemas operativos vienen con Python preinstalado. Antes de descargar nada, veamos si Python ya está en tu sistema.

En Windows:

1. Abre la consola de comandos (Command Prompt):

   • Presiona Windows + R para abrir el cuadro de diálogo Ejecutar
   • Escribe cmd y presiona Enter

2. Escribe el siguiente comando y presiona Enter:

python --version

Si Python está instalado, verás algo como:

Python 3.11.5

Si ves un mensaje de error como 'python' is not recognized as an internal or external command, Python no está instalado o no está en tu PATH del sistema.

En macOS:

1. Abre la aplicación Terminal:

   • Presiona Command + Space para abrir Spotlight
   • Escribe Terminal y presiona Enter

2. Escribe el siguiente comando y presiona Enter:

python3 --version

Nota: En macOS, normalmente usas python3 en lugar de python porque python puede referirse a Python 2, que está obsoleto.

Si Python 3 está instalado, verás algo como:

Python 3.11.5

En Linux:

1. Abre tu aplicación de terminal (varía según la distribución).

2. Escribe el siguiente comando y presiona Enter:

python3 --version

La mayoría de distribuciones Linux modernas vienen con Python 3 preinstalado.

1.2.2) Descargar e instalar Python

Si Python no está instalado o tienes una versión antigua, sigue estos pasos para instalar la versión más reciente.

Instalación en Windows:

1. Visita el sitio oficial de Python: https://www.python.org/downloads/

2. Haz clic en el botón "Download Python" (mostrará la versión más reciente, como "Download Python 3.11.5")

3. Ejecuta el instalador descargado (archivo .exe)

4. Importante: En la primera pantalla del instalador, marca la casilla que dice "Add Python to PATH". Esto es crucial: te permite ejecutar Python desde cualquier consola.

   Qué pasa si lo olvidas: Si no marcas "Add Python to PATH", no podrás ejecutar Python desde la línea de comandos, y verás un error como 'python' is not recognized as an internal or external command. Si esto ocurre, tendrás que reinstalar Python (marcando la casilla esta vez) o añadir Python manualmente a tu PATH, lo cual es más complejo para principiantes.

5. Haz clic en "Install Now" y espera a que termine la instalación.

6. Verifica la instalación abriendo una nueva consola de comandos y escribiendo:

python --version

Deberías ver el número de versión que acabas de instalar.

Instalación en macOS:

1. Visita https://www.python.org/downloads/

2. Haz clic en el botón "Download Python" para la versión más reciente.

3. Abre el archivo .pkg descargado y sigue el asistente de instalación.

4. Verifica la instalación abriendo Terminal y escribiendo:

python3 --version

Instalación en Linux:

La mayoría de distribuciones Linux vienen con Python 3, pero si necesitas instalarlo o actualizarlo:

Para sistemas basados en Ubuntu/Debian:

sudo apt update
sudo apt install python3

Para sistemas basados en Fedora/Red Hat:

sudo dnf install python3

Verifica con:

python3 --version

1.2.3) Ejecutar el intérprete de Python

Una vez instalado Python, puedes ejecutar el intérprete de Python directamente desde tu consola o terminal. El intérprete es el programa que ejecuta código Python. Ejecutarlo directamente abre la consola interactiva (REPL), que exploraremos en detalle en la siguiente sección. Esto es distinto de ejecutar un archivo de script, algo que veremos en la Sección 1.4.

En Windows:

Abre la consola de comandos y escribe:

python

En macOS y Linux:

Abre Terminal y escribe:

python3

Deberías ver algo como:

Python 3.11.5 (main, Sep 11 2023, 13:54:46) [GCC 11.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

El prompt >>> indica que Python está listo para aceptar tus comandos. A esto se le llama la consola interactiva de Python o REPL (Read-Eval-Print Loop), que exploraremos en detalle en la siguiente sección.

Para salir del intérprete, puedes:

• Escribir exit() y presionar Enter
• Escribir quit() y presionar Enter
• Presionar Ctrl + D (en macOS/Linux) o Ctrl + Z y luego Enter (en Windows)

Enhorabuena. Has instalado Python correctamente y verificado que el intérprete funciona. Ya estás listo para empezar a escribir código Python.

1.3) Usar la consola interactiva de Python (REPL)

La consola interactiva de Python, conocida como REPL (Read-Eval-Print Loop), es una de las características más útiles de Python para aprender y experimentar. Te permite escribir código Python y ver los resultados de inmediato, lo que la hace perfecta para probar conceptos nuevos, testear pequeños fragmentos de código y explorar las capacidades de Python.

1.3.1) Qué es el REPL

La consola interactiva de Python, comúnmente llamada REPL (Read-Eval-Print Loop), es una de las características más útiles de Python para aprender y experimentar. El REPL también se llama la consola interactiva de Python o simplemente el intérprete interactivo: todos estos términos se refieren a lo mismo, el prompt >>> donde puedes escribir código Python y ver resultados inmediatos.

REPL significa:

• Read (leer): Python lee el código que escribes
• Eval (evaluar): Python evalúa (ejecuta) ese código
• Print (imprimir): Python imprime el resultado
• Loop (bucle): Python vuelve a empezar el ciclo para leer más código

Este ciclo continúa hasta que sales del REPL. Es como tener una conversación con Python: le das una instrucción, responde, y puedes darle otra instrucción inmediatamente en función de esa respuesta.

1.3.2) Iniciar y usar el REPL

Para iniciar el REPL, abre tu consola o terminal y escribe python (Windows) o python3 (macOS/Linux), como hicimos en la sección anterior.

Cuando veas el prompt >>>, puedes empezar a escribir código Python. Probemos algunos ejemplos básicos:

Aritmética simple:

>>> 5 + 3
8
>>> 10 * 2
20
>>> 15 / 3
5.0

Observa que no necesitas usar print() en el REPL: Python muestra automáticamente el resultado de cada expresión. Esta es una de las comodidades del REPL.

Trabajando con texto:

>>> "Hello, World!"
'Hello, World!'
>>> "Python" + " is " + "great"
'Python is great'

Cuando escribes solo una cadena (texto entre comillas), Python la muestra con comillas: es la forma en que Python representa la cadena. Si quieres mostrar el texto sin comillas, usa la función print():

>>> print("Hello, World!")
Hello, World!

Observa la diferencia: escribir solo la cadena la muestra con comillas (la representación de Python), pero print() la muestra sin comillas (el texto real).

Almacenar valores en variables:

Aunque escribir valores directamente es útil para pruebas rápidas, a menudo querrás almacenar valores en variables: contenedores con nombre que guardan datos que puedes reutilizar en tu programa.

>>> name = "Alice"
>>> name
'Alice'
>>> age = 25
>>> age
25

Cuando asignas un valor a una variable (como name = "Alice"), Python no imprime nada. Pero cuando escribes solo el nombre de la variable, Python te muestra su valor.

Usar Python como calculadora:

>>> 2 + 2
4
>>> (10 + 5) * 2
30
>>> 100 / 4
25.0
>>> 7 % 3
1

El REPL es excelente para cálculos rápidos y para probar expresiones matemáticas.

1.3.3) Entrada de varias líneas en el REPL

A veces necesitas escribir código que abarca varias líneas, como definiciones de funciones. El REPL maneja esto cambiando su prompt. Cuando empiezas una instrucción de varias líneas, el prompt cambia de >>> a ... para indicar que Python está esperando a que completes la instrucción.

Aquí tienes un ejemplo sencillo usando una función (nota: aprenderemos sobre funciones en detalle en el Capítulo 19. Este ejemplo solo muestra cómo el REPL maneja la entrada de varias líneas con el prompt de continuación ...):

>>> def greet():
...     print("Hello!")
...
>>> greet()
Hello!

Después de escribir la primera línea y presionar Enter, el prompt se convierte en .... Escribes la línea indentada, presionas Enter y luego presionas Enter de nuevo en una línea vacía para ejecutar el código.

1.3.4) Acceder a comandos anteriores

El REPL conserva un historial de los comandos que has escrito. Puedes usar las flechas arriba y abajo para navegar por tu historial de comandos:

• Flecha arriba: Muestra el comando anterior
• Flecha abajo: Muestra el siguiente comando (si has ido hacia atrás)

Esto es muy útil cuando quieres modificar y volver a ejecutar un comando, o cuando quieres recordar qué escribiste antes.

1.3.5) Obtener ayuda en el REPL

El REPL de Python tiene funciones de ayuda integradas. Puedes obtener información sobre objetos, funciones y módulos de Python directamente.

Estas funciones de ayuda son especialmente útiles cuando estás explorando Python y quieres saber qué está disponible. Por ejemplo, si estás trabajando con cadenas y te preguntas qué métodos hay, dir(str) te muestra todas las opciones. A medida que avances en este libro, estas herramientas serán cada vez más valiosas para explorar por tu cuenta.

>>> help()

Esto entra en el sistema de ayuda. Luego puedes escribir el nombre de aquello sobre lo que quieres ayuda, o escribir quit para salir del sistema de ayuda.

También puedes obtener ayuda directa sobre cosas concretas:

>>> help(print)

Esto muestra la documentación de la función print(). Pulsa q para salir de la vista de ayuda.

Otra función útil es dir(), que lista los atributos y métodos disponibles en un objeto. (Nota: los atributos y métodos son características y acciones disponibles en un objeto; aprenderemos más sobre esto en el Capítulo 43. También aprenderemos a importar módulos en el Capítulo 22. Este ejemplo muestra cómo el REPL ayuda a explorar las capacidades de Python).

>>> dir(str)

Esto muestra todos los métodos disponibles para objetos de tipo cadena.

1.3.6) Cuándo es más útil el REPL

El REPL sobresale en:

1. Aprendizaje y exploración: Cuando estás aprendiendo un concepto nuevo, el REPL te permite experimentar de inmediato sin crear archivos.

2. Probar pequeños fragmentos de código: Antes de añadir código a tu programa, puedes probarlo en el REPL para asegurarte de que funciona como esperas.

3. Cálculos rápidos: El REPL es una calculadora potente que siempre está disponible.

4. Depuración: Cuando tu programa no funciona, puedes usar el REPL para probar partes individuales de tu código de forma aislada.

5. Explorar bibliotecas: Al aprender una biblioteca nueva, puedes importarla en el REPL y probar sus funciones de forma interactiva.

Sin embargo, el REPL tiene limitaciones. El código que escribes en el REPL desaparece cuando lo cierras: no hay forma de guardar tu sesión del REPL como un programa. Para cualquier código que quieras conservar y ejecutar repetidamente, necesitas crear archivos de script, algo que veremos en la siguiente sección.

1.3.7) Salir del REPL

Cuando termines con el REPL, puedes salir de varias maneras:

>>> exit()

O:

>>> quit()

O usando atajos de teclado:

• Windows: Presiona Ctrl + Z y luego Enter
• macOS/Linux: Presiona Ctrl + D

Tras salir, volverás a tu consola o terminal normal.

1.4) Crear y ejecutar archivos de script de Python

El REPL es excelente para la experimentación y las pruebas rápidas, pero ¿qué pasa si quieres guardar tu código y ejecutarlo de nuevo más tarde? ¿Y si quieres escribir un programa más largo con docenas o cientos de líneas? Para estas situaciones necesitas archivos de script: archivos permanentes que contienen código Python que puedes editar, guardar y ejecutar repetidamente.

Aunque el REPL es excelente para experimentar, la mayor parte de la programación en Python implica escribir archivos de script: archivos de texto que contienen código Python que se puede guardar, editar y ejecutar repetidamente. En esta sección aprenderás a crear tu primer script de Python y a ejecutarlo desde la línea de comandos.

1.4.1) Qué es un script de Python

Un script de Python es simplemente un archivo de texto que contiene código Python, guardado con la extensión .py. A diferencia del código que escribes en el REPL, los archivos de script:

• Son permanentes: puedes guardarlos y ejecutarlos más tarde
• Pueden editarse y modificarse fácilmente
• Pueden contener tanto código como necesites
• Pueden compartirse con otras personas
• Pueden ejecutarse de forma automática o programada

Piensa en un archivo de script como una receta que escribes, mientras que el REPL es como cocinar inventando la receta sobre la marcha. Ambos tienen su lugar, pero para cualquier cosa significativa querrás un archivo de script.

1.4.2) Elegir un editor de texto

Para crear scripts de Python necesitas un editor de texto. No uses procesadores de texto como Microsoft Word o Google Docs: estos añaden formato que Python no puede entender.

Buenas opciones para principiantes:

1. IDLE: Viene incluido con Python. Sencillo y pensado para aprender.

   • En Windows: Busca "IDLE" en el menú Inicio
   • En macOS/Linux: Escribe idle3 en el terminal

2. Visual Studio Code (VS Code): Gratuito, potente y ampliamente usado por profesionales. Excelente soporte para Python con extensiones.

   • Descarga desde: https://code.visualstudio.com/

3. PyCharm Community Edition: Un IDE (Entorno de Desarrollo Integrado) completo específicamente para Python.

   • Descarga desde: https://www.jetbrains.com/pycharm/

4. Notepad++ (solo Windows): Ligero y sencillo.

   • Descarga desde: https://notepad-plus-plus.org/

5. Sublime Text: Rápido y elegante, con buen soporte para Python.

   • Descarga desde: https://www.sublimetext.com/

En este libro usaremos ejemplos sencillos que funcionan con cualquier editor de texto. Elige el editor con el que te sientas más cómodo.

1.4.3) Crear tu primer script de Python

Vamos a crear un script sencillo de Python que imprime mensajes de saludo.

Paso 1: Crear un archivo nuevo

Abre el editor de texto que hayas elegido y crea un archivo nuevo. Guárdalo como hello.py en un lugar que recuerdes (como tu Escritorio o una carpeta dedicada a proyectos Python).

Importante: La extensión .py es crucial. Le dice a tu sistema operativo y a tu editor de texto que se trata de un archivo Python.

Paso 2: Escribir tu código

Escribe el siguiente código en tu archivo:

# hello.py
# My first Python script
 
print("Hello, World!")
print("Welcome to Python programming!")

Las líneas que empiezan por # son comentarios: notas para las personas que leen el código. Python las ignora completamente. Los comentarios te ayudan a recordar qué hace tu código y ayudan a otros a entender tu trabajo. Exploraremos los comentarios con más detalle en el Capítulo 2.

Paso 3: Guardar el archivo

Guarda el archivo. Asegúrate de que se guarde como hello.py, no como hello.py.txt ni con otra extensión.

Entendamos qué hace este código:

• print("Hello, World!") le dice a Python que muestre el texto "Hello, World!" en la pantalla.
• print("Welcome to Python programming!") muestra otro mensaje.

Añadamos un ejemplo más para hacer transición antes de pasar a scripts más complejos:

# greetings.py
# A script with multiple print statements
 
print("Python is fun!")
print("Let's learn together.")
print("This is exciting!")

Guarda esto como greetings.py. Este ejemplo usa tres sentencias print pero aún no usa variables, ayudándote a sentirte cómodo con la estructura básica antes de pasar a conceptos más complejos.

1.4.4) Ejecutar tu script desde la línea de comandos

Ahora que has creado tu script, vamos a ejecutarlo.

Paso 1: Abrir tu consola/terminal

• Windows: Abre la consola de comandos
• macOS/Linux: Abre Terminal

Paso 2: Navegar hasta la ubicación de tu script

Usa el comando cd (change directory) para ir al lugar donde guardaste hello.py. Por ejemplo, si lo guardaste en el Escritorio:

Windows:

cd Desktop

macOS/Linux:

cd ~/Desktop

Si obtienes un error como "No such file or directory" al intentar ejecutar tu script, probablemente estés en la carpeta equivocada. Usa el comando cd para ir a la carpeta donde lo guardaste.

Para verificar que estás en el lugar correcto, puedes listar los archivos:

Windows:

dir

macOS/Linux:

ls

Deberías ver hello.py en la lista.

Paso 3: Ejecutar tu script

Windows:

python hello.py

macOS/Linux:

python3 hello.py

Deberías ver la salida:

Hello, World!
Welcome to Python programming!

Enhorabuena. Acabas de crear y ejecutar tu primer script de Python.

1.4.5) Entender la ejecución de un script

Cuando ejecutas un script de Python, esto es lo que ocurre:

1. Escribes el comando para ejecutar tu script
2. Tu sistema operativo lanza el intérprete de Python
3. El intérprete lee todo tu archivo de script
4. Comprueba si hay errores de sintaxis (fallos en cómo has escrito el código)
5. Si hay errores, muestra un mensaje de error y se detiene
6. Si no hay errores, ejecuta tu código línea por línea, de arriba abajo
7. Cualquier salida (de sentencias print()) se muestra
8. Cuando el script termina, el control vuelve a tu consola

1.4.6) Un ejemplo más complejo

Vamos a crear un script un poco más complejo que demuestre varios conceptos. Primero, añadamos un ejemplo intermedio que introduzca las variables de forma más suave:

# simple_variable.py
# Using a variable for the first time
 
message = "Hello, Python!"
print(message)

Salida:

Hello, Python!

Esto sirve de puente entre las sentencias print puras y ejemplos más complejos. Ahora veamos un script con múltiples variables:

# student_info.py
# A script that uses variables and multiple print statements
 
name = "Alice"
age = 25
city = "New York"
 
print("Student Information")
print("-------------------")
print("Name:", name)
print("Age:", age)
print("City:", city)

Guárdalo como student_info.py y ejecútalo:

Windows:

python student_info.py

macOS/Linux:

python3 student_info.py

Salida:

Student Information
-------------------
Name: Alice
Age: 25
City: New York

Este script demuestra:

• Cómo crear variables (aprenderemos más sobre variables en el Capítulo 3)
• Cómo usar múltiples sentencias print()
• Cómo imprimir texto literal y valores de variables

1.4.7) Buenas prácticas para archivos de script

Incluso en esta etapa temprana, es bueno desarrollar algunos hábitos:

1. Usa nombres de archivo descriptivos: Nombra tus archivos según lo que hacen. student_info.py es mejor que test.py o program1.py porque recordarás qué hace cuando lo veas en una lista de archivos dentro de seis meses.

2. Mantén los scripts organizados: Crea una carpeta dedicada a tus proyectos Python. No disperses scripts por todo tu equipo. Esto hace que sea más fácil encontrar tu trabajo y mantiene tus archivos organizados.

3. Añade comentarios: Empieza cada script con un comentario que explique qué hace. Esto te ayuda a recordar más adelante y ayuda a otros a entender tu código.

4. Un script, un propósito: Cada script debería hacer una cosa principal. No intentes meter múltiples tareas no relacionadas en un solo archivo. Esto hace tu código más fácil de entender y mantener.

5. Prueba con frecuencia: Ejecuta tu script a menudo mientras lo escribes. No esperes a tener 100 líneas para probar: prueba después de cada pocas líneas. Esto te ayuda a detectar errores pronto, cuando son más fáciles de arreglar.

1.5) Primer vistazo a errores y tracebacks

Los errores son una parte natural de la programación. Todo programador, desde principiantes hasta expertos, se encuentra con errores regularmente. Aprender a leer y entender los mensajes de error es una habilidad crucial que te ayudará a arreglar problemas rápidamente y a ser un programador más seguro.

1.5.1) Tipos de errores

Python distingue entre dos categorías principales de errores:

Errores de sintaxis: Fallos en cómo has escrito el código, violaciones de las reglas gramaticales de Python. Python los detecta antes de ejecutar tu código. Piensa en los errores de sintaxis como errores gramaticales en la escritura: Python ni siquiera puede entender lo que estás intentando decir.

Excepciones: Errores que ocurren mientras tu código se está ejecutando. La sintaxis es correcta, pero algo sale mal durante la ejecución. Las excepciones son como problemas en tiempo de ejecución: Python entiende tus instrucciones pero no puede llevarlas a cabo.

Veamos ambos tipos con ejemplos.

1.5.2) Errores de sintaxis

Un error de sintaxis ocurre cuando escribes código que no sigue las reglas de Python. Python ni siquiera puede empezar a ejecutar tu código porque no entiende lo que has escrito.

Ejemplo 1: Falta dos puntos

Crea un archivo llamado syntax_error1.py:

# syntax_error1.py
# This code has a syntax error
 
if 5 > 3
    print("Five is greater than three")

Cuando intentes ejecutar esto:

python syntax_error1.py

Verás:

  File "syntax_error1.py", line 4
    if 5 > 3
            ^
SyntaxError: expected ':'

Python te está diciendo varias cosas:

• Qué archivo tiene el problema: syntax_error1.py
• Qué línea tiene el problema: línea 4
• Dónde en esa línea está el problema: el ^ señala la ubicación
• Qué tipo de error: SyntaxError
• Una descripción útil: expected ':'

El problema es que las sentencias if en Python deben terminar con dos puntos (:). El código correcto es:

# syntax_error1_fixed.py
# Fixed version
 
if 5 > 3:
    print("Five is greater than three")

Salida:

Five is greater than three

Ejemplo 2: Comillas que no coinciden

# syntax_error2.py
# Another syntax error example
 
message = "Hello, World!'
print(message)

Al ejecutar esto se produce:

  File "syntax_error2.py", line 4
    message = "Hello, World!'
              ^
SyntaxError: unterminated string literal (detected at line 4)

El problema es que la cadena empieza con comillas dobles (") pero termina con comillas simples ('). Python exige comillas coincidentes. Arréglalo usando comillas que coincidan:

# syntax_error2_fixed.py
# Fixed version
 
message = "Hello, World!"
print(message)

Salida:

Hello, World!

1.5.3) Excepciones en tiempo de ejecución

Las excepciones en tiempo de ejecución (o simplemente “excepciones”) ocurren cuando tu código es sintácticamente correcto, pero algo sale mal durante la ejecución.

Ejemplo 1: NameError

# name_error.py
# This code will cause a NameError
 
print(greeting)

Cuando ejecutes esto:

python name_error.py

Verás:

Traceback (most recent call last):
  File "name_error.py", line 4, in <module>
    print(greeting)
          ^^^^^^^^
NameError: name 'greeting' is not defined

Esto se llama un traceback. Analicémoslo:

• "Traceback (most recent call last):" indica que lo que sigue es un traceback que muestra dónde ocurrió el error.
• Información de archivo y línea: File "name_error.py", line 4, in <module> te dice qué archivo y línea causaron el error.
• El código problemático: print(greeting) muestra la línea exacta que falló.
• Tipo de error: NameError te indica qué tipo de error ocurrió.
• Descripción del error: name 'greeting' is not defined explica el problema: estás intentando usar una variable que no existe.

Para arreglarlo, tienes que definir la variable antes de usarla:

# name_error_fixed.py
# Fixed version
 
greeting = "Hello!"
print(greeting)

Salida:

Hello!

Ejemplo 2: TypeError

# type_error.py
# This code will cause a TypeError
 
number = 5
text = "The number is "
result = text + number
print(result)

Al ejecutar esto se produce:

Traceback (most recent call last):
  File "type_error.py", line 6, in <module>
    result = text + number
             ~~~~~^~~~~~~~
TypeError: can only concatenate str (not "int") to str

El mensaje de error te dice que no puedes sumar (concatenar) directamente una cadena y un entero. Python no sabe si quieres hacer una suma matemática o una concatenación de texto.

Para arreglarlo, convierte el número a cadena:

# type_error_fixed.py
# Fixed version
 
number = 5
text = "The number is "
result = text + str(number)
print(result)

Salida:

The number is 5

Ejemplo 3: ZeroDivisionError

¿Qué pasa si intentas dividir entre cero?

# zero_division.py
# This code will cause a ZeroDivisionError
 
result = 10 / 0
print(result)

Al ejecutar esto se produce:

Traceback (most recent call last):
  File "zero_division.py", line 4, in <module>
    result = 10 / 0
             ~~~^~~
ZeroDivisionError: division by zero

Este error se explica por sí solo: no puedes dividir entre cero. Matemáticamente está indefinido, así que Python lanza un error.

1.5.4) Leer tracebacks de forma eficaz

Cuando te encuentres con un traceback, léelo de abajo hacia arriba. Leemos de abajo a arriba porque la última línea muestra qué salió mal (el tipo de error y el mensaje), mientras que las líneas anteriores muestran la secuencia de llamadas a funciones que llevaron al error. Para programas sencillos como los nuestros, la última línea te dice todo lo que necesitas saber.

1. Empieza por abajo: Mira primero el tipo de error y el mensaje.
2. Entiende el error: ¿Qué te está diciendo Python que salió mal?
3. Busca la ubicación: Mira el archivo y el número de línea donde ocurrió el error.
4. Examina el código: Mira esa línea en tu archivo.
5. Retrocede si hace falta: A veces el problema está en realidad en una línea anterior a la que indica Python.

1.5.5) Errores comunes de principiantes

Aquí tienes algunos errores con los que probablemente te encontrarás mientras aprendes Python:

Errores de indentación:

Python usa la indentación (espacios o tabulaciones al principio de las líneas) para definir bloques de código. Una indentación incorrecta provoca errores:

# indentation_error.py
# Incorrect indentation
 
print("First line")
    print("Second line")  # This line is incorrectly indented

Error:

  File "indentation_error.py", line 5
    print("Second line")
    ^
IndentationError: unexpected indent

Errores de escritura (typos):

Python distingue entre mayúsculas y minúsculas. Print no es lo mismo que print:

# spelling_error.py
# Incorrect capitalization
 
Print("Hello")  # Should be print, not Print

Error:

Traceback (most recent call last):
  File "spelling_error.py", line 4, in <module>
    Print("Hello")
    ^^^^^
NameError: name 'Print' is not defined

Paréntesis faltantes:

En Python 3, print requiere paréntesis:

# missing_parentheses.py
# Missing parentheses
 
print "Hello"  # Should be print("Hello")

Error:

  File "missing_parentheses.py", line 4
    print "Hello"
          ^^^^^^^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(...)?

Fíjate en lo útil que es el mensaje de error de Python aquí: incluso sugiere la solución.

1.5.6) Estrategias para lidiar con errores

Cuando te encuentres con un error:

1. No te asustes: Los errores son normales. Todo programador los ve constantemente.

2. Lee el mensaje de error con atención: Los mensajes de error de Python suelen ser útiles. Te dicen qué salió mal y dónde.

3. Revisa el número de línea: Ve a la línea que indica Python y busca el problema.

4. Mira las líneas cercanas: A veces el error está en realidad en la línea anterior a la que señala Python.

5. Revisa errores comunes: Falta de dos puntos, comillas que no coinciden, indentación incorrecta y errores tipográficos son muy frecuentes.

6. Prueba cambios pequeños: Arregla una cosa cada vez y prueba después de cada cambio.

7. Usa el REPL: Si no estás seguro de algo, pruébalo primero en el REPL.

8. Busca el error: Si no entiendes un mensaje de error, búscalo en internet. A menudo encontrarás explicaciones y soluciones.

1.5.7) Ejemplo completo con error y corrección

Veamos un script con múltiples errores y arreglémoslos paso a paso. Este programa está diseñado para mostrar información sobre una estudiante y calcular su edad dentro de 10 años:

Original (con errores):

# buggy_student.py
# This program has several errors
 
student_name = "Alice
student_age = 25
 
print("Name:", student_name)
print("Age:" student_age)
print("In 10 years, you will be", student_age + "10")

Ejecutar esto produce múltiples errores. Vamos a arreglarlos uno a uno:

Error 1: String sin terminar

  File "buggy_student.py", line 4
    student_name = "Alice
                   ^
SyntaxError: unterminated string literal (detected at line 4)

Arreglo: Añadir la comilla de cierre:

student_name = "Alice"

Tras corregir el Error 1, obtenemos el Error 2: Falta una coma

  File "buggy_student.py", line 8
    print("Age:" student_age)
                 ^^^^^^^^^^^
SyntaxError: invalid syntax. Perhaps you forgot a comma?

Arreglo: Añadir una coma entre la cadena y la variable:

print("Age:", student_age)

Tras corregir el Error 2, obtenemos el Error 3: Error de tipo

Traceback (most recent call last):
  File "buggy_student.py", line 9, in <module>
    print("In 10 years, you will be", student_age + "10")
                                      ~~~~~~~~~~~~^~~~~~
TypeError: unsupported operand type(s) for +: 'int' and 'str'

Arreglo: Convertir "10" a entero:

print("In 10 years, you will be", student_age + 10)

Versión corregida final:

# buggy_student_fixed.py
# Fixed version of the program
 
student_name = "Alice"
student_age = 25
 
print("Name:", student_name)
print("Age:", student_age)
print("In 10 years, you will be", student_age + 10)

Salida:

Name: Alice
Age: 25
In 10 years, you will be 35

Este ejemplo demuestra que arreglar errores suele ser un proceso iterativo. Arreglas un error, ejecutas el código de nuevo y descubres el siguiente error. Esto es completamente normal.

1.6) Cuándo usar la consola interactiva y cuándo archivos de script

Ahora que has aprendido tanto sobre el REPL como sobre archivos de script, quizá te preguntes cuándo usar cada uno. Ambos son herramientas valiosas, y los programadores experimentados de Python usan ambos con regularidad. Entender cuándo usar cada uno te hará más eficiente.

1.6.1) Usa la consola interactiva (REPL) cuando:

1. Estés aprendiendo conceptos nuevos

Cuando estás aprendiendo algo nuevo, el REPL proporciona retroalimentación inmediata:

>>> # Testing string methods
>>> text = "hello world"
>>> text.upper()
'HELLO WORLD'
>>> text.title()
'Hello World'
>>> text.capitalize()
'Hello world'

Puedes experimentar con distintos métodos y ver los resultados al instante sin crear archivos.

2. Pruebes pequeños fragmentos de código

Antes de añadir código a tu programa, pruébalo en el REPL:

>>> # Testing a calculation
>>> price = 19.99
>>> quantity = 3
>>> total = price * quantity
>>> total
59.97
>>> # Looks good, now I can add this to my script

3. Necesites cálculos rápidos

El REPL siempre está disponible como calculadora:

>>> # How many seconds in a day?
>>> 24 * 60 * 60
86400
>>> # What's 15% of 250?
>>> 250 * 0.15
37.5

4. Estés depurando

Cuando tu script no funciona, usa el REPL para probar partes individuales:

>>> # My script isn't working. Let me test this part:
>>> numbers = [1, 2, 3, 4, 5]
>>> sum(numbers) / len(numbers)
3.0
>>> # This works, so the problem must be elsewhere

Nota: Aprenderemos sobre listas en el Capítulo 13. Este ejemplo muestra cómo el REPL ayuda a probar fragmentos de código.

1.6.2) Usa archivos de script cuando:

1. Escribas programas que quieras conservar

Cualquier cosa que quieras guardar y ejecutar de nuevo debería estar en un archivo de script:

# temperature_converter.py
# A program to convert Fahrenheit to Celsius
 
fahrenheit = 98.6
celsius = (fahrenheit - 32) * 5/9
print("Temperature:", fahrenheit, "°F is", round(celsius, 1), "°C")

Salida:

Temperature: 98.6 °F is 37.0 °C

Puedes ejecutar este script siempre que lo necesites y modificarlo más adelante.

2. Escribas programas de varias líneas

Aunque puedes escribir código de varias líneas en el REPL, resulta incómodo para algo más grande. Usa un archivo de script:

# grade_calculator.py
# Calculate final grade from multiple scores
 
homework = 85
midterm = 78
final = 92
 
# Calculate weighted average
final_grade = (homework * 0.3) + (midterm * 0.3) + (final * 0.4)
 
print("Final Grade:", final_grade)

Salida:

Final Grade: 85.3

3. Quieras compartir código con otras personas

Los archivos de script se pueden compartir fácilmente, mientras que las sesiones del REPL no:

# greeting.py
# A simple greeting program
 
name = input("What is your name? ")
print("Hello,", name + "! Welcome to Python.")

Nota: Aprenderemos sobre la función input() en el Capítulo 2. Este ejemplo muestra cómo los scripts pueden compartirse.

Puedes enviar este archivo a otra persona y podrá ejecutarlo en su computadora.

4. Construyas herramientas reutilizables

Si estás creando algo que usarás repetidamente, conviértelo en un script:

# file_counter.py
# Count files in a directory
 
import os
 
directory = "."  # Current directory
files = [f for f in os.listdir(directory) if os.path.isfile(f)]
print("Number of files:", len(files))

Nota: Aprenderemos a importar módulos en el Capítulo 22 y listas por comprensión en el Capítulo 34. Este ejemplo muestra cómo los scripts pueden ser herramientas reutilizables.

5. Desarrolles lógica compleja

Para cualquier cosa con múltiples funciones, clases o lógica compleja, usa archivos de script:

# password_checker.py
# Check password strength
 
def check_password_strength(password):
    """Check if a password meets basic requirements."""
    if len(password) < 8:
        return "Too short"
    if not any(c.isupper() for c in password):
        return "Needs uppercase letter"
    if not any(c.isdigit() for c in password):
        return "Needs number"
    return "Strong password"
 
# Test the function
test_password = "MyPass123"
result = check_password_strength(test_password)
print("Password '" + test_password + "':", result)

Salida:

Password 'MyPass123': Strong password

Nota: Aprenderemos sobre funciones en el Capítulo 19. Este ejemplo muestra cómo los scripts manejan lógica compleja.

6. Quieras automatizar tareas

Los scripts son perfectos para automatizar:

# backup_reminder.py
# Remind user to backup files
 
import datetime
 
today = datetime.date.today()
day_of_week = today.strftime("%A")
 
if day_of_week == "Friday":
    print("Don't forget to backup your files!")
else:
    print("Backup reminder: Next backup on Friday")

Nota: Aprenderemos sobre el módulo datetime en el Capítulo 39. Este ejemplo muestra cómo los scripts pueden automatizar tareas.

1.6.3) Un flujo de trabajo práctico

Los programadores profesionales de Python suelen usar tanto el REPL como los archivos de script de forma complementaria:

Ejemplo de flujo de trabajo:

1. Explorar en el REPL: Probar un concepto nuevo o un cálculo
2. Prototipar en el REPL: Construir una versión pequeña que funcione
3. Pasar a un script: Cuando funciona, ponerlo en un archivo de script
4. Ampliar en el script: Añadir más funciones, manejo de errores, etc.
5. Depurar con el REPL: Si algo falla, probar partes en el REPL
6. Finalizar el script: Completar, probar y guardar tu programa

1.6.4) Un ejemplo concreto

Veamos este flujo de trabajo en acción. Supongamos que quieres escribir un programa que calcule el área de un círculo.

Paso 1: Explorar en el REPL

>>> # What's the formula? Area = π * r²
>>> # Let me use a simple approximation for π
>>> 3.14159 * 5 * 5
78.53975
>>> # Looks right!

Paso 2: Crear un script

Ahora que sabes que funciona, crea circle_area.py:

# circle_area.py
# Calculate the area of a circle
 
radius = 5
pi = 3.14159
area = pi * radius * radius
 
print("Radius:", radius)
print("Area:", area)

Salida:

Radius: 5
Area: 78.53975

Paso 3: Mejorar el script

Haz que funcione con distintos radios:

# circle_area_enhanced.py
# Calculate area for multiple circles
 
radii = [3, 5, 7, 10]
pi = 3.14159
 
for radius in radii:
    area = pi * radius * radius
    print("Circle with radius", radius, "has area", round(area, 2))

Salida:

Circle with radius 3 has area 28.27
Circle with radius 5 has area 78.54
Circle with radius 7 has area 153.94
Circle with radius 10 has area 314.16

Nota: Aprenderemos sobre bucles for (bucles, en inglés loops) en el Capítulo 11. En el Capítulo 2 aprenderemos a hacer esto interactivo pidiendo datos al usuario.

Este flujo de trabajo —experimentar en el REPL y luego formalizar en un script— es cómo se desarrollan muchos programas en Python.

1.6.5) Ideas clave

Fortalezas del REPL:

• Retroalimentación inmediata
• Genial para aprender
• Perfecto para pruebas rápidas
• Excelente para la exploración
• No requiere gestionar archivos

Limitaciones del REPL:

• El código no se guarda
• Incómodo para código de varias líneas
• No se puede compartir fácilmente
• No es adecuado para programas complejos

Fortalezas de los archivos de script:

• El código se guarda de forma permanente
• Fácil de editar y modificar
• Se puede compartir con otros
• Adecuado para programas complejos
• Se puede ejecutar repetidamente
• Se puede automatizar

Limitaciones de los archivos de script:

• Requiere crear y gestionar archivos
• Necesitas ejecutarlos para ver resultados
• Más preparación para pruebas rápidas

La mejor estrategia es usar ambos: el REPL para aprender, probar y explorar, y los archivos de script para todo lo que quieras conservar, compartir o ejecutar repetidamente.

1.7) Qué versión de Python usa este libro (y por qué importa)

Python ha evolucionado de forma importante a lo largo de los años, y diferentes versiones pueden comportarse de manera distinta. Entender las versiones de Python te ayudará a evitar confusiones y a asegurarte de que tu código funcione como esperas.

Quizá te preguntes por qué dedicamos tiempo a las versiones de Python. La razón es sencilla: te encontrarás código Python en internet, en tutoriales y en la documentación. Entender las versiones te ayuda a reconocer cuándo el código está obsoleto y a evitar confusiones cuando algo no funciona como esperabas.

1.7.1) Python 2 vs Python 3

La división más importante en la historia de Python es entre Python 2 y Python 3.

Python 2 se publicó en el año 2000 y fue la versión dominante durante muchos años. Sin embargo, tenía algunos problemas de diseño que no se podían arreglar sin romper el código existente.

Python 3 se publicó en 2008 como un rediseño importante que solucionó esos problemas. Sin embargo, no era retrocompatible con Python 2, lo que significa que el código escrito para Python 2 a menudo no funcionaba en Python 3 sin modificaciones.

Durante muchos años, ambas versiones coexistieron. Sin embargo, Python 2 llegó a su fin de vida el 1 de enero de 2020. Esto significa:

• No hay más actualizaciones ni parches de seguridad para Python 2
• Todo el desarrollo nuevo en Python usa Python 3
• Todas las bibliotecas importantes se han movido a Python 3
• No se recomienda aprender Python 2 hoy en día

Este libro usa exclusivamente Python 3. Todos los ejemplos de código están escritos para Python 3 y pueden no funcionar en Python 2.

1.7.2) Versiones menores de Python 3

Dentro de Python 3, hay versiones menores (3.6, 3.7, 3.8, 3.9, 3.10, 3.11, 3.12, etc.). Cada versión menor añade nuevas características y mejoras manteniendo la compatibilidad hacia atrás con versiones anteriores de Python 3.

Este libro está escrito para Python 3.11 y posteriores, pero la mayoría de ejemplos funcionarán en Python 3.8 en adelante.

Para comprobar tu versión de Python:

python --version  # Windows
python3 --version  # macOS/Linux

Deberías ver algo como:

Python 3.11.5

Si ves:

Python 2.7.18

Estás ejecutando Python 2, que está obsoleto. Instala Python 3 siguiendo las instrucciones de la Sección 1.2.

1.7.3) Diferencias clave que podrías encontrar

Si lees tutoriales antiguos o código en internet (especialmente tutoriales y respuestas en Stack Overflow de antes de 2020), puedes encontrar sintaxis que no funciona en Python 3. Aquí están las diferencias más comunes:

1. La sentencia print vs la función print

Python 2:

print "Hello, World!"  # No parentheses

Python 3:

print("Hello, World!")  # Parentheses required

En Python 3, print es una función y requiere paréntesis. Esta es la diferencia más visible.

2. Comportamiento de la división

Estos cambios se hicieron para que Python fuera más coherente y seguro. Por ejemplo, convertir print en una función permite usarlo como cualquier otra función, y hacer que / siempre haga división en coma flotante elimina una fuente común de errores.

Python 2:

>>> 5 / 2
2  # Integer division
>>> 5.0 / 2
2.5  # Float division

Python 3:

>>> 5 / 2
2.5  # Always float division
>>> 5 // 2
2  # Integer division (floor division)

En Python 3, / siempre realiza división en coma flotante. Usa // para división entera.

3. Función input()

Python 2:

name = raw_input("Enter your name: ")  # Returns string
age = input("Enter your age: ")  # Evaluates input as Python code (dangerous!)

Python 3:

name = input("Enter your name: ")  # Always returns string
age = int(input("Enter your age: "))  # Convert to int if needed

En Python 3, input() siempre devuelve una cadena, lo que es más seguro y coherente.

4. Cadenas y Unicode

Python 3 maneja texto (Unicode) mucho mejor que Python 2. Todas las cadenas en Python 3 son Unicode por defecto, lo que facilita mucho el manejo de texto internacional.

1.7.4) Características por versión de Python 3

Diferentes versiones de Python 3 introdujeron diferentes características. Esto es lo que necesitas saber:

Python 3.6 (diciembre de 2016):

• f-strings para formateo de cadenas (las usaremos ampliamente)

# f_string_example.py
name = "Alice"
print("Hello, " + name + "!")

Salida:

Hello, Alice!

Nota: Aprenderemos sobre f-strings en el Capítulo 6. Por ahora usamos concatenación simple de cadenas con +.

Python 3.8 (octubre de 2019):

• El operador “morsa” (:=) para expresiones de asignación (lo veremos en el Capítulo 40)

Python 3.10 (octubre de 2021):

• Structural pattern matching con match y case (lo veremos en el Capítulo 12)

Python 3.11 (octubre de 2022):

• Mensajes de error significativamente mejorados
• Mejor rendimiento
• Manejo de excepciones mejorado

Python 3.12 (octubre de 2023):

• Más mejoras de rendimiento
• Nuevas características de anotaciones de tipos
• Sintaxis de f-strings mejorada

1.7.5) Qué versión deberías usar

Recomendación: Usa Python 3.11 o posterior si es posible. He aquí por qué:

1. Mejores mensajes de error: Python 3.11 tiene mensajes de error significativamente mejorados que son más útiles para principiantes.

2. Mejor rendimiento: Python 3.11 es más rápido que versiones anteriores.

3. Características modernas: Tendrás acceso a todas las características más recientes de Python.

4. Preparado para el futuro: El código escrito para Python 3.11 funcionará en versiones futuras.

Sin embargo, cualquier Python 3.8 o posterior funcionará bien para aprender con este libro. Los conceptos básicos son los mismos.

1.7.6) Comprobar la disponibilidad de características

Si usas una versión más antigua de Python y encuentras código que no funciona, puedes comprobar en qué versión se introdujo una característica.

Por ejemplo, si usas Python 3.5 o anterior, quizá tengas que usar un formato de cadenas más antiguo:

# format_example.py
# Works in all Python 3 versions
name = "Alice"
print("Hello, {}!".format(name))

Salida:

Hello, Alice!

1.7.7) Mantenerse al día

Python publica una nueva versión menor aproximadamente una vez al año. Aunque no necesitas actualizar inmediatamente, es bueno mantenerse razonablemente al día:

• Busca actualizaciones cada pocos meses
• Lee las notas de la versión para conocer las nuevas características
• Actualiza cuando te convenga, especialmente por actualizaciones de seguridad
• Prueba tu código después de actualizar para asegurarte de que sigue siendo compatible

Puedes encontrar las versiones de Python y su documentación en https://www.python.org/.

1.7.8) Compatibilidad de versiones en este libro

A lo largo de este libro:

• Todos los ejemplos de código funcionan en Python 3.11+
• La mayoría de ejemplos funcionan en Python 3.8+
• Las características específicas de versión están claramente indicadas (por ejemplo, “Esto requiere Python 3.10+”)
• Se proporcionan enfoques alternativos cuando es adecuado para versiones más antiguas

Cuando veas código en este libro, puedes escribirlo con confianza en Python 3.11 o posterior y esperar que funcione exactamente como se muestra.

1.7.9) Una nota sobre código Python 2 que podrías encontrar en internet

Si buscas ayuda sobre Python en internet, puede que encuentres código Python 2. Aquí tienes cómo reconocerlo:

Señales de código Python 2:

• print sin paréntesis: print "Hello"
• Función raw_input()
• División que produce enteros: 5 / 2 es 2
• Formateo antiguo de cadenas: "Hello %s" % name
• Comentarios que dicen "Python 2" o mencionan la versión 2.x

Qué hacer:

• Busca alternativas para Python 3
• Añade "python 3" a tus búsquedas
• Revisa la fecha: cualquier cosa anterior a 2020 podría ser Python 2
• Usa la documentación oficial de Python 3: https://docs.python.org/3/

Enhorabuena. Has completado el Capítulo 1 y has dado tus primeros pasos con Python. Ahora ya sabes:

• Qué es Python y cómo funciona
• Cómo instalar Python y ejecutar el intérprete
• Cómo usar la consola interactiva de Python (REPL) para experimentar
• Cómo crear y ejecutar archivos de script de Python
• Cómo leer y entender mensajes de error y tracebacks
• Cuándo usar el REPL y cuándo usar archivos de script
• Qué versión de Python usar y por qué importa

Ahora estás listo para pasar al Capítulo 2, donde escribirás tus primeros programas completos en Python, aprenderás la función print() en detalle y empezarás a trabajar con entrada de usuario. La base que has construido en este capítulo sustentará todo lo que aprendas a partir de ahora.