Immutable vs Mutable types

Question

I m confused on what an immutable type is  I know the float object is considered to be immutable  with this type of example from my book   class RoundFloat float       def   new   cls  val           return float   new   cls  round val  2     Is this considered to be immutable because of the class structure   hierarchy   meaning float is at the top of the class and is its own method call  Similar to this type of example  even though my book says dict is mutable    class SortedKeyDict dict       def   new   cls  val           return dict   new   cls  val clear      Whereas something mutable has methods inside the class  with this type of example   class SortedKeyDict a dict       def example self           return self keys       Also  for the last class SortedKeyDict a   if I pass this type of set to it   d      zheng-cai   67     hui-jun   68    xin-yi   2     without calling the example method  it returns a dictionary  The SortedKeyDict with   new   flags it as an error  I tried passing integers to the RoundFloat class with   new   and it flagged no errors

User · Answer

Difference between Mutable and Immutable objects

Definitions

Mutable object: Object that can be changed after creating it.
Immutable object: Object that cannot be changed after creating it.

In python if you change the value of the immutable object it will create a new object.

Mutable Objects

Here are the objects in Python that are of mutable type:

list
Dictionary
Set
bytearray
user defined classes

Immutable Objects

Here are the objects in Python that are of immutable type:

int
float
decimal
complex
bool
string
tuple
range
frozenset
bytes

Some Unanswered Questions

Questions: Is string an immutable type?
Answer: yes it is, but can you explain this: Proof 1:

a = "Hello"
a +=" World"
print a

Output

"Hello World"

In the above example the string got once created as "Hello" then changed to "Hello World". This implies that the string is of the mutable type. But it is not when we check its identity to see whether it is of a mutable type or not.

a = "Hello"
identity_a = id(a)
a += " World"
new_identity_a = id(a)
if identity_a != new_identity_a:
    print "String is Immutable"

Output

String is Immutable

Proof 2:

a = "Hello World"
a[0] = "M"

Output

TypeError 'str' object does not support item assignment

Questions: Is Tuple an immutable type?
Answer: yes, it is. Proof 1:

tuple_a = (1,)
tuple_a[0] = (2,)
print a

Output

'tuple' object does not support item assignment

User · Answer

You have to understand that Python represents all its data as objects  Some of these objects like lists and dictionaries are mutable  meaning you can change their content without changing their identity  Other objects like integers  floats  strings and tuples are objects that can not be changed   An easy way to understand that is if you have a look at an objects ID    Below you see a string that is immutable  You can not change its content  It will raise a TypeError if you try to change it  Also  if we assign new content  a new object is created instead of the contents being modified    gt  gt  gt  s    abc   gt  gt  gt id s  4702124  gt  gt  gt  s 0    a   gt  gt  gt  s 0     o  Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  TypeError   str  object does not support item assignment  gt  gt  gt  s    xyz   gt  gt  gt id s  4800100  gt  gt  gt  s     uvw   gt  gt  gt id s  4800500   You can do that with a list and it will not change the objects identity   gt  gt  gt  i    1 2 3   gt  gt  gt id i  2146718700  gt  gt  gt  i 0   1  gt  gt  gt  i 0    7  gt  gt  gt  id i  2146718700   To read more about Python s data model you could have a look at the Python language reference    Python 2 datamodel Python 3 datamodel

User · Answer

The simplest answer   A mutable variable is one whose value may change in place  whereas in an immutable variable change of value will not happen in place  Modifying an immutable variable will rebuild the same variable   Example    gt  gt  gt x   5   Will create a value 5 referenced by x  x -  5   gt  gt  gt y   x   This statement will make y refer to 5 of x  x -------------  5  lt -----------y   gt  gt  gt x   x   y   As x being an integer  immutable type  has been rebuild   In the statement  the expression on RHS will result into value 10 and when this is assigned to LHS  x   x will rebuild to 10  So now  x--------- 10  y--------- 5

User · Answer

