Do you ever wonder how one can simply fill data once and then merely make its copy to prefer ease? Not possible for a textbook, of course, but Python has its own magic, and yes, it does this for his coder.<\/p>\n
How?<\/p>\n
Copies in python are such functions that maintain a skeleton of any code as a carbon copy in the library. This helps the coder to retrieve any such code in case of any error.<\/p>\n
There are basically two types of copies: shallow copy and deep copy. But there lies a major difference in the working of both, what is it and where are they used?<\/p>\n
Everything is explained in the article. So, let’s get started.<\/p>\n
A copy module is used when some changes are needed in the backup files but not in the main source code. This refers to the internal storage that can be manipulated from the coder\u2019s point of view but not the user\u2019s point of view in the main source file.<\/p>\n
Some of the attributes are:<\/p>\n
1. copy.copy(x)<\/strong> 2. copy.deepcopy(x)<\/strong> 3. exception copy.error<\/strong> A shallow copy creates a separate file within the text file which stores information. The original code is never manipulated, but changes can be surely made in the new copied file.<\/p>\n The basic idea of shallow and deep copy constructs a few debugging problems within the text.<\/p>\n Recursive objects face problems in shallow copy, but this is resolved with deep copy. This also intends the deep copy to work more efficiently than the shallow copies in runtime.<\/p>\n This module copies functions and classes both deep and shallow by returning the original object unchanged in the main code itself.<\/p>\n It is generally also compatible with the way these are treated by the pickle module in any code specific run time in python.<\/p>\n Shallow Copy Syntax in Python:<\/strong><\/p>\n Deep Copy Syntax in Python:<\/strong><\/p>\n Python Copy Example<\/strong><\/p>\n Output:<\/strong><\/p>\n While a deep copy in Python creates a new object, it also inserts the new object in the original object by efficiently copying it. Similarly it copies an object into another object within the main code. This basically signifies that the required changes in the main dictionary are well automated in the main library also.<\/p>\n Python Deep Copy Example<\/strong><\/p>\n Output:<\/strong><\/p>\n Addition of Nested Loop:<\/strong> Nested loop, unlike in lists, can be added in the deep copy. The shallow copy doesn\u2019t support the reframe work of nested loops in new versions of python. Though it can be used in the old versions.<\/p>\n Code:<\/strong><\/p>\n Output:<\/strong><\/p>\n While it is possible that recursive objects cause a recursive loop; these are the compound objects that directly or indirectly reference themselves. And it is possible that a deep copy may copy too much. 1. Deep copy parses the newly added information in its file. This helps the coder to identify new files easily in the code. Regardless of this, the copy module uses the registered pickle functions from the copyreg module within the code itself, it does not refer to the original code.<\/p>\n Copying Arbitrary Python Objects:<\/strong> Python arbitrary objects can be compiled in a list easily. It can be done by adding the elements recursively in the runtime for any defined list.<\/p>\n Code:<\/strong><\/p>\n Output:<\/strong><\/p>\n While using a Shallow Copy in Python, the coder creates a new object in which he\/she recursively puts all the copies of objects into the original code. Similarly, we copy a reference of an object into another object also. Any changes the coder makes to the copy do reflect in the original copy of code in the runtime.<\/p>\n Python Shallow Copy Example:<\/strong><\/p>\n Output:<\/strong><\/p>\n Shallow Copying Dictionaries:<\/strong> This is a general method for providing an interface in the main source code.<\/p>\n Code:<\/strong><\/p>\n Output:<\/strong><\/p>\n Adding any element as [0,0] to the list, using shallow copy:<\/strong> This method adds elements by extracting from one list to another one by one.<\/p>\n Code:<\/strong><\/p>\n Output:<\/strong><\/p>\n Adding new nested objects using Shallow copy:<\/strong> The objects are oriented from the list, and then extracted in the copies of the source code.<\/p>\n Code:<\/strong><\/p>\n Output:<\/strong><\/p>\n #no new obj to append<\/p>\n Having discussed what shallow and deep copies are and why we create copies, it’s time to learn about the difference between them. Actually, there are just two core differences and they’re linked with each other:<\/p>\n Code 1:<\/strong><\/p>\n Output:<\/strong><\/p>\n Code 2:<\/strong><\/p>\n Output:<\/strong><\/p>\n As the article concludes, we get to know about the 2 different types of copies that python serves us and their correct usage. Copying is easy, but the assessment of where to do it is a tough task.<\/p>\n","protected":false},"excerpt":{"rendered":" Do you ever wonder how one can simply fill data once and then merely make its copy to prefer ease? Not possible for a textbook, of course, but Python has its own magic, and...<\/p>\n","protected":false},"author":1,"featured_media":80231,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1053],"tags":[3371,3372,3373,3374],"class_list":["post-80211","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python","tag-python-copies","tag-python-deep-copy","tag-python-deep-copy-vs-shallow-copy","tag-python-shallow-copy"],"yoast_head":"\n
\nIt returns a shallow copy of x.<\/p>\n
\nIt returns a deep copy of x.<\/p>\n
\nIt returns an exception if needed.<\/p>\nHow to Perform Shallow and Deep Copy in Python?<\/h3>\n
import copy\ncopy.copy(objectvariable_name)\n<\/pre>\n
import copy\ncopy.deepcopy(objectvariable_name)\n<\/pre>\n
#method to print the list\nthisistech= [1, 2, 3],['#',\"*\",\"-\"]\nnewtech=[0,9,8,7]\n#the functions returns as it is \nprint('Old List:', thisistech)\n<\/pre>\nPython Deep Copy<\/h2>\n
>>> import copy\n>>> list1=[1,0,[7,9],6]\n>>> list2=copy.deepcopy(list1) #Making a deep copy\n>>>print( list1)\n<\/pre>\n
l=int(input(\"enter number\"))\n \n \nold__list = [[1, 1, 1], [2, 2, 2], [5, 5, 5]]\n \nprint(\"Old list:\", old__list)\n<\/pre>\n
\nOld list: [[1, 1, 1], [2, 2, 2], [5, 5, 5]]<\/div>\nIssues With Python Deep Copy<\/h3>\n
\nTo deal with these problems, deepcopy() also :<\/p>\n
\n2. Deep copy does not allow the coder to overwrite in the code, but builds a copy of the shallow code using internal files.
\n3. Deep copy, as well as shallow copy, is made by parsing a list or tuple together in the runtime.<\/p>\nclass Point:\n def __init__(self, A, B):\n self.P = A\n self.Q= B\n\n\nA = int(input(\"a\")\n<\/pre>\n
Python Shallow Copy<\/h2>\n
>>>import copy\nlist=1,0,[7,9],6\nlist_2=copy.copy(list) #Making a shallow copy\nprint(list)\n<\/pre>\n
\n>>><\/div>\n>>> dict_1={'a':0,'b':2,'c':[0,2,3]}\n \n \ndict_2=dict_1.copy()\n \ndict_2['c'].append(9)\ndict_1={\"a\": 0}\nprint(dict_2)\n \n<\/pre>\n
\n>>><\/div>\nimport copy\nold_list0 = [[1,1], [2,2]]\nnew_list1 = copy.copy(old_list0)\nold_list0.append([0,0])\nprint(\"New list:\", new_list1)\n<\/pre>\n
import copy\nl=(\u201center number\u201d)\nli=[]\nl.append(li)\nprint(li)\nlistone = [[1, 1, 1], [2, 2]]\nn=(\u201center number\u201d)\nni=[]\nn.append(ni)\nprint(ni)\nnew_list = copy.copy(old_list)\noldlist0[1][1] = 'pq'\nprint(\"New list:\", new_list1)\n<\/pre>\n
Difference Between Python Deep Copy and Shallow Copy<\/h3>\n
\n
Example for Python Deep Copy vs Shallow Copy<\/h4>\n
import copy\nresult_p = [100,90], [30,40] \nresult_q = [10,90], [340] \n \n \nprint(\"Original List: \")\nprint(result_p)\nprint(\"Deep Copy:\")\nprint(result_q)\n<\/pre>\n
\n([100, 90], [30, 40])
\nDeep Copy:
\n([10, 90], [340])
\n>>><\/div>\nimport copy\nresult_p = [[85, 82], [ 88, 90]] \n \n \nprint(\"Original List: \")\nprint(result_p)\n<\/pre>\n
\n[[85, 82], [88, 90]]
\n>>><\/div>\nConclusion<\/h2>\n