---
title: "Cómo instalar Python en Mac, actualizarlo y usar VENV (2026)"
description: "Guía paso a paso para instalar Python en Mac con Homebrew, actualizar a la última versión y configurar un entorno virtual de Python (venv) para tus proyectos."
date: 2024-03-26
categories: ["tools"]
tags: ["python","homebrew","venv"]
---

import Button from "@components/widgets/Button.astro";
import Notice from "@components/widgets/Notice.astro";
import ListCheck from "@components/widgets/ListCheck.astro";
import Accordion from "@components/widgets/Accordion.astro";

Si has intentado hacer `pip install` de algo en un Mac recientemente, te habrás topado con el error `externally-managed-environment`. Desde Python 3.12, Homebrew sigue PEP 668, lo que significa que los entornos virtuales ya no son opcionales. Son obligatorios. Esta guía te lleva paso a paso por cómo instalar Python en Mac con Homebrew, configurar tu PATH para que `python` funcione, actualizar entre versiones sin romper nada y configurar venv correctamente para tus proyectos.

<Notice type="info" title="Actualizado para 2026">
Python 3.14 es la versión estable actual (lanzada en octubre de 2025). La fórmula `python` por defecto de Homebrew ahora instala 3.14.x. PEP 668 se aplica en todas las compilaciones de Homebrew con Python 3.12+. `pip install` fuera de un venv fallará por diseño.
</Notice>

## Antes de empezar: requisitos previos

### Comprueba tu versión de macOS y la arquitectura (Apple Silicon vs Intel)

Homebrew se instala en ubicaciones diferentes según el procesador de tu Mac:

| Tipo de Mac | Prefijo de Homebrew | Ruta del binario de Python |
|----------|----------------|-------------------|
| Apple Silicon (M1/M2/M3/M4) | `/opt/homebrew/` | `/opt/homebrew/bin/python3` |
| Intel | `/usr/local/` | `/usr/local/bin/python3` |

Comprueba cuál tienes:

```bash
uname -m
```

- `arm64` → Apple Silicon
- `x86_64` → Intel

<Notice type="info" title="Apple Silicon vs Intel">
Todos los comandos de esta guía usan rutas de Apple Silicon (`/opt/homebrew/`). Si estás en Intel, sustituye por `/usr/local/` donde corresponda. Los comandos en sí (`brew install`, `python3`, etc.) son idénticos.
</Notice>

Si quieres una mejor experiencia de terminal antes de empezar, considera configurar primero [un terminal de desarrollo moderno para Mac](/es/terminal-ghostty/).

### Instala Xcode Command Line Tools

macOS incluye su propio Python 3 (instalado mediante Xcode Command Line Tools, normalmente 3.9.x). Necesitas las CLT para que Homebrew funcione, pero **no elimines el Python del sistema**. Las herramientas de macOS dependen de él.

```bash
xcode-select --install
```

Haz clic en "Instalar" en el diálogo. Esto tarda unos minutos.

Verifica que se instaló:

```bash
xcode-select -p
```

Salida esperada: `/Library/Developer/CommandLineTools`

<Notice type="warning" title="No elimines el Python del sistema">
macOS usa su Python 3 integrado para herramientas y scripts del sistema. Homebrew se instala junto a él, no encima. Nunca borres ni modifiques `/usr/bin/python3`.
</Notice>

### Instala Homebrew en Mac

Homebrew es el gestor de paquetes que hace que instalar Python sea sencillo. Si aún no lo tienes:

```bash
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```

En Apple Silicon, Homebrew añade su entrada de PATH a `~/.zprofile` automáticamente. Sigue las instrucciones post-instalación que aparecen en el terminal. Puede que necesites ejecutar:

```bash
eval "$(/opt/homebrew/bin/brew shellenv)"
```

Comprueba que Homebrew está en buen estado:

```bash
brew doctor
```

Esperado: `Your system is ready to brew.`

Si estás personalizando tu shell, [potencia tu terminal Zsh](/es/mejores-plugins-oh-my-zsh/) con plugins útiles y [activa el resaltado de sintaxis en Zsh](/es/activar-resaltado-sintaxis-zsh/) para una mejor experiencia.

