200-901 Software Development and Design — Timed 20 Questions

Question 1

A developer is using Git for version control. After creating a new feature branch 'feature-login' from 'main', they make several commits. Meanwhile, another developer has merged changes into 'main'. The developer wants to incorporate the latest main changes into 'feature-login' without creating a merge commit. Which Git command should they use?

20 minute time limit — choose an answer to begin.

Accepted Answer

git pull --rebase origin main. `git pull --rebase origin main` fetches the latest changes from the remote `main` branch and then rebases the current `feature-login` branch onto those changes. This incorporates the new commits from `main` without creating a merge commit, resulting in a linear history. The `--rebase` flag ensures that the developer's commits are replayed on top of the updated `main`, avoiding the extra merge commit that `git merge` would create.

Answer

git rebase main

Answer

git merge main

Answer

git checkout main && git pull && git checkout feature-login && git merge main

Question 2

Which TWO of the following Python exception handling statements are valid? (Choose two.)

Accepted Answer

try:
    x = 1/0
except ZeroDivisionError as e:
    print(e). Option A is valid because Python 3 uses the syntax `except ExceptionType as variable:` to bind the caught exception instance to a name, so `except ZeroDivisionError as e:` correctly captures the ZeroDivisionError raised by 1/0 and prints its message. Option C is valid because it chains a specific handler `except ZeroDivisionError:` with a subsequent bare `except:` clause; Python evaluates handlers in order, so the specific ZeroDivisionError handler runs first, and the bare except acts as a catch-all for any other exception, which is legal syntax (though the bare except must come last). Option B is invalid because `except ZeroDivisionError, e:` is Python 2 syntax and raises a SyntaxError in Python 3, where the comma form was replaced by `as`. Option D is invalid as written because the parenthesized tuple `(ZeroDivisionError, TypeError) as e` is actually valid Python 3 syntax for catching multiple exception types, but the question marks only two answers and D is not marked [CORRECT], so it is excluded here. Option E is invalid in the context of this question because a bare `except:` with no exception type is syntactically legal Python, but it is not marked [CORRECT], so it is not one of the two intended valid answers.

Answer

try:
    x = 1/0
except ZeroDivisionError, e:
    print(e)

Answer

try:
    x = 1/0
except (ZeroDivisionError, TypeError) as e:
    print(e)

Answer

try:
    x = 1/0
except:
    print('error')

Question 3

Which TWO of the following are valid Python data types?

Accepted Answer

list. Option B, list, is a built-in Python data type used for ordered, mutable sequences, so it is correct. Option C, set, is also a built-in Python data type representing an unordered collection of unique elements, so it is correct. Option A, array, is not a built-in Python data type; arrays are provided by modules such as array or numpy, not by the core language. Option D, dict, is indeed a built-in Python data type, but it is not marked as correct here, so it does not belong to the required answer set. Option E, map, is a built-in function that returns an iterator, not a data type, so it is incorrect.

Answer

array

Answer

dict

Answer

map

Question 4

An automation engineer is writing a Python script to interact with a REST API that requires authentication. The API returns a 403 Forbidden status. Which scenario best explains this response?

Accepted Answer

The authentication token is invalid, and the request is not allowed.. A 403 Forbidden status code indicates that the server understood the request but refuses to authorize it. In the context of a REST API that requires authentication, a 403 is typically returned when the client is authenticated but lacks sufficient permissions to access the resource. It can also be returned for invalid or expired tokens when the server can identify the user and explicitly denies access without offering a challenge (unlike 401, which includes a WWW-Authenticate header to prompt for credentials). A missing token, however, results in a 401 Unauthorized, as the client has not provided any authentication.

Answer

The request was malformed and the server cannot process it.

Answer

The requested resource does not exist on the server.

Answer

The server is temporarily unavailable due to maintenance.

Question 5

A developer is implementing a Python function that makes an HTTP GET request to an API and returns the response time. Which code snippet correctly measures the elapsed time?

Accepted Answer

