Small Integer Pool

The small integer pool is a memory optimizaton strategy implemented in CPython to reduce memory allocation and garbage collection overhead caused by frequent creation and destruction of commonly used small integers. When the CPython interpreter starts, it pre-creates and caches all integers in the range from -5 to 256 inclusive. Any reference to an integer within this range will reuse the pre-allocated cached object instead of creating a new one.

This specific range was chosen based on real-world usage frequency: these values appear constantly in common programming scenarios like loop counting, sequence indexing, and status codes, so reusing them delivers measurable performance and memory benefits. The two main advantages of the small integer pool are:

1. Performence improvement: Avoids repeated memory allocation and deallocation operations for common values, cutting runtime overhead
2. Memory efficiency: Eliminates duplicate copies of the same small integer in memory, reducing overall memory usage

x = 12
y = 12
print(x is y) # Output: True, both variables reference the same cached object

u = 280
v = 280
print(u is v) # Output is often False in standard Python REPL, as 280 is outside the default small integer pool range
# Note: In IDEs like PyCharm or Jupyter, additional interpreter-level optimizations may reuse same-value larger integers. This behavior is environment-specific, not required by the Python language specification.

In the example above:

• x and y both reference the same pre-cached 12 object from the small integer pool
• u and v have the same value but may reference different objects, since 280 falls outside the default cached range

String Interning (Internal String Pool)

Python also uses a string optimization mechanism called string enterning, which maintains an internal pool of strings to ensure only one copy of each unique string content exists in memory. This optimization is primarily applied to short strings that match identifier naming rules, such as words without spaces or special symbols. When creating a new eligible string, the interpreter first checks the pool for an identical existing string, and reuses it if found instead of allocating new memory.

>>> str1 = 'qwertyuioasdfg'
>>> str2 = 'qwertyuioasdfg'
>>> print(str1 is str2)
True
>>> print(str1 == str2)
True

greeting1 = "world"
greeting2 = "world"
print(greeting1 is greeting2) # Usually outputs True, the string is interned

dynamic1 = "".join(["wo", "rld"]) # Dynamically generated strings are usually not interned
dynamic2 = "".join(["wo", "rld"])
print(dynamic1 is dynamic2) # Usually outputs False, no interning applied

Manual Interning with sys.intern()

You can manually force interning for any string using sys.intern(), which is useful for performance optimization when working with many repeated dynamic strings:

# Test in Python REPL:
>>> a = "hello world"
>>> b = "hello world"
>>> print(a is b)
False
>>> print(a == b)
True
>>> import sys
>>> x = sys.intern('hello python')
>>> y = sys.intern('hello python')
>>> print(x is y)
True
>>> print(x == y)
True

Difference Between is and ==

• is checks if two variables reference the exact same object in memory, comparing object identity
• == checks only if the values stored in the two objects are equal, regardless of whether they are the same object

The print() Function

print() is Python's standard function for outputting data to the console or other output streams. It accepts multiple input values and several optional keyword parameters to customize output behavior:

• file: A file-like object to write output to; defaults to the current standard output stream sys.stdout
• sep: String inserted between multiple input values; defaults to a single space
• end: String appended after the last input value; defaults to a newline character \n
• flush: Boolean flag that forces an immediate flush of the output stream if set to True

Usage Examples

user_age = 28
username = "Alex"

# Basic usage with multiple parameters, custom separator and ending
print("Name:", username, "Age:", user_age)
print("Name:", username, "Age:", user_age, sep=" | ", end="\n----------\n")

# Output to a file instead of console
with open('print_output.txt', 'w') as out_stream:
    print("Name:", username, "Age:", user_age, file=out_stream)

# Old-style % formatting
print("Name is %s, age is %d" % (username, user_age))

# f-string formatting (Python 3.6+)
print(f"Name is {username}, age is {user_age}")

# str.format() with positional arguments
print("Name is {}, age is {}".format(username, user_age))
print("Name is {1}, age is {0}".format(user_age, username))

# Formatting with dictionary inputs
print("Name is {name}, age is {age}".format(name="Alex", age=28))
print("Name is {name}, age is {age}".format(**{"name": "Alex", "age": 28}))
print("Name is {name}, age is {age}".format_map({"name": "Alex", "age": 28}))

# String concatenation
print("Name is " + username + ", age is " + str(user_age))

# Joining a list of strings
print("Name is " + ", age is ".join([username, str(user_age)]) )

Common String Operations

# Repeat a string n times with multiplication
print("=" * 50)

# Access character by 0-based index
sample_str = "apple"
print(sample_str[1])

# Slice strings
text = "pythonbasics"
print(text[0:6])
print(text[6:])
print(text[:6])
print(text[0:6:2]) # Step of 2
print(text[::-1]) # Reverse the entire string

# Get string length
print(len("hello"))

# Check prefix and suffix
test_str = "introduction"
print(test_str.startswith("in"))
print(test_str.endswith("tion"))

# Find substring, return -1 if not found
print("test string".find("str"))
print("test string".find("xyz"))

# Find substring, raise ValueError if not found
print("test string".index("str"))
# print("test string".index("xyz")) # Uncomment to raise exception

# Count occurrences of a substring
print("abababa".count("aba"))

# Replace all occurrences of a substring
print("hello world".replace("hello", "hi"))

# Split string by delimiter, optional maximum split count
print("a b c d".split(" "))
print("a b c d".split(" ", 1)) # Split only once

# Join a list of strings with a delimiter
print(", ".join(["apple", "banana", "cherry"]))
print("".join(["a", "b", "c"]))

# Strip whitespace from both ends
print("  hello world  \n".strip())

# Strip whitespace from left end
print("  hello world  \n".lstrip())

# Strip whitespace from right end
print("  hello world  \n".rstrip())

# Convert string case
print("hello".upper())
print("HELLO".lower())

# Check if all characters are alphabetic
print("abc123".isalpha())
print("abc".isalpha())

# Check if all characters are digits
print("1234".isdigit())
print("12a4".isdigit())

# Check if all characters are alphanumeric
print("abc123".isalnum())
print("abc 123".isalnum())

# Check if string contains only whitespace
print("   \n".isspace())

# Check if string is all upper or lower case
print("HELLO".isupper())
print("hello".islower())