## Instala la última versión de Python en Mac con Homebrew

Con Homebrew listo, instala la última versión estable de Python:

```bash
brew install python
```

Esto instala Python 3.14.x (la versión estable actual a fecha de 2026), junto con `pip`, `setuptools` y `wheel`.

### Verifica tu instalación de Python

Ejecuta estas comprobaciones para confirmar que todo funciona:

<ListCheck>
<ul>
<li><code>python3 --version</code> → debería mostrar <code>Python 3.14.x</code></li>
<li><code>which python3</code> → debería mostrar <code>/opt/homebrew/bin/python3</code> (Apple Silicon)</li>
<li><code>which pip3</code> → debería mostrar <code>/opt/homebrew/bin/pip3</code></li>
<li><code>python --version</code> → funciona tras la configuración del PATH (ver la siguiente sección)</li>
</ul>
</ListCheck>

```bash
python3 --version
which python3
which pip3
```

Salida esperada:

```sh
Python 3.14.6
/opt/homebrew/bin/python3
/opt/homebrew/bin/pip3
```

### Configura tu PATH para Python en Mac

Esto es lo que nadie te cuenta: después de `brew install python`, el comando `python3` funciona, pero `python` NO. Verás:

```sh
zsh: command not found: python
```

Homebrew instala los enlaces simbólicos sin versión (`python`, `pip`) en un directorio aparte que no está en tu PATH por defecto. Arréglalo así:

```bash
# Añade los comandos sin versión del Python de Homebrew al PATH
echo 'export PATH="$(brew --prefix python)/libexec/bin:$PATH"' >> ~/.zprofile
source ~/.zprofile
```

<Notice type="warning" title="¿`python`: command not found?">
Es lo esperado antes de configurar el PATH. La solución es la línea `export PATH` de arriba. Añádela a `~/.zprofile` (para shells de inicio de sesión) o a `~/.zshrc` (para shells interactivos). Cualquiera de las dos funciona en Terminal.app.
</Notice>

Verifica:

```bash
python --version
```

Debería mostrar la misma versión que `python3 --version`.

## Instala una versión específica de Python en Mac

A veces un proyecto requiere una versión específica de Python. Homebrew ofrece fórmulas versionadas para esto.

### Cómo buscar versiones de Python disponibles en Homebrew

```bash
brew search python@
```

Verás entradas desde `python@3.9` hasta `python@3.14`. Para la lista actualizada con los números de versión exactos:

<Button text="Ver todas las fórmulas de Python en Homebrew" link="https://formulae.brew.sh/formula/" variant="outline" color="blue" size="sm" />

Instala la versión que necesites. Por ejemplo, Python 3.13:

```bash
brew install python@3.13
```

El comando versionado funciona inmediatamente después de la instalación:

```bash
python3.13 --version
```

```sh
Python 3.13.14
```

No hace falta enlazar nada. Puedes usar `python3.13` directamente en tus comandos y entornos virtuales.

### Enlazar fórmulas de Python keg-only

Las fórmulas versionadas de Python (como `python@3.13`) son "keg-only". Homebrew no las enlaza a tu PATH por defecto. Si intentas hacer `brew link` de una y ya hay otra versión de Python enlazada, obtendrás un error:

```sh
Error: Cannot link python@3.13
```

Si realmente necesitas que `python3` apunte a otra versión:

```bash
# Desenlaza primero la versión actual
brew unlink python

# Enlaza la versión que quieras
brew link --force python@3.13
```

<Notice type="warning" title="Reenlazar cambia `python3` globalmente">
Después de `brew link --force python@3.13`, el comando `python3` apuntará a 3.13 en lugar de 3.14. Esto afecta a todas tus sesiones de terminal. En la mayoría de los casos, es más sencillo usar directamente el comando versionado (`python3.13`) y evitar el reenlazado por completo.
</Notice>

## Actualiza Python a la última versión en Mac

Aquí es donde la mayoría de las guías se equivocan, incluida la versión anterior de este artículo.

### La verdad sobre `brew upgrade python` (versiones mayores vs. parches)

