The string objects themselves are immutable.

The variable, a, which points to the string, is mutable.

Consider:

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.

Because strings are mostly used as values, not as references. fruit = 'apple' frist_ingridient = fruit #apple recipe = f'Put one {fruit} on a plate' print(frist_ingridient, recipe) #apple Put one apple on a plate fruit[0] = 'A' #we don't change frist_ingridient or recipe here print(frist_ingridient, recipe) #Apple Put one apple on a plate - frist_ingridient has changed!

A variable in Python holds a reference to an object, not the object itself. So reassigning a variable is different from modifying an object. If you have a variable that points to a string, you can reassign it to point to a different string, but you can't modify the string itself. The flip-side of this is that you never have to worry about a string changing unexpectedly because some other part of your program holds a reference to it. In contrast, if you have a mutable object like a list, this kind of thing can happen: >>> list1 = [] >>> list2 = list1 # both variables point to the same list >>> print(list1 is list2) True >>> list1.append(123) >>> print(list1) [123] >>> print(list2) [123]

Well, immutability is overall a good thing. It prevents many dumb mistakes, for one, and since immutable types' methods return new instances, method chaining is not only possible but easy and "safe". Say strings were mutable. You could no longer use them as dictionary keys, which would make JSON parsing much more annoying and less intuitive. It would also mean that you'd have to treat them with care just like lists because, while assigning immutable references is in practice not really different from copying values, with mutable types you run the risk of mutating values you never intended. You would have to start explicitly copying strings, which is not intuitive especially to newcomers.

What does that mean exactly? You've already said exactly what it means (impossible to change), so I'll clarify: the programming language does not allow immutable values to change. A variable is like a name tag: you can stick it on whatever you please. If I reattach my name tag onto you, though, I haven't actually changed myself into you. Whether you or I have changed (eg, get a tattoo, grow a tail) is an entirely different question; the name tag has nothing to do with it. The same distinction applies between a variable and the value assigned to it. Variables (unlike values) are names that can be (re)assigned. Can we change a value itself rather than a variable assignment? This distinction matters when multiple variables are assigned to the same value. When a value itself changes, all variables assigned to it are still assigned to the updated value: no variable reassignments are needed to "propagate" the update. This differs from tracking down every single variable and reassigning its value. Consider the code python variable1 = 'string' variable2 = variable1 with both variable1 and variable2 assigned the same string value. Is it possible to update the value assigned to variable2 by only manipulating variable1? Not in python.