If you see the object IDs of the various DataFrames you create, you can clearly see what is happening. When you write df2 = df1, you are creating a variable named df2, and binding it with an object with id 4541269200. When you write df1 = pd.DataFrame([9,9,9]), you are creating a new object with id … Read more
Note that here is a shorter, maybe a bit cleaner version of this (that I quite enjoy): $data = Import-Csv .\test.csv $serialData = [System.Management.Automation.PSSerializer]::Serialize($data) $data2 = [System.Management.Automation.PSSerializer]::Deserialize($serialData) Note: However, weirdly, it does not keep the ordering of ordered hashtables. $data = [ordered] @{ 1 = 1 2 = 2 } $serialData = [System.Management.Automation.PSSerializer]::Serialize($data) $data2 = … Read more
In Python3: import types import functools def copy_func(f): “””Based on http://stackoverflow.com/a/6528148/190597 (Glenn Maynard)””” g = types.FunctionType(f.__code__, f.__globals__, name=f.__name__, argdefs=f.__defaults__, closure=f.__closure__) g = functools.update_wrapper(g, f) g.__kwdefaults__ = f.__kwdefaults__ return g def f(arg1, arg2, arg3, kwarg1=”FOO”, *args, kwarg2=”BAR”, kwarg3=”BAZ”): return (arg1, arg2, arg3, args, kwarg1, kwarg2, kwarg3) f.cache = [1,2,3] g = copy_func(f) print(f(1,2,3,4,5)) print(g(1,2,3,4,5)) print(g.cache) assert … Read more
The FunctionType constructor is used to make a deep copy of a function. import types def copy_func(f, name=None): return types.FunctionType(f.func_code, f.func_globals, name or f.func_name, f.func_defaults, f.func_closure) def A(): “””A””” pass B = copy_func(A, “B”) B.__doc__ = “””B”””
Forget about deep copy, even shallow copy isn’t safe, if the object you’re copying has a property with enumerable attribute set to false. MDN : The Object.assign() method only copies enumerable and own properties from a source object to a target object take this example var o = {}; Object.defineProperty(o,’x’,{enumerable: false,value : 15}); var ob={}; … Read more
Deep copy isn’t built into vanilla Ruby, but you can hack it by marshalling and unmarshalling the object: Marshal.load(Marshal.dump(@object)) This isn’t perfect though, and won’t work for all objects. A more robust method: class Object def deep_clone return @deep_cloning_obj if @deep_cloning @deep_cloning_obj = clone @deep_cloning_obj.instance_variables.each do |var| val = @deep_cloning_obj.instance_variable_get(var) begin @deep_cloning = true val … Read more
You are creating a shallow copy, because nested values are not copied, merely referenced. A deep copy would create copies of the values referenced by the list too. Demo: >>> lst = [{}] >>> lst_copy = lst[:] >>> lst_copy[0][‘foo’] = ‘bar’ >>> lst_copy.append(42) >>> lst [{‘foo’: ‘bar’}] >>> id(lst) == id(lst_copy) False >>> id(lst[0]) == … Read more
Cloning the objects before adding them. For example, instead of newList.addAll(oldList); for(Person p : oldList) { newList.add(p.clone()); } Assuming clone is correctly overriden inPerson.
The idiomatic way to approach this in C# is to implement ICloneable on your Data, and write a Clone method that does the deep copy (and then presumably a Enumerable.CloneRange method that can clone part of your list at once.) There isn’t any built-in trick or framework method to make it easier than that. Unless … Read more
The clone method is Ruby’s standard, built-in way to do a shallow-copy: irb(main):003:0> h0 = {“John” => “Adams”, “Thomas” => “Jefferson”} => {“John”=>”Adams”, “Thomas”=>”Jefferson”} irb(main):004:0> h1 = h0.clone => {“John”=>”Adams”, “Thomas”=>”Jefferson”} irb(main):005:0> h1[“John”] = “Smith” => “Smith” irb(main):006:0> h1 => {“John”=>”Smith”, “Thomas”=>”Jefferson”} irb(main):007:0> h0 => {“John”=>”Adams”, “Thomas”=>”Jefferson”} Note that the behavior may be overridden: This … Read more