# Come disinstallare Python e Node.js su un Mac

> Scopri quale Python o Node è nel PATH, rimuovi nel modo previsto le copie di Homebrew, pyenv, conda, nvm o degli installer, poi ripulisci righe del PATH e cache.

Published: 2026-10-06 | Updated: 2026-10-17

Per disinstallare Python o Node.js su un Mac, prima scopri quale copia stai rimuovendo, perché di solito ce ne sono diverse e ognuna si toglie in modo diverso. Esegui `which -a python3` o `which -a node` per vedere tutte le copie nel PATH, poi rimuovile tramite lo strumento che le ha installate: Homebrew con `brew uninstall`, pyenv con `pyenv uninstall`, nvm con `nvm uninstall`, conda con i passaggi documentati da Anaconda, e gli installer di python.org o nodejs.org rimuovendo i file scritti dai loro pacchetti. Lascia stare `/usr/bin/python3`: appartiene a macOS e agli strumenti per sviluppatori di Apple.

Dopo, ripulisci le righe che quegli strumenti hanno aggiunto ai file di avvio della shell e le cache che hanno lasciato nella cartella Inizio. Questa guida segue quell'ordine: identificare, rimuovere, ripulire il PATH, svuotare le cache, verificare.

## Trova ogni Python e Node nel PATH

Questi comandi si limitano a leggere:

```
which -a python3 python node npm
type -a python3 node
python3 -c 'import sys; print(sys.executable)'
```

`which -a` stampa ogni corrispondenza nell'ordine del PATH, e la prima riga è quella che viene eseguita quando digiti il comando. `type -a` mostra anche alias e funzioni della shell, il che conta per i gestori di versioni: nvm, per esempio, definisce `nvm` come funzione della shell, e pyenv e alcune configurazioni mettono degli shim davanti ai binari veri. Segui un link simbolico con `ls -l` per vedere dove punta davvero.

Leggi i percorsi con questa tabella:

| Il percorso inizia con | Chi l'ha installato | Come si rimuove |
| --- | --- | --- |
| `/usr/bin/python3` | macOS, per Xcode e i Command Line Tools | Lascialo |
| `/Library/Frameworks/Python.framework` o link in `/usr/local/bin` che puntano lì | Installer di python.org | Rimuovi le sue tre parti (più sotto) |
| `/opt/homebrew` (Apple silicon) o `/usr/local/Cellar`, `/usr/local/opt` (Intel) | Homebrew | `brew uninstall` |
| `~/.pyenv/shims` o `~/.pyenv/versions` | pyenv | `pyenv uninstall` |
| `~/anaconda3`, `~/miniconda3`, `/opt/anaconda3`, `/opt/miniconda3` | Anaconda o Miniconda | `conda init --reverse`, poi rimuovi la cartella |
| `/usr/local/bin/node` che non è un link di Homebrew | Installer di nodejs.org | Rimuovi i suoi file, dimentica la sua ricevuta |
| `~/.nvm/versions/node` | nvm | `nvm uninstall` |
| `~/Library/Application Support/fnm` o `~/.fnm` | fnm | `fnm uninstall`, poi rimuovi la cartella |
| `~/.volta` | Volta | Rimuovi `~/.volta` |

Su un Mac Intel sia Homebrew sia gli installer di nodejs.org e python.org scrivono in `/usr/local`, quindi controlla con `ls -l` se un file lì è un link verso il Cellar di Homebrew prima di dare per scontato che tocchi a te eliminarlo.

## Non rimuovere il Python di macOS

