PCPP1 Graphical User Interface Programming Practice Test 4 — 15 Questions

Question 1

Which TWO of the following are valid ways to add padding to a widget in the grid layout?

Accepted Answer

padx=10. In Tkinter's grid geometry manager, external padding around a widget is set with the padx and pady options, so option D (padx=10) adds 10 pixels of horizontal padding and option E (pady=10) adds 10 pixels of vertical padding to the widget's cell. These are the standard grid() parameters for per-widget padding, e.g., widget.grid(row=0, column=0, padx=10, pady=10). Option A (margin=10) is not a recognized Tkinter geometry option, and option B (spacing=10) is not a valid grid() parameter either. Option C (gap=10) is likewise not a Tkinter grid option; internal padding between widgets in a container is instead controlled by the container's padx/pady or by grid's ipadx/ipady for internal widget padding, not by a 'gap' keyword.

Answer

margin=10

Answer

spacing=10

Answer

gap=10

Question 2

Which THREE of the following widgets are part of the 'ttk' (Themed Tkinter) module?

Accepted Answer

ttk.Entry. Options A, B, and C are correct because ttk.Entry, ttk.Button, and ttk.Label are all genuine themed widgets provided by the tkinter.ttk module, replacing their classic Tkinter counterparts (tkinter.Entry, tkinter.Button, tkinter.Label) with native-looking, theme-aware versions. ttk.Entry provides a themed single-line text input, ttk.Button provides a themed push button, and ttk.Label provides a themed non-editable text or image display. Option D is incorrect because there is no ttk.Window widget; top-level windows are created with tkinter.Tk or tkinter.Toplevel, and ttk offers no window class. Option E is incorrect because ttk.Canvas does not exist; the canvas widget is only available as tkinter.Canvas in the classic Tk widget set, not in the themed ttk module.

Answer

ttk.Window

Answer

ttk.Canvas

Question 3

Which TWO of the following are valid ways to terminate a Tkinter script gracefully?

Accepted Answer

root.quit(). Option B, root.quit(), is correct because it tells the Tkinter mainloop to stop processing events and return control to the code after mainloop(), which is the standard graceful way to end the event loop while allowing cleanup code to run. Option E, root.destroy(), is also correct because it destroys the root window and all its child widgets, causing the mainloop to exit and the application to terminate cleanly. Option A, os.kill(), is not appropriate because it sends a low-level signal to a process (e.g., SIGTERM/SIGKILL) rather than performing a Tkinter-aware shutdown, so it bypasses widget cleanup. Option C, exit(), is not a Tkinter method and is intended for interactive interpreters; calling it in a GUI script raises SystemExit abruptly rather than gracefully stopping the Tk mainloop. Option D, root.close(), is invalid because Tkinter's Tk root object has no close() method; the correct window-closing method is destroy().

Answer

os.kill()

Answer

exit()

Answer

root.close()

Question 4

You have a Button widget and want to trigger a function named 'process_data' when the user clicks it. Which is the standard way to associate the function with the button?

Accepted Answer

button = Button(root, command=process_data). The 'command' parameter is the standard way to bind a callback function to a button click event.

Answer

button = Button(root, event=process_data)

Answer

button.bind('<Button-1>', process_data)

Answer

button.set_action(process_data)

Question 5

Which TWO of the following statements correctly describe the behavior of the Tkinter 'pack' geometry manager?

Accepted Answer

The 'side' parameter can be set to 'top', 'bottom', 'left', or 'right'.. Option B is correct because pack()'s 'side' parameter accepts exactly the four values 'top', 'bottom', 'left', and 'right', which determine the edge of the container against which the widget is packed (defaulting to 'top'). Option E is correct because the 'fill' parameter accepts 'x', 'y', 'both', or 'none', controlling whether the widget stretches to fill available space along the horizontal axis, vertical axis, both, or neither. Option A is wrong because pack() honors call order: widgets are allocated space in the sequence pack() is invoked, so order directly affects layout. Option C is wrong because the grid coordinate system belongs to the grid() geometry manager, not pack(). Option D is wrong because absolute X/Y positioning is the domain of the place() geometry manager, whereas pack() uses relative cavity-based allocation.

Answer

The manager automatically ignores the order in which pack() is called.

Answer

Widgets are placed in a grid coordinate system.

Answer

Widgets are positioned at exact X and Y coordinates.

Question 6

