human
I am working on the file "Section 1 - Core Python/Chapter 16 - Standard library/Reference, Shallow and deep copy.ipynb".
The first task is:
Difference between shallow and deep copying
The difference between shallow and deep copying is only relevant for compound objects (objects that contain other objects, like lists or class instances):
A shallow copy constructs a new compound object and then (to the extent possible) inserts references into it to the objects found in the original.
A deep copy constructs a new compound object and then, recursively, inserts copies into it of the objects found in the original.

Two problems often exist with deep copy operations that don't exist with shallow copy operations:
Recursive objects (compound objects that, directly or indirectly, contain a reference to themselves) may cause a recursive loop.
Because deep copy copies everything it may copy too much, such as data which is intended to be shared between copies.

The deepcopy() function avoids these problems by:
keeping a 'memo' dictionary of objects already copied during the current copying pass.
and
letting user-defined classes override the copying operation or the set of components copied.

Controlling Copy Behavior
It is possible to control how copies are made using the copy and deepcopy hooks.
__copy__() is called without any arguments and should return a shallow copy of the object.
__deepcopy__() is called with a memo dictionary, and should return a deep copy of the object. Any member attributes that need to be deep-copied should be passed to copy.deepcopy(), along with the memo dictionary, to control for recursion (see below).

This example illustrates how the methods are called:
Can you write Python program for it?
 ... What is a the Python program you requested?
assistant
#Here is the Python program you requested.

import copy

class MyClass:
    def __init__(self, name):
        self.name = name
    def __cmp__(self, other):
        return cmp(self.name, other.name)
    def __copy__(self):
        print ('__copy__()')
        return MyClass(self.name)
    def __deepcopy__(self, memo):
        print ('__deepcopy__(%s)' % str(memo))
        return MyClass(copy.deepcopy(self.name, memo))

a = MyClass('a')

sc = copy.copy(a)
dc = copy.deepcopy(a)