The goal of this answer is to create a single place to find all the good ideas about how to tell if you are dealing with mutating nonmutating  immutable mutable   and where possible  what to do about it   There are times when mutation is undesirable and python s behavior in this regard can feel counter-intuitive to coders coming into it from other languages   As per a useful post by  mina-gabriel    Books to read that might help    Data Structures and Algorithms in Python  Excerpt from that book that lists mutable immutable types   mutable imutable types image   Analyzing the above and combining w  a post by  arrak    n   What cannot change unexpectedly    scalars  variable types storing a single value  do not change unexpectedly   numeric examples  int    float    complex    there are some  mutable sequences     str    tuple    frozenset    bytes      What can     list like objects  lists  dictionaries  sets  bytearray    a post on here also says classes and class instances but this may depend on what the class inherits from and or how its built    by  unexpectedly  I mean that programmers from other languages might not expect this behavior  with the exception or Ruby  and maybe a few other  Python like  languages    Adding to this discussion   This behavior is an advantage when it prevents you from accidentally populating your code with mutliple copies of memory-eating large data structures   But when this is undesirable  how do we get around it   With lists  the simple solution is to build a new one like so   list2   list list1   with other structures     the solution can be trickier   One way is to loop through the elements and add them to a new empty data structure  of the same type    functions can mutate the original when you pass in mutable structures   How to tell    There are some tests given on other comments on this thread but then there are comments indicating these tests are not full proof object function   is a method of the original object but only some of these mutate   If they return nothing  they probably do   One would expect  append   to mutate without testing it given its name    union   returns the union of set1 union set2  and does not mutate   When in doubt  the function can be checked for a return value   If return   None  it does not mutate  sorted   might be a workaround in some cases   Since it returns a sorted version of the original  it can allow you to store a non-mutated copy before you start working on the original in other ways  However  this option assumes you don t care about the order of the original elements  if you do  you need to find another way    In contrast  sort   mutates the original  as one might expect     Non-standard Approaches  in case helpful   Found this on github published under an MIT license     github repository under  tobgu named  pyrsistent What it is   Python persistent data structure code written to be used in place of core data structures when mutation is undesirable   For custom classes   semicolon suggests checking if there is a   hash   function because mutable objects should generally not have a   hash     function   This is all I have amassed on this topic for now   Other ideas  corrections  etc  are welcome   Thanks

User · Answer

For immutable objects  assignment creates a new copy of values  for example   x 7 y x print x y  x 10   so for immutable objects this creates a new copy so that it doesnot   effect the value of y print x y    For mutable objects  the assignment doesn t create another copy of values  For example   x  1 2 3 4  print x  y x  for immutable objects assignment doesn t create new copy  x 2  5 print x y    both x amp y holds the same list

User · Answer

Common immutable type     numbers  int    float    complex   immutable sequences  str    tuple    frozenset    bytes     Common mutable type  almost everything else     mutable sequences  list    bytearray   set type  set   mapping type  dict   classes  class instances etc    One trick to quickly test if a type is mutable or not  is to use id   built-in function    Examples  using on integer    gt  gt  gt  i   1  gt  gt  gt  id i     704  gt  gt  gt  i    1  gt  gt  gt  i 2  gt  gt  gt  id i     736  different from    704    using on list    gt  gt  gt  a    1   gt  gt  gt  id a     416  gt  gt  gt  a append 2   gt  gt  gt  a  1  2   gt  gt  gt  id a     416  same with the above id

User · Answer

First of all  whether a class has methods or what it s class structure is has nothing to do with mutability   ints and floats are immutable  If I do  a   1 a    5   It points the name a at a 1 somewhere in memory on the first line  On the second line  it looks up that 1  adds 5  gets 6  then points a at that 6 in memory -- it didn t change the 1 to a 6 in any way  The same logic applies to the following examples  using other immutable types   b    some string  b     some other string  c     some    tuple   c      some    other    tuple     For mutable types  I can do thing that actallly change the value where it s stored in memory  With   d    1  2  3    I ve created a list of the locations of 1  2  and 3 in memory  If I then do  e   d   I just point e to the same list d points at  I can then do   e     4  5    And the list that both e and d points at will be updated to also have the locations of 4 and 5 in memory   If I go back to an immutable type and do that with a tuple   f    1  2  3  g   f g     4  5    Then f still only points to the original tuple -- you ve pointed g at an entirely new tuple   Now  with your example of   class SortedKeyDict dict       def   new   cls  val           return dict   new   cls  val clear      Where you pass   d      zheng-cai   67     hui-jun   68    xin-yi   2      which is a tuple of tuples  as val  you re getting an error because tuples don t have a  clear   method -- you d have to pass dict d  as val for it to work  in which case you ll get an empty SortedKeyDict as a result

