# Python requests: invio di richieste HTTP con Python

Python `requests` è un’apprezzata libreria che ti consente di inviare richieste HTTP e verificare le risposte. Sebbene `.get()` sia il metodo principale di questo modulo, sono disponibili molte altre opzioni.

## Che cos’è Python `requests`?

Python `requests` è uno standard che ti consente di **inviare richieste HTTP** all’interno di questo [linguaggio di programmazione](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/quale-linguaggio-di-programmazione-imparare/). La base è un’interfaccia di programma chiara ed efficace, che rende particolarmente semplice l’integrazione di funzionalità da parte di fornitori terzi. La libreria `requests` di Python offre vari strumenti che permettono di inviare richieste HTTP e ricevere le relative risposte. Anche se il modulo Python `requests` è ampiamente utilizzato e altamente consigliabile, **non fa parte dell’installazione standard** di Python.

## Installazione e avvio della libreria Python `requests`

Prima di installare Python `requests` ti consigliamo di creare una [macchina virtuale](https://www.ionos.it/digitalguide/server/know-how/macchine-virtuali/), dove poter testare la libreria senza preoccupazioni. Per l’installazione si utilizza `pip`. Il codice si presenta così:

```bash
$ python -m pip install requests
```

Dopo aver completato l’installazione, per utilizzare la libreria è necessario questo codice:

```python
import requests
```

## Funzionamento, sintassi e metodi

Come altri strumenti simili, Python `requests` invia una richiesta HTTP, che poi riceve una risposta se la trasmissione ha esito positivo. Questa risposta è un oggetto che contiene tutte le informazioni importanti come **contenuto, codifica e stato**. La sintassi per tale richiesta è sempre simile alla seguente:

```python
requests.methode(url, **kwargs)
```

N.B. `**kwargs` sta a indicare i metodi opzionali che è possibile assegnare a metodi come `headers`, `files` o `cookies`.

La funzione che utilizzerai più spesso è `.get()`, ma Python requests mette a tua disposizione anche altri metodi. Sono disponibili le seguenti funzioni:

- `.delete(url, **kwargs)`: utilizza `.delete()` per eliminare un’origine specifica
- `.get(url, parameter=None, **kwargs)`: con `.get()` puoi richiedere informazioni da un server
- `.head(url, **kwargs)`: anche con `.head()` puoi richiedere una risposta da un server, ma limitata all’intestazione
- `.patch(url, data=None, **kwargs)`: utilizzando `.patch()` è possibile aumentare le prestazioni. Con questo metodo, soltanto le modifiche vengono inviate all’origine
- `.post(url, data=None, json=None, **kwargs)`: con `.post()` è possibile trasmettere a un server principalmente le informazioni su un modulo
- `.put(url, data=None, **kwargs)`: con `.put()` puoi modificare un’origine già esistente e creare nuovi dati sul server
- `.request(method, url, **kwargs)`: `.request()` ti permette di inviare una richiesta all’URL utilizzando un metodo specifico

## Esempio per il metodo `.get()`

La struttura di `.get()` è molto chiara e rende Python `requests` una libreria pratica da usare. Tutto ciò che ti serve sono il metodo e l’URL a cui vuoi fare riferimento. Quest’ultimo viene scritto tra virgolette. Un codice del genere si presenta ad esempio così:

```python
import requests
requests.get("https://esempio.com")
```

Riceverai quindi una risposta dal tuo server di destinazione. Per capire meglio il funzionamento, puoi anche richiederne la visualizzazione in una variabile. Per il nostro esempio, il codice si presenterebbe così:

```python
import requests
response = requests.get("https://esempio.com")
```

## Richiesta di codici di stato

La risposta più semplice che puoi ricevere a una richiesta è un [codice di stato HTTP](https://www.ionos.it/digitalguide/hosting/tecniche-hosting/spiegazione-dei-piu-importanti-codici-di-stato-http/). Esso ti permette di capire se la tua richiesta ha avuto successo o meno. Il codice di stato è composto da tre cifre. Esistono numerose varianti che forniscono informazioni sullo stato di avanzamento della tua richiesta. Le categorie principali sono le seguenti:

- **1XX**: contiene ulteriori informazioni
- **2XX**: certifica che una richiesta è andata a buon fine
- **3XX**: ti informa se la tua richiesta è stata reindirizzata
- **4XX**: segnala un errore lato client
- **5XX**: segnala un errore lato server

Tra i codici di stato più noti vi sono “200 – OK” (per una richiesta andata a buon fine) e “[404 – Not Found](https://www.ionos.it/digitalguide/siti-web/creare-siti/cosa-significa-lerrore-404-not-found/)” (se i dati richiesti non sono stati trovati sul server).

Dopo aver inviato la tua richiesta tramite Python `requests`, puoi interrogare lo stato con `.status_code`. A tal fine utilizza il codice seguente:

```python
response.status_code
```

Se la richiesta ha avuto successo, ricevi questo risultato:

```python
200
```

Per maggiore chiarezza è utile anche il codice seguente:

```python
if response.status_code == 200:
	print("La richiesta è andata a buon fine.")
elif response.status_code == 404:
	print("La richiesta non è andata a buon fine.")
```

## Visualizzazione dell’intestazione con Python `requests`

Molte informazioni utili sono contenute nell’intestazione di una risposta HTTP. Qui trovi tra l’altro il **tipo di dati inviati, un limite di tempo per la memorizzazione temporanea** e altre informazioni. Con la libreria Python `requests` puoi anche visualizzare facilmente l’intestazione. A tal fine, esegui prima la funzione `.get()` e quindi `.headers`:

```python
import requests
response = requests.get("https://esempio.com")
response.headers
```

Come risultato ottieni un oggetto contenente i valori dell’intestazione. Inoltre, puoi interrogare tali valori singolarmente aggiungendo specificazioni al comando. Ad esempio, se desideri avere ulteriori informazioni sul tipo di dati, il codice da inserire è questo:

```python
response.headers["content-type"]
```

## Accesso al payload

Il pacchetto di dati inviato **tra il server e il client** è noto anche come “payload”. Si trova nel corpo, o body, della risposta. Utilizzando `response` puoi accedere alle informazioni al suo interno. Per ottenere una rappresentazione in byte, utilizza questa istruzione:

```python
import requests
response = requests.get("https://esempio.com")
response.content
type(response.content)
```

Se desideri convertire in una stringa le informazioni così ottenute, utilizza questo codice:

```python
response.text
type(response.text)
```

Python `requests` rimuove la crittografia dall’intestazione. In alternativa puoi dire al sistema di utilizzare un metodo diverso. Un esempio è rappresentato da questo codice:

```python
response.encoding = "utf-8"
response.text
```

## Verifica dello stato di avanzamento

Quando invii una richiesta, Python `requests` la prepara per evitare spiacevoli errori. Tra le altre cose, viene anche **controllata l’intestazione**. Puoi verificare l’avanzamento di questo metodo per mezzo della funzione `.request`. A tal fine utilizza il codice seguente:

```python
import requests
response = requests.post("https://esempio.com", json={"key": "value"})
print(response.request.headers["content-type"])
print(response.request.url)
print(response.request.body)
```

In questo modo ottieni informazioni su payload, intestazione, URL e molto altro ancora.

## Verifica dell’autenticità con i moduli Python`requests`

Il parametro `auth` è utilizzato in Python `requests` per inviare un’autenticazione al server. Quest’ultimo può quindi effettuare una verifica dell’autenticità e controllare con chi sta interagendo effettivamente. Per utilizzare questa verifica, usa un codice come questo:

```python
import requests
from requests.auth import HTTPBasicAuth
response = requests.get("https://il_tuo_sito.com/basic-auth/user/passwd", 
	auth=HTTPBasicAuth("user", "passwd"))
print(response.status_code)
print(response.request.headers["Authorization"])
```

## Utilizzo di un certificato SSL

In generale, l’uso di un [certificato SSL](https://www.ionos.it/digitalguide/siti-web/creare-siti/certificato-ssl/) è utile per prevenire le perdite di dati e le intromissioni indesiderate. Python `requests` offre questa opzione come impostazione predefinita. Tuttavia, se desideri **interrompere la verifica reciproca per una richiesta**, puoi disattivare SSL con questo codice:

```python
import requests
requests.get("https://esempio.com", verify=False)
```

Tuttavia, riceverai un chiaro messaggio di avvertimento.

## Inizializzazione di un timeout con Python `requests`

Tra le varie possibilità, Python `requests` ti permette anche di **limitare il tempo massimo per una risposta**. Per impostazione predefinita, il client attende una risposta senza alcuna limitazione. Se la risposta non arriva, le richieste possono accumularsi e le prestazioni ne risentono. Per prevenire questo problema puoi utilizzare il parametro `timeout`. Con il codice seguente indichiamo a Python `requests` di interrompere la richiesta dopo due secondi:

```python
requests.get("https://esempio.com", timeout=2)
```

Consiglio Effettua il deployment del tuo sito web o della tua app direttamente tramite GitHub: con [Deploy Now](https://www.ionos.it/hosting/deploy-now "Deploy Now di IONOS") di IONOS hai a tua disposizione la soluzione ottimale sia per le applicazioni a pagina singola che per i siti web statici. Scegli il piano più adatto alle tue esigenze e approfitta di una configurazione più rapida, flussi di lavoro ottimizzati e progettazione sicura.


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/moduli-python-requests/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/moduli-python-requests/) for AI/LLM consumption.