`brew upgrade python` **no** salta entre versiones mayores. Actualiza al último **parche** de la fórmula que tengas instalada.

```bash
# Actualiza el índice de paquetes de Homebrew
brew update

# Actualiza al último parche de la fórmula actual (p. ej., de 3.14.5 a 3.14.6)
brew upgrade python
```

Verifica:

```bash
python3 --version
```

<Notice type="warning" title="Versiones mayores vs. parches">
<code>brew upgrade python</code> NO actualizará de Python 3.13 a 3.14. Para cambiar de versión mayor, debes ejecutar <code>brew install python@3.14</code> explícitamente. Este es el error de concepto n.º 1 al actualizar Python con Homebrew.
</Notice>

Para saltar de una versión mayor a otra:

```bash
# Instala la nueva versión mayor
brew install python@3.14

# Úsala con el comando versionado
python3.14 --version
```

### Fija Python para evitar actualizaciones accidentales

Cuando Homebrew actualiza otros paquetes, a veces puede actualizar Python como dependencia. Esto cambia la ruta del binario de Python, lo que **rompe los entornos virtuales existentes**. Fija tu versión de Python para evitarlo:

```bash
# Fijar evita actualizaciones accidentales
brew pin python@3.14

# Comprueba qué está fijado
brew list --pinned

# Desfíjala cuando estés listo para actualizar
brew unpin python@3.14
```

<Accordion label="¿Por qué se rompió mi entorno virtual?" group="faq">
Cuando Homebrew actualiza Python (incluso una versión de parche), puede cambiar la ruta absoluta al binario de Python dentro de tu `.venv`. Como los venv guardan rutas absolutas en `pyvenv.cfg` y en los scripts de activación, el venv antiguo puede dejar de funcionar tras una actualización.

Solución: recrea el venv y reinstala las dependencias.

```bash
rm -rf .venv
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
```

Prevención: usa `brew pin` en tu fórmula de Python.
</Accordion>

## Entendiendo PEP 668: por qué necesitas entornos virtuales

Esta es la sección que me hubiera gustado encontrar cuando me topé con el error por primera vez. Si has intentado instalar un paquete de Python globalmente con pip y te has llevado un muro de texto rojo, aquí está el porqué.

### El error `externally-managed-environment` explicado

