The short answer is that if you have, say, a numpy array of ints, floats, etc (which is usually) and you want to make a separate copy where the two will not interact in any way (which is what it sounds like), there's no need to deepcopy, and you can just use the array.copy() method. Long version: You are also correct on copy vs deepcopy. If you use copy on, say, a list (more on arrays later), you will get a different list containing the same elements of the original. So: l = [[1], [2]] l2 = copy.copy(l) # l2 is different from l # The sublists inside l2 are the same as the ones in l l2[0] = 42 # l unchanged, you modified l2 which is different l2[1][0] = 1337 # reflected in l, because l2[1] is the same as l[1] So in this case, if you didn't want l2[1][0] = 1337 to be reflected in l, you'd use deepcopy. This would ensure that the sublists are different, as well as the outer list. However, if the contents of l are say, floats or ints, then this doesn't matter. Floats are immutable - you can't change em. What you might think of as modifying a float is actually creating a new float and putting that new float somewhere. So: l = [1.2, 3.4] l2 = l.copy() # same as copy.copy(l) # The elements of l2 are still the same as of l as before. But: l2[0] += 7 # does not actually modify the # float 1.2, but creates a new # float 8.2 and assigns that to # l2[0] - which modifies l2, which # is different from l, so l is unchanged So in this case deepcopy is not necessary to make l and l2 behave completely distinctly (though it doesn't hurt anything - might use a bit more ram depending on what types are in l). Numpy arrays are almost certainly a bit different though. For one thing, a single numpy array with shape (5, 5), say, is not actually an array of arrays, but a single sequence of length 25 that uses math to let you use double indexing. Also, under the hood numpy arrays have byte buffers representing whatever types, so I strongly suspect that array.copy just copies that buffer (at least if it's an array of numbers). So it's possible that it's not really the same rules as lists of objects anyway. But .copy is certainly sufficient for what you want. More on reddit.com

I have a numpy array of different numpy arrays and I want to make a deep copy of the arrays. I found out the following: import numpy as np pairs = [(2, 3), (3, 4), (4, 5)] array_of_arrays = np.ar... More on stackoverflow.com

The difference between a deep copy and a shallow copy is whether or not nested mutable structures are (recursively) copied (deep) or just referenced (shallow). All elements of your list are immutable. Therefore, there is no difference between a shallow and a deep copy. A proper demonstration of the difference is this: import copy my_list = [['first'], ['second'], ['third']] my_deep_copy = copy.deepcopy(my_list) my_deep_copy[1][0] = 'new value' print(my_list) my_shallow_copy = copy.copy(my_list) my_shallow_copy[1][0] = 'new value' print(my_list) Note how it requires nested mutable structures. More on reddit.com

Does Python just have multiple ways to copy a list in the same way??? Although most of the approaches mentioned can be used to copy lists, that doesn't mean that's what they're for! Every operation has a different purpose: Using the slicing technique The purpose of slicing is to select an arbitrary subset of a list. Slices can be used to either obtain a copy of this subset, or to modify the selected subset. For example: foo = [1, 2, 3, 4, 5] print(foo[1:3]) # will print: [2, 3] foo[1:3] = ['a', 'b', 'c', 'd'] print(foo) # will print: [1, a, b, c, d, 4, 5] 2. Using the extend() method The purpose of extend is to add a whole other collection of items onto the end of an existing list. Although slicing can be used for this too, .extend() is less error prone since you don't have to worry about calculating the correct indexes. 3. List copy using =(assignment operator) Geeksforgeeks is wrong here. The = operator doesn't make a copy. Rather, you simply have two different variables refer to the exact same list. 4. Using the method of Shallow Copy Python's copy module wasn't made for lists. The copy() and deepcopy() functions are able to make copies of any arbitrary Python object. For example: from copy import copy class Person: def __init__(self, fname, lname): self.first_name = fname self.last_name = lname def print_greeting(self): print(f"Hello! My name is {self.first_name} {self.last_name}.") foo = Person("Jack", "Johnson") foo.print_greeting() # Will print: Hello! My name is Jack Johnson. bar = copy(foo) bar.print_greeting() # Will print: Hello! My name is Jack Johnson. foo.first_name = "John" foo.last_name = "Jackson" foo.print_greeting() # Will print: Hello! My name is John Jackson bar.print_greeting() # Will print: Hello! My name is Jack Johnson As you see, the copy operation actually made a copy of our Person object. The fact that it works for lists is just a consequence, but that doesn't make it the way of copying lists. 5. Using list comprehension List comprehensions are for constructing a new list based on the data in existing collections. Basically, they're meant to be a concise way to compose map() and filter() operations. You can also use it to quickly construct the cartesian product of multiple collections. 6. Using the append() method The append operation is simply for adding a single item onto a list. Nothing more. Manually writing your own for-loop to append items one by one is perhaps the most clucky & verbose way to copy a list. 7. Using the copy() method This is the only operation whose specific purpose is to copy a Python list. It's finely tuned just for that. Thus, it'll offer you the best performance. 8. Using the method of Deep Copy See #4. The deepcopy() function can make a copy of any arbitrary object, not just a list. 9. The list() function (not mentioned on geeksforgeeks). This is simply the list class constructor. Since 'list' is a class, it has to have a constructor, so might as well make it useful. It can accept any arbitrary collection - a set, a dictionary, a generator, a custom collection class, basically any object that has __iter__ defined on it. It uses the iterator interface to copy each item one by one into the new Python list. More on reddit.com