PCPP1 Networking And Restful Apis — Timed 20 Questions

Question 1

You are parsing a JSON response that contains a large list of objects. Which technique is most memory-efficient for processing these objects?

Accepted Answer

Iterate through the list object after parsing. If you have control over the response, streaming the JSON or processing it iteratively (if supported by the parser) saves memory.

Answer

Convert the entire JSON to a string then split

Answer

Use the 'json.loads()' method on the full response

Answer

Use a custom regex to parse the JSON

Question 2

You are writing a Python client that sends a POST request with a JSON body to a REST endpoint using the requests library. The server requires basic authentication credentials and expects the response in JSON format. You want to ensure the request uses HTTP Basic Auth and automatically parses the JSON response. Which code snippet correctly accomplishes this?

Accepted Answer

requests.post(url, json=data, auth=('user', 'pass')).json(). The requests library provides a high-level interface for HTTP. Using the json parameter automatically serializes the data and sets the Content-Type header to application/json. The auth parameter accepts a tuple for HTTP Basic Auth. The response's .json() method parses the JSON content into Python objects. Combining these features yields a concise and correct implementation.

Answer

requests.post(url, data=data, auth=('user', 'pass')).json()

Answer

requests.post(url, json=data, auth=('user', 'pass'), headers={'Accept': 'application/json'}).text

Answer

requests.post(url, data=json.dumps(data), headers={'Authorization': 'Basic user:pass'}).json()

Question 3

You are building a Python application that interacts with a REST API. The API requires you to send a GET request with query parameters for filtering results. You decide to use the 'requests' library. Which of the following code snippets correctly sends a GET request to 'https://api.example.com/items' with the query parameters 'category=books' and 'limit=10'?

Accepted Answer

requests.get('https://api.example.com/items', params={'category': 'books', 'limit': 10}). The correct way to send query parameters in a GET request with 'requests' is to use the 'params' argument, which takes a dictionary and properly encodes it into the URL. This method handles special characters and ensures the parameters are sent as part of the query string, which is the standard for filtering and pagination in REST APIs.

Answer

requests.get('https://api.example.com/items', data={'category': 'books', 'limit': 10})

Answer

requests.get('https://api.example.com/items', json={'category': 'books', 'limit': 10})

Answer

requests.get('https://api.example.com/items?category=books&limit=10')

Question 4

You are writing a Python client that must call a REST API which sometimes returns HTTP 429 (Too Many Requests) with a 'Retry-After' header. Your current code uses requests.get() and raises an exception on any 4xx status. You need to automatically wait for the server-specified interval and retry the request up to three times. Which approach correctly implements this behavior?

Accepted Answer

Check the response status code; if it is 429, read the Retry-After header, convert it to a number of seconds, call time.sleep() with that value, and loop up to three times before giving up.. The correct approach reads the Retry-After header, sleeps for the specified duration, and retries the request a limited number of times. This respects the server's rate-limiting policy and is a standard pattern for handling 429 responses. Fixed delays or relying on default adapter retries do not guarantee compliance with the header and may lead to repeated failures or unnecessary delays.

Answer

Use requests.get() with the timeout parameter set to the value of Retry-After, and catch requests.exceptions.Timeout to trigger a retry.

Answer

Configure a requests.Session() with an HTTPAdapter that has max_retries set to 3, and rely on urllib3's built-in handling of Retry-After for 429 responses.

Answer

Use a try/except block around requests.get(), and in the except clause call time.sleep(5) before retrying, ignoring the Retry-After header.

Question 5

You are writing a Python client that consumes a REST API. The API documentation states that the server returns a JSON object with a top-level key 'items', but for a specific endpoint the response body is an empty JSON object '{}'. You need to distinguish between a missing 'items' key and a present but empty list. Which approach correctly handles this without raising an exception?

Accepted Answer

Use response.json().get('items', []) and then check if the result is an empty list.. The .get() method with a default value safely retrieves the value for a key and returns the default if the key is absent. In this scenario, using .get('items', []) ensures that a missing key results in an empty list, and a present key returns its actual value, whether that is an empty list or a populated one. This approach avoids exceptions and provides a consistent type for further processing.

Answer

Access response.json()['items'] directly and catch a KeyError to set a flag.

Answer

Use response.json().get('items') and then check if the result is None.

Answer

Check if 'items' in response.json() and then access it, else use None.

Question 6

You are developing a Python script that retrieves data from a REST API using the 'requests' library. The API returns JSON responses, but occasionally the server responds with a 500 Internal Server Error and an HTML error page. Your script must handle these errors gracefully by logging the status code and not crashing. Which of the following approaches is most appropriate for robust error handling?

Accepted Answer