Desde Python 3.12, Homebrew marca su instalación de Python como "gestionada externamente" (según [PEP 668](https://peps.python.org/pep-0668/)). Esto significa:

```bash
pip install requests
```

Da como resultado:

```
error: externally-managed-environment

× This environment is externally managed
╰─> To install Python packages system-wide, try brew install
    xyz, where xyz is the package you are trying to install.
```

Esto **no es un bug**. Es una protección deliberada. El Python de Homebrew está gestionado por Homebrew. Permitir que pip instale paquetes globalmente podría entrar en conflicto con los paquetes gestionados por Homebrew y romper tu sistema.

La solución: usa un entorno virtual (para las dependencias del proyecto) o `pipx` (para herramientas CLI). Ambos se cubren en las siguientes secciones.

<Notice type="error" title="¿Error `externally-managed-environment`?">
Es un comportamiento esperado desde Python 3.12, no un fallo. Activa un entorno virtual antes de usar <code>pip install</code>, o usa <code>pipx</code> para herramientas CLI globales. Consulta las siguientes secciones para ambos enfoques.
</Notice>

Referencia: documentación de [Homebrew and Python](https://docs.brew.sh/Homebrew-and-Python).

## Ejecuta Python en VENV en Mac

Los entornos virtuales son ahora la forma estándar (y obligatoria) de gestionar las dependencias de proyectos Python. Este es el flujo de trabajo completo.

### Crea un entorno virtual de Python en Mac

Ve al directorio de tu proyecto y crea un venv:

```bash
cd ~/my-project
python3 -m venv .venv
```

<Notice type="info" title="¿Por qué `.venv`?">
<code>.venv</code> es la convención moderna. Es lo que VS Code, PyCharm, uv y Poetry detectan automáticamente. Está oculto por defecto en macOS (por el punto inicial), y es el nombre que verás en la mayoría de los proyectos Python en GitHub. Puedes usar un nombre personalizado si lo prefieres, pero <code>.venv</code> es el estándar por una razón.
</Notice>

### Activa y usa tu entorno virtual

```bash
source .venv/bin/activate
```

Tu prompt del terminal cambia para mostrar el entorno activo:

```sh
(.venv) user@mac my-project %
```

Verifica que funciona:

```bash
which python
```

Debería mostrar: `/Users/youruser/my-project/.venv/bin/python`

Ahora `pip install` funciona sin errores de PEP 668:

```bash
pip install requests
```

### Instala paquetes y congela los requisitos

Este es el flujo de trabajo práctico que faltaba en el artículo antiguo:

```bash
# Instala paquetes dentro de tu venv activo
pip install requests pandas fastapi

# Congela las dependencias actuales en un archivo
pip freeze > requirements.txt
```

El archivo `requirements.txt` permite a cualquiera recrear el mismo entorno:

```bash
# En otra máquina (o tras clonar un repositorio):
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
```

<Accordion label="¿Usar uv en lugar de pip?" group="faq">
`uv` es un reemplazo directo de pip que es 10-100 veces más rápido. Instálalo con `brew install uv` y usa:

```bash
uv pip install requests pandas
uv pip freeze > requirements.txt
uv venv  # crea venvs más rápido que python -m venv
```

Para una guía completa, consulta [uv, un gestor de paquetes de Python moderno](/es/empezar-uv/).
</Accordion>

### Desactiva el entorno virtual

Cuando termines de trabajar:

```bash
deactivate
```

Tu prompt vuelve a la normalidad. Los paquetes permanecen instalados en `.venv/`. No se pierde nada.

### Añade `.venv` a `.gitignore`

Nunca subas tu entorno virtual a git. Añade estas entradas a tu `.gitignore`:

```
.venv/
venv/
env/
```

<ListCheck>
<ul>
<li>Añade <code>.venv/</code> a <code>.gitignore</code></li>
<li>Añade también <code>venv/</code> y <code>env/</code> (alternativas comunes)</li>
<li>Sube <code>requirements.txt</code> en lugar del directorio del venv</li>
<li>La plantilla <code>.gitignore</code> de Python por defecto de GitHub ya las incluye</li>
</ul>
</ListCheck>

## Solución de problemas comunes de Python en Mac

<Accordion label="Solución: no se encuentra el comando `python`" group="troubleshooting" expanded="true">
**Causa**: Homebrew no añade `python` (sin versión) a tu PATH por defecto.

**Solución**:

```bash
echo 'export PATH="$(brew --prefix python)/libexec/bin:$PATH"' >> ~/.zprofile
source ~/.zprofile
python --version
```

Mientras tanto, `python3` siempre funciona después de `brew install python`.
</Accordion>

<Accordion label="Solución: `brew link` falla con Python versionado" group="troubleshooting">
**Causa**: las fórmulas versionadas de Python son keg-only. Ya hay otra versión de Python enlazada.

**Solución**: usa el comando versionado directamente en lugar de reenlazar:

```bash
# Usa simplemente el comando versionado. No hace falta enlazar.
python3.13 --version
python3.13 -m venv .venv
```

Si debes reenlazar:

```bash
brew unlink python
brew link --force python@3.13
```
</Accordion>

<Accordion label="Solución: error `externally-managed-environment`" group="troubleshooting">
**Causa**: estás ejecutando `pip install` fuera de un entorno virtual. PEP 668 lo bloquea con Python 3.12+ de Homebrew.

**Solución**: activa primero un venv:

```bash
python3 -m venv .venv
source .venv/bin/activate
pip install <package>
```

Para herramientas CLI globales (black, ruff, mypy), usa `pipx` en su lugar:

```bash
brew install pipx
pipx ensurepath
pipx install black
```
</Accordion>

<Accordion label="Solución: venv roto tras `brew upgrade`" group="troubleshooting">
**Causa**: Homebrew actualizó Python, cambiando la ruta del binario que tu venv referencia.

**Solución**: recrea el venv:

```bash
rm -rf .venv
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
```

**Prevención**: fija tu versión de Python con `brew pin python@3.14`.
</Accordion>

## Alternativas a considerar

Homebrew es el camino más sencillo, pero no el único. Estas son las principales alternativas.

### uv: un gestor de paquetes de Python moderno

`uv`, de Astral, es una herramienta de Python todo en uno que reemplaza a pip, venv, pyenv y pipx. Está escrita en Rust y es significativamente más rápida que pip.

```bash
brew install uv
uv venv           # crea venvs más rápido
uv pip install requests  # reemplazo directo de pip
uv python install 3.13   # instala versiones específicas de Python
```

Si quieres una sola herramienta que se encargue de todo lo cubierto en este artículo, `uv` merece un vistazo. Guía completa: [uv, un gestor de paquetes de Python moderno](/es/empezar-uv/). Para despliegue: [despliega un proyecto Python con uv y Dokploy](/es/dokploy-python-railpack-uv/).

### pyenv: gestiona múltiples versiones de Python

[pyenv](https://github.com/pyenv/pyenv) es para cuando necesitas cambiar entre versiones de Python con frecuencia en distintos proyectos. La propia documentación de Homebrew lo recomienda "si necesitas estabilidad en las versiones menores o de parche para entornos virtuales".

```bash
brew install pyenv
pyenv install 3.13.14
pyenv install 3.14.6
pyenv global 3.14.6
```

pyenv gestiona las versiones independientemente de Homebrew, así que actualizar Homebrew no cambiará accidentalmente la versión de Python de tu proyecto. Supone más trabajo de configuración, pero más control.

### Instaladores oficiales de Python.org

Python.org ofrece [instaladores universal2 para macOS](https://www.python.org/downloads/macos/) que funcionan tanto en Apple Silicon como en Intel. Son independientes, sin dependencia de Homebrew.

Usa esta opción si no quieres Homebrew en absoluto, o si necesitas una compilación específica de Python. La desventaja: configuración manual del PATH, sin actualizaciones automáticas, y no se integra con el ecosistema de Homebrew.

### pipx: instala herramientas CLI de Python globalmente

`pipx` instala herramientas CLI de Python (como `black`, `ruff`, `mypy`, `poetry`) en entornos aislados, haciéndolas disponibles globalmente sin ensuciar el Python de tu sistema.

```bash
brew install pipx
pipx ensurepath
pipx install black
pipx install ruff
```

<Notice type="info" title="pipx vs venv">
<strong>pipx</strong> es para herramientas CLI que ejecutas desde cualquier lugar (formateadores, linters, herramientas de build). <strong>venv</strong> es para las dependencias del proyecto que tu código importa. Resuelven problemas diferentes y funcionan bien juntos.
</Notice>

## Siguientes pasos: qué construir con Python en Mac

Ahora que tienes Python instalado y sabes cómo gestionar entornos, estos son los próximos pasos:

- [Explora los mejores frameworks web de Python](/es/mejores-frameworks-web-python/): encuentra el framework adecuado para tu próximo proyecto
- [Crea una UI para tu app Python con NiceGUI](/es/empezar-nicegui/): guía de inicio rápido para apps Python con interfaz
- [Añade varias páginas a tu app NiceGUI](/es/paginas-nicegui/): continuación para proyectos NiceGUI
- [Ejecuta tu app Python en Docker](/es/docker-ejecutar-python/): conteneriza tu proyecto para despliegues consistentes
- [Despliega un proyecto Python con uv y Dokploy](/es/dokploy-python-railpack-uv/): despliegue en producción en un VPS
- [Genera imágenes con IA localmente con Python](/es/imagenes-ia-mac/): ejecuta modelos Flux en tu Mac

Si vas a desplegar en un servidor, [Hetzner](https://go.bitdoze.com/hetzner) ofrece VPS europeos asequibles que funcionan bien para apps Python.

_Los precios de los VPS subieron en general en 2026 — si estás reconsiderando un servidor alquilado, mira [qué cambió y cuándo gana un mini PC](/es/subidas-precios-vps/)._

<Button text="Ver todos los tutoriales de Python" link="/tags/python/" variant="solid" color="blue" size="md" icon="arrow-right" />