Hyppää sisältöön

Ei vielä käännetty

Tätä sivua ei ole vielä käännetty suomeksi, joten se näytetään englanniksi. Auta kääntämään

print() Function Complexity

The print() function outputs text to standard output.

Complexity Analysis

Case Time Space Notes
Print single argument O(n)* O(n) n = string length; * I/O dominates
Print multiple arguments O(n + m) O(n + m) n = total string length
Print with formatting O(n) O(n) String conversion cost
Print to file O(n) O(n) Same as stdout

Basic Usage

Single Argument

# O(n) - where n is string length
print("hello")              # Output: hello
print(42)                   # Output: 42
print([1, 2, 3])           # Output: [1, 2, 3]

Multiple Arguments

# O(n + m) - total string length of all arguments
print("Hello", "World")     # Output: Hello World
print("x =", 42)           # Output: x = 42
print(1, 2, 3, 4, 5)       # Output: 1 2 3 4 5

Custom Separators and Terminators

# O(n) - separator/end parameters affect output only
print("a", "b", "c", sep=", ")  # Output: a, b, c
print("no newline", end="")     # No trailing newline
print("x", "y", sep="-", end="!\n")  # Output: x-y!

Complexity Details

String Conversion

Each argument must be converted to string (if not already):

# O(1) - string argument, just write
print("hello")

# O(1) - integer to string conversion
print(42)

# O(n) - list conversion, where n = number of elements
items = [1, 2, 3, 4, 5]
print(items)  # O(n) - builds string representation

# O(n) - dictionary conversion
data = {"a": 1, "b": 2}
print(data)   # O(n) - string representation

Multiple Arguments

# O(n + m) - time to convert and write both
print("Count:", 42)  # O(2) approximately

# O(k * n) - k arguments, each of size ~n
args = [str(i) for i in range(100)]
print(*args)  # O(100) - 100 conversions + writes

Performance Patterns

Repeated Printing

# O(n * k) - n = string length, k = iterations
for i in range(1000):
    print(f"Iteration {i}")  # O(1000) total

# Accumulate then print once - better if massive
lines = []
for i in range(1000):
    lines.append(f"Iteration {i}")
print("\n".join(lines))  # O(n) single write

Writing Many Values

# O(n) - each item is O(1) conversion + write
values = list(range(10))
for val in values:
    print(val)  # O(10) total - constant per item

# More efficient - collect then print
print(*values)  # O(n) - single operation

Formatted Output

# O(n) - string formatting cost
print(f"Value: {42}")      # O(1) - simple format
print(f"Value: {large_list}")  # O(n) - depends on list size

# String format method
print("Value: {}".format(value))  # O(n) - conversion cost
print("Value: %s" % value)        # O(n) - conversion cost

I/O Considerations

Writing to Files

# O(n) - same complexity as stdout
output_file = open("output.txt", "w")

# Time = string conversion + I/O write time
print("Line 1", file=output_file)
print("Line 2", file=output_file)

output_file.close()

# Batch writing - more efficient
with open("output.txt", "w") as f:
    for i in range(1000):
        print(f"Line {i}", file=f)  # O(n) total

Comparison with Alternatives

String Concatenation vs Print

# Inefficient - builds intermediate strings
output = ""
for i in range(1000):
    output += f"Item {i}\n"  # O(n^2) - string concatenation
print(output)

# Better - collect then print
items = []
for i in range(1000):
    items.append(f"Item {i}")
print("\n".join(items))  # O(n) - single join + print

# Best - print directly
for i in range(1000):
    print(f"Item {i}")  # O(n) - direct output

sys.stdout.write() vs print()

import sys

# print() adds overhead for argument handling
print("hello world")  # Slightly slower

# Direct write - O(n) same complexity, less overhead
sys.stdout.write("hello world\n")  # O(n), minimal overhead

# For many small writes, print() convenience vs write() speed
# Difference is negligible in practice

Edge Cases

Empty Print

# O(1) - just writes newline
print()  # Output: \n

None and Special Values

# O(1) - conversion to string "None"
print(None)  # Output: None

# O(1) - boolean conversion
print(True)  # Output: True
print(False)  # Output: False

Circular References

# O(n) - detects circular references gracefully
lst = []
lst.append(lst)
print(lst)  # Output: [[...]] - handles circular refs

Best Practices

✅ Do:

  • Collect strings then print once for massive output

❌ Avoid:

  • Building large strings with += before printing (O(n²))
  • Calling flush=True unless you need immediate output
  • Printing inside tight loops without buffering considerations
  • Complex string formatting when simple concatenation suffices

Version Notes

  • Python 2.x: print is a statement, not a function
  • Python 3.x: print() is a function with keyword arguments
  • All versions: I/O complexity dominated by actual write time, not computation