Use a try-except block around the request and check response.status_code.. Robust error handling with 'requests' involves both catching exceptions for transport-level failures and checking the HTTP status code for application-level errors. A try-except block around the request call handles exceptions like timeouts or connection errors, while inspecting 'response.status_code' allows you to log and respond to server errors such as 500. This dual approach ensures the script does not crash and provides useful diagnostics.

Answer

Check if response.ok is False and then log the error.

Answer

Use requests.get() with a timeout and ignore any exceptions.

Answer

Call response.raise_for_status() and catch requests.exceptions.HTTPError.

Question 7

You are developing a Python application that must send a large file to a REST API using the 'requests' library. The server expects the file to be streamed to avoid high memory usage on the client. Which method should you use to achieve this?

Accepted Answer

Pass a generator that yields chunks of the file as the 'data' parameter to requests.post().. To stream a large file upload with requests, you should provide an iterable or generator as the 'data' parameter. This allows requests to send the file in chunks as they are generated, avoiding loading the entire file into memory. This method is efficient for large files and is the correct way to achieve streaming on the client side.

Answer

Use the 'files' parameter with a file object opened in binary mode to requests.post().

Answer

Set the 'stream' parameter to True in requests.post() and pass the file object as 'data'.

Answer

Pass a file object opened in binary mode as the 'data' parameter to requests.post().

Question 8

You are building a Python client that consumes a REST API which returns JSON. You want to handle common error responses gracefully. Which TWO of the following are correct practices when using the requests library to process an API response? (Choose two.)

Accepted Answer

Check response.status_code against expected values and handle each case accordingly.. The correct practices are to call raise_for_status() to raise an exception for 4xx/5xx responses, and to explicitly check the status code to handle different cases. These approaches ensure that errors are detected and can be handled appropriately. Relying on response.json() alone or assuming automatic exceptions can lead to missed errors.

Answer

Use response.json() without checking the status code, because it will raise an exception if the response is not valid JSON.

Answer

Use response.ok to determine if the request was successful, and if not, access response.content to get the error message.

Answer

Rely on the default behavior of requests, which automatically raises an exception for any non-2xx response.

Question 9

You are designing a REST API client in Python that must handle HTTP redirects and authentication. The API uses OAuth 2.0 with bearer tokens and may redirect to a different host for authentication. You need to configure the 'requests' library to follow redirects, preserve the Authorization header across redirects, and handle token refresh. Which two of the following approaches are correct? (Choose two.)

Accepted Answer

Set 'allow_redirects=True' in the request and use a custom 'requests.Session' with an 'auth' object that handles token refresh.. The correct approaches involve using a Session with a custom auth object that can refresh tokens and re-add headers, or subclassing AuthBase to override redirect handling. Both ensure the Authorization header is preserved across redirects, including to different hosts, and support token refresh. These methods integrate with requests' built-in redirect following and provide a robust solution for OAuth 2.0 bearer token authentication.

Answer

Use 'requests.get()' with 'allow_redirects=False' and manually handle each redirect by inspecting the 'Location' header and re-sending the request with the Authorization header.

Answer

Set the 'Authorization' header directly on the request and rely on requests to automatically forward it on redirects to the same host.

Answer

Use a 'requests.Session' and set 'session.max_redirects' to a high value, then set the 'Authorization' header on the session.

Question 10

You are using the `requests` library to interact with a REST API. The API returns JSON data, and you need to extract a specific value from a nested structure. After calling `response = requests.get(url)`, which line of code correctly parses the JSON response and accesses the value of the key 'name' inside the 'user' object?

Accepted Answer

data = response.json(); name = data['user']['name']. The `requests` library provides the `response.json()` method to parse JSON content into Python dictionaries and lists. Once parsed, nested values are accessed using dictionary indexing with square brackets. The other options either use incorrect attribute access on dictionaries or unnecessarily use `json.loads` on `response.text` instead of the built-in `response.json()`.

Answer

data = response.json(); name = data.user.name

Answer

data = response.json(); name = data['user'].name

Answer

data = json.loads(response.text); name = data['user']['name']

Question 11

You are building a Python REST API client that needs to send a JSON payload in a POST request using the `requests` library. The API expects the JSON data to be properly serialized and the `Content-Type` header set to `application/json`. Which code snippet correctly accomplishes this?

Accepted Answer

requests.post(url, json={'key': 'value'}). The `requests` library provides a `json` parameter for POST requests that automatically serializes the given data to JSON and sets the `Content-Type` header to `application/json`. Using `data` sends form-encoded data, `params` appends query parameters, and manual serialization with `json.dumps` is unnecessary and less clean. Thus, the `json` parameter is the correct choice.

Answer

