Built-in functions

Python’s built-in functions are the Swiss Army knife of the language — small, fast, always available, and surprisingly powerful. They handle common tasks like printing, length calculation, iteration, sorting, summing, mapping, and more, often faster and cleaner than custom code. Mastering them is one of the fastest ways to write professional, Pythonic code.

In 2026, these functions remain essential — even with libraries like pandas, NumPy, and Polars, you still reach for them constantly. Here’s a practical guide to the most useful built-ins, with real-world patterns, tips, and modern usage.

1. Output & Debugging: print()


name = "Alice"
age = 30

# Basic print
print("Hello,", name)

# f-strings (Python 3.6+) — cleanest way
print(f"{name} is {age} years old.")

# Debugging with variables (Python 3.8+ walrus-style)
print(f"{age = }")          # age = 30
print(f"{name = !r}")       # name = 'Alice'

2. Length & Size: len()


my_list = [1, 2, 3, 4, 5]
my_string = "Hello world"
my_dict = {"a": 1, "b": 2}

print(len(my_list))     # 5
print(len(my_string))   # 11
print(len(my_dict))     # 2  (number of keys)

3. Sequences & Ranges: range(), enumerate(), zip()


# range() — perfect for loops with indices or counters
for i in range(5):              # 0 to 4
    print(i)

for i in range(2, 10, 2):       # 2, 4, 6, 8
    print(i)

# enumerate() — loop with index + value
fruits = ["apple", "banana", "cherry"]
for idx, fruit in enumerate(fruits, start=1):
    print(f"{idx}. {fruit}")

# zip() — parallel iteration over multiple iterables
names = ["Alice", "Bob", "Charlie"]
ages = [30, 25, 35]
for name, age in zip(names, ages):
    print(f"{name} is {age}")

4. Math & Aggregation: sum(), min(), max(), sorted()


numbers = [5, 2, 8, 1, 9]

print(sum(numbers))          # 25
print(min(numbers))          # 1
print(max(numbers))          # 9

# sorted() — returns new sorted list (original unchanged)
sorted_nums = sorted(numbers)            # [1, 2, 5, 8, 9]
sorted_desc = sorted(numbers, reverse=True)  # [9, 8, 5, 2, 1]

# Sort strings case-insensitively
words = ["Zebra", "apple", "Banana"]
print(sorted(words, key=str.lower))      # ['apple', 'Banana', 'Zebra']

5. Functional Tools: map(), filter()


nums = [1, 2, 3, 4, 5]

# map() — apply function to every element
squared = list(map(lambda x: x**2, nums))       # [1, 4, 9, 16, 25]

# filter() — keep elements that match condition
evens = list(filter(lambda x: x % 2 == 0, nums))  # [2, 4]

# Modern list comprehension alternative (often more readable)
squared_comp = [x**2 for x in nums]
evens_comp = [x for x in nums if x % 2 == 0]

6. Quick Conversion & Inspection: list(), dict(), set(), type()


# list() — convert iterable to list
print(list(range(5)))        # [0, 1, 2, 3, 4]

# dict() — from pairs
pairs = [('a', 1), ('b', 2)]
print(dict(pairs))           # {'a': 1, 'b': 2}

# set() — unique elements
print(set([1, 2, 2, 3]))     # {1, 2, 3}

# type() — inspect object type
print(type(42))              #

Best Practices & Common Patterns (2026 Edition)

Prefer f-strings over .format() or % — faster and more readable
Use enumerate(start=1) when 1-based indexing is needed (reports, UI)
zip(*lists) + zip() unpacking for transposing data
Avoid map()/filter() with lambdas when list comprehensions are clearer
Use sorted(key=…) with custom functions or operator.itemgetter for complex sorts
Pitfall: range() in Python 3 returns a range object — use list(range()) only when needed
Modern tip: combine with walrus operator (:=) for concise assignment in loops/conditions

Conclusion

Python’s built-in functions are small, fast, and always available — mastering them makes your code cleaner, faster, and more Pythonic. In 2026, reach for print, len, range, enumerate, zip, sum/min/max/sorted, map/filter, and conversion tools first — before writing custom loops or importing extras. These functions power 80% of your everyday data tasks, from quick scripts to production pipelines.

Next time you write a loop or process a list — ask: “Can a built-in do this better?” The answer is usually yes. Practice them, and your code will become noticeably more elegant and efficient.