Python 1.1: What's New, Release History & EOL Status

What Is New in Python 1.1

Python 1.1 added several important features including callable objects, lambda expressions, map(), filter(), reduce() built-ins, and significant improvements to the class system and module handling. It brought Python closer to a complete functional and object-oriented language.

Key Additions in Python 1.1

lambda -- Anonymous Functions

lambda creates a small anonymous function inline. It is limited to a single expression -- no statements allowed, no multi-line bodies. In Python 1.1, lambda was the primary way to pass a simple function to map(), filter(), or sorted()-like calls before list comprehensions or generator expressions existed.

double = lambda x: x * 2
square = lambda x: x ** 2

print(double(5))   # 10
print(square(4))   # 16

# Used with map/filter:
numbers = [1, 2, 3, 4, 5, 6]
evens   = list(filter(lambda x: x % 2 == 0, numbers))
doubled = list(map(lambda x: x * 2, numbers))

In modern Python, list comprehensions and generator expressions are preferred over map()/filter() with lambdas for readability. Lambdas remain useful as callbacks in GUI code, sorting keys, and functional-style pipelines.

map(), filter(), reduce()

These three higher-order functions, borrowed from functional programming, apply a function to every element of an iterable, select elements matching a predicate, and fold a sequence to a single value, respectively.

from functools import reduce  # in Python 3, reduce moved to functools

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

doubled  = list(map(lambda x: x * 2, nums))     # [2, 4, 6, 8, 10]
evens    = list(filter(lambda x: x % 2 == 0, nums))  # [2, 4]
total    = reduce(lambda acc, x: acc + x, nums)  # 15

Callable Objects via __call__

Implementing __call__ on a class makes instances callable like functions. This pattern is used for stateful callables -- objects that behave like functions but carry configuration or accumulated state.

class Multiplier:
    def __init__(self, factor):
        self.factor = factor

    def __call__(self, value):
        return value * self.factor

triple = Multiplier(3)
print(triple(10))  # 30
print(callable(triple))  # True