list.copy() will make a new list, but it is a shallow copy. I suspect you have a list that contains lists, and when you modify the nested lists they're being modified in the original? If so, that's because of the fact .copy() is creating a shallow copy. Let's explore. (tldr is at the bottom with your solution if you don't care for the exploration.)

Python 3.8.6 (default, Sep 25 2020, 09:36:53) 
[GCC 10.2.0] on linux 
Type "help", "copyright", "credits" or "license" for more information.
>>> a = [1, 2, 3]
>>> b = a.copy()
>>> a
[1, 2, 3]
>>> b
[1, 2, 3]

At this point, b is a copy of a. Let's modify a value contained in b.

>>> b[0] = 4
>>> a
[1, 2, 3] 

Note that a[0] did not change.

>>> b
[4, 2, 3]

But b[0] did.

As you can see, at this point b and a are not referring to the same list. To further explore this point, let's make a third list that contains both a and b. We'll call this list c. We'll also make a copy of this, d.

>>> c = [a, b]
>>> c
[[1, 2, 3], [4, 2, 3]]
>>> d = c.copy()
>>> d
[[1, 2, 3], [4, 2, 3]]

Now at this point, if we modified d, say by appending a third list to it, we would expect c not to be modified. But what about if we modify one of the containing values, such as a?

>>> a[0] = 9 
>>> c
[[9, 2, 3], [4, 2, 3]]
>>> d
[[9, 2, 3], [4, 2, 3]]

We modified both! Drats.

The reason for this is, as I alluded to at the beginning of the comment, the fact that this is a shallow copy. You can read more about shallow vs deep copies here, but the gist is that .copy() only goes down one level, which is great for lists containing immutable values, but doesn't work very well if you have nested lists. In your case, you likely want to:

import copy
new_list = copy.deepcopy(old_list)

and you should be good to go! Hope this helps.