requests.post(url, data=json.dumps({'key': 'value'}), headers={'Content-Type': 'application/json'})

Answer

requests.post(url, params={'key': 'value'})

Answer

requests.post(url, data={'key': 'value'})

Question 12

When working with raw sockets, what does the 'socket.SOCK_STREAM' constant represent?

Accepted Answer

TCP connection-oriented sockets. socket.SOCK_STREAM designates a reliable, connection-oriented byte stream, which in practice maps to TCP (or a Unix-domain stream socket). The Python socket module passes this constant to socket() to select the transport semantics, so SOCK_STREAM sockets guarantee ordered, error-checked delivery via the TCP three-way handshake. This is why HTTP, SMTP, and SSH clients built on Python sockets use SOCK_STREAM.

Answer

UDP datagram sockets

Answer

Raw network sockets

Answer

Unix domain sockets only

Question 13

You are using the socket module to create a TCP client. After creating the socket object, which method call is required to establish a connection to a remote server listening on 192.168.1.50 at port 8080?

Accepted Answer

sock.connect(('192.168.1.50', 8080)). For a TCP client socket, after creating the socket with socket.socket(socket.AF_INET, socket.SOCK_STREAM), the connect() method is what initiates the TCP three-way handshake with the remote server. Passing a tuple of (host, port) — here ('192.168.1.50', 8080) — tells the OS to open a connection to that endpoint. This is the client-side counterpart to the server's bind/listen/accept sequence.

Answer

sock.bind(('192.168.1.50', 8080))

Answer

sock.accept()

Answer

sock.listen(1)

Question 14

You are consuming a REST API that returns data in JSON format. After calling response.json(), you notice the data contains nested dictionaries. What is the most Pythonic way to handle a missing key in the response dictionary safely?

Accepted Answer

Use response.json().get('key', default_value). The dict.get() method provides a way to access a key with a default value if the key does not exist, preventing a KeyError.

Answer

Wrap the access in a try-except KeyError block

Answer

Check 'if 'key' in response.json():' before access

Answer

Use response.json()['key'] and assume the API schema is always correct

Question 15

When using the 'socket' module, what is the effect of calling 'socket.settimeout(5.0)' on a socket object?

Accepted Answer

It causes the operation to raise a socket.timeout after 5 seconds. The settimeout() method sets a timeout in seconds for subsequent socket operations. If the operation does not complete within the time, a socket.timeout exception is raised.

Answer

It sets the send buffer size to 5.0 bytes

Answer

It blocks the thread for exactly 5 seconds

Answer

It forces the socket to close after 5 seconds of inactivity

Question 16

In the 'requests' library, which HTTP method is typically used to update an existing resource on a server?

Accepted Answer

PUT. The PUT method is standard for replacing or updating an existing resource at a specific URI.

Answer

POST

Answer

GET

Answer

DELETE

Question 17

You are building a REST client that needs to handle 429 Too Many Requests status codes. Which strategy is most effective when implementing an automatic retry mechanism?

Accepted Answer

Implement an exponential backoff strategy with jitter. Implementing exponential backoff ensures that you do not overwhelm the server while waiting for the rate limit to reset.

Answer

Switch to a different base URL immediately

Answer

Ignore 429 errors and continue execution

Answer

Retry immediately in a loop until successful

Question 18

When using the 'requests' library to perform a GET request, which parameter should be passed to the 'params' argument to include query string parameters in the URL?

Accepted Answer

A dictionary. The requests library's params argument accepts a dictionary (or list of tuples) that it URL-encodes and appends as a query string. Passing a dict like {'q': 'python', 'page': 2} produces ?q=python&page=2 automatically. This is the idiomatic and documented usage for GET query parameters.

Answer

A tuple of values

Answer

A single formatted string

Answer

A list of strings

Question 19

You are developing a multithreaded HTTP scraper. When using the 'requests' library inside 'threading.Thread' objects, what is the recommended practice for handling session persistence?

Accepted Answer

Initialize a new Session object inside each thread's run method. The requests.Session object is not thread-safe because it maintains shared state such as cookies, connection pools, and headers. Initializing a new Session inside each thread's run method ensures each thread has its own isolated session, avoiding race conditions and data corruption. This is the recommended practice for multithreaded scraping with requests.

Answer

Wrap the session object in a threading.Lock

Answer

Share a single global Session object across all threads

Answer

Disable connection pooling using 'pool_connections=0'

Question 20

When using 'requests.get()', how can you include a custom HTTP header in your request?

Accepted Answer

Use the 'headers' dictionary argument. The 'headers' parameter accepts a dictionary of HTTP headers.

Answer

Use the 'data' argument

Answer

Pass it as part of the URL string

Answer

Use the 'params' dictionary