Which THREE of the following are valid ways to pass arguments to a function called by a Tkinter button command?

Accepted Answer

command=lambda arg=arg1: my_func(arg). Option A is correct because a lambda with a default argument (arg=arg1) captures the value at definition time and passes it to my_func when the button is clicked, avoiding late-binding issues. Option B is correct because a zero-argument lambda that closes over arg1 defers execution of my_func(arg1) until the button is pressed, which is the standard Tkinter pattern for passing arguments. Option C is correct because functools.partial(my_func, arg1) creates a callable that already has arg1 bound, and Tkinter accepts any callable as the command. Option D is wrong because my_func(arg1=value) is invoked immediately at widget creation, so command receives the function's return value rather than a callable. Option E is wrong for the same reason: my_func(arg1) executes right away and its result is assigned to command, not deferred until the button is clicked.

Answer

command=my_func(arg1=value)

Answer

command=my_func(arg1)

Question 7

You are developing a Tkinter application that includes a Canvas widget for drawing a dynamic bar chart. The chart data updates every second, and you must redraw the bars. To avoid visual flicker and improve performance, you decide to reuse existing canvas items instead of deleting and recreating them. Which Canvas method should you use to change the height of an existing rectangle item identified by its item ID?

Accepted Answer

canvas.coords(item_id, x1, y1, x2, y2). To dynamically update the size of an existing canvas item, you should modify its coordinates. The coords() method allows you to set new coordinates for an item, effectively resizing or repositioning it without deleting and recreating. This is efficient and avoids flicker. Other methods like itemconfig() are for changing options like fill, move() only translates, and scale() applies proportional scaling, which is not ideal for precise height adjustments.

Answer

canvas.move(item_id, 0, delta_y)

Answer

canvas.scale(item_id, x_origin, y_origin, x_scale, y_scale)

Answer

canvas.itemconfig(item_id, height=new_height)

Question 8

You are developing a Tkinter application that includes a Button widget. When the user clicks the button, you need to execute a function named handle_click that accepts no arguments. Which approach correctly associates this function with the button's click event?

Accepted Answer

button = Button(root, text='Click', command=handle_click). The command option of a Tkinter Button expects a callable object that will be invoked when the button is clicked. Passing the function name without parentheses provides that callable. Using parentheses calls the function immediately, a lambda that returns the function does not call it, and a string is not callable. Therefore, the only correct approach is to pass the function object itself.

Answer

button = Button(root, text='Click', command='handle_click')

Answer

button = Button(root, text='Click', command=lambda: handle_click)

Answer

button = Button(root, text='Click', command=handle_click())

Question 9

You are building a Tkinter GUI that includes a Canvas widget. You want to draw a rectangle and then later change its fill color without redrawing the entire canvas. Which method should you use to update the rectangle's fill color?

Accepted Answer

canvas.itemconfig(rectangle_id, fill='blue'). Canvas items are managed by the Canvas widget and are referenced by integer IDs. To change an item's options after creation, you use canvas.itemconfig with the item ID and the new option values. Recreating the item adds a new one, configuring the canvas itself does not affect items, and items are not Python objects with methods. Thus, itemconfig is the correct method.

Answer

rectangle.fill('blue')

Answer

canvas.create_rectangle(..., fill='blue')

Answer

canvas.config(fill='blue')

Question 10

You are creating a Tkinter application with a menu bar. You want to add a keyboard shortcut (accelerator) to a menu item so that pressing Ctrl+S triggers the save action. Which option of the add_command method should you use to display the shortcut text, and what additional step is required to make the shortcut functional?

Accepted Answer

Use the accelerator option to display 'Ctrl+S', and bind the keystroke to the save function using the bind method on the root window.. In Tkinter, the accelerator option of a menu item only displays the shortcut text; it does not create a key binding. To make the shortcut functional, you must explicitly bind the key sequence to the desired function using the bind method, typically on the root window. The underline option is for mnemonics, and the command option only sets the callback for menu selection.

Answer

Use the accelerator option to display 'Ctrl+S', and the shortcut will automatically be functional without additional code.

Answer

Use the command option to specify both the function and the shortcut, e.g., command=(save, 'Ctrl+S').

Answer

Use the underline option to set the shortcut key, and bind it using the bind method.

Question 11

You are building a Tkinter application with a Button widget that should run a long-running calculation when clicked, but the GUI freezes until the calculation finishes. Which approach best keeps the interface responsive while performing the calculation?

