Immutable vs. Mutable Types: When Does Value Assignment Mean In-Place Modification?

Immutable vs Mutable Types: Clarifying the Concepts

When working with programming languages, understanding the distinction between immutable and mutable types is crucial. The examples provided in the query raise questions regarding this concept.

What Constitutes an Immutable Type?
Immutable types are objects whose values cannot be modified once created. Float objects are often considered immutable, as seen in the example:

class RoundFloat(float):
    def __new__(cls, val):
        return float.__new__(cls, round(val, 2))

This example defines a class that extends the float type. However, the new method does not modify the underlying float value established during object creation. Similarly, the example:

class SortedKeyDict(dict):
    def __new__(cls, val):
        return dict.__new__(cls, val.clear())

creates a class that extends the dict type, where new removes all keys from the dictionary upon creation. Both RoundFloat and SortedKeyDict demonstrate immutability because their new methods do not alter the original values.

Mutable Types: In-Place Modification
In contrast, mutable types allow for in-place modification of values. The example:

class SortedKeyDict_a(dict):
    def example(self):
        return self.keys()

defines a class that extends the dict type with an example method returning a list of keys. However, the dict remains mutable, as demonstrated by:

d = (('zheng-cai', 67), ('hui-jun', 68),('xin-yi', 2))
SortedKeyDict_a(d)  # Returns a dictionary without calling example

Mutability: Value Assignment vs In-Place Modification
The behavior of immutable types can be confusing, particularly when considering value assignments:

x = 5.0
x += 7.0
print x # 12.0

In this example, x is a float object, which is immutable. However, the assignment x = 7.0 appears to change its value. The key distinction here is that the original float value of x is assigned a new value, rather than modified in place.

This distinction also applies to mutable types. Consider the following example:

s = 'foo'
s += 'bar'
print s # foobar

As s is of type string (immutable), it must be reassigned to include 'bar.' In place modifications can be made with mutable types:

x = [1, 2, 3]
x += [3, 2, 1]
print x # [1, 2, 3, 3, 2, 1]

Here, the list x is extended by appending another list. These examples highlight that the mutability of types relates to in-place modification capabilities.

The above is the detailed content of Immutable vs. Mutable Types: When Does Value Assignment Mean In-Place Modification?. For more information, please follow other related articles on the PHP Chinese website!