200-901 Software Development and Design Practice Test 1 — 15 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?

Choose an answer to begin — your selection is scored in the full session.

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