Accepted Answer

Run the calculation in a separate thread and update the GUI using a thread-safe mechanism such as a queue polled by after().. Tkinter widgets must be manipulated from the thread that created the Tk instance, which is normally the main thread running mainloop(). Performing a long computation in a button callback monopolizes that thread, freezing the interface. The reliable pattern is to execute the computation in a worker thread and pass results back through a thread-safe queue that the main thread inspects with after(). This keeps the event loop cycling and the GUI responsive.

Answer

Call update_idletasks() inside the calculation loop to refresh the window.

Answer

Call the calculation function directly inside the button's command callback.

Answer

Use the after() method with a delay of zero to schedule the calculation repeatedly.

Question 12

You are designing a Tkinter application with a Listbox widget that displays multiple items. You want to allow the user to select multiple non-contiguous items (e.g., by holding Ctrl and clicking). Which configuration option of the Listbox should you set, and to what value?

Accepted Answer

selectmode='extended'. The Listbox widget's selectmode option controls how many items can be selected and how. The 'extended' mode allows multiple selections using Ctrl+click for non-contiguous items and Shift+click for ranges, which is the standard behavior. The 'multiple' mode allows multiple selections but with a toggle mechanism, not requiring Ctrl. 'single' and 'browse' restrict to one selection.

Answer

selectmode='multiple'

Answer

selectmode='browse'

Answer

selectmode='single'

Question 13

You are creating a dialog window in a Tkinter application that must block interaction with the main window until the user closes it, and must return a value to the caller. Which approach correctly implements this behavior?

Accepted Answer

Create a Toplevel, call grab_set() on it, use wait_window() to wait until it is destroyed, then read the stored result.. A modal dialog must prevent input to other application windows and block the caller until dismissed. Creating a Toplevel, calling grab_set() to capture input, and then calling wait_window() achieves both: the grab routes events to the dialog, and wait_window() suspends the caller until the dialog is destroyed. Storing the result on the dialog instance before destruction lets the caller retrieve it after wait_window() returns.

Answer

Use the messagebox.askyesno() function, since it returns a value and is always modal.

Answer

Set the Toplevel's transient() option to True and call update() in a loop until the user closes it.

Answer

Create a Toplevel, call its mainloop(), and read a global variable after it returns.

Question 14

You maintain a Tkinter inventory dashboard whose main window contains a large frame with a Treeview listing warehouse items. Operators complain that when they maximize the window, the Treeview stays at its original size and leaves a large empty gray area. The frame is already managed with grid() and the Treeview is placed inside that frame with pack(). Which single change most directly makes the Treeview grow with the frame when the window is resized?

Accepted Answer

Call tree.pack(fill='both', expand=True) and configure the frame's row and column weights with frame.grid_rowconfigure(0, weight=1) and frame.grid_columnconfigure(0, weight=1).. A Treeview that must follow its parent needs two cooperating mechanisms: the geometry manager inside the frame must allow expansion, and the frame must be told to give surplus space to the cell containing the Treeview. Combining pack(fill='both', expand=True) with weighted grid rows and columns satisfies both conditions, which is why this is the canonical Tkinter pattern for resizable data tables.

Answer

Call tree.config(width=200, height=50) so the Treeview requests a larger size whenever the window is maximized.

Answer

Replace pack() with place() and use relwidth=1, relheight=1 so the Treeview always occupies the whole frame.

Answer

Set the frame's propagate(False) method and assign explicit pixel dimensions to the Treeview's width and height attributes.

Question 15

You are developing a Tkinter application that uses multiple threads to perform background tasks. One thread updates a Label widget's text using its config method. Occasionally, the application crashes with a Tcl error about calling from a different thread. What is the correct approach to safely update the GUI from a background thread?

Accepted Answer

Use the after method to schedule the update on the main thread.. Tkinter is not thread-safe; all GUI updates must occur in the main thread. To safely update a widget from a background thread, you should use the after method to schedule a callback that performs the update. This callback runs in the main event loop. Other approaches like using locks or update_idletasks do not address the fundamental thread safety issue. Direct calls from background threads are unsafe.

Answer

Directly call the widget's config method from the background thread; Tkinter handles thread safety internally.

Answer

Use a lock (threading.Lock) around the widget update to prevent concurrent access.

Answer

Call update_idletasks() before updating the widget from the background thread.