PCPP1 Practice Questions

Connection-oriented communication, such as the Transmission Control Protocol (TCP), establishes a dedicated connection or session before any data is sent. This process, often called a handshake, ensures that both ends are ready to communicate. A traditional phone call is a classic real-world analogy: a connection is established when the call is answered and maintained until one party hangs up. In the TCP/IP client-server model, the client is the party that actively initiates the connection request to a server, which passively listens for and accepts such requests.

B. Connectionless communications are usually built on top of UDP (User Datagram Protocol), not TCP. TCP is the canonical example of a connection-oriented protocol.

C. Using walkie-talkies is an example of connectionless communication. A user transmits without first establishing a dedicated session, broadcasting to any device listening on the same frequency.

1. Kurose, J. F., & Ross, K. W. (2017). Computer Networking: A Top-Down Approach (7th ed.). Pearson.

Section 2.1.2, "The Client-Server Architectural Model": "In the client-server architecture, there is an always-on host, called the server, which services requests from many other hosts, called clients." This supports option A.

Section 3.2, "Connection-Oriented versus Connectionless Service": The text explicitly uses the analogy of a telephone call for connection-oriented service and the postal service for connectionless service. This supports option D and refutes C.

Section 3.5, "Connection-Oriented Transport: TCP": This section details TCP as the primary connection-oriented protocol of the Internet, which directly contradicts option B.

2. Postel, J. (Ed.). (1981). RFC 793: Transmission Control Protocol. IETF.

Section 3.3, "Connection Establishment": "To establish a connection, one TCP sends a SYN segment... The other TCP, if it is in a LISTEN state, will see the incoming SYN... and will return a SYN acknowledgment." This document formally defines the connection establishment process where an initiator (client) connects to a listener (server), supporting option A.

3. Python Software Foundation. Python 3.12.3 Documentation, "socket — Low-level networking interface".

Section "Module contents": The documentation specifies socket.SOCKSTREAM for connection-oriented protocols (like TCP) and socket.SOCKDGRAM for connectionless protocols (like UDP). This distinction reinforces why option B is incorrect.

The Python sqlite3 module implements the DB-API 2.0 specification (PEP 249). In this API, database operations are performed using a Cursor object. The Cursor.execute() method is used to execute a single SQL statement. After executing a SELECT query, data is retrieved using fetch methods. The Cursor.fetchone() method retrieves the next available row from the result set. If no more rows are available to be fetched, it returns None, signaling the end of the result set.

A. The sqlite3.Cursor object does not have a method named fetchalt. The fetchall() method returns an empty list ([]), not None, when no rows are available.

B. The execute() method is designed to execute only one SQL statement at a time. For executing multiple statements, the non-standard executescript() method must be used.

1. Python 3 Documentation, sqlite3 — DB-API 2.0 interface for SQLite databases:

Section 13.13.4.2. Cursor Objects: States that Cursor.execute(sql[, parameters]) executes an SQL statement. This validates option C.

Section 13.13.4.2. Cursor Objects: Describes Cursor.fetchone() as: "Fetches the next row of a query result set, returning a single tuple, or None when no more data is available." This validates option D.

Section 13.13.4.2. Cursor Objects: Describes Cursor.fetchall() as: "Fetches all (remaining) rows of a query result, returning a list." This confirms an empty list is returned for no rows, invalidating the premise of option A.

Section 13.13.4.2. Cursor Objects: Describes Cursor.executescript() as the method for executing multiple SQL statements, which invalidates option B.

2. PEP 249 -- Python Database API Specification v2.0:

Cursor Objects Section: The specification mandates that cursor objects must have an execute() method, confirming option C.

fetchone() Method Description: The specification requires that fetchone() "return a single sequence, or None when no more data is available," which directly supports option D.

The code uses the csv.DictWriter class to write data from a list of dictionaries to a CSV file. The fieldnames parameter in the csv.DictWriter constructor specifies the header and the order of columns. The writer.writeheader() method writes the specified fieldnames ('color', 'hex') as the first line of the file. Subsequently, the writer.writerows(colors) method iterates through the colors list. For each dictionary, it extracts the values corresponding to the keys in fieldnames and writes them as a comma-separated row. This process results in the header color,hex, followed by the data rows red,#FF0000 and green,#00FF00.

A: DictWriter writes the dictionary values in the order specified by fieldnames, not the string representation of the dictionary objects themselves.

C: The csv module writes the contents as plain, comma-separated text, not as the string representation of Python list objects with brackets and quotes.

D: The code is syntactically correct and uses the csv module's DictWriter as intended. The keys in the data dictionaries match the fieldnames, so no exception will be raised.

1. Python Software Foundation. (2023). csv — CSV File Reading and Writing. Python 3.11.5 documentation.