User · Answer

One way of thinking of the difference   Assignments to immutable objects in python can be thought of as deep copies   whereas assignments to mutable objects are shallow

User · Answer

What  Floats are immutable  But can t I do  x   5 0 x    7 0 print x   12 0   Doesn t that  mut  x   Well you agree strings are immutable right  But you can do the same thing   s    foo  s     bar  print s   foobar   The value of the variable changes  but it changes by changing what the variable refers to  A mutable type can change that way  and it can also change  in place    Here is the difference   x   something   immutable type print x func x  print x   prints the same thing  x   something   mutable type print x func x  print x   might print something different  x   something   immutable type y   x print x   some statement that operates on y print x   prints the same thing  x   something   mutable type y   x print x   some statement that operates on y print x   might print something different   Concrete examples  x    foo  y   x print x   foo y     bar  print x   foo  x    1  2  3  y   x print x    1  2  3  y     3  2  1  print x    1  2  3  3  2  1   def func val       val     bar   x    foo  print x   foo func x  print x   foo  def func val       val     3  2  1   x    1  2  3  print x    1  2  3  func x  print x    1  2  3  3  2  1

User · Answer

Whether an object is mutable or not depends on its type  This doesn t depend on whether or not it has certain methods  nor on the structure of the class hierarchy  User-defined types  i e  classes  are generally mutable  There are some exceptions  such as simple sub-classes of an immutable type  Other immutable types include some built-in types such as int  float  tuple and str  as well as some Python classes implemented in C  A general explanation from the  quot Data Model quot  chapter in the Python Language Reference quot    The value of some objects can change  Objects whose value can change are said to be mutable  objects whose value is unchangeable once they are created are called immutable   The value of an immutable container object that contains a reference to a mutable object can change when the latter   s value is changed  however the container is still considered immutable  because the collection of objects it contains cannot be changed  So  immutability is not strictly the same as having an unchangeable value  it is more subtle   An object   s mutability is determined by its type  for instance  numbers  strings and tuples are immutable  while dictionaries and lists are mutable

User · Answer

A mutable object has to have at least a method able to mutate the object  For example  the list object has the append method  which will actually mutate the object    gt  gt  gt  a    1 2 3   gt  gt  gt  a append  hello      a  has mutated but is still the same object  gt  gt  gt  a  1  2  3   hello     but the class float has no method to mutate a float object  You can do    gt  gt  gt  b   5 0   gt  gt  gt  b   b   0 1  gt  gt  gt  b 5 1   but the   operand is not a method  It just make a bind between the variable and whatever is to the right of it  nothing else  It never changes or creates objects  It is a declaration of what the variable will point to  since now on    When you do b   b   0 1 the   operand binds the variable to a new float  wich is created with te result of  5   0 1   When you assign a variable to an existent object  mutable or not  the   operand binds the variable to that object  And nothing more happens  In either case  the   just make the bind  It doesn t change or create objects   When you do a   1 0  the   operand is not wich create the float  but the 1 0 part of the line  Actually when you write 1 0 it is a shorthand for float 1 0  a constructor call returning a float object   That is the reason why if you type 1 0 and press enter you get the  echo  1 0 printed below  that is the return value of the constructor function you called   Now  if b is a float and you assign a   b  both variables are pointing to the same object  but actually the variables can t comunicate betweem themselves  because the object is inmutable  and if you do b    1  now b point to a new object  and a is still pointing to the oldone and cannot know what b is pointing to   but if c is  let s say  a list  and you assign a   c  now a and c can  comunicate   because list is mutable  and if you do c append  msg    then just checking a you get the message    By the way  every object has an unique id number asociated to  wich you can get with id x   So you can check if an object is the same or not checking if its unique id has changed

