python-requests

#python-
requests
Sommario
Di 1

Capitolo 1: Iniziare con le richieste Python 2

Osservazioni 2

HTTP per gli umani 2

Examples 2

Installazione o configurazione 2

Ottieni richieste 3

Richieste POST 3

Altri metodi di richiesta 3

Leggendo la risposta 4

Lettura dei codici di stato 4

Capitolo 2: Automazione dell'accesso tramite Richieste su Single Sign-On 5

Examples 5

Esempio di accesso a pagine autenticate usando le richieste 5

Capitolo 3: Django Framework 7

Examples 7

Installazione e configurazione 7

Django Core Concepts 7

Core Concepts - Views 8

Core Concepts - Templates 8

Core Concepts - URL 9

Capitolo 4: File 10

Parametri 10

Osservazioni 10

Examples 10

Caricamento file semplice 10

Caricamento file con params manuali 10

Invio di stringhe come file 10

Capitolo 5: Invio e ricezione di JSON 11

Examples 11
 POSTing JSON 11

Ricezione di JSON in una risposta 11

ETL dalle API web con moduli json e richieste 11

Capitolo 6: Utilizzo delle richieste dietro un proxy 14

Examples 14

Impostazione del proxy in codice Python 14

Utilizzo di variabili di ambiente proxy 14

Titoli di coda 15
Di
You can share this PDF with anyone you feel could benefit from it, downloaded the latest version
from: python-requests

It is an unofficial and free python-requests ebook created for educational purposes. All the content
is extracted from Stack Overflow Documentation, which is written by many hardworking individuals
at Stack Overflow. It is neither affiliated with Stack Overflow nor official python-requests.

The content is released under Creative Commons BY-SA, and the list of contributors to each
chapter are provided in the credits section at the end of this book. Images may be copyright of
their respective owners unless otherwise specified. All trademarks and registered trademarks are
the property of their respective company owners.

Use the content presented in this book at your own risk; it is not guaranteed to be correct nor
accurate, please send your feedback and corrections to info@zzzprojects.com

https://riptutorial.com/it/home 1
Capitolo 1: Iniziare con le richieste Python
Osservazioni

HTTP per gli umani

Requests è l'unica libreria HTTP non OGM per Python, sicura per il consumo umano.

Le richieste consentono di inviare richieste HTTP/1.1 organiche e alimentate con erba, senza la
necessità di manodopera manuale. Non è necessario aggiungere manualmente stringhe di query
ai tuoi URL o codificare in forma i tuoi dati POST. Il pool di connessioni keep-alive e HTTP sono al
100% automatiche, alimentate da urllib3 , che è incorporato in Requests.

Il potere delle richieste:

>>> r = requests.get('https://api.github.com/user', auth=('user', 'pass'))

>>> r.status_code
200
>>> r.headers['content-type']
'application/json; charset=utf8'
>>> r.encoding
'utf-8'
>>> r.text
u'{"type":"User"...'
>>> r.json()
{u'private_gists': 419, u'total_private_repos': 77, ...}

Examples
Installazione o configurazione

python-requests è disponibile su PyPI, l'indice del pacchetto Python, il che significa che può essere
installato tramite pip:

pip install requests

È possibile trovare il codice sorgente aggiornato sulle richieste del repository GitHub

Se si desidera installarlo dal sorgente, è possibile farlo clonando il repository GitHub:

git clone git://github.com/kennethreitz/requests.git

Oppure ottenendo il tarball ( -O scrive l'output in un file; -L segue i redirect):

curl -OL https://github.com/kennethreitz/requests/tarball/master

https://riptutorial.com/it/home 2
Quindi puoi installarlo eseguendo setup.py

python setup.py install

Comunque lo hai installato, puoi iniziare a usarlo importando il solito modo

>>> import requests

>>> requests.get('http://stackoverflow.com')

Ottieni richieste

requests.get() crea una richiesta GET:

response = requests.get('https://example.com/')

Passare i parametri di query come dizionario all'argomento params :

response = requests.get('https://example.com/', params={"a": 1, "b": 2})

Per le richieste GET che potrebbero richiedere l'autenticazione di base, è possibile includere il
parametro auth come segue:

response = requests.get('https://api.github.com/user', auth=('user', 'pass'))

Richieste POST

Le richieste POST vengono eseguite con il metodo request.post() .

Se è necessario inviare una richiesta di modulo Web come corpo POST, passare un dizionario
con coppie chiave-valore come argomento data ; requests li codificheranno in un corpo del
mimetype application/x-www-form-urlencoded :

r = requests.post('https://github.com/', data={"a": 1, "b": 2})

Se è necessario caricare un carico utile JSON, è possibile utilizzare json= . Questo imposterà
automaticamente l'intestazione Content-Type su application/json

r = requests.post('https://github.com/', data={"a": 1, "b": 2})

Altri metodi di richiesta

Il modulo delle requests ha funzioni di primo livello per la maggior parte dei metodi HTTP:

r = requests.put('https://example.com/', data=put_body)
r = requests.delete('https://example.com/')
r = requests.head('https://example.com/')
r = requests.options('https://example.com/')

https://riptutorial.com/it/home 3
 r = requests.patch('https://example.com/', data=patch_update)

Leggendo la risposta

response = requests.get("https://api.github.com/events")
text_resp = response.text

Risposta JSON : per le risposte in formato json, il pacchetto fornisce un decoder incorporato

response = requests.get('https://api.github.com/events')
json_resp = response.json()

Questo metodo genera un errore ValueError in caso di risposta vuota o contenuto non variabile.

Lettura dei codici di stato

L'attributo status_code contiene il codice di stato della risposta

good_req = requests.get('https://api.github.com/events')
code_200 = good_req.status_code

notfound_req = requests.get('https://api.github.com/not_found')
code_404 = notfound_req.status_code

requests.codes.__dict__ fornirà un elenco di codici di stato http disponibili.

È possibile utilizzare raise_for_status per verificare se lo status_code era 4xx o 5xx e generare
un'eccezione corrispondente in quel caso.

good_req = requests.get('https://api.github.com/events')
good_req.raise_for_status()
# is a 200 status code so nothing happens

notfound_req = requests.get('https://api.github.com/not_found')
notfound_req.raise_for_status()
# raises requests.exceptions.HTTPError: 404 Client Error

Leggi Iniziare con le richieste Python online: https://riptutorial.com/it/python-

requests/topic/1115/iniziare-con-le-richieste-python

https://riptutorial.com/it/home 4
Capitolo 2: Automazione dell'accesso tramite
Richieste su Single Sign-On
Examples
Esempio di accesso a pagine autenticate usando le richieste

A volte abbiamo bisogno di analizzare le pagine, ma farlo richiede che tu sia un utente autorizzato.
Ecco un esempio che mostra come eseguire l'accesso Oracle.

import sys
import requests
import json
from bs4 import BeautifulSoup

def mprint(x):
sys.stdout.write(x)
print
return

headers = {'User-Agent': 'Mozilla/5.0 (X11; Linux i686; rv:7.0.1) Gecko/20100101

Firefox/7.0.1'}

mprint('[-] Initialization...')
s = requests.session()
s.headers.update(headers)
print 'done'

mprint('[-] Gathering JSESSIONID..')

# This should redirect us to the login page

# On looking at the page source we can find that
# in the submit form 6 values are submitted (at least at the time of this script)
# try to take those values out using beautiful soup
# and then do a post request. On doing post https://login.oracle.com/mysso/signon.jsp
# we will be given message we have the data which is more than necessary
# then it will take us to the form where we have to submit data here
# https://login.oracle.com/oam/server/sso/auth_cred_submit
# once done we are signed in and doing and requests.get(url) will get you the page you want.

r = s.get("company's local url- a link which requires authentication")

if r.status_code != requests.codes.ok:
print 'error'
exit(1)
print 'done'

c = r.content
soup = BeautifulSoup(c,'lxml')
svars = {}

for var in soup.findAll('input',type="hidden"):

https://riptutorial.com/it/home 5
 svars[var['name']] = var['value']

s = requests.session()
r = s.post('https://login.oracle.com/mysso/signon.jsp', data=svars)

mprint('[-] Trying to submit credentials...')

inputRaw = open('credentials.json','r')
login = json.load(inputRaw)

data = {
'v': svars['v'],
'OAM_REQ': svars['OAM_REQ'],
'site2pstoretoken': svars['site2pstoretoken'],
'locale': svars['locale'],
'ssousername': login['ssousername'],
'password': login['password'],
}

r = s.post('https://login.oracle.com/oam/server/sso/auth_cred_submit', data=data)

r = s.get("company's local url- a link which requires authentication")

# dumping the html page to html file
with open('test.html','w') as f:
f.write(r.content)

credentials.json come menzionato nel codice è il seguente:

{
"ssousername":"example@oracle.com",
"password":"put your password here"
}

Collegamento a github - gist

Leggi Automazione dell'accesso tramite Richieste su Single Sign-On online:

https://riptutorial.com/it/python-requests/topic/6240/automazione-dell-accesso-tramite-richieste-su-
single-sign-on

https://riptutorial.com/it/home 6
Capitolo 3: Django Framework
Examples
Installazione e configurazione

Django è un framework completo per lo sviluppo web. Alimenta alcuni dei siti Web più popolari su
Internet.

Installare la struttura; usa lo strumento pip :

pip install django

Se si sta installando questo su OSX o Linux, il comando sopra riportato potrebbe causare un
errore di autorizzazione; per evitare questo errore, installa il pacchetto per il tuo account utente o
usa un ambiente virtuale:

pip install --user django

Una volta installato, avrai accesso allo strumento di bootstrap django-admin , che creerà una
directory con alcune impostazioni predefinite per avviare lo sviluppo.

django-admin startproject myproject

Questo creerà una directory myproject con il layout di progetto predefinito.

Django Core Concepts

Django è uno stack completo, ricco di funzionalità per lo sviluppo web. Raggruppa un sacco di
funzionalità per fornire un'esperienza comune, rapida e produttiva per gli sviluppatori web.

I progetti Django consistono in impostazioni comuni e una o più applicazioni . Ogni applicazione è
un insieme di funzionalità insieme a dipendenze (come modelli e modelli) che sono raggruppate
insieme come moduli Python.

Lo script django bootstrapping crea automaticamente un file di impostazioni per il tuo progetto,
con le funzionalità più comuni abilitate.

Questo concetto di applicazioni consente una facile funzionalità plug-and-play e vi è una vasta
libreria di applicazioni disponibili per gestire le attività più comuni. Questo concetto di applicazioni
è fondamentale per Django; molte delle funzionalità integrate (come l'autenticazione dell'utente e il
sito di amministrazione) sono semplicemente app django.

Per creare la tua prima applicazione, dall'interno della directory del progetto:

python manage.py startapp yourapp

https://riptutorial.com/it/home 7
yourapp è il nome della tua applicazione personalizzata.

Ogni applicazione ti consente di sviluppare:

1. Una serie di visualizzazioni : si tratta di parti di codice eseguite in risposta a una richiesta.

2. Uno o più modelli ; che sono un'astrazione per i database. Questi consentono di definire i
propri oggetti come oggetti Python e l'ORM integrato fornisce un'API amichevole per
l'archiviazione, il recupero e il filtraggio degli oggetti dai database.

3. Strettamente correlati ai modelli sono le migrazioni che sono script generati per fornire un
metodo coerente e affidabile per applicare le modifiche nei modelli al database.

4. Una serie di URL a cui l'applicazione risponderà.

5. Una o più classi di amministrazione; per personalizzare come si comporta l'applicazione

nell'applicazione di amministrazione django integrata.

6. Qualsiasi test che tu possa scrivere.

Core Concepts - Views

Una view è qualsiasi parte di codice che risponde a una richiesta e restituisce una risposta. Le
viste normalmente restituiscono modelli insieme a un dizionario (chiamato contesto ) che di solito
contiene dati per segnaposto nel modello. Nei progetti di Django, le viste si trovano nel modulo
views.py delle applicazioni.

La vista più semplice, restituisce una risposta diretta:

from django.http import HttpResponse

def simple_view(request):
return HttpResponse('<strong>Hello World</strong>')

Tuttavia, la maggior parte delle visualizzazioni utilizza un modello:

from django.shortcuts import render

def simple_template_view(request):
return render(request, 'some_template.html')

Un modello è semplicemente qualsiasi file e può opzionalmente contenere un markup speciale per
funzionalità aggiunte; ciò significa che le viste di Django possono restituire qualsiasi tipo di
risposta, non solo HTML.

Core Concepts - Templates

In django, un modello è semplicemente un file che contiene tag speciali che possono essere
sostituiti da dati dalla vista.

https://riptutorial.com/it/home 8
L'esempio di modello canonico potrebbe essere:

<strong>Hello {{ name }}, I am a template!</strong>

Qui, la stringa {{ name }} identifica un segnaposto che può essere sostituito da un contesto.

Per rendere questo modello da una vista, possiamo passare il valore come dizionario:

from django.shortcuts import render

def simple_view(request):
return render(request, 'template.html', {'name': 'Jim'})

Una volta che questa vista è resa, l'HTML risultante sarà Hello Jim, I am a template! .

Core Concepts - URL

In Django esiste un mapper url che mappa gli URL di funzioni specifiche (viste) che restituiscono
le risposte. Questa stretta separazione tra il layout del file system e il layout degli URL consente
una grande flessibilità durante la scrittura delle applicazioni.

Tutti i pattern URL sono memorizzati in uno o più file urls.py e c'è un file master urls.py che viene
letto prima da django.

Django analizza i pattern nell'ordine in cui sono scritti e si ferma quando trova una corrispondenza
con l'URL richiesto dall'utente. Se non vengono trovate corrispondenze, viene generato un errore.

In modalità debug (attivato impostando DEBUG = True in settings.py ), django stamperà un

messaggio di errore dettagliato quando un url richiesto non corrisponde ad alcun pattern. In
produzione, tuttavia, django visualizzerà un normale messaggio 404.

Un pattern url consiste in un'espressione regolare Python, seguita da un callable (un metodo o
funzione) da chiamare quando quel pattern è abbinato. Questa funzione deve restituire una
risposta HTTP:

url(r'/hello$', simple_view)

Leggi Django Framework online: https://riptutorial.com/it/python-requests/topic/6579/django-

framework

https://riptutorial.com/it/home 9
Capitolo 4: File
Parametri

parametri Funzione

file JSON Elenco dei percorsi dei file.

tipo di contenuto Tipi MIME

intestazioni Intestazioni HTTP

Osservazioni
La variabile r negli esempi contiene i dati binari completi del file che stai inviando.

Examples
Caricamento file semplice

url = 'http://your_url'
files = {'file': open('myfile.test', 'rb')}
r = requests.post(url, files=files)

Caricamento file con params manuali

url = 'http://httpbin.org/post'
files = {'file': ('report.xls', open('report.xls', 'rb'), 'application/vnd.ms-excel',
{'Expires': '0'})}
r = requests.post(url, files=files)

Invio di stringhe come file

url = 'http://httpbin.org/post'
files = {'file': ('report.csv', 'some,data,to,send\nanother,row,to,send\n')}
r = requests.post(url, files=files)
r.text

Leggi File online: https://riptutorial.com/it/python-requests/topic/5929/file

https://riptutorial.com/it/home 10
Capitolo 5: Invio e ricezione di JSON
Examples
POSTing JSON

Per POSTARE un corpo JSON, passare una struttura dati Python all'argomento json ; qui viene
pubblicato un dizionario, ma tutto ciò che può essere codificato in JSON lo farà:

import requests

# Create a dictionary to be sent.

json_data = {'foo': ['bar', 'baz'], 'spam': True, 'eggs': 5.5}

# Send the data.

response = requests.post(url='http://example.com/api/foobar', json=json_data)
print("Server responded with %s" % response.status_code)

requests prendono cura della codifica su JSON per te e imposta Content-Type su application/json .

Ricezione di JSON in una risposta

Quando una risposta contiene JSON valido, basta usare il metodo .json() sull'oggetto Response
per ottenere il risultato decodificato:

response = requests.get('http://example.com/')
decoded_result = response.json()

Tuttavia, questo non fallisce con grazia; solleverà un JSONDecodeError se l'oggetto risposta non è
JSONDecodeError JSON.

Potresti voler controllare prima il tipo MIME del contenuto, per una gestione più agevole degli
errori:

if 'application/json' in response.headers['Content-Type']:
decoded_result = response.json()
else:
non_json_result = response.data

ETL dalle API web con moduli json e richieste

Innanzitutto, importa i moduli e imposta le stringhe di connessione. Se hai bisogno di parametri,

puoi metterli direttamente nella stringa dell'URL (una API in questo caso) o costruirli come dict e
passarli all'argomento params.

import requests
import json

https://riptutorial.com/it/home 11
 params = {'id': 'blahblah', 'output': 'json'} # You could use
https://www.somesite.com/api/query?id=blahblah&output=json directly.
API = 'https://www.somesite.com/api/query'
APIcred = 'username','password'

Le richieste gestiscono automaticamente HTTPBasicAuth e HTTPDigestAuth. Questa API di

esempio restituirà una stringa JSON. Fai la richiesta GET e cattura l'output. Solleva un errore per
lo stato HTTP errato.

r = requests.get(API, params = params, auth = APIcred)

r.raise_for_status()
#print(r.status) # Optionally print HTTP status code

Converti una stringa di JSON in un oggetto python con cui puoi lavorare. JSON ha un aspetto
visivo simile a quello di un pyt dict, ma ci sono differenze significative tra valori nulli, vero / falso,
ecc.

r_dict = json.loads(r.text)
print(r_dict)

Immagina che l'output appena stampato provenga da un database multilinea a più colonne e sia di
difficile lettura:

{'row': [{'Paese': 'Stati Uniti', 'pid': 'cc12608f-4591-46d7-b8fe-6222e4cde074', 'Stato': '',

'FormerLastName': '', 'Grado': 'Amministrazione aziendale'}, {'Paese': 'Gran Bretagna',
'pid': 'c9f2c6f7-f736-49d3-8adf-fd8d533bbd58', 'Stato': '', 'FormerLastName': '', 'Grado':
' Gestione generale'}]}

È possibile stampare () una versione più leggibile con json.dumps (). La riga sottostante codifica
l'oggetto python in una stringa di JSON con schede e lo stampa.

print(json.dumps(r_dict, indent = 4))

Produzione:

{
"row": [
{
"Country": "United States",
"pid": "cc12608f-4591-46d7-b8fe-6222e4cde074",
"Status": "",
"FormerLastName": "",
"Degree": "Business Administration"
},
{
"Country": "Britain",
"pid": "c9f2c6f7-f736-49d3-8adf-fd8d533bbd58",
"Status": "",
"FormerLastName": "",
"Degree": "General Management"
}
]

https://riptutorial.com/it/home 12
 }

Puoi accedere a elementi nidificati in un dict come questo:

print(some_dict['BuildingA']['Room12'])

Ma il nostro campione ha un numero arbitrario di oggetti in un array, che è a sua volta annidato
come valore di una chiave! Questi sono accessibili con un numero di riga, a partire da 0.

Cambiamo uno dei nostri valori "Paese" da "Gran Bretagna" a "Albania":

r_dict['row'][1]['Country'] = 'Albania'

Ora inviamo questi dati a un'altra API. Le richieste possono accettare un dict direttamente
sull'argomento json, invece di codificare una stringa con json.dumps ().

r = requests.post('https://www.somesite.com/" + 'api/carrots', json = r_dict, auth = APIcred)

r.raise_for_status()

Leggi Invio e ricezione di JSON online: https://riptutorial.com/it/python-requests/topic/3099/invio-e-

ricezione-di-json

https://riptutorial.com/it/home 13
Capitolo 6: Utilizzo delle richieste dietro un
proxy
Examples
Impostazione del proxy in codice Python

Se il codice è in esecuzione dietro un proxy e si conosce il punto finale, è possibile impostare

queste informazioni nel codice.

requests accetta un parametro proxies . Questo dovrebbe essere un dizionario che associa il
protocollo all'URL del proxy.

proxies = {
'http': 'http://proxy.example.com:8080',
'https': 'http://secureproxy.example.com:8090',
}

Si noti che nel dizionario abbiamo definito l'URL del proxy per due protocolli separati: HTTP e
HTTPS. Ogni mappa a un singolo URL e porta. Questo non significa che i due non possano
essere uguali, però. Questo è anche accettabile:

proxies = {
'http': 'http://secureproxy.example.com:8090',
'https': 'http://secureproxy.example.com:8090',
}

Una volta definito il dizionario, lo si passa come parametro.

requests.get('http://example.org', proxies=proxies)

Utilizzo di variabili di ambiente proxy

requests usa specifiche variabili d'ambiente automaticamente per il rilevamento del proxy.

• HTTP_PROXY definirà l'URL del proxy da utilizzare per le connessioni HTTP

• HTTPS_PROXY definirà l'URL del proxy da utilizzare per le connessioni HTTPS

Una volta impostate queste variabili di ambiente, il codice Python non ha bisogno di passare nulla
al parametro proxies .

requests.get('http://example.com')

Leggi Utilizzo delle richieste dietro un proxy online: https://riptutorial.com/it/python-

requests/topic/5933/utilizzo-delle-richieste-dietro-un-proxy

https://riptutorial.com/it/home 14
Titoli di coda
S.
Capitoli Contributors
No

Andy, Batsu, Burhan Khalid, Community, dansyuqri, icesin, k-

Iniziare con le
1 nut, Martijn Pieters, Meysam, mickeyandkaka, mphuie, OJFord,
richieste Python
supersam654

Automazione
dell'accesso tramite
2 lordzuko
Richieste su Single
Sign-On

3 Django Framework Burhan Khalid

4 File ReverseCold

Invio e ricezione di
5 bendodge, Martijn Pieters, OJFord, Olli, Stan
JSON

Utilizzo delle
6 richieste dietro un Andy
proxy

https://riptutorial.com/it/home 15