Section 14.1.3. Writer Objects: The documentation for csv.DictWriter states, "Create an object which operates like a regular writer but maps dictionaries onto output rows. The fieldnames parameter is a sequence of keys that identify the order in which values in the dictionary... are written."

Section 14.1.3. DictWriter.writeheader(): "Write a row with the field names (as specified in the constructor) to the writer’s file object..."

Section 14.1.3. DictWriter.writerows(): "Write all elements in rows (an iterable of dict objects...) to the writer’s file object..."

This confirms that the header is written first, followed by rows constructed from the dictionary values.

2. Van Rossum, G., & Drake, F. L. (2009). The Python Language Reference Manual. Python Software Foundation.

Section 6.11. The with statement: The use of with open(...) ensures the file is properly closed after its suite finishes, which is standard best practice for file operations shown in the code. This supports the conclusion that the code will run to completion without error.

The sqlite3 module is Python's built-in interface for the SQLite database engine. It is designed to be compliant with the Python Database API Specification 2.0 (PEP 249), which standardizes how Python programs interact with databases. This compliance ensures a consistent API for developers. As part of this specification, the cursor.fetchall() method is required to fetch all remaining rows from a query result. If the query yields no rows, or all rows have already been fetched, the method correctly returns an empty list ([]), providing a predictable way to handle empty result sets.

B. The special filename required to create an in-memory SQLite database is the string ":memory:", not "memory". The leading colon is mandatory.

C. The sqlite3 module fully supports database transactions through the Connection object's commit() and rollback() methods, which are essential for ensuring data integrity.

1. Python 3 Documentation, sqlite3 — DB-API 2.0 interface for SQLite databases.

For A: Section 13.13, Introduction. "This module provides a DB-API 2.0 compliant interface to the SQLite database."

For B: Section 13.13.2.1, sqlite3.connect(). "To use the database in RAM, specify :memory: for database."

For C: Section 13.13.3.2, Connection.commit(). This documents the method for committing the current transaction, confirming transaction support.

For D: Section 13.13.4.5, Cursor.fetchall(). The description states it "fetches all (remaining) rows of a query result, returning a list." This implies an empty list if no rows are available.

2. PEP 249 -- Python Database API Specification v2.0.

For A: Section "Introduction". The entire document specifies the interface that modules like sqlite3 implement.

For D: Section "Cursor Objects", .fetchall(). "Fetch all (remaining) rows of a query result, returning them as a sequence of sequences... An empty sequence is returned when no rows are available."

The resizable() method is used to control whether a tkinter main window or Toplevel window can be resized by the user. To fix both the width and height, you would call the method with two False arguments, like w.resizable(width=False, height=False). The first argument controls horizontal resizing, and the second controls vertical resizing. Setting them to False (or 0) disables the user's ability to change the window's dimensions, effectively fixing its size.

A. w.fixshape(): This is not a valid method in the standard tkinter library for controlling window dimensions or resizability.

B. w.fixdim(): This method does not exist in the tkinter API. It is a fabricated name.

D. w.makewindow(): This is not a standard tkinter method for creating or modifying window properties like resizability.

1. Official Python Documentation: The tkinter documentation describes the resizable() method for Tk and Toplevel widgets. It states, "This method is used to control whether the window can be resized or not. w.resizable(width=False, height=False) makes the window non-resizable."

Source: Python Software Foundation, tkinter — Python interface to Tcl/Tk, Section 27.1.1.1. Window Manager Methods. Available at: https://docs.python.org/3/library/tkinter.html#window-manager-methods

2. University Courseware: Course materials from reputable computer science programs often cover tkinter basics. For example, materials on GUI programming explain that resizable(False, False) is the standard way to make a window's size fixed.

Source: New Mexico Tech, CS 107 - GUI Programming with Tkinter, Page 10. "To prevent a window from being resized, use the resizable method: window.resizable(width=FALSE, height=FALSE)". Available at: http://infohost.nmt.edu/~shipman/doc/tkinter/tkinter.pdf

3. Academic Resource: An introduction to programming using Python from Michigan State University's Department of Computer Science and Engineering details the use of tkinter methods.

Source: Punch, W. F., & Enbody, R. J. (2017). The Practice of Computing Using Python. Michigan State University, Chapter 11: Graphical User Interfaces, Section 11.3.2, Page 498. The text describes basic widget properties, including making a window non-resizable with win.resizable(0,0).

Deserialization is the process of converting data that has been serialized

Explanation:or encoded in a specific format, back into its original form as an object or a data

structure in memory. In Python, this typically involves creating Python objects based on sequences of

bytes that have been serialized using a protocol such as JSON, Pickle, or YAML.

For example, if you have a Python object my_obj and you want to serialize it to a JSON string, you

might do something like this:

import json