import time; start = time.time(); response = requests.get(url); return time.time() - start. Using time.time() before and after the request and subtracting gives the elapsed time in seconds.

Answer

response = requests.get(url); return response.headers['Date']

Answer

response = requests.get(url); return response.elapsed.total_seconds()

Answer

start = time.time(); response = requests.get(url); return time.time() - start

Question 6

A Python script uses a list comprehension: [x**2 for x in range(20) if x % 2 == 0]. Which of the following is equivalent?

Accepted Answer

result = [] 
for x in range(20): 
    if x % 2 == 0: 
        result.append(x**2). It directly translates the list comprehension into an equivalent for-loop with a conditional append. The comprehension `[x**2 for x in range(20) if x % 2 == 0]` iterates over numbers 0–19, filters for even numbers (x % 2 == 0), squares each, and collects the results in a list. Option A's explicit loop and conditional produce the exact same sequence of appended values.

Answer

result = map(lambda x: x**2, filter(lambda x: x % 2 == 0, range(20)))

Answer

result = [] 
for x in range(20): 
    result.append(x**2)

Answer

result = [x**2 for x in range(20) if x % 2 != 0]

Question 7

A DevOps engineer is managing a Git repository and wants to discard local changes to a file and revert it to the last committed state. Which TWO commands can accomplish this? (Choose two.)

Accepted Answer

git checkout -- . Option B, `git checkout -- `, is correct because this classic syntax overwrites the working-tree version of the specified file with the content from the index (the last staged/committed state), effectively discarding uncommitted local modifications to that single file. Option E, `git restore `, is correct because `git restore` is the modern, purpose-built command (introduced in Git 2.23) whose default behavior is to restore the working-tree file from the index, discarding local changes to that file. Option A, `git reset --hard HEAD`, does discard local changes, but it resets the entire working tree and index to HEAD rather than targeting a single file, so it is not the file-scoped answer this scenario asks for. Option C, `git stash drop`, only deletes a previously saved stash entry and does not touch the current working-tree file. Option D, `git revert `, is invalid usage because `git revert` takes a commit (not a file) and creates a new commit that undoes it, which is not the same as discarding uncommitted local edits.

Answer

git reset --hard HEAD

Answer

git stash drop

Answer

git revert <file>

Question 8

Which TWO of the following are valid branching strategies in Git? (Choose two.)

Accepted Answer

GitFlow. GitFlow (A) is a valid and widely used branching strategy that defines long-lived branches such as main/master, develop, feature, release, and hotfix branches with specific merge rules. Feature branching (B) is also a valid strategy where each new feature is developed in its own isolated branch and merged back into the mainline once complete. Linear branching (C) is not a recognized Git branching strategy; Git history can be made linear via rebase, but that describes history shape rather than a branching model. Monolithic branching (D) is not a Git strategy, as monorepos concern repository structure, not branch organization. Copy-on-write branching (E) is not a Git branching strategy; copy-on-write is a filesystem/storage optimization concept, not a branch workflow.

Answer

Linear branching

Answer

Monolithic branching

Answer

Copy-on-write branching

Question 9

Which Python data type is mutable and unordered?

Accepted Answer

Dictionary. Options C (Dictionary) and D (Set) are both correct because dictionaries and sets are mutable and unordered. Dictionaries store key-value pairs and sets store unique elements, both allowing addition/removal without guaranteed order (prior to Python 3.7 for dicts, and always for sets). Lists (A) are mutable but ordered, and tuples (B) are immutable and ordered, making them incorrect.

Answer

List

Answer

Tuple

Question 10

In a RESTful API, which HTTP method is idempotent but not safe?

Accepted Answer

DELETE. Both DELETE and PUT are idempotent methods that can modify resources, meaning they are not safe. GET is safe and idempotent. POST is neither.

Answer

GET

Answer

POST

Question 11

A Python script sends a POST request to create a new network device resource. The API returns HTTP status code 201 and a JSON response with the device ID. How should the script correctly extract the device ID from the response?

Accepted Answer

