5 Crazy Python Features in Under 10 Minutes

Surprising Yet Practical Python Tricks

The Python programming language is often praised for its readability and straightforward syntax, a design philosophy that lowers the barrier for beginners while still offering advanced capabilities for experienced developers. Yet beneath the surface of everyday scripts and standard library calls lies a collection of lesser-known features that can reshape how programmers approach problem-solving. Some of these features exist as deliberate design choices, while others emerge from subtle interactions between built-in data types and object protocols. In the video 5 Crazy Python Features in Under 10 Minutes, the channel Indently presents a compact but dense tour of exactly this kind of material, introducing viewers to idioms and quirks that challenge common assumptions about Python.

The video moves quickly through five distinct features, each chosen for its ability to both surprise and teach something deeper about how Python works. Rather than focusing on purely theoretical curiosities, the examples invite hands-on experimentation. The discussion spans syntactic shortcuts, method chaining elegance, lazy data structures, an operator unusual for a mainstream language, and a pattern leveraging dictionary views. Together they form a practical toolkit for more expressive and efficient code.

The IIFE Pattern in Python

One of the first features covered is the Immediately Invoked Function Expression, commonly known by its acronym IIFE and most frequently associated with JavaScript. In Python, the concept maps naturally onto lambda functions, which are anonymous and designed for single-expression use. The presenter demonstrates how a lambda can be defined and called in the same expression by wrapping it in parentheses and adding a second pair of parentheses afterward: (lambda x: x + 1)(5). This idiom offers a way to evaluate code inline without permanently binding a name to a function object, useful in certain factory patterns or when localizing computation inside larger expressions. The video highlights that although this pattern is not widely used in typical Python codebases, understanding it can improve fluency with functional programming concepts and make certain one-liners more concise.

Format Specifiers for Clean Rendering

Python's string formatting system has evolved through several stages, moving from percent-formatting to the str.format method and eventually to f-strings and format specifiers. The second feature dives into the nesting and mini-language behind format specifiers, which many developers only encounter in their most basic form. The presenter shows advanced-level control over alignment, padding, number precision, and data conversion types. The discussion includes the often overlooked fact that format specifiers can themselves be dynamic, using nested braces or expressions to determine formatting at runtime. This turns string output from a static process into a declarative one, greatly simplifying tasks like building tables, aligning columns, or generating reports.

Infinite Nested Lists Without Loops

The third segment deals with recursive data structures and how intentionally self-referential lists can create infinite nesting without runtime errors. Python lists are mutable containers, and assigning a list to an element of itself creates a cycle that the language tolerates without complaint. The presenter explores how this leads to surprising behavior under printing, copying, and traversal, while also connecting the mechanics to common pitfalls in graph traversal and serialization. Understanding this feature clarifies memory layout and reference semantics in Python's object model.

The Snail Operator Explained

Because the @ symbol resembles a snail when viewed in certain fonts, the matrix multiplication operator introduced in Python 3.5 is often informally called the snail operator. The fourth feature explains that @ is not just for decorators but serves as a dedicated operator for matrix multiplication via the __matmul__ special method. This feature appears most commonly in scientific computing environments such as NumPy and PyTorch, where concise notation for matrix and tensor operations is essential. The video likely also mentions that while many developers see @ only in decorator syntax, the operator's presence in expressions enables more intuitive linear algebra code.

Live Views for Dynamic Data

The final feature covers dictionary views, introduced with the keys, values, and items methods in Python 3. Instead of returning static lists, these methods return dynamic view objects that reflect changes made to the underlying dictionary after the view is created. This means a key added or value modified later immediately appears in a previously held view. The presenter shows how this enables patterns where an object can be iterated while being updated, and explains the differences between views and materialized lists. This feature is crucial for writing memory-efficient code and for understanding how to avoid subtle bugs involving stale data.

Practical Takeaways for Python Developers

Across these five features, a common theme emerges: Python's apparent simplicity is layered on top of a sophisticated and flexible object model that rewards deeper exploration. The IIFE pattern shows that functional programming concepts can be applied even outside dedicated FP languages. Format specifiers demonstrate that string-processing tasks need not require external templating libraries. Infinite nested lists provide insight into identity and mutability. The snail operator points toward Python's importance in scientific and numerical computing. Live views about dictionary behavior illustrate the dynamic nature of Python's core data structures.

The video's format—under ten minutes with clear sponsor and chapter breakdown—makes it an efficient resource for developers who want to deepen their understanding of the language without committing to a long course. The inclusion of a sponsor segment for Zed, a code editor positioned as modern alternative to traditional tools, does not distract from the technical content. The chapter markers are well structured, allowing viewers to jump directly to a given feature. Overall, the video fits well within Indently's catalogue of targeted Python tutorials.

Ideal Audience and Context

This content is best suited for Python developers with at least a beginner to intermediate understanding of syntax and basic data structures. Absolute beginners may find some sections moving too quickly, although the explanations remain clear enough to follow. More experienced developers will appreciate the deeper emphasis on lesser-known characteristics rather than rehashing common tutorials. The video can serve as a quick reference for revising specific features before technical interviews or when encountering unfamiliar patterns in code reviews. Because each feature is presented independently, viewers can return to individual timestamps without needing to rewatch the entire video.