La [documentazione di Python per macOS](https://docs.python.org/3/using/mac.html) è esplicita: le versioni recenti di macOS includono un comando `python3` in `/usr/bin/python3` che punta a una versione di Python fornita da e per gli strumenti di sviluppo Apple, e non dovresti mai modificarlo né tentare di eliminarlo, perché è controllato da Apple e usato da software di Apple e di terze parti. In ogni caso si trova sul volume di sistema sigillato. Un secondo Python da python.org o Homebrew può convivere con quello; quale dei due viene eseguito lo decidi tramite il PATH, non eliminando quello di Apple.

## Disinstallare Python installato da python.org

Secondo la stessa documentazione, l'installer di python.org mette tre cose sul Mac: una cartella `Python 3.x` in Applicazioni con IDLE e Python Launcher, il framework in `/Library/Frameworks/Python.framework` e i link simbolici agli eseguibili in `/usr/local/bin`. La documentazione dice che per disinstallare Python puoi rimuovere queste tre cose.

Rimuovi una versione alla volta. Per esempio, per la 3.12:

```
ls /Library/Frameworks/Python.framework/Versions
ls -l /usr/local/bin | grep 'Python.framework/Versions/3.12'
```

Il primo comando elenca le versioni installate; il secondo mostra quali link in `/usr/local/bin` puntano alla versione che stai rimuovendo. Poi sposta `/Applications/Python 3.12` nel Cestino, elimina `/Library/Frameworks/Python.framework/Versions/3.12` con i privilegi di amministratore ed elimina solo i link stampati dal secondo comando. Se rimuovi l'ultima versione, puoi eliminare l'intera cartella `Python.framework`.

L'installer lascia anche una ricevuta, che trovi con `pkgutil --pkgs | grep -i python`. Una ricevuta non viene eseguita, ma `pkgutil --files <id>` mostra esattamente cosa ha scritto quel pacchetto, ed è l'elenco di percorsi più affidabile. [Come disinstallare le app .pkg](https://mole.fit/it/blog/how-to-uninstall-pkg-apps-mac) spiega come leggere e dimenticare le ricevute.

## Disinstallare Python installato con Homebrew

Homebrew dà alle formule di Python un nome con la versione, come `python@3.13`. Controlla prima cosa è installato e cosa dipende da esso:

```
brew list --formula | grep '^python'
brew uses --installed python@3.13
```

Se `brew uses` stampa altre formule, queste hanno bisogno di quel Python, e Homebrew si rifiuterà di disinstallarlo finché restano installate. Rimuovi prima le formule dipendenti oppure tieni quella versione. Quando niente dipende da esso, `brew uninstall python@3.13` lo rimuove e `brew autoremove` elimina le dipendenze che non servono più a nient'altro. Rimuovere Homebrew stesso è un lavoro separato e molto più grande; vedi [come disinstallare Homebrew](https://mole.fit/it/blog/how-to-uninstall-homebrew-mac).

## Disinstallare versioni di pyenv o pyenv stesso

Il [README di pyenv](https://github.com/pyenv/pyenv) dice di rimuovere le vecchie versioni con `pyenv uninstall <version>`, e che `pyenv prefix <version>` mostra la directory di una versione. I plugin possono fare lavoro aggiuntivo durante la disinstallazione; pyenv-virtualenv, per esempio, rimuove anche gli ambienti virtuali collegati a quella versione.

```
pyenv versions
pyenv uninstall 3.11.9
```

Per rimuovere del tutto pyenv, il README dice di togliere tutte le righe di configurazione di pyenv dai file di avvio della shell, poi di rimuovere la sua directory principale con `rm -rf $(pyenv root)`, che elimina ogni Python installato al suo interno. Se hai installato pyenv con Homebrew, concludi con `brew uninstall pyenv`. Esegui prima `pyenv root` e leggi il percorso che stampa prima di eliminare qualcosa.

## Disinstallare Anaconda o Miniconda

La [guida alla disinstallazione di Anaconda](https://www.anaconda.com/docs/getting-started/anaconda/uninstall) e la corrispondente [guida di Miniconda](https://www.anaconda.com/docs/getting-started/miniconda/uninstall) usano gli stessi tre passaggi su macOS:

1. Rimuovi l'inizializzazione di conda dai profili della shell: esegui `conda activate`, poi `conda init --reverse --all`.
2. Elimina la cartella di installazione. Anaconda precisa che può trovarsi nella cartella Inizio o in `/opt`, a seconda di come hai installato; `conda info --base` stampa la posizione reale. I percorsi tipici sono `~/anaconda3`, `~/miniconda3`, `/opt/anaconda3` o `/opt/miniconda3`, e quelli in `/opt` richiedono `sudo`.
3. Se vuoi, rimuovi i file nascosti di configurazione e dati `~/.condarc`, `~/.conda` e `~/.continuum`. Anaconda suggerisce di conservare `.condarc` se hai impostazioni personalizzate e pensi di reinstallare.

La guida avverte che `rm -rf` elimina senza conferma e non si può annullare, quindi controlla il percorso prima di premere Invio. Gli ambienti che hai creato stanno nella cartella di installazione o sotto `~/.conda`, quindi esporta prima quelli che ti servono con `conda env export -n <name> > env.yml`.

## Disinstallare Node.js installato da nodejs.org

Il pacchetto ufficiale per macOS è in realtà due pacchetti in uno. La definizione dell'installer di Node li registra come `org.nodejs.node.pkg` e `org.nodejs.npm.pkg`, e la sua schermata finale dice di aver installato `node` in `/usr/local/bin/node` e `npm` in `/usr/local/bin/npm` ([sorgente dell'installer](https://github.com/nodejs/node/tree/main/tools/macos-installer)). Il pacchetto npm crea anche il link `npx` in `/usr/local/bin` a partire da `/usr/local/lib/node_modules/npm`.

Elenca cosa hanno scritto i pacchetti prima di rimuovere qualcosa:

```
pkgutil --pkgs | grep -i nodejs
pkgutil --pkg-info org.nodejs.node.pkg
pkgutil --files org.nodejs.node.pkg | head -50
```

`--pkg-info` mostra la posizione di installazione, e l'elenco dei file è relativo a essa. Rimuovi ciò che nominano i due elenchi, che si concentra su `/usr/local/bin/node`, `npm` e `npx` e sulla cartella `/usr/local/lib/node_modules/npm`. Guarda dentro `/usr/local/lib/node_modules` prima di eliminare l'intera cartella: lì ci sono anche i pacchetti globali che hai installato con `npm install -g`. Poi esegui `sudo pkgutil --forget org.nodejs.node.pkg` e lo stesso per `org.nodejs.npm.pkg`, che rimuove solo le ricevute.

## Disinstallare Node da Homebrew, nvm, fnm o Volta

**Homebrew:** `brew uninstall node`, oppure la formula con la versione, come `node@20`. `brew uses --installed node` mostra cosa dipende da essa.

**nvm:** `nvm ls` elenca le versioni installate e `nvm uninstall <version>` ne rimuove una, insieme ai pacchetti globali installati per quella versione. Per rimuovere nvm stesso, il [README di nvm](https://github.com/nvm-sh/nvm) dice di eseguire `nvm unload`, eliminare la sua directory (`$NVM_DIR`, per impostazione predefinita `~/.nvm`) e togliere dalla configurazione della shell l'export di `NVM_DIR` e le righe che caricano `nvm.sh` e `bash_completion`. nvm non supporta l'installazione con Homebrew, quindi un nvm arrivato da Homebrew va rimosso con `brew uninstall nvm`.

**fnm:** `fnm list` e `fnm uninstall <version>` gestiscono le versioni. Il [README di fnm](https://github.com/Schniz/fnm) dice che rimuovere fnm significa eliminare la sua cartella e togliere i riferimenti a fnm dalla configurazione della shell, come la riga `eval "$(fnm env ...)"`. La sua cartella dati predefinita su macOS è `~/Library/Application Support/fnm`; le installazioni più vecchie usavano `~/.fnm`. Un fnm installato con Homebrew richiede anche `brew uninstall fnm`.

**Volta:** secondo la [documentazione di Volta](https://docs.volta.sh/advanced/uninstall), rimuovi la directory `~/.volta` e le due righe che citano Volta nel profilo della shell.

## Ripulire le righe del PATH dai file di avvio della shell

Installer e gestori di versioni aggiungono righe a questi file, e le righe restano anche dopo che il software non c'è più:

```
grep -n -E 'python|Python.framework|pyenv|conda|nvm|fnm|volta|node' ~/.zshrc ~/.zprofile ~/.bash_profile ~/.bashrc ~/.profile 2>/dev/null
```

L'output indica file e numero di riga di ogni corrispondenza. Modifica il file in un editor di testo ed elimina le righe che appartengono a ciò che hai rimosso: le righe `export PATH=...` che puntano dentro `Python.framework`, le righe `pyenv init`, il blocco `>>> conda initialize >>>` se `conda init --reverse` non è riuscito a funzionare, le righe di nvm e fnm e le due righe di Volta. Lascia le righe che non riconosci finché non sai cosa fanno. Poi apri una nuova finestra del Terminale: una finestra già aperta mantiene il vecchio PATH, e `hash -r` cancella in quella attuale le posizioni dei comandi memorizzate da zsh.

## Cache e dati che restano

Disinstallare un interprete non svuota le sue cache dei pacchetti:

| Cache | Posizione | Come svuotarla |
| --- | --- | --- |
| pip | `~/Library/Caches/pip` per impostazione predefinita su macOS; `pip cache dir` mostra quella attiva | `pip cache purge`, da eseguire prima di rimuovere l'ultimo pip, oppure elimina la cartella |
| npm | `~/.npm`, con i pacchetti in `~/.npm/_cacache` | `npm cache clean --force`, oppure elimina la cartella dopo aver rimosso Node |
| Pacchetti conda | `pkgs` dentro la cartella di installazione, oppure `~/.conda/pkgs` | Rimossi insieme alla cartella di installazione; `~/.conda` è facoltativa |

La [documentazione sulla cache di pip](https://pip.pypa.io/en/stable/topics/caching/) indica la posizione predefinita su macOS e `pip cache purge`. La [documentazione sulla cache di npm](https://docs.npmjs.com/cli/v10/commands/npm-cache) osserva che svuotare la cache di solito non serve finché usi ancora npm, perché si ripara da sola; una volta rimosso Node, la cartella è solo dati.

Gli ambienti virtuali dei progetti sono un caso a parte. Un `.venv` creato con un Python che hai rimosso punta a un interprete che non esiste più e smette di funzionare. Eliminalo e ricrealo con il Python che hai tenuto, a partire dal `requirements.txt` o dal lockfile del progetto. Lo stesso vale per i `node_modules` con moduli nativi compilati per una vecchia versione di Node.

## Dove si inserisce Mole

[Mole](https://mole.fit/it/) non disinstalla interpreti o gestori di versioni; per quello usa i comandi qui sopra. La sua scheda **Pulizia** è utile dopo, per le cache. La cartella predefinita di pip su macOS, `~/Library/Caches/pip`, compare come riga a sé sotto **Cache e log delle app**, e `~/.cache/pip` (la posizione XDG che usano alcune configurazioni) come riga della cache di pip sotto **Strumenti per sviluppatori**; entrambe sono selezionate per impostazione predefinita, dato che pip scarica di nuovo ciò che gli serve. **Strumenti per sviluppatori** elenca anche le cartelle `_cacache` e `_npx` di npm come righe non selezionate, perché l'installazione successiva le scarica di nuovo, un gruppo selezionato per impostazione predefinita, **Dati della cache npm non più utilizzati**, per i file di cache a cui l'indice di npm non fa più riferimento, i log di npm, e `~/.conda/pkgs` di Conda come riga non selezionata. Le righe non selezionate restano così finché non le scegli tu, e niente viene rimosso prima della tua conferma. [Perché Mole svuota meno cache npm di npm cache verify](https://mole.fit/it/blog/mole-developer-cache-gc) spiega la regola per npm, e [come svuotare le cache per sviluppatori](https://mole.fit/it/blog/how-to-clear-dev-caches-mac) copre le altre toolchain.

## Verifica

Apri una nuova finestra del Terminale ed esegui:

```
which -a python3 node
python3 --version
node --version
```

La copia che hai rimosso non dovrebbe più comparire. Se l'unico Python rimasto è `/usr/bin/python3`, quella è la copia di sistema ed è normale. "command not found" per `node` è la risposta giusta se volevi rimuovere ogni Node. Se viene ancora eseguita una vecchia versione, la sua riga del PATH è ancora in uno dei file della shell oppure un altro installer ha messo una seconda copia altrove; torna al primo passaggio.

## Domande frequenti

### Come disinstallo Python su un Mac?

Esegui `which -a python3` per vedere quale copia hai, poi rimuovila nel modo in cui è stata installata: `brew uninstall python@3.x` per Homebrew, `pyenv uninstall` per pyenv, oppure per python.org rimuovi la cartella in Applicazioni, la versione del framework e i link in `/usr/local/bin`. Non eliminare `/usr/bin/python3`, che appartiene a macOS.

### Come disinstallo Node.js su un Mac?

Usa `brew uninstall node` per Homebrew, `nvm uninstall <version>` per nvm, oppure per l'installer di nodejs.org rimuovi `/usr/local/bin/node`, `npm`, `npx` e la cartella npm sotto `/usr/local/lib/node_modules`, poi dimentica le ricevute `org.nodejs.node.pkg` e `org.nodejs.npm.pkg`.

### Come disinstallo completamente Anaconda su un Mac?

Esegui `conda activate` e `conda init --reverse --all`, elimina la cartella di installazione indicata da `conda info --base`, come `~/anaconda3` o `/opt/anaconda3`, e se vuoi rimuovi `~/.condarc`, `~/.conda` e `~/.continuum`.

### Posso eliminare il Python incluso in macOS?

No. La documentazione di Python dice che `/usr/bin/python3` è controllato da Apple, usato da software di Apple e di terze parti, e non va mai modificato né eliminato. Installa un altro Python accanto e scegli tramite il PATH quale viene eseguito.

### Perché python3 funziona ancora dopo che ho disinstallato Python?

O un'altra copia è ancora nel PATH, spesso `/usr/bin/python3` di macOS, oppure il Terminale ha ancora il vecchio PATH. Apri una nuova finestra, esegui `which -a python3` e rimuovi le righe del PATH rimaste in `~/.zshrc` o `~/.zprofile`.

---

Canonical HTML page: https://mole.fit/it/blog/how-to-uninstall-python-node-mac
Blog index for agents: https://mole.fit/it/blog/llms.txt
Site index for agents: https://mole.fit/llms.txt