serialized_obj = json.dumps(my_obj)

To deserialize the JSON string back into a Python object, you would use the json.loads() method:

deserialized_obj = json.loads(serialized_obj)

This would convert the JSON string back into its original Python object form.

Reference:

Official

Python

Documentation

on

Serialization: https://docs.python.org/3/library/pickle.html#module-pickle

Real Python Tutorial on Serialization and Deserialization in Python: https://realpython.com/pythonserialization/

Deserialization is the process of converting a sequence of bytes, such as a file or a network message,

into a Python object. This is the opposite of serialization, which is the process of converting a Python

object into a sequence of bytes for storage or transmission.

The json.dumps() function is used for serialization, which is the process of converting a Python object into a JSON formatted string. The function's name itself, "dump string," indicates its purpose. It takes a Python data structure (like a dictionary or list) as its primary argument and returns a str object representing that data in JSON format. This process is essential for storing data or transmitting it over a network in a standardized, language-independent format.

B. It returns a Python entity.

This describes the deserialization function json.loads(), which parses a JSON string and converts it back into a Python object.

C. It takes a JSON string as its argument.

This is also a description of json.loads(), which requires a JSON-formatted string as input for deserialization.

1. Official Python Documentation: The documentation for the json module explicitly states, "Serialize obj to a JSON formatted str using this conversion table." This confirms that the function takes a Python object (obj) as an argument (D) and returns a JSON formatted string (A).

Source: Python Software Foundation. (2023). json — JSON encoder and decoder. Python 3.12.0 documentation. Retrieved from https://docs.python.org/3/library/json.html#json.dumps, Section: json.dumps.

2. University Courseware (MIT OpenCourseWare): In the lecture notes for "Introduction to Computer Science and Programming in Python," the process of using the json library is detailed. The examples show json.dumps() being called with a Python dictionary as an argument to produce a string, reinforcing that it takes Python data and returns a string.

Source: Guttag, J. V. (2016). Introduction to Computation and Programming Using Python, With Application to Understanding Data (2nd ed.). MIT Press. Chapter 10, Section 10.2, "Reading and Writing Files". (While the book is a primary source, its principles are reflected in MIT OCW course 6.0001 materials which cover file I/O and data structures).

3. University Courseware (University of Michigan): The "Python for Everybody" course materials, widely adopted by universities, explain that json.dumps() is used to "take a Python data structure and put it into a string." This directly supports both correct answers.

Source: Severance, C. R. (2016). Python for Everybody: Exploring Data in Python 3. Chapter 13: Web Services and XML. Section: "Parsing JSON".

The question requires identifying the options where the code snippet correctly follows the described PEP 8 recommendation for whitespace.

Option A correctly states that there should be no whitespace before the parenthesis in a function call (spam(1)), which is a standard PEP 8 rule.

Option C correctly states that there should be no whitespace between a trailing comma and a closing parenthesis, which is essential for creating single-element tuples like foo = (0,). This also adheres to PEP 8.

Both options present a valid PEP 8 rule and a code snippet that correctly implements it.

Option B: The description is incorrect. PEP 8 explicitly advises against whitespace before a comma, semicolon, or colon. The provided code snippet demonstrates this incorrect practice.

Option D: The description is incorrect. PEP 8 recommends no whitespace immediately inside brackets for indexing or slicing. Although the code snippet (dct['key']) is correct, the accompanying textual rule is wrong, making the option invalid.

1. Python Enhancement Proposals, PEP 8 -- Style Guide for Python Code. This is the official style guide.

For A & D: In the "Pet Peeves" section, it states: "Avoid extraneous whitespace... Immediately before the opening parenthesis that starts the argument list of a function call: Yes: spam(1)... Immediately inside parentheses, brackets or braces: Yes: spam(ham[1], {eggs: 2}) No: spam( ham[ 1 ], { eggs: 2 } )". This confirms A is correct and the description in D is incorrect.

For B: The "Pet Peeves" section states: "Avoid extraneous whitespace... Immediately before a comma, semicolon, or colon: Yes: if x == 4: print(x, y); x, y = y, x No: if x == 4 : print(x , y) ; x , y = y , x". This confirms the description in B is incorrect.

For C: The "Pet Peeves" section states: "Avoid extraneous whitespace... Between a trailing comma and a following closing parenthesis. Yes: foo = (0,) No: bar = (0, )". This confirms C is correct.

Source: van Rossum, G., Warsaw, B., & Coghlan, N. (2001). PEP 8 -- Style Guide for Python Code. Python Software Foundation. https://peps.python.org/pep-0008/#pet-peeves

2. MIT OpenCourseWare, 6.0001 Introduction to Computer Science and Programming in Python, Fall 2016, Style Guide.

