200-901 Software Development and Design Practice Test 2 — 15 Questions

Question 1

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.)

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

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 2

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 3

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 4

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 5

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):

Question 6

A developer clones an internal Git repository that contains an application plus a large binary test fixture committed directly to the repository. The team wants to reduce clone size for future contributors without rewriting existing history or removing the fixture from the current commit. Which Git feature should the developer use?

Accepted Answer

Git LFS (Large File Storage). Git LFS keeps large binaries out of the main object database by storing pointer files in the repository and the real content on an LFS endpoint. This reduces clone size for future contributors while leaving existing history intact, which is exactly what the team needs without rewriting commits or deleting the fixture.

Answer

git gc --aggressive

Answer

git filter-branch

Answer

git submodule

Question 7

A developer is reviewing a Python script that uses the requests library to interact with a REST API. The script must handle HTTP errors gracefully and ensure that the connection is closed after each request. Which TWO practices should be implemented? (Choose two.)

Accepted Answer

Use a context manager with requests.Session() to ensure connections are closed.. To handle HTTP errors gracefully, raise_for_status() should be used to trigger exceptions on error status codes. To ensure connections are closed, using a Session within a context manager is the recommended approach. Together, these practices provide robust error handling and proper resource management.

Answer

Use response.close() after each request to free resources.

Answer

Set the verify parameter to False to speed up HTTPS requests.

Answer

Set a timeout value in the request to avoid hanging indefinitely.

Question 8

A developer is designing a Python class to model a network device. The class should enforce that the hostname attribute is always a string and cannot be changed after the object is created. Which approach best achieves this in Python?

Accepted Answer

Use a dataclass with frozen=True and type annotations. Using a frozen dataclass with type annotations ensures immutability and type clarity. The frozen parameter prevents attribute reassignment after creation, and the annotation hostname: str documents the intended type, which static checkers can verify. Other approaches either do not enforce immutability or add unnecessary complexity.

Answer

Define hostname as a class variable and assign it in __init__

Answer

Implement __setattr__ to allow setting hostname only once and validate it is a string

Answer

Use a property with a setter that raises AttributeError after initialization

Question 9

A developer is reviewing a Python script that manages a list of VLAN IDs. The script must remove duplicate VLAN IDs while preserving the original order in which they first appear. Which code snippet achieves this requirement?

Accepted Answer

vlan_ids = list(dict.fromkeys(vlan_ids)). The requirement is to remove duplicate VLAN IDs while preserving first-occurrence order. Using dict.fromkeys() leverages ordered dictionaries in modern Python to deduplicate in linear time without altering order. The other options either lose order, add unnecessary sorting, or use inefficient nested comparisons, so they do not meet the scenario's needs as cleanly or correctly.

Answer

vlan_ids = [v for i, v in enumerate(vlan_ids) if v not in vlan_ids[:i]]

Answer

vlan_ids = sorted(set(vlan_ids), key=vlan_ids.index)

Answer

vlan_ids = list(set(vlan_ids))

Question 10

A developer is using Git to manage source code for a network automation project. The developer has made several commits on the local master branch but now needs to create a new branch called feature/api and switch to it, while keeping the current commits on master. Which Git command accomplishes this in a single step?

Accepted Answer

git checkout -b feature/api. The command git checkout -b feature/api creates a new branch named feature/api and switches to it in a single step. This is a common Git operation. The other options either require multiple steps, use a newer command that may not be universally supported, or perform an unrelated action like merging.

Answer

git switch -c feature/api

Answer

git branch feature/api && git checkout feature/api

Answer

git merge feature/api

Question 11

A network automation team keeps its Python collector scripts and their JSON device-inventory fixtures in the same Git repository. A developer edits a fixture file and a collector script, then runs 'git status' and sees the fixture listed under 'Changes not staged for commit' while the script is not listed anywhere. Which Git concept explains why the script does not appear in the output?

Accepted Answer