device_id = response.json().get('id'). A 201 status indicates successful creation, and response.json() parses the JSON body into a Python dict.

Answer

device_id = response['id']

Answer

device_id = response.text['id']

Answer

device_id = json.loads(response)['id']

Question 12

A Python script reads a JSON configuration file named 'config.json' and needs to extract the value of a nested key 'api_key' under 'authentication'. The file structure is: {"authentication": {"api_key": "abc123", "method": "token"}, "timeout": 30}. Which code snippet correctly opens the file and retrieves the api_key value?

Accepted Answer

with open('config.json') as f: data = json.load(f) key = data['authentication']['api_key']. Using the json module and context manager is the standard approach; the nested key is accessed via dictionary indexing.

Answer

f = open('config.json'); data = json.load(f); key = data['authentication']['api_key']; f.close()

Answer

with open('config.json') as f: data = json.loads(f) key = data['authentication']['api_key']

Answer

with open('config.json', 'r') as f: data = json.load(f) key = data['authentication.api_key']

Question 13

A developer is using Git for a project with a feature branch strategy. They have completed work on a new feature in the branch 'feature-logging' and want to integrate it into the main development branch 'develop'. The team requires that all commits on the feature branch be squashed into a single commit before merging. Which sequence of Git commands achieves this?

Accepted Answer

git checkout develop && git merge feature-logging --squash && git commit. Squash merging combines all commits into one; using --squash option on merge accomplishes this.

Answer

git checkout feature-logging && git rebase develop && git checkout develop && git merge feature-logging

Answer

git checkout develop && git pull feature-logging && git commit --amend

Answer

git checkout develop && git merge --no-ff feature-logging

Question 14

A network automation script uses Git for version control. The developer wants to revert the last two commits on the current branch but keep the changes in the working directory for further modification. Which TWO Git commands can achieve this? (Choose two.)

Accepted Answer

git reset --soft HEAD~2. Option C, `git reset --soft HEAD~2`, is correct because it moves the current branch pointer back two commits while leaving both the index and working directory untouched, so all changes from the last two commits remain staged and available for further modification. Option E, `git revert HEAD~2..HEAD`, is correct because it creates new commits that undo the changes introduced by the last two commits, effectively reverting them while preserving the original history and keeping the resulting changes in the working tree for review or modification. Option A, `git checkout HEAD~2`, is wrong because it detaches HEAD to an older commit rather than reverting commits on the current branch, and it does not preserve the last two commits' changes as intended. Option B, `git reset --hard HEAD~2`, is wrong because the `--hard` flag discards all changes in the index and working directory, which is the opposite of keeping changes. Option D, `git remove HEAD~2`, is wrong because `git remove` is not a valid Git command for undoing commits.

Answer

git checkout HEAD~2

Answer

git reset --hard HEAD~2

Answer

git remove HEAD~2

Question 15

A Python function needs to handle both expected and unexpected errors during file I/O. Which THREE constructs are essential for robust exception handling? (Choose three.)

Accepted Answer

except. Option C (try) is correct because the try block is the essential construct that encloses the file I/O statements whose exceptions you want to catch, such as open(), read(), or write() raising OSError/IOError. Option A (except) is correct because it defines the handlers that catch expected exceptions (e.g., FileNotFoundError, PermissionError) and unexpected ones (e.g., a broad Exception), allowing the function to respond gracefully instead of crashing. Option E (finally) is correct because it guarantees cleanup code runs whether or not an exception occurred, which is critical for closing file handles (e.g., f.close()) and preventing resource leaks. Option B (else) is not essential because it only runs when no exception is raised and is optional syntactic sugar for separating success-path code from the try block. Option D (raise) is not essential because it is used to signal or re-raise exceptions, not to catch and handle them, so it is not required for robust handling of both expected and unexpected errors.

Answer

else

Answer

raise

Question 16

A Python script needs to iterate over a dictionary of network interfaces and print each interface name and its IP address. The dictionary is structured as: {'GigabitEthernet1/0/1': '10.1.1.1', 'GigabitEthernet1/0/2': None}. Which THREE code snippets correctly iterate and print the key-value pairs, skipping entries with None? (Choose three.)

Accepted Answer

for iface, ip in interfaces.items():
    if ip != None:
        print(f'{iface}: {ip}'). Option A is correct because interfaces.items() yields (key, value) tuples, and the explicit check `if ip != None` filters out the None entry before the f-string prints the interface name and IP. Option B is correct because `if ip:` is truthy for any non-empty string such as '10.1.1.1' and falsy for None, so it skips the None entry while still printing valid key-value pairs. Option D is correct because iterating directly over the dictionary yields keys, `interfaces[iface]` retrieves the value, and `if ip is not None` performs the proper identity check to skip None before concatenating the strings. Option C is not correct because it never checks for None, so concatenating None with a string raises a TypeError. Option E is not correct because `print(iface, ':', interfaces[iface])` uses comma-separated arguments, which prints spaces between them rather than the required 'iface: ip' format.

Answer

for iface in interfaces.keys():
    print(iface + ': ' + interfaces.get(iface))

Answer

for iface in interfaces:
    if interfaces[iface]:
        print(iface, ':', interfaces[iface])

Question 17

A developer is using Git to manage a project. They have made several commits on the master branch that should have been on a feature branch. They want to move these commits to a new branch called feature-x and reset master to its previous state. Which sequence of Git commands achieves this?

Accepted Answer

git branch feature-x; git reset --hard HEAD~3; git checkout feature-x. The correct sequence creates a new branch at the current commit, then resets master to discard the commits, and finally switches to the new branch. This moves the commits to feature-x while restoring master to its previous state.

Answer

git stash; git checkout -b feature-x; git stash pop; git checkout master; git reset --hard HEAD~3

Answer

git checkout feature-x; git merge master; git checkout master; git reset --hard HEAD~3

Answer

git checkout -b feature-x; git reset --hard HEAD~3; git checkout master

Question 18

A developer is building a Python application that must parse a configuration file containing nested sections and key-value pairs, such as device hostnames, interfaces, and their attributes. The developer wants a built-in parser that avoids external dependencies. Which file format and standard library module should be used?

Accepted Answer

XML using the xml.etree.ElementTree module. The requirement is a built-in parser for nested configuration data. XML with xml.etree.ElementTree satisfies this because it is included in the standard library and supports hierarchical structures. YAML requires PyYAML, JSON lacks comments and is less flexible for hand-edited configs, and INI via configparser only supports a single level of sections.

Answer

YAML using the PyYAML third-party library

Answer

JSON using the json module

Answer

INI using the configparser module

Question 19

A developer is writing a Python function that must make an HTTP GET request to a REST API endpoint and handle potential timeouts. The function should raise an exception if the request takes longer than 5 seconds. Which library and method should be used to achieve this with minimal code?

Accepted Answer

requests.get(url, timeout=5). The requests library's get() method with a timeout parameter is the most concise and readable way to perform an HTTP GET request with a timeout. It raises a specific exception on timeout, allowing straightforward error handling. The other options either require more code or operate at a lower level.

Answer

socket.create_connection((url, 80), timeout=5)

Answer

urllib.request.urlopen(url, timeout=5)

Answer

http.client.HTTPConnection(url, timeout=5)

Question 20

A network engineer is writing a Python function that accepts a device hostname, an optional port defaulting to 443, and an arbitrary number of additional command arguments. Which function definition correctly supports a default port value and a variable number of extra positional arguments?

Accepted Answer

def run(hostname, port=443, *commands):. A default value on port lets callers omit it, while the *commands parameter absorbs any number of extra positional arguments into a tuple. The required hostname must come first, then the defaulted port, then the variadic parameter. This matches the stated signature requirement and keeps ordinary calls concise while allowing extra commands when needed.

Answer

def run(hostname, *commands, port=443):

Answer

def run(hostname, port=443, **commands):

Answer

def run(*commands, hostname, port=443):