CODEWITHSUNDEEP
python
maverick
maverick

Reputation: 279

Does python create an object for string constants in equality comparisons?

In python for comparisons like this, does python create a temporary object for the string constant "help" and then continue with the equality comparison ? The object would be GCed after some point.

s1 = "nohelp"
if s1 == "help":
   # Blah Blah

Upvotes: 3

Views: 463

Answers (1)

PM 2Ring
PM 2Ring

Reputation: 55479

String literals, like all Python constants, are created during compile time, when the source code is translated to byte code. And because all Python strings are immutable the interpreter can re-use the same string object if it encounters the same string literal in multiple places. It can even do that if the literal string is created via concatenation of literals, but not if the string is built by concatenating a string literal to an existing string object.

Here's a short demo that creates a few identical strings inside and outside of functions. It also dumps the disassembled byte code of one of the functions.

from __future__ import print_function
from dis import dis

def f1(s):
    a = "help"
    print('f1', id(s), id(a))
    return s > a 

def f2(s):
    a = "help"
    print('f2', id(s), id(a))
    return s > a 

a = "help"
print(id(a))
print(f1("he" + "lp")) 
b = "h"
print(f2(b + "elp")) 

print("\nf1")
dis(f1)

typical output on a 32 bit machine running Python 2.6.6

3073880672
f1 3073880672 3073880672
False
f2 3073636576 3073880672
False

f1
 26           0 LOAD_CONST               1 ('help')
              3 STORE_FAST               1 (a)

 27           6 LOAD_GLOBAL              0 (print)
              9 LOAD_CONST               2 ('f1')
             12 LOAD_GLOBAL              1 (id)
             15 LOAD_FAST                0 (s)
             18 CALL_FUNCTION            1
             21 LOAD_GLOBAL              1 (id)
             24 LOAD_FAST                1 (a)
             27 CALL_FUNCTION            1
             30 CALL_FUNCTION            3
             33 POP_TOP             

 28          34 LOAD_FAST                0 (s)
             37 LOAD_FAST                1 (a)
             40 COMPARE_OP               4 (>)
             43 RETURN_VALUE

Note that the ids of all the "help" strings are identical, apart from the one constructed with b + "elp".
(BTW, Python will concatenate adjacent string literals, so instead of writing "he" + "lp" I could've written "he" "lp", or even "he""lp").

The string literals themselves are not freed until the process is cleaning itself up at termination, however a string like b would be GC'ed if it went out of scope.

Note that in CPython (standard Python) when objects are GC'ed their memory is returned to Python's allocation system for recycling, not to the OS. Python does return unneeded memory to the OS, but only in special circumstances. See Releasing memory in Python and Why doesn't memory get released to system after large queries (or series of queries) in django?

Another question that discusses this topic: Why strings object are cached in python

Upvotes: 5

Related Questions