Types immuables ou mutables : quand l'attribution de valeur signifie-t-elle une modification sur place ?

Types immuables et types mutables : clarifier les concepts

Lorsque vous travaillez avec des langages de programmation, il est crucial de comprendre la distinction entre les types immuables et mutables. Les exemples fournis dans la requête soulèvent des questions concernant ce concept.

Qu'est-ce qui constitue un type immuable ?
Les types immuables sont des objets dont les valeurs ne peuvent pas être modifiées une fois créées. Les objets float sont souvent considérés comme immuables, comme le montre l'exemple :

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

Cet exemple définit une classe qui étend le type float. Cependant, la méthode new ne modifie pas la valeur float sous-jacente établie lors de la création de l'objet. De même, l'exemple :

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

crée une classe qui étend le type dict, où new supprime toutes les clés du dictionnaire lors de la création. RoundFloat et SortedKeyDict démontrent l'immuabilité car leurs nouvelles méthodes ne modifient pas les valeurs d'origine.

Types mutables : modification sur place
En revanche, les types mutables permettre la modification sur place des valeurs. L'exemple :

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

définit une classe qui étend le type dict avec un exemple de méthode renvoyant une liste de clés. Cependant, le dict reste mutable, comme le démontre :

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

Mutabilité : affectation de valeur vs modification sur place
Le comportement des types immuables peut prêter à confusion, en particulier si l'on considère attributions de valeurs :

x = 5.0
x += 7.0
print x # 12.0

Dans cet exemple, x est un objet float, qui est immuable. Cependant, l'affectation x = 7,0 semble changer de valeur. La distinction clé ici est que la valeur flottante d'origine de x se voit attribuer une nouvelle valeur, plutôt que d'être modifiée sur place.

Cette distinction s'applique également aux types mutables. Prenons l'exemple suivant :

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

Comme s est de type chaîne (immuable), il doit être réaffecté pour inclure « bar ». Des modifications sur place peuvent être apportées avec des types mutables :

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

Ici, la liste x est étendue en ajoutant une autre liste. Ces exemples soulignent que la mutabilité des types est liée aux capacités de modification sur place.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!