User · Answer

It would seem to me that you are fighting with the question what mutable immutable actually means  So here is a simple explenation   First we need a foundation to base the explenation on    So think of anything that you program as a virtual object  something that is saved in a computers memory as a sequence of binary numbers   Don t try to imagine this too hard  though     Now in most computer languages you will not work with these binary numbers directly  but rather more you use an interpretation of binary numbers   E g  you do not think about numbers like 0x110  0xaf0278297319 or similar  but instead you think about numbers like 6 or Strings like  Hello  world   Never the less theses numbers or Strings are an interpretation of a binary number in the computers memory  The same is true for any value of a variable   In short  We do not program with actual values but with interpretations of actual binary values   Now we do have interpretations that must not be changed for the sake of logic and other  neat stuff  while there are interpretations that may well be changed  For example think of the simulation of a city  in other words a program where there are many virtual objects and some of these are houses  Now may these virtual objects  the houses  be changed and can they still be considered to be the same houses  Well of course they can  Thus they are mutable  They can be changed without becoming a  completely  different object   Now think of integers  These also are virtual objects  sequences of binary numbers in a computers memory   So if we change one of them  like incrementing the value six by one  is it still a six  Well of course not  Thus any integer is immutable   So  If any change in a virtual object means that it actually becomes another virtual object  then it is called immutable   Final remarks    1  Never mix up your real-world experience of mutable and immutable with programming in a certain language    Every programming language has a definition of its own on which objects may be muted and which ones may not    So while you may now understand the difference in meaning  you still have to learn the actual implementation for each programming language      Indeed there might be a purpose of a language where a 6 may be muted to become a 7  Then again this would be quite some crazy or interesting stuff  like simulations of parallel universes      2  This explenation is certainly not scientific  it is meant to help you to grasp the difference between mutable and immutable

User · Answer

Mutable means that it can change mutate  Immutable the opposite  Some Python data types are mutable  others not  Let s find what are the types that fit in each category and see some examples   Mutable In Python there are various mutable types   lists  dict  set   Let s see the following example for lists  list    1  2  3  4  5   If I do the following to change the first element list 0                2    3    4    5    It works just fine  as lists are mutable  If we consider that list  that was changed  and assign a variable to it y   list  And if we change an element from the list such as list 0     Hello     Hello    2    3    4    5    And if one prints y it will give   Hello    2    3    4    5    As both list and y are referring to the same list  and we have changed the list   Immutable In some programming languages one can define a constant such as the following const a   10  And if one calls  it would give an error a   20  However  that doesn t exist in Python  In Python  however  there are various immutable types   None  bool  int  float  str  tuple   Let s see the following example for strings  Taking the string a a    abcd   We can get the first element with a 0    a   If one tries to assign a new value to the element in the first position a 0         It will give an error   str  object does not support item assignment  When one says    to a string  such as a     e    abcde   It doesn t give an error  because it is pointing a to a different string  It would be the same as the following a   a    f   And not changing the string  Some Pros and Cons of being immutable     The space in memory is known from the start  It would not require extra space      Usually  it makes things more efficiently  Finding  for example  the len   of a string is much faster  as it is part of the string object

User · Answer

In Python  there s a easy way to know   Immutable        gt  gt  gt  s  asd       gt  gt  gt  s is  asd      True      gt  gt  gt  s None      gt  gt  gt  s is None     True      gt  gt  gt  s 123      gt  gt  gt  s is 123     True   Mutable    gt  gt  gt  s     gt  gt  gt  s is    False  gt  gt  gt     is    Flase  gt  gt  gt  s  1 2   gt  gt  gt  s is  1 2  False  gt  gt  gt  s  1 2   gt  gt  gt  s is  1 2  False   And    gt  gt  gt  s abs  gt  gt  gt  s is abs True   So I think built-in function is also immutable in Python   But I really don t understand how float works    gt  gt  gt  s 12 3  gt  gt  gt  s is 12 3 False  gt  gt  gt  12 3 is 12 3 True  gt  gt  gt  s    12 3 True  gt  gt  gt  id 12 3  140241478380112  gt  gt  gt  id s  140241478380256  gt  gt  gt  s 12 3  gt  gt  gt  id s  140241478380112  gt  gt  gt  id 12 3  140241478380256  gt  gt  gt  id 12 3  140241478380256   It s so weird

