Python - Python's built-in functions

Built-in Functions in Python

Python is a powerful and versatile programming language known for its simplicity and readability. One of the key features that contribute to Python’s efficiency is its rich set of built-in functions. These functions are always available for use without requiring any imports or external modules. Understanding these built-in functions can significantly enhance a developer’s ability to write clean, concise, and efficient code.

Introduction to Built-in Functions

Built-in functions in Python are functions that are always available in the Python environment. These functions are implemented in C and are part of the Python Standard Library. There are more than 70 built-in functions in Python 3, each serving a unique and often commonly needed task.

Examples of such functions include len() for measuring length, type() for checking data types, int() for converting to integers, and sum() for adding elements of an iterable.

Advantages of Using Built-in Functions

• Optimized for performance and reliability
• Reduce the need for writing boilerplate code
• Improve readability and maintainability
• Enhance consistency across projects

Categories of Built-in Functions

For easier understanding, we will group the built-in functions into several categories:

• Type Conversion Functions
• Mathematical Functions
• Iterable and Collection Functions
• Input/Output Functions
• Object Introspection Functions
• Functional Programming Helpers
• Utility Functions

Type Conversion Functions

These functions are used to convert one data type into another.

int(), float(), complex()

int("42")      # Converts string to integer
float("3.14")  # Converts string to float
complex(2, 3)  # Creates a complex number (2+3j)

str(), repr()

str(123)       # Returns string '123'
repr(123)      # Returns string '123' (representation)

bool()

bool(0)        # Returns False
bool("Hello")  # Returns True

chr(), ord()

chr(97)        # Returns 'a'
ord('a')       # Returns 97

list(), tuple(), set(), dict()

list("abc")    # ['a', 'b', 'c']
tuple([1, 2])  # (1, 2)
set([1, 2, 2]) # {1, 2}
dict([[1, 'a'], [2, 'b']])  # {1: 'a', 2: 'b'}

Mathematical Functions

abs()

abs(-10)       # Returns 10

round()

round(3.14159, 2)  # Returns 3.14

divmod()

divmod(10, 3)      # Returns (3, 1)

pow()

pow(2, 3)          # Returns 8 (2**3)
pow(2, 3, 5)       # Returns 3 (modulo 5)

Iterable and Collection Functions

len()

len("Python")      # Returns 6

sum()

sum([1, 2, 3])     # Returns 6

max(), min()

max([3, 5, 2])     # Returns 5
min([3, 5, 2])     # Returns 2

sorted()

sorted([3, 1, 2])  # Returns [1, 2, 3]

any(), all()

any([0, False, 5])  # Returns True
all([1, True, 3])   # Returns True

enumerate()

for i, value in enumerate(['a', 'b']):
    print(i, value)

zip()

list(zip([1, 2], ['a', 'b']))  # [(1, 'a'), (2, 'b')]

Input/Output Functions

input()

name = input("Enter your name: ")

print()

print("Hello", "World", sep="-", end="!")

Object Introspection Functions

These functions are used to examine or introspect objects.

type()

type(10)           # 

id()

id("a")            # Memory address

isinstance(), issubclass()

isinstance(10, int)      # True
issubclass(bool, int)    # True

callable()

callable(len)            # True
callable(42)             # False

dir()

dir("abc")               # Lists available methods and attributes

vars()

class A:
    def __init__(self):
        self.x = 5

a = A()
print(vars(a))           # {'x': 5}

Functional Programming Helpers

map()

list(map(str.upper, ['a', 'b']))  # ['A', 'B']

filter()

list(filter(lambda x: x % 2 == 0, [1, 2, 3]))  # [2]

reduce()

from functools import reduce
reduce(lambda x, y: x + y, [1, 2, 3])  # 6

lambda

square = lambda x: x * x
print(square(5))  # 25

Utility Functions

help()

help(print)  # Displays documentation

eval()

eval("3 + 4")  # Returns 7

exec()

exec("x = 5")
print(x)  # Outputs 5

compile()

code = compile('x = 10\nprint(x)', '', 'exec')
exec(code)

open()

f = open('file.txt', 'r')
content = f.read()
f.close()

Deprecated or Less Common Built-in Functions

Some functions are rarely used directly by beginners but can be powerful tools.

memoryview()

mv = memoryview(bytearray('xyz', 'utf-8'))
print(mv[0])  # 120

bytearray(), bytes()

ba = bytearray([65, 66, 67])
print(ba)  # bytearray(b'ABC')

Best Practices for Using Built-in Functions

• Use built-in functions instead of reinventing the wheel.
• Prefer built-ins over custom implementations for readability and performance.
• Refer to the official Python documentation for the complete list.
• Avoid overwriting built-in function names with variables (e.g., don’t name a variable list).

Common Pitfalls to Avoid

• Overriding built-in function names: e.g., str = "hello" can cause errors.
• Misusing eval() or exec(): These can pose security risks if used on untrusted input.
• Using input() without casting: It returns a string by default.

Python’s built-in functions are incredibly powerful and form the backbone of efficient Python programming. Mastering them allows you to write more effective, readable, and maintainable code. These functions cover a wide range of functionalities—from type conversions, data manipulation, mathematical operations, to introspection and file handling.

Being familiar with these built-ins not only saves time but also reduces the need for external libraries or additional code. Whether you're a beginner or an experienced developer, keeping a solid grasp on Python's built-in capabilities is essential to becoming a proficient Python programmer.

To explore even more, visit the official documentation on Python’s built-in functions.