Python API Interaction (REST API) Exercises

• The requests library is the most widely used and beginner-friendly option for sending HTTP requests in Python.
• It allows you to easily send GET, POST, PUT, DELETE requests without manually handling low-level networking.

Example:

import requests

response = requests.get("https://api.example.com/data")
print(response.status_code)

• Option 1 (http.client) is a low-level library, not ideal for simple REST API interaction.
• Option 2 (urllib3) is powerful but not as simple as requests.
• Option 4 (socket) is for raw network communication, not direct API requests.

• This code uses the requests library to send a GET request to GitHub's API.
• response.status_code returns the HTTP status code, such as 200 for success or 404 for not found.
• checking status_code before processing data to ensure the request was successful.

Example:

if response.status_code == 200:
    print("Request successful!")
else:
    print("Something went wrong.")

• Option 1 is incorrect because .status_code does not return JSON data.
• Option 3 would require response.text.
• Option 4 would only happen if the request failed and was handled separately.

• The POST method is used to send new data to a server in a REST API.
• For example, to create a new record in the SolutionBazz API, you might do:

import requests

data = {"title": "New Python Exercise", "level": "Easy"}
response = requests.post("https://api.solutionbazz.com/exercises", json=data)
print(response.status_code)

• Option 1 (GET) is for retrieving data.
• Option 2 (PUT) is for updating or replacing existing data.
• Option 4 (DELETE) removes a resource from the server.

When working with APIs like SolutionBazz’s, understanding the correct HTTP method ensures that your requests are processed correctly and don’t accidentally modify or delete data.

• The .json() method in the requests library parses a JSON-formatted response body and converts it into a Python dictionary.
• This is particularly useful when interacting with REST APIs that return structured data.
• For example, fetching Python exercises from a mock SolutionBazz API:

import requests

response = requests.get("https://api.solutionbazz.com/exercises")
data = response.json()
print(data["exercises"][0]["title"])

• Option 1 is incorrect because form-encoded data is sent with the data parameter in requests, not json().
• Option 3 is incorrect because .json() doesn’t save anything locally; you’d need Python’s json.dump() for that.
• Option 4 is incorrect because .json() doesn’t validate—only parses.

• In the requests library, query parameters should be passed using the params argument.
• This keeps your code cleaner and automatically encodes the parameters.
• Example with a SolutionBazz-like API:

import requests

params = {"topic": "Python", "level": "easy"}
response = requests.get("https://api.solutionbazz.com/exercises", params=params)
print(response.url)  # Shows full URL with parameters

• Option 2 is possible but less maintainable, as it requires manual string formatting.
• Option 3 is incorrect because json is for sending JSON in the request body, not for query strings.
• Option 4 is incorrect because headers are for metadata like authentication, not for passing query parameters.

• When sending JSON data with the requests library, you should use the json parameter, which automatically serializes the Python dictionary to JSON and sets the Content-Type header to application/json.

• Example:

import requests

payload = {"title": "New Question"}
response = requests.post("https://api.solutionbazz.com/exercises", json=payload)
print(response.status_code)

• Option 1 is incorrect because params adds data to the query string, not the request body.

• Option 3 could work but requires manual json.dumps() and setting headers—less convenient.

• Option 4 is incorrect because headers are for metadata, not data payloads.

• Many REST APIs, including a hypothetical SolutionBazz API, return paginated data with a next field containing the URL for the next page.
• The loop in Option 1 keeps requesting new pages until next becomes None, ensuring all results are fetched.

Example:

import requests

url = "https://api.solutionbazz.com/tutorials"
while url:
    res = requests.get(url).json()
    for tutorial in res['results']:
        print(tutorial['title'])
    url = res.get('next')

• Option 2 fetches only the first page.
• Option 3 causes an infinite loop because it never updates url with next.
• Option 4 is incorrect unless the API specifically supports retrieving all results at once.

• The tags field contains a list, and indexing [0] retrieves the first element.
• Example with the SolutionBazz API:

import requests

url = "https://api.solutionbazz.com/problems/1"
res = requests.get(url).json()
print(res['tags'][0])  # Output: python