User · Answer

I haven t read all the answers  but the selected answer is not correct and I think the author has an idea that being able to reassign a variable means that whatever datatype is mutable  That is not the case  Mutability has to do with passing by reference rather than passing by value   Lets say you created a List  a    1 2    If you were to say   b   a b 1    3   Even though you reassigned a value on B  it will also reassign the value on a  Its because when you assign  b   a   You are passing the  Reference  to the object rather than a copy of the value  This is not the case with strings  floats etc  This makes list  dictionaries and the likes mutable  but booleans  floats etc immutable

User · Answer

A class is immutable if each object of that class has a fixed value upon instantiation that cannot SUBSEQUENTLY be changed    In another word change the entire value of that variable  name  or leave it alone   Example    my string    Hello world   my string 0     h  print my string    you expected this to work and print hello world but this will throw the following error    Traceback  most recent call last   File  test py   line 4  in  lt module gt  my string 0     h  TypeError   str  object does not support item assignment   The interpreter is saying   i can t change the first character of this string  you will have to change the whole string in order to make it works   my string    Hello World   my string    hello world  print my string  hello world   check this table      source

User · Answer

If you re coming to Python from another language  except one that s a lot like Python  like Ruby   and insist on understanding it in terms of that other language  here s where people usually get confused    gt  gt  gt  a   1  gt  gt  gt  a   2   I thought int was immutable  but I just changed it     In Python  assignment is not mutation in Python   In C    if you write a   2  you re calling a operator  2   which will mutate the object stored in a   And if there was no object stored in a  that s an error    In Python  a   2 does nothing to whatever was stored in a  it just means that 2 is now stored in a instead   And if there was no object stored in a  that s fine      Ultimately  this is part of an even deeper distinction   A variable in a language like C   is a typed location in memory  If a is an int  that means it s 4 bytes somewhere that the compiler knows is supposed to be interpreted as an int  So  when you do a   2  it changes what s stored in those 4 bytes of memory from 0  0  0  1 to 0  0  0  2  If there s another int variable somewhere else  it has its own 4 bytes   A variable in a language like Python is a name for an object that has a life of its own  There s an object for the number 1  and another object for the number 2  And a isn t 4 bytes of memory that are represented as an int  it s just a name that points at the 1 object  It doesn t make sense for a   2 to turn the number 1 into the number 2  that would give any Python programmer way too much power to change the fundamental workings of the universe   what it does instead is just make a forget the 1 object and point at the 2 object instead     So  if assignment isn t a mutation  what is a mutation    Calling a method that s documented to mutate  like a append b    Note that these methods almost always return None   Immutable types do not have any such methods  mutable types usually do  Assigning to a part of the object  like a spam   b or a 0    b  Immutable types do not allow assignment to attributes or elements  mutable types usually allow one or the other  Sometimes using augmented assignment  like a    b  sometimes not  Mutable types usually mutate the value  immutable types never do  and give you a copy instead  they calculate a   b  then assign the result to a     But if assignment isn t mutation  how is assigning to part of the object mutation  That s where it gets tricky  a 0    b does not mutate a 0   again  unlike C     but it does mutate a  unlike C    except indirectly    All of this is why it s probably better not to try to put Python s semantics in terms of a language you re used to  and instead learn Python s semantics on their own terms

[python] Immutable vs Mutable types

Difference between Mutable and Immutable objects

Definitions

Mutable Objects

Immutable Objects

Some Unanswered Questions

Examples related to python

Examples related to immutability

Examples related to mutable