As strings de Python não são imutáveis? Então, por que a + “” + b funciona?

Meu entendimento era que as strings Python são imutáveis.

Tentei o seguinte código:

a = "Dog"
b = "eats"
c = "treats"

print a, b, c
# Dog eats treats

print a + " " + b + " " + c
# Dog eats treats

print a
# Dog

a = a + " " + b + " " + c
print a
# Dog eats treats
# !!!

O Python não deveria ter impedido a atribuição? Provavelmente estou perdendo alguma coisa.

Qualquer ideia?

Primeiro aapontou para a string "Dog". Em seguida, você alterou a variável apara apontar para uma nova string "Dog come trata". Você não alterou a string "Dog". Strings são imutáveis, variáveis ​​podem apontar para o que quiserem.

Os próprios objetos string são imutáveis.

A variável, aque aponta para a string, é mutável.

Considerar:

a = "Foo"
# a now points to "Foo"
b = a
# b points to the same "Foo" that a points to
a = a + a
# a points to the new string "FooFoo", but b still points to the old "Foo"

print a
print b
# Outputs:

# FooFoo
# Foo

# Observe that b hasn't changed, even though a has.

A variável a está apontando para o objeto "Cachorro". É melhor pensar na variável em Python como uma tag. Você pode mover a tag para objetos diferentes, que é o que você fez quando mudou a = "dog"para a = "dog eats treats".

No entanto, a imutabilidade se refere ao objeto, não à tag.

Se você tentasse a[1] = 'z'fazer "dog"em "dzg", obteria o erro:

TypeError: 'str' object does not support item assignment" 

porque as strings não suportam atribuição de itens, portanto, são imutáveis.

Algo é mutável apenas quando somos capazes de alterar os valores mantidos no local da memória sem alterar o próprio local da memória.

O truque é: se você descobrir que a localização da memória antes e depois da alteração é a mesma, ela é mutável.

Por exemplo, a lista é mutável. Quão?

>> a = ['hello']
>> id(a)
139767295067632

# Now let's modify
#1
>> a[0] = "hello new"
>> a
['hello new']
Now that we have changed "a", let's see the location of a
>> id(a)
139767295067632
so it is the same as before. So we mutated a. So list is mutable.

Uma string é imutável. Como podemos provar isso?

> a = "hello"
> a[0]
'h'
# Now let's modify it
> a[0] = 'n'
----------------------------------------------------------------------

Nós temos

TypeError: o objeto 'str' não suporta atribuição de item

Portanto, falhamos na mutação da string. Isso significa que uma string é imutável.

Ao reatribuir, você altera a variável para apontar para um novo local. Aqui você não alterou a string, mas alterou a própria variável. A seguir está o que você está fazendo.

>> a = "hello"
>> id(a)
139767308749440
>> a ="world"
>> id(a)
139767293625808

idantes e depois da reatribuição é diferente, então isso prova que você não está realmente sofrendo mutação, mas apontando a variável para um novo local. O que não é uma mutação dessa string, mas uma mutação dessa variável.

Uma variável é apenas um rótulo apontando para um objeto. O objeto é imutável, mas você pode fazer o rótulo apontar para um objeto completamente diferente, se desejar.

Considerar:

>>> a='asdf'
>>> a.__repr__
<method-wrapper '__repr__' of str object at 0x1091aab90>
>>> a='asdf'
>>> a.__repr__
<method-wrapper '__repr__' of str object at 0x1091aab90>
>>> a='qwer'
>>> a.__repr__
<method-wrapper '__repr__' of str object at 0x109198490>

Observe que a localização da memória hexadecimal não mudou quando armazenei o mesmo valor na variável duas vezes. Ele mudou quando armazenei um valor diferente. A string é imutável. Não por zelo, mas porque você paga a penalidade de desempenho de criar um novo objeto na memória. A variável aé apenas um rótulo apontando para aquele endereço de memória. Ele pode ser alterado para apontar para qualquer coisa.

A instrução a = a + " " + b + " " + cpode ser dividida com base em ponteiros.

a + " "diz para me dar o que aaponta, o que não pode ser alterado e adicionar" " ao meu conjunto de trabalho atual.

memória:

working_set = "Dog "
a = "Dog" 
b = "eats"
c = "treats"

+ bdiz para me dar o que baponta, o que não pode ser alterado, e adicioná-lo ao conjunto de trabalho atual.

memória:

working_set = "Dog eats"
a = "Dog" 
b = "eats"
c = "treats"

+ " " + cdiz adicionar " "ao conjunto atual. Em seguida, dê-me o que caponta, o que não pode ser alterado, e adicione-o ao conjunto de trabalho atual. memória:

working_set = "Dog eats treats"
a = "Dog" 
b = "eats"
c = "treats"

Por fim, a =diz definir meu ponteiro para apontar para o conjunto resultante.

memória:

a = "Dog eats treats"
b = "eats"
c = "treats"

"Dog"é recuperado, porque não há mais ponteiros se conectando a seu pedaço de memória. Nunca modificamos a seção de memória "Dog"em que residia, que é o que significa imutável. No entanto, podemos alterar quais rótulos, se houver, apontam para essa seção da memória.

l = [1,2,3]
print id(l)
l.append(4)
print id(l) #object l is the same

a = "dog"
print id(a)
a = "cat"
print id(a) #object a is a new object, previous one is deleted

Há uma diferença entre os dados e o rótulo ao qual estão associados. Por exemplo, quando você faz

a = "dog"