The guide, under the "Whitespace" section, specifies rules derived from PEP 8: "Don't use spaces in the following places: ... Immediately before an opening parenthesis that starts the arguments of a function call. ... Immediately before a comma or a colon. ... Immediately inside of parentheses, brackets, or braces." This supports the reasoning for A, B, and D.

Source: MIT OpenCourseWare. (2016). Style Guide for 6.0001. https://ocw.mit.edu/courses/6-0001-introduction-to-computer-science-and-programming-in-python-fall-2016/pages/readings/style-guide-for-6-0001/

PEP 8, the official style guide for Python code, provides explicit naming conventions to enhance code readability and consistency. It specifies that function and variable names should use snakecase, which is lowercase with words separated by underscores. This convention distinguishes them from CamelCase, which is reserved for class names. Furthermore, PEP 8 strongly recommends using self as the name for the first argument of an instance method and cls for the first argument of a class method. While these are not enforced by the interpreter, they are a near-universal convention followed by the Python community to maintain clarity.

C. This is incorrect. PEP 8 states that modules should have short, all-lowercase names, and underscores can be used if it improves readability. CamelCase is for class names.

D. This is incorrect. PEP 8 specifies that constants should be written in all capital letters with words separated by underscores (e.g., MAXCONNECTIONS).

1. PEP 8 -- Style Guide for Python Code. (2001, updated 2013). G. van Rossum, B. Warsaw, N. Coghlan. Python Software Foundation.

For Answer A (Function and Variable Names): In the "Naming Conventions" section, under "Function and Variable Names," it states: "Function names should be lowercase, with words separated by underscores as necessary to improve readability. Variable names follow the same convention as function names."

For Answer B (Method Arguments): In the "Naming Conventions" section, under "Method Names and Instance Variables," it states: "Always use self for the first argument to instance methods. Always use cls for the first argument to class methods."

For Answer C (Module Names): In the "Naming Conventions" section, under "Package and Module Names," it states: "Modules should have short, all-lowercase names. Underscores can be used in the module name if it improves readability."

For Answer D (Constants): In the "Naming Conventions" section, under "Constants," it states: "Constants are usually defined on a module level and written in all capital letters with underscores separating words."

2. University of California, Berkeley, CS 61A Course Materials. (Fall 2023). "Style and Composition." The course style guide, which is based on PEP 8, reinforces these conventions for students. It explicitly mentions using snakecase for functions and variables and UPPERSNAKECASE for constants. (Referenced in the course's general style guide documents).

PEP 257, "Docstring Conventions," extends the concept of docstrings beyond the standard doc attribute attached to modules, functions, classes, and methods. It specifies two other types of docstrings that are not assigned to doc but can be processed by documentation tools. "Attribute docstrings" are string literals immediately following a public attribute assignment. "Additional docstrings" are string literals that appear immediately after another docstring. The PEP explicitly states that software tools may extract both of these for documentation purposes, making them recognized conventions.

A. String literals immediately after another docstring are called "additional docstrings," not "attribute docstrings." Attribute docstrings follow an attribute assignment.

C. Only a string literal that is the first statement in a module, function, or class is recognized by the compiler as a docstring and assigned to the doc attribute.

D. The term for a docstring following a top-level assignment is "attribute docstring." PEP 257 does not define or use the term "complementary docstrings."

1. Python Enhancement Proposals (PEP) 257: This document is the primary source for docstring conventions.

For Correct Answer B: The sections "Attribute Docstrings" and "Additional Docstrings" explicitly define these types and note: "Docstring processing tools may extract attribute docstrings..." and "These docstrings may be extracted by software tools." (Source: https://peps.python.org/pep-0257/)

For Incorrect Option A & D: The section "Attribute Docstrings" defines them as following an assignment, and the section "Additional Docstrings" defines them as following another docstring, clarifying the terminology. (Source: https://peps.python.org/pep-0257/)

2. The Python Language Reference, Section 8.7 "Function definitions": This official documentation confirms that a docstring must be the first statement in a definition body.

For Incorrect Option C: "The first statement of the function body can optionally be a string literal; this string literal is the function’s documentation string, or docstring." This clarifies that subsequent string literals are not treated as the primary docstring. (Source: https://docs.python.org/3/reference/compoundstmts.html#function-definitions)

3. MIT OpenCourseWare, 6.0001 Introduction to Computer Science and Programming in Python, Fall 2016, Lecture 5 Notes: University courseware reinforces the fundamental definition of a docstring.

For Incorrect Option C: The notes on "Specifications" for functions state, "In Python, we add a string as the first line of the function body" to serve as the docstring, confirming its required position. (Source: https://ocw.mit.edu/courses/6-0001-introduction-to-computer-science-and-programming-in-python-fall-2016/resources/lec5functions/, Section: "Specifications")