• Option 2 returns the entire list instead of just the first tag.
• Option 3 is incorrect because res is a dictionary, not a list.
• Option 4 also returns the entire list since it does not index into it.

• The timeout parameter in the requests.get() method specifies the maximum number of seconds to wait for a response before raising a requests.exceptions.Timeout error.
• Example:

import requests

try:
    r = requests.get("https://api.solutionbazz.com/users", timeout=5)
    print(r.status_code)
except requests.exceptions.Timeout:
    print("Request timed out")

• Option 2 is invalid because wait is not a recognized parameter.
• Option 3 is incorrect because setting timeout in headers does nothing—it’s a method parameter.
• Option 1 is invalid since delay is not a parameter in the requests library.

• The json parameter in requests.post() automatically serializes Python dictionaries to JSON format and sets the correct Content-Type header.
• Example:

import requests

data = {"username": "harun", "role": "developer"}
response = requests.post("https://api.solutionbazz.com/create-user", json=data)
print(response.status_code)

• Option 1 is incorrect because text is not a valid parameter for sending JSON in the body.
• Option 3 is incorrect because params sends data as query parameters, not in the request body.
• Option 4 is invalid since body is not a recognized parameter in the requests library.

• The raise_for_status() method raises an exception if the HTTP response code is 4xx or 5xx, allowing you to catch and handle errors gracefully.
• Example with a SolutionBazz-like API:

import requests

try:
    response = requests.get("https://api.solutionbazz.com/exercises/999")
    response.raise_for_status()
    print(response.json())
except requests.exceptions.HTTPError as err:
    print(f"HTTP error occurred: {err}")

• Option 1 just prints content without checking for errors.
• Option 2 manually checks status 200 but ignores other errors.
• Option 3 only prints the status code, offering no error handling.

• The PATCH method is used for partial updates to a resource in a REST API.
• Unlike PUT, which replaces the entire resource, PATCH only modifies the fields you provide.

Example:

import requests

data = {"title": "Updated Python Exercise"}
response = requests.patch("https://api.solutionbazz.com/exercises/1", json=data)
print(response.status_code)

• Option 1 (GET) retrieves data and does not modify the resource.
• Option 2 (POST) is for creating new resources.
• Option 3 (PUT) replaces the full resource instead of updating partially.

• The headers argument is used to send additional information to the server. In this case, "Authorization": "Bearer abc123" is a common way to authenticate with REST APIs.
• Without the correct headers, the SolutionBazz API might reject your request with a 401 Unauthorized error.
• This approach is also used to set content types, custom tokens, or other metadata required by the server.

Unlike query parameters or body data, headers are not part of the URL or payload—they are part of the HTTP request metadata, which the server uses to process your request correctly.

• Using response.json() attempts to parse the response as JSON. If the content is not valid JSON, it raises a ValueError, which you can catch and handle gracefully.
• This is important when working with APIs like SolutionBazz, which might occasionally return HTML error pages or plain text instead of JSON.

Example:

import requests

response = requests.get("https://api.solutionbazz.com/exercises/invalid")
try:
    data = response.json()
except ValueError:
    print("The response is not JSON!")

• Option 1 is incorrect because text() is a method call; it should be response.text and it doesn’t parse JSON.
• Option 3 (get_json()) is a Flask method, not part of requests.
• Option 4 (content()) is invalid; response.content is an attribute, not a method.

• Option 1: Invalid because requests has no remove() method. ❌
• Option 2: Incorrect; requests.get() does not accept a method argument. ❌
• Option 3: Sometimes used in APIs that override HTTP methods via POST, but not standard. ❌
• Option 4: ✅ Correct. requests.delete() sends a proper DELETE request, which is the standard way to remove a resource in REST APIs.

Example:

import requests

response = requests.delete("https://api.solutionbazz.com/exercises/1")
print(response.status_code)  # 200 or 204 if successful

• This style clearly shows why each option is right or wrong, helping beginners understand common mistakes.

• The list comprehension sends GET requests one after another, so the total time is the sum of each request.
• For multiple API calls like in SolutionBazz, using concurrent requests via concurrent.futures.ThreadPoolExecutor or asyncio can significantly speed up the process.

