PCPP-32-101 1.10 Perform Shallow and Deep Copy Operations PCPP-32-1 Practice Questions (Page 2)

Questions 6–10

1. 6application · medium

   A team stores a master template as a nested dictionary containing user profile data with lists of permissions. Each new user must receive a completely independent copy so that modifying one user's permissions never affects another user or the master template. Which code correctly creates such a copy?

   • Auser_copy = dict(master_template)
   • Buser_copy = master_template.copy()
   • Cuser_copy = master_template
   • Duser_copy = copy.deepcopy(master_template)
   Reveal Solution Discussion Select an answer first
2. 7application · medium

   A developer writes a validation function that receives a list and must verify whether the caller passed the original list object or a copy. The function needs to reject copies and only proceed with the original object. Which check correctly implements this requirement?

   • Aif id(data) != id(original_list):
   • Bif data in [original_list]:
   • Cif data is original_list:
   • Dif data == original_list:
   Reveal Solution Discussion Select an answer first
4. 8expert · hard

   A developer maintains a data pipeline where a source list contains tuples of (timestamp, value). The pipeline creates a working copy with working = source.copy() and then replaces elements in working with new tuples. The developer notices the source list is unchanged. However, when the pipeline later modifies a mutable object stored inside one of the tuples, the source is also affected. What is the correct explanation?

   • AThe source list is modified because copy() shares the outer list.
   • Bcopy() creates a deep copy of the list and all its contents.
   • CTuples are automatically deep-copied by copy().
   • Dcopy() creates a new outer list but shares the tuple elements; tuples are immutable, but if they contain mutable objects, those are shared.
   Reveal Solution Discussion Select an answer first
5. 9foundation · easy

   After `a = [[1, 2], 3]` and `b = copy.deepcopy(a)`, what happens if you modify `b[0][0] = 99`?

   • AOnly `a` is affected; `b` remains unchanged
   • BAn error occurs because deep copies are immutable
   • COnly `b` is affected; `a` remains unchanged
   • DBoth `a` and `b` are affected because they share the nested list
   Reveal Solution Discussion Select an answer first
6. 10application · medium

   A developer needs to serialize a complex nested data structure for an audit trail. The structure contains lists, dictionaries, and tuples. Before serialization, the developer wants to create a snapshot that can be freely modified without any risk of altering the original data. Which approach guarantees this?

   • Asnapshot = copy.deepcopy(data)
   • Bsnapshot = data
   • Csnapshot = data.copy()
   • Dsnapshot = list(data)
   Reveal Solution Discussion Select an answer first