Types de public vs immuable - Python

Question

Je suis confus sur ce qu'est un immuable type est. Je sais que l' float objet est considéré comme immuable, avec ce type d'exemple de mon livre:

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

Est-il considéré comme immuable, en raison de la structure de classe / de la hiérarchie?, sens float est au top de la classe et qui est son propre appel de méthode. Similaire à ce type d'exemple (même si mon livre, dit - dict est sujette au changement):

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

Alors que quelque chose mutable a des méthodes à l'intérieur de la classe, avec ce type d'exemple:

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

---

Aussi, pour la dernière class(SortedKeyDict_a), si je passe ce type de set:

d = (('zheng-cai', 67), ('hui-jun', 68),('xin-yi', 2))

sans appel de la example méthode, il retourne un dictionnaire. L' SortedKeyDict avec __new__ drapeaux comme une erreur. J'ai essayé en passant entiers à l' RoundFloat classe avec __new__ et qu'elle avait pas d'erreurs. Quelqu'un peut-il svp m'éclairer sur le pourquoi il fonctionne de la manière qu'il le fait.

S'il vous plaît aider avec ma compréhension de immuable types vs non.

Answer 1

Quoi? Les flotteurs sont-ils immuables? Mais on ne peut pas faire

x = 5.0
x += 7.0
print x # 12.0

N'est-ce pas "mut" x?

Eh bien, vous acceptez les chaînes sont immuables droit? Mais vous pouvez faire la même chose.

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

La valeur de la variable change, mais il change en changeant ce que la variable se rapporte. Une mutable peut évoluer de cette façon, et il peut également modifier "en place".

Là est la différence.

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

Des exemples concrets

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]

Answer 2

Vous devez comprendre que Python représente l'ensemble de ses données comme des objets. Certains de ces objets comme les listes et les dictionnaires sont mutables, ce qui signifie que vous pouvez en modifier le contenu sans changer leur identité. D'autres objets tels que les entiers, les décimaux, les chaînes et les tuples ... sont des objets qui ne peuvent pas être modifiés. Une manière facile à comprendre c'est si vous avez un coup d'oeil à l'un des objets de l'ID.

Ci-dessous vous voyez une chaîne de caractères qui est immuable. Vous ne pouvez pas modifier son contenu. Ce sera grâce à une erreur, à vous, si vous essayez de le changer. Aussi, si nous attribuer un nouveau contenu, un nouvel objet est créé à la place du contenu en cours de modification.

>>> s = "abc"
>>>id(s)
4702124
>>> s[0] 
'a'
>>> s[0] = "o"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> s = "xyz"
>>>id(s)
4800100
>>> s += "uvw"
>>>id(s)
4800500

Vous pouvez le faire avec une liste et il ne changera pas les objets de l'identité

>>> i = [1,2,3]
>>>id(i)
2146718700
>>> i[0] 
1
>>> i[0] = 7
>>> id(i)
2146718700

Pour en savoir plus sur les Pythons modèle de données, vous pourriez avoir un coup d'oeil à la référence au langage Python ici: http://docs.python.org/reference/datamodel.html

Answer 3

Immuable :

1. entiers et autres types numériques
2. types de chaînes comme str et unicode
3. n-uplets

Mutable : tout le reste, comme :

1. listes
2. DICTS
3. classes
4. instances de classe
5. etc.

Et `` méthode est bonne à dire. Par exemple

Pour un entier :

Pour obtenir la liste :

Answer 4

Tout d'abord, si une classe possède des méthodes ou ce que c'est la structure de la classe n'a rien à voir avec la mutabilité.

ints et floats sont immuables. Si je ne

a = 1
a += 5

Il indique le nom de l' a à 1 quelque part dans la mémoire de la première ligne. Sur la deuxième ligne, il semble qu' 1, ajoute 5, obtient 6, puis les points de a à 6 à la mémoire -- il n'a pas changer l' 1 d'un 6 , en quelque sorte. La même logique s'applique pour les exemples suivants, à l'aide d'autres immuable types:

b = 'some string'
b += 'some other string'
c = ('some', 'tuple')
c += ('some', 'other', 'tuple')

Pour mutable types, je peux faire la chose que actallly modifier la valeur où il est stocké dans la mémoire. Avec:

d = [1, 2, 3]

J'ai créé une liste des emplacements de 1, 2, et 3 dans la mémoire. Si je puis faire

e = d

Je viens de point de e à la même list d points au. Je peux alors faire:

e += [4, 5]

Et la liste que les deux e et d des points seront mis à jour à ont également l'emplacement de 4 et 5 dans la mémoire.

Si je reviens un immuable type et de le faire avec un tuple:

f = (1, 2, 3)
g = f
g += (4, 5)

Ensuite, f encore seuls les points à l' originale tuple -- vous l'avez souligné g sur un entièrement nouveau tuple.

Maintenant, avec votre exemple de

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

Où l'on passe

d = (('zheng-cai', 67), ('hui-jun', 68),('xin-yi', 2))

(qui est une tuple de tuples) val, vous obtenez une erreur car tuples n'ont pas d' .clear() méthode, vous auriez à passer dict(d) comme val pour que cela fonctionne, dans ce cas, vous obtiendrez un vide SortedKeyDict .

Answer 5

Si un objet est mutable ou non dépend de son type. Cela ne veut pas dépendre de l'existence ou non de certaines méthodes, ni sur la structure de la hiérarchie de classe.

Types définis par l'utilisateur (c'est à dire les classes) sont généralement mutable. Il y a quelques exceptions près, comme de simples sous-classes d'une immuable type. D'autres immuable types incluent certains types intégrés tels que l' int, float, tuple et str, ainsi que quelques classes Python mis en œuvre dans C.

Une explication générale de l' "Modèle de Données" dans le chapitre du Langage Python de Référence":

La valeur de certains objets peut changer. Les objets dont la valeur peut changer dit que ce sont mutables; les objets dont la valeur est immuable, une fois qu'ils sont créés sont appelés immuable.

(La valeur d'un immuable conteneur objet qui contient une référence à un objet mutable peut changer lorsque l' cette dernière valeur est modifiée; toutefois, le conteneur est encore considéré comme immuable, parce que la collecte des objets qu'il contient ne peut pas être modifié. Ainsi, l'immutabilité n'est pas strictement la même chose que d'avoir une valeur éternelle, c'est plus subtil.)

Un objet de la mutabilité est déterminée par son type; par exemple, des nombres, des chaînes et des n-uplets sont immuable, tandis que les dictionnaires et les listes sont mutables.