Top Python Requests Interview Questions and Answers for 2022

Python Requests is one of the most popular libraries for making HTTP requests in Python. It provides a simple yet powerful API for interacting with web services and APIs. With the rise of microservices and API-driven development, knowledge of Requests is becoming indispensable for Python developers.

In this article, we will look at some of the most frequently asked interview questions on Python Requests. Mastering these questions will help you ace your next Python interview and land your dream job!

What is Python Requests?

Python Requests is an elegant and simple HTTP library for Python. It allows you to send HTTP requests extremely easily. The key features of Requests are:

• Make HTTP requests (GET, POST, PUT, DELETE, etc.)
• Simple and intuitive API
• Automatic JSON decoding
• Connection pooling and sessions
• Feature-rich – proxies, authentication, streaming downloads, timeouts etc.
• Works with Python 2 and 3

Requests allows you to send HTTP requests in Python in a human-friendly way and gives you proper exception-raised HTTP responses. Under the hood, it is using the reliable urllib3 library.

How does Requests differ from urllib / urllib2?

Prior to Requests, developers used the urllib and urllib2 modules for making HTTP requests in Python. However, working with these low-level modules can be complex, tedious and error-prone

Requests makes HTTP interactions far simpler and more human-friendly Some key differences are

• Requests takes care of tedious tasks like ensuring proper encodings, JSON decoding, Cookies etc.
• The API is much simpler and elegant. No need to know low-level nitty-gritties of HTTP.
• Better connection pooling, sessions and proxy support.
• Proper exception handling.
• Support for streaming large file downloads.

How do you make a GET request in Python using Requests?

This is one of the most basic questions on using Requests. Making a simple GET request is extremely easy:

import requestsresponse = requests.get('https://api.github.com')print(response.status_code)

We simple import the requests module, call the get() method with the URL, and we get a response object back with all details of the HTTP response. We can check the status code to ensure the request was successful.

We can also pass query parameters, headers, cookies etc. to requests:

payload = {'page': 2, 'count': 25}headers = {'User-Agent': 'Mozilla/5.0'}response = requests.get('https://api.github.com/users', params=payload, headers=headers)

So Requests really simplifies sending parameterized HTTP requests in Python.

How can you send a POST request using Requests?

Sending a POST request with Requests is just as simple. We use the post() method:

import jsondata = {'name': 'John', 'age': 28}response = requests.post('https://api.example.com/users', data=json.dumps(data))

We simply pass the URL, data payload and we get back the response. This is much simpler compared to manually formatting POST data and handling encodings in barebone modules like urllib.

How do you pass authentication details in Requests?

Many web APIs require authentication details like username/password or API keys to be passed with the request.

There are several ways to provide authentication credentials in Requests:

Basic Auth: Pass a tuple of (username, password) to the auth parameter:

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

API Key: Pass the API key as a query parameter or header:

requests.get('https://api.example.com?api_key=ABCD1234') requests.get('https://api.example.com', headers={'X-API-Key': 'ABCD1234'})

OAuth: For OAuth authenticated APIs, pass the OAuth token to the headers:

oauth_token = 'xyz123'headers = {'Authorization': f'Bearer {oauth_token}'}  requests.get('https://api.example.com', headers=headers)

So Requests makes working with authenticated APIs very straightforward.

How can you send multipart/form data using Requests?

Sometimes you need to send data encoded as multipart/form-data, e.g. when uploading files to a server.

With Requests, you can send form-encoded data using the files parameter.

For example, to upload a file:

url = 'https://api.example.com/upload'files = {'file': open('report.xls', 'rb')}r = requests.post(url, files=files)

We simply pass a dictionary with the key being the form data name, and value is the file object we want to send.

How can you stream a large file download using Requests?

By default, when you make a request in Requests, it will download the entire response body into memory. This can be problematic for large responses, as it might exhaust system memory.

The best way is to stream the response by iterating over the response object:

response = requests.get('http://bigfiles.com/large-file.iso', stream=True)with open('large-file.iso', 'wb') as fd:    for chunk in response.iter_content(4096):        fd.write(chunk) 

This way, the file will be streamed in small chunks and written to disk without loading the entire file into memory.

How can you specify timeouts in Requests?

Sometimes API calls can hang and stall indefinitely. To prevent this, you can specify timeout durations in Requests:

requests.get('https://api.example.com', timeout=3) 

This will raise a Timeout exception if the request takes longer than 3 seconds.

You can set the connect and read timeouts individually too:

requests.get('https://api.example.com', timeout=(3, 10))  

So Requests gives you full control over the request timeouts.

How do you parse JSON response in Requests?

Many modern APIs return output in JSON format. Requests makes it very easy to process JSON responses:

response = requests.get('https://api.github.com/users/octocat')json_data = response.json()print(json_data['name']) # Mr. Octocat

By calling the .json() method, Requests will parse the JSON automatically and return a dictionary or list for usage in your code.

How can you send cookies in Requests?

To send your own cookies to the server, you can use the cookies parameter:

url = 'https://httpbin.org/cookies'cookies = {'foo': 'bar'}response = requests.get(url, cookies=cookies)

This will set the cookie foo=bar in the outgoing request.

To send cookies received from the server in subsequent requests, use the Response.cookies attribute:

response = requests.get('https://httpbin.org/cookies/set?choco=chip')cookies = response.cookiesresponse = requests.get('https://httpbin.org/cookies', cookies=cookies) 

This makes persisting and sending cookies very straightforward in Requests.

How can you persist settings across Requests?

For reuse across multiple requests, the Request object exposes a Session object. This persists settings across requests:

s = requests.Session()s.auth = ('user', 'pass')s.headers.update({'x-test': 'true'})# settings persist across requests s.get('https://api.example.com/users')  s.get('https://api.example.com/comments')

This way, we don’t need to repeat auth credentials, headers, proxies etc. for all requests.

How can you implement rate-limiting and retries in Requests?

Too many frequent requests can cause servers to block your IP address. You can implement rate-limiting using the time module:

import timelast_request = 0delay = 1 while True:   if time.time() - last_request > delay:      response = requests.get('https://api.example.com')      last_request = time.time()   else:      time.sleep(delay - (time.time() - last_request))  

This inserts a pause between requests to avoid hitting rate-limits.

For failed requests, you can retry