os dados "dog"são criados e colocados sob o rótulo a. O rótulo pode mudar, mas o que está na memória não. Os dados "dog"ainda existirão na memória (até que o coletor de lixo os exclua) depois que você fizer

a = "cat"

Em seu programa aagora ^ aponta para ^ "cat"mas a string "dog"não mudou.

As strings Python são imutáveis. No entanto, anão é uma string: é uma variável com um valor de string. Você não pode alterar a string, mas pode alterar o valor da variável para uma nova string.

As variáveis ​​podem apontar para qualquer lugar que desejarem. Um erro será gerado se você fizer o seguinte:

a = "dog"
print a                   #dog
a[1] = "g"                #ERROR!!!!!! STRINGS ARE IMMUTABLE

Os objetos de string do Python são imutáveis. Exemplo:

>>> a = 'tanim'
>>> 'Address of a is:{}'.format(id(a))
'Address of a is:64281536'
>>> a = 'ahmed'
>>> 'Address of a is:{}'.format(id(a))
'Address of a is:64281600'

Neste exemplo, podemos ver que quando atribuímos valores diferentes em um, ele não se modifica. Um novo objeto é criado.
E não pode ser modificado. Exemplo:

  >>> a[0] = 'c'
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    **TypeError**: 'str' object does not support item assignment

Ocorreu um erro.

'mutável' significa que podemos alterar o conteúdo da string, 'imutável' significa que não podemos adicionar uma string extra.

>>> a = 'dogs'

>>> a.replace('dogs', 'dogs eat treats')

'dogs eat treats'

>>> print a

'dogs'

Imutável, não é ?!

A parte da mudança variável já foi discutida.

Considere esta adição ao seu exemplo

 a = "Dog"
 b = "eats"
 c = "treats"
 print (a,b,c)
 #Dog eats treats
 d = a + " " + b + " " + c
 print (a)
 #Dog
 print (d)
 #Dog eats treats

Uma das explicações mais precisas que encontrei em um blog é:

Em Python, (quase) tudo é um objeto. O que comumente nos referimos como "variáveis" em Python são mais apropriadamente chamados de nomes. Da mesma forma, "atribuição" é realmente a vinculação de um nome a um objeto. Cada associação possui um escopo que define sua visibilidade, geralmente o bloco em que o nome se origina.

Por exemplo:

some_guy = 'Fred'
# ...
some_guy = 'George'

Quando mais tarde dissermos some_guy = 'George', o objeto string contendo 'Fred' não será afetado. Acabamos de alterar a vinculação do nome some_guy. Não mudamos, entretanto, os objetos string 'Fred' ou 'George'. No que nos diz respeito, eles podem viver indefinidamente.

Link para o blog: https://jeffknupp.com/blog/2012/11/13/is-python-callbyvalue-or-callbyreference-neither/

Adicionando um pouco mais às respostas mencionadas acima.

id de uma variável muda após a reatribuição.

>>> a = 'initial_string'
>>> id(a)
139982120425648
>>> a = 'new_string'
>>> id(a)
139982120425776

O que significa que alteramos a variável apara apontar para uma nova string. Agora existem dois string objetos (str):

'initial_string'com id= 139982120425648

e

'new_string'com id= 139982120425776

Considere o código abaixo:

>>> b = 'intitial_string'
>>> id(b)
139982120425648

Agora, baponta para 'initial_string'e tem o mesmo idque atinha antes da reatribuição.

Portanto, o 'intial_string'não sofreu mutação.

Resumindo:

a = 3
b = a
a = 3+2
print b
# 5

Não imutável:

a = 'OOP'
b = a
a = 'p'+a
print b
# OOP

Imutável:

a = [1,2,3]
b = range(len(a))
for i in range(len(a)):
    b[i] = a[i]+1

Este é um erro no Python 3 porque é imutável. E não é um erro no Python 2 porque claramente não é imutável.

A função id()interna retorna a identidade de um objeto como um inteiro. Este inteiro geralmente corresponde à localização do objeto na memória.

\>>a='dog'
\>>print(id(a))

139831803293008

\>>a=a+'cat'
\>>print(id(a))

139831803293120

Inicialmente, 'a' é armazenado no local da memória 139831803293008, pois o objeto string é imutável em python se você tentar modificar e reatribuir a referência será removida e será um ponteiro para um novo local da memória (139831803293120).

a = 'dog'
address = id(a)
print(id(a))

a = a + 'cat'
print(id(a))      #Address changes

import ctypes
ctypes.cast(address, ctypes.py_object).value    #value at old address is intact

Esta imagem dá a resposta. Por favor, leia.

Devemos apenas concatenar os dois valores de string. Nunca mudamos o valor de (a). Agora, (a) representa outro bloco de memória que tem o valor "cãozinho". Porque no backend, uma variável nunca representa dois blocos de memória ao mesmo tempo. O valor de (a) antes da concatenação era "cachorro". Mas depois disso (a) representam o "cãozinho", porque agora (a) no representante de backend. o bloco que tem o valor "dogdog". E "cachorro" é representante. por (b) e "cachorro" não é contado como valor de lixo até que (b) represente o "cachorro".

A confusão é que representamos os blocos de memória (que contêm dados ou informações) no backend com o mesmo nome de variável.

Você pode tornar uma matriz numpy imutável e usar o primeiro elemento:

numpyarrayname[0] = "write once"

então:

numpyarrayname.setflags(write=False)

ou

numpyarrayname.flags.writeable = False