Sometimes a copy is required so that you can change one copy without changing another. Python has two ways of making copies:
- Deep copy
- Shallow copy
To make these copies, we use copy
module. We use the copy
module for shallow and deep copy operations. For example
p> |
In the above code, copy ()
returns a shallow copy of the list, and deepcopy ()
returns a deep copy of the list.
deepcopy
Deep Copy — it is a process in which the copying process occurs recursively. This means first creating a new collection object and then recursively filling it with copies of the child objects found in the original. In the case of a deep copy, a copy of an object is copied to another object. This means that any changes made to the copy of the object are not reflected in the original object. In python this is done using the deepcopy () function.
|
p>
Exit:
The original elements before deep copying 1 2 [3, 5] 4 The new list of elements after deep copying 1 2 [7, 5] 4 The original elements after deep copying 1 2 [3, 5] 4
In the above example, a change made to the list did not affect other lists, indicating deep copying list.
Shallow copy
p>
Shallow copy means creating a new collection object and then populating it with references to child objects found in the original. The copying process does not repeat itself and therefore does not create copies of the child objects themselves. In the case of a shallow copy, a reference to an object is copied to another object. This means that any changes made to the copy of the object are reflected in the original object. Python does this with the " copy () " function.
|
Exit:
The o riginal elements before shallow copying 1 2 [3, 5] 4 The original elements after shallow copying 1 2 [7, 5] 4
In the above example, the change made to the list is took effect on another list, indicating that the list was copied.
Important points:
The difference between shallow and deep copies only applies to composite objects (objects that contain other objects, such as lists or class instances):
- The shallow copy creates a new composite object and then (as far as possible) inserts references to objects found in the original.
- A deep copy creates a new compound object and then recursively inserts copies of the objects found in the original into it.
copy to Python (Deep Copy and Shallow Copy) insert: Questions
How to insert newlines on argparse help text?
5 answers
I"m using argparse
in Python 2.7 for parsing input options. One of my options is a multiple choice. I want to make a list in its help text, e.g.
from argparse import ArgumentParser
parser = ArgumentParser(description="test")
parser.add_argument("-g", choices=["a", "b", "g", "d", "e"], default="a",
help="Some option, where
"
" a = alpha
"
" b = beta
"
" g = gamma
"
" d = delta
"
" e = epsilon")
parser.parse_args()
However, argparse
strips all newlines and consecutive spaces. The result looks like
~/Downloads:52$ python2.7 x.py -h usage: x.py [-h] [-g {a,b,g,d,e}] test optional arguments: -h, --help show this help message and exit -g {a,b,g,d,e} Some option, where a = alpha b = beta g = gamma d = delta e = epsilon
How to insert newlines in the help text?
Answer #1
Try using RawTextHelpFormatter
:
from argparse import RawTextHelpFormatter
parser = ArgumentParser(description="test", formatter_class=RawTextHelpFormatter)
Is a Python list guaranteed to have its elements stay in the order they are inserted in?
5 answers
If I have the following Python code
>>> x = []
>>> x = x + [1]
>>> x = x + [2]
>>> x = x + [3]
>>> x
[1, 2, 3]
Will x
be guaranteed to always be [1,2,3]
, or are other orderings of the interim elements possible?
Answer #1
Yes, the order of elements in a python list is persistent.
Inserting image into IPython notebook markdown
5 answers
I am starting to depend heavily on the IPython notebook app to develop and document algorithms. It is awesome; but there is something that seems like it should be possible, but I can"t figure out how to do it:
I would like to insert a local image into my (local) IPython notebook markdown to aid in documenting an algorithm. I know enough to add something like <img src="image.png">
to the markdown, but that is about as far as my knowledge goes. I assume I could put the image in the directory represented by 127.0.0.1:8888 (or some subdirectory) to be able to access it, but I can"t figure out where that directory is. (I"m working on a mac.) So, is it possible to do what I"m trying to do without too much trouble?
Answer #1
Most of the answers given so far go in the wrong direction, suggesting to load additional libraries and use the code instead of markup. In Ipython/Jupyter Notebooks it is very simple. Make sure the cell is indeed in markup and to display a image use:

Further advantage compared to the other methods proposed is that you can display all common file formats including jpg, png, and gif (animations).
copy to Python (Deep Copy and Shallow Copy) mean: Questions
Meaning of @classmethod and @staticmethod for beginner?
5 answers
Could someone explain to me the meaning of @classmethod
and @staticmethod
in python? I need to know the difference and the meaning.
As far as I understand, @classmethod
tells a class that it"s a method which should be inherited into subclasses, or... something. However, what"s the point of that? Why not just define the class method without adding @classmethod
or @staticmethod
or any @
definitions?
tl;dr: when should I use them, why should I use them, and how should I use them?
Answer #1
Though classmethod
and staticmethod
are quite similar, there"s a slight difference in usage for both entities: classmethod
must have a reference to a class object as the first parameter, whereas staticmethod
can have no parameters at all.
Example
class Date(object):
def __init__(self, day=0, month=0, year=0):
self.day = day
self.month = month
self.year = year
@classmethod
def from_string(cls, date_as_string):
day, month, year = map(int, date_as_string.split("-"))
date1 = cls(day, month, year)
return date1
@staticmethod
def is_date_valid(date_as_string):
day, month, year = map(int, date_as_string.split("-"))
return day <= 31 and month <= 12 and year <= 3999
date2 = Date.from_string("11-09-2012")
is_date = Date.is_date_valid("11-09-2012")
Explanation
Let"s assume an example of a class, dealing with date information (this will be our boilerplate):
class Date(object):
def __init__(self, day=0, month=0, year=0):
self.day = day
self.month = month
self.year = year
This class obviously could be used to store information about certain dates (without timezone information; let"s assume all dates are presented in UTC).
Here we have __init__
, a typical initializer of Python class instances, which receives arguments as a typical instancemethod
, having the first non-optional argument (self
) that holds a reference to a newly created instance.
Class Method
We have some tasks that can be nicely done using classmethod
s.
Let"s assume that we want to create a lot of Date
class instances having date information coming from an outer source encoded as a string with format "dd-mm-yyyy". Suppose we have to do this in different places in the source code of our project.
So what we must do here is:
- Parse a string to receive day, month and year as three integer variables or a 3-item tuple consisting of that variable.
- Instantiate
Date
by passing those values to the initialization call.
This will look like:
day, month, year = map(int, string_date.split("-"))
date1 = Date(day, month, year)
For this purpose, C++ can implement such a feature with overloading, but Python lacks this overloading. Instead, we can use classmethod
. Let"s create another "constructor".
@classmethod
def from_string(cls, date_as_string):
day, month, year = map(int, date_as_string.split("-"))
date1 = cls(day, month, year)
return date1
date2 = Date.from_string("11-09-2012")
Let"s look more carefully at the above implementation, and review what advantages we have here:
- We"ve implemented date string parsing in one place and it"s reusable now.
- Encapsulation works fine here (if you think that you could implement string parsing as a single function elsewhere, this solution fits the OOP paradigm far better).
cls
is an object that holds the class itself, not an instance of the class. It"s pretty cool because if we inherit ourDate
class, all children will havefrom_string
defined also.
Static method
What about staticmethod
? It"s pretty similar to classmethod
but doesn"t take any obligatory parameters (like a class method or instance method does).
Let"s look at the next use case.
We have a date string that we want to validate somehow. This task is also logically bound to the Date
class we"ve used so far, but doesn"t require instantiation of it.
Here is where staticmethod
can be useful. Let"s look at the next piece of code:
@staticmethod
def is_date_valid(date_as_string):
day, month, year = map(int, date_as_string.split("-"))
return day <= 31 and month <= 12 and year <= 3999
# usage:
is_date = Date.is_date_valid("11-09-2012")
So, as we can see from usage of staticmethod
, we don"t have any access to what the class is---it"s basically just a function, called syntactically like a method, but without access to the object and its internals (fields and another methods), while classmethod does.
Answer #2
Rostyslav Dzinko"s answer is very appropriate. I thought I could highlight one other reason you should choose @classmethod
over @staticmethod
when you are creating an additional constructor.
In the example above, Rostyslav used the @classmethod
from_string
as a Factory to create Date
objects from otherwise unacceptable parameters. The same can be done with @staticmethod
as is shown in the code below:
class Date:
def __init__(self, month, day, year):
self.month = month
self.day = day
self.year = year
def display(self):
return "{0}-{1}-{2}".format(self.month, self.day, self.year)
@staticmethod
def millenium(month, day):
return Date(month, day, 2000)
new_year = Date(1, 1, 2013) # Creates a new Date object
millenium_new_year = Date.millenium(1, 1) # also creates a Date object.
# Proof:
new_year.display() # "1-1-2013"
millenium_new_year.display() # "1-1-2000"
isinstance(new_year, Date) # True
isinstance(millenium_new_year, Date) # True
Thus both new_year
and millenium_new_year
are instances of the Date
class.
But, if you observe closely, the Factory process is hard-coded to create Date
objects no matter what. What this means is that even if the Date
class is subclassed, the subclasses will still create plain Date
objects (without any properties of the subclass). See that in the example below:
class DateTime(Date):
def display(self):
return "{0}-{1}-{2} - 00:00:00PM".format(self.month, self.day, self.year)
datetime1 = DateTime(10, 10, 1990)
datetime2 = DateTime.millenium(10, 10)
isinstance(datetime1, DateTime) # True
isinstance(datetime2, DateTime) # False
datetime1.display() # returns "10-10-1990 - 00:00:00PM"
datetime2.display() # returns "10-10-2000" because it"s not a DateTime object but a Date object. Check the implementation of the millenium method on the Date class for more details.
datetime2
is not an instance of DateTime
? WTF? Well, that"s because of the @staticmethod
decorator used.
In most cases, this is undesired. If what you want is a Factory method that is aware of the class that called it, then @classmethod
is what you need.
Rewriting Date.millenium
as (that"s the only part of the above code that changes):
@classmethod
def millenium(cls, month, day):
return cls(month, day, 2000)
ensures that the class
is not hard-coded but rather learnt. cls
can be any subclass. The resulting object
will rightly be an instance of cls
.
Let"s test that out:
datetime1 = DateTime(10, 10, 1990)
datetime2 = DateTime.millenium(10, 10)
isinstance(datetime1, DateTime) # True
isinstance(datetime2, DateTime) # True
datetime1.display() # "10-10-1990 - 00:00:00PM"
datetime2.display() # "10-10-2000 - 00:00:00PM"
The reason is, as you know by now, that @classmethod
was used instead of @staticmethod
Answer #3
@classmethod
means: when this method is called, we pass the class as the first argument instead of the instance of that class (as we normally do with methods). This means you can use the class and its properties inside that method rather than a particular instance.
@staticmethod
means: when this method is called, we don"t pass an instance of the class to it (as we normally do with methods). This means you can put a function inside a class but you can"t access the instance of that class (this is useful when your method does not use the instance).