The script is already tracked and its content is identical to the version in the index and HEAD, so Git has nothing to report for it.. Git's status output reflects differences among the working tree, the index, and HEAD. A tracked file that has been edited back to its committed content, or never actually changed, produces no difference and therefore no entry. The fixture appears because its content genuinely diverges from what is recorded, while the script does not.

Answer

Git only tracks file extensions it recognizes, and .py files are excluded from status reporting unless 'git add -f' is used.

Answer

The script must be listed in .gitignore, which silently suppresses any modification to a tracked file from appearing in git status.

Answer

The script has been staged, so git status moves it out of the working-tree section and hides it until the next commit is created.

Question 12

A developer is designing a Python application that must make multiple API calls to different endpoints. The calls are independent and can run concurrently to reduce total execution time. Which approach correctly uses the concurrent.futures module to execute the calls in parallel and collect results?

Accepted Answer

with ThreadPoolExecutor(max_workers=5) as executor: futures = [executor.submit(requests.get, url) for url in urls]; results = [f.result() for f in futures]. Using ThreadPoolExecutor with submit allows concurrent execution of I/O-bound HTTP requests. Each submit returns a Future, and calling result() on each Future blocks until that request completes, ensuring all responses are collected. This approach is efficient for reducing total execution time when making independent API calls, and the context manager handles thread cleanup.

Answer

with ThreadPoolExecutor(max_workers=5) as executor: futures = [executor.submit(requests.get, url) for url in urls]; results = [f.result() for f in futures if f.done()]

Answer

with ThreadPoolExecutor(max_workers=5) as executor: results = executor.map(requests.get, urls)

Answer

with ProcessPoolExecutor(max_workers=5) as executor: futures = [executor.submit(requests.get, url) for url in urls]; results = [f.result() for f in futures]

Question 13

A developer is building a Python script that interacts with a REST API that requires an OAuth 2.0 access token. The token expires every hour. The script makes multiple API calls over a long period. The developer wants to ensure the script automatically refreshes the token when it expires without manual intervention. Which approach is most appropriate?

Accepted Answer

Implement a custom requests.auth.AuthBase subclass that adds the token to requests and handles token refresh on 401 responses.. Implementing a custom AuthBase subclass for requests is the most elegant and robust way to handle OAuth 2.0 token refresh. It centralizes token management, automatically adds the token to requests, and can refresh on 401 errors. This approach is maintainable and integrates well with the requests library, unlike global variables, fixed sleeps, or per-call token requests.

Answer

Create a new session for each API call and request a new token each time.

Answer

Use a while loop that continuously makes API calls and sleeps for one hour, then refreshes the token.

Answer

Store the token in a global variable and check its expiration time before each API call, refreshing if necessary.

Question 14

A developer writes a Python script to read a configuration file. Which code snippet correctly opens the file 'config.json' for reading and ensures the file is closed after use?

Accepted Answer

with open('config.json', 'r') as f:
    data = f.read(). It uses the `with` statement, which is a context manager that automatically calls `f.close()` when the block exits, ensuring the file is properly closed even if an exception occurs. The `'r'` mode opens the file for reading, and `f.read()` reads the entire contents into the `data` variable.

Answer

open('config.json', 'r') as f:
    data = f.read()

Answer

with open('config.json', 'r') as f, data = f.read()

Answer

file = open('config.json', 'r')
data = file.read()
file.close()

Question 15

A network automation script uses the requests library to retrieve device information from a REST API. The API requires authentication via a bearer token. Which code example correctly sets the Authorization header?

Accepted Answer

headers = {'Authorization': 'Bearer ' + token}
response = requests.get(url, headers=headers). It constructs the Authorization header using the 'Bearer' scheme, which is the standard method for passing OAuth 2.0 bearer tokens in HTTP requests. The requests library requires the header to be explicitly set as a dictionary, and the token must be prefixed with 'Bearer ' to comply with RFC 6750.

Answer

headers = {'Authorization': 'Token ' + token}
response = requests.get(url, headers=headers)

Answer

response = requests.get(url, headers={'Authorization': token})

Answer

response = requests.get(url, auth=('Bearer', token))