Comparing Duck Typing in Python's Built-in Types

>>> from collections.abc import Iterable, Iterator
>>> from typing import Any

>>> obj: Iterable[Any] = ...  # instantiation logic
>>> iter_: Iterator = obj.__iter__()
>>> hasattr(iter_, '__iter__')
True
>>> hasattr(iter_, '__next__')
True

>>> reversed({"a": 1, "b": 2})
<dict_reversekeyiterator object at 0x7aee027c89f0>

>>> sorted(set([3, 1, 2]))
[1, 2, 3]
>>> sorted(range(3))
[0, 1, 2]
>>> sorted({"b": 2, "a": 1})
['a', 'b']

#!/usr/bin/python3.11
"""
./getting_to_know_duck_typing_in_python/operations_supported.py

For a set of built-in Python types, determine whether they support 
common object protocols and operations, such as iteration, indexing, 
slicing, concatenation, length retrieval, reversing, and sorting.

This script illustrates Python's dynamic and duck-typed behavior by
attempting to perform these operations on concrete instances of
selected built-in types, and recording which operations succeed.

Note
----
From a mathematical standpoint, this process does not constitute a 
formal proof of support, as instantiation inherently limits generality.
Specifically, attempting operations on default-constructed instances 
(i.e., with no arguments) represents an extreme and often minimal case.

Nevertheless, such an approach is adopted here for pedagogical clarity 
and practical inspection, enabling empirical observation of behavior
while respecting Python’s runtime-driven model of polymorphism.
"""

from typing import Any


class Table:
    """
    Table for evaluating support for common operations across built-in 
    Python types.

    The objective of this exercise is to recreate the values shown in
    the tutorial's reference table. To do so, each built-in type is 
    instantiated with default arguments, and operations are applied 
    directly to the resulting object. While this does not cover all 
    possible instantiations or edge cases, it offers a practical and 
    reproducible means of observing runtime behavior.

    This approach aligns with Python's duck typing philosophy by 
    emphasizing behavior over static type declarations.

    Attributes
    ----------
    built_in_types : list[Any]
        List of initialized instances of built-in types to evaluate.
    """

    def __init__(self) -> None:
        """
        Initialize built-in type instances using zero-argument 
        constructors.

        Empty instantiation is used to enable consistent, 
        side-effect-free application of protocol operations without 
        requiring parameter handling.

        Note
        ----
        Since the `range` constructor requires at least one argument 
        (`stop`), object `range(0)` is used as a minimal, valid 
        instantiation. 
        """
        self.built_in_types: list[Any] = [
            list(), tuple(), str(), range(0), set(), dict()
        ]

    @property
    def iteration(self) -> list[bool]:
        """
        Check whether each object supports iteration via `iter(obj)`.

        Returns
        -------
        list[bool]
            True if the object is iterable; False otherwise.
        """
        results: list[bool] = []
        for obj in self.built_in_types:
            try:
                _: Any = iter(obj)
                results.append(True)
            except Exception:
                results.append(False)
        return results

    @property
    def indexing(self) -> list[bool]:
        """
        Check whether `obj[0]` is valid for each object.

        Returns
        -------
        list[bool]
            True if the object allows positional indexing; False 
            otherwise.

        Notes
        -----
        IndexError is interpreted as valid indexing on an empty 
        structure.
        """
        results: list[bool] = []
        for obj in self.built_in_types:
            try:
                _: Any = obj[0]
                results.append(True)
            except IndexError:
                results.append(True)
            except (KeyError, TypeError):
                results.append(False)
        return results

    @property
    def slicing(self) -> list[bool]:
        """
        Check whether `obj[:]` is valid for each object.

        Returns
        -------
        list[bool]
            True if the object supports slicing; False otherwise.
        """
        results: list[bool] = []
        for obj in self.built_in_types:
            try:
                _: Any = obj[:]
                results.append(True)
            except TypeError:
                results.append(False)
        return results

    @property
    def concatenating(self) -> list[bool]:
        """
        Check whether `obj + obj` is supported for each object.

        Returns
        -------
        list[bool]
            True if concatenation is supported; False otherwise.
        """
        results: list[bool] = []
        for obj in self.built_in_types:
            try:
                _: Any = obj + obj
                results.append(True)
            except TypeError:
                results.append(False)
        return results

    @property
    def finding_length(self) -> list[bool]:
        """
        Check whether `len(obj)` is valid for each object.

        Returns
        -------
        list[bool]
            True if the object supports length retrieval; False 
            otherwise.
        """
        results: list[bool] = []
        for obj in self.built_in_types:
            try:
                _: Any = len(obj)
                results.append(True)
            except Exception:
                results.append(False)
        return results

    @property
    def reversing(self) -> list[bool]:
        """
        Check whether `reversed(obj)` is valid for each object.

        Returns
        -------
        list[bool]
            True if the object supports reverse iteration; False 
            otherwise.
        """
        results: list[bool] = []
        for obj in self.built_in_types:
            try:
                _: Any = reversed(obj)
                results.append(True)
            except Exception:
                results.append(False)
        return results

    @property
    def sorting(self) -> list[bool]:
        """
        Check whether `sorted(obj)` is valid for each object.

        Returns
        -------
        list[bool]
            True if the object can be sorted; False otherwise.
        """
        results: list[bool] = []
        for obj in self.built_in_types:
            try:
                _: Any = sorted(obj)
                results.append(True)
            except Exception:
                results.append(False)
        return results


def main() -> None:
    """
    Render an operation support table for selected built-in types.

    The output displays which operations succeed on each type by 
    applying them to default-constructed instances and reporting results
    in a visually aligned format.

    Note
    ----
    The output is not version-agnostic; results may vary across Python 
    versions. The current results were obtained using Python 3.11, as 
    indicated in the shebang. This explains any divergence from the 
    tutorial's reference output.
    """
    table: Table = Table()
    type_names: list[str] = [
        type(obj).__name__ for obj in table.built_in_types
    ]

    col_width: int = 13

    header_row: str = f"{'Operation ':<{col_width}}" + " ".join(
        f"{name:^{col_width}}" for name in type_names
    )
    print(header_row)
    print("-" * len(header_row))

    def print_row(label: str, values: list[bool]) -> None:
        """Format and print a single row of the result table."""
        row: str = f"{label:<{col_width}}" + "".join(
            f"{'✅' if val else '❌':^{col_width}}" for val in values
        )
        print(row)

    print_row("Iteration", table.iteration)
    print_row("Indexing", table.indexing)
    print_row("Slicing", table.slicing)
    print_row("Concatenating", table.concatenating)
    print_row("Length", table.finding_length)
    print_row("Reversing", table.reversing)
    print_row("Sorting", table.sorting)


if __name__ == "__main__":
    main()