Example using ThreadPoolExecutor:

import requests
from concurrent.futures import ThreadPoolExecutor

urls = [
    "https://api.solutionbazz.com/exercises/1",
    "https://api.solutionbazz.com/exercises/2",
    "https://api.solutionbazz.com/exercises/3"
]

with ThreadPoolExecutor() as executor:
    responses = list(executor.map(requests.get, urls))

• Option 1 is incorrect because requests.get() can still return JSON.
• Option 3 is incorrect; requests.get() does not raise exceptions automatically unless you call raise_for_status().
• Option 4 is wrong because GET requests do not modify server data.

When interacting with REST APIs like SolutionBazz, servers often enforce rate limits to prevent overload. If your request receives a 429 status code, the best approach is to catch the error and retry after waiting for a specified time. Using time.sleep() or implementing exponential backoff ensures you don’t exceed the limit and risk being temporarily blocked. Simply ignoring the error or changing the URL does not resolve the rate-limiting issue, and adding a timeout only affects how long you wait for a response, not whether you can safely retry.

Example of handling rate limits:

import requests
import time

url = "https://api.solutionbazz.com/exercises"

for _ in range(5):
    response = requests.get(url)
    if response.status_code == 429:
        print("Rate limit exceeded, waiting...")
        time.sleep(5)  # Wait before retrying
    else:
        break

This approach ensures your script respects API usage policies while successfully retrieving the data.

When working with multiple API endpoints, making sequential HTTP requests can be very slow because each request waits for the previous one to complete. This can become a bottleneck, especially when fetching data from several endpoints on the SolutionBazz API.</p> <p>Using Python’s `asyncio` along with the `aiohttp` library allows you to make requests **concurrently**. This means multiple API calls are sent and handled in parallel, significantly reducing the total runtime and making your application much more efficient.

For example, you could use the following pattern:

import asyncio
import aiohttp

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.json()

async def main():
    urls = ["https://api.solutionbazz.com/exercises/1",
            "https://api.solutionbazz.com/exercises/2",
            "https://api.solutionbazz.com/exercises/3"]
    async with aiohttp.ClientSession() as session:
        results = await asyncio.gather(*(fetch(session, url) for url in urls))
        print(results)

asyncio.run(main())

This approach ensures faster data retrieval and better resource utilization. Sequential loops or excessive timeouts (Options 1 and 2) are inefficient, and duplicating requests (Option 4) is wasteful and could trigger rate limits.

When interacting with APIs, server errors such as 500 Internal Server Error can occur due to temporary issues on the server side. The best practice is to implement retry logic with exponential backoff, which means you wait progressively longer between retries. This reduces load on the server and increases the likelihood of a successful request.

For example, in Python you could use a loop with increasing delays:

import requests
import time

url = "https://api.solutionbazz.com/exercises"
data = {"title": "Retry Example"}

for i in range(5):
    try:
        response = requests.post(url, json=data)
        if response.status_code == 500:
            raise requests.exceptions.HTTPError("Server error")
        break
    except requests.exceptions.HTTPError:
        time.sleep(2 ** i)  # Exponential backoff

Ignoring errors or retrying immediately can overwhelm the server or fail repeatedly. Simply skipping or changing the URL does not address the root problem. Proper error handling ensures your application interacts reliably with the SolutionBazz API even under temporary server issues.

Fetching large datasets can easily overwhelm memory if you load everything at once. The requests library provides a stream=True option, which allows you to process the response incrementally as the data arrives, rather than holding the entire response in memory.

For example, using the SolutionBazz API:

import requests

url = "https://api.solutionbazz.com/large-exercises"
with requests.get(url, stream=True) as response:
    for line in response.iter_lines():
        if line:
            print(line.decode("utf-8"))

This approach is efficient and scalable for large datasets. Option 1 consumes all memory at once, which can lead to crashes. Option 2 is better than loading all at once but requires extra file I/O. Option 4 is inefficient because it still loads everything in memory first before splitting. Streaming ensures minimal memory usage while still allowing processing in real time.