Python strives to be simple and clear, so some operations are implemented as built-in functions, while others are object-specific methods. This distinction arises from the way Python handles different types of objects.

Built-in Functions

len() is a built-in function that works with many different types, including strings, lists, tuples, dictionaries, and more. This allows for a consistent and flexible way to handle sequences, without requiring each type to define its own method for length. Internally, len() works by calling the object’s special method __len__(). The main advantage of using len() as a function is that it can work across various data types in Python.

Examples of Built-in Functions:

len(): Returns the length of any sequence type.

len("hello")  # 5
len([1, 2, 3])  # 3

range(): Returns a sequence of numbers, often used in loops.

list(range(5))  # [0, 1, 2, 3, 4]

type(): Returns the type of an object.

type(42)  # <class 'int'>

Object-Oriented Methods

On the other hand, methods like upper(), lower(), and strip() are specific to string objects. These methods operate directly on string instances and provide functionality specific to text manipulation. By defining string-specific behaviors as methods, Python follows an object-oriented approach, where the behavior (methods) is tied to the object (strings).

Examples of Object-Oriented Methods:

upper(): Converts all characters in the string to uppercase.

"hello".upper()  # 'HELLO'

lower(): Converts all characters in the string to lowercase.

"HELLO".lower()  # 'hello'

strip(): Removes whitespace (or specified characters) from both ends of the string.

" hello ".strip() # 'hello'

Consistency and Duck Typing

The len() function showcases Python’s duck typing philosophy: “if it looks like a duck and quacks like a duck, it must be a duck.” The function works with any object that defines the __len__() method, be it a list, a string, or a user-defined class. In contrast, methods like upper() apply only to strings, and keeping them as methods makes their usage more intuitive and logical within the context of the object they operate on.

Historical Reason

Historically, Python adopted certain built-in functions (like len(), max(), range()) to provide a consistent interface across multiple data types. This reduces complexity and ensures that common operations are easily accessible for all kinds of objects. Methods like upper() and lower() emerged as part of Python’s gradual shift toward a more object-oriented paradigm, allowing for clearer, more object-specific functionality.

More Examples: Built-in Functions and Methods

To clarify the distinction further, let’s look at a few more examples of Python’s built-in functions versus object-oriented methods.

Other Built-in Functions

sum(): Returns the sum of a sequence.

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

max(): Returns the maximum value in a sequence.

max([1, 2, 3])  # 3

Other Object-Oriented Methods

count(): Counts the number of occurrences of a substring in a string.

"banana".count("a")  # 3

find(): Finds the first occurrence of a substring.

"banana".find("n")  # 2

Conclusion

In Python, built-in functions like len() are designed to work with multiple data types, promoting consistency and flexibility. Meanwhile, methods like upper() are object-specific, allowing for clearer and more object-oriented manipulation. This design choice helps Python remain simple, readable, and powerful, adhering to its guiding principles of clarity and elegance.