0 views collected around this technical thread.
This article explains what Python context managers are, how they work under the hood, and why they are far more useful than simple file handling, providing practical examples ranging from resource management and testing to advanced asynchronous usage and common pitfalls.
This article explains the concept of Python context managers, demonstrates how the with statement simplifies resource handling compared to manual open/close patterns, and shows how defining __enter__ and __exit__ methods enables cleaner code, testing, and error handling.
This article explains Python's with statement as a context management tool, describes the required __enter__ and __exit__ methods, and provides multiple practical examples—including file handling, custom managers, multiple managers, third‑party resources, and automation scenarios—to illustrate reliable resource acquisition and cleanup.
This article presents a collection of lesser‑known Python tricks—including string cleaning with translate, iterator slicing via itertools.islice, skipping header lines, keyword‑only functions, custom context managers, memory‑saving __slots__, resource limits, import control, and total_ordering—to help developers write cleaner, more efficient code.
This article explains Python magic (dunder) methods, their purposes, common examples such as __init__, __str__, __repr__, __len__, __getitem__, __setitem__, __delitem__, __iter__, __call__, __add__, __eq__, __hash__, and shows how to implement operator overloading, iterator and context‑manager protocols while discussing naming rules, performance, inheritance, type checking, and limitations.
This article explains Python exception handling fundamentals, covering basic try‑except, multiple exception catches, else/finally blocks, custom exceptions, exception propagation, raise‑from chaining, context manager handling, assert statements, generic suppression, and selective suppression with contextlib.
This article explores how to replicate Python's context manager behavior in Go by examining defer's delayed execution, demonstrating its limitations in loops, and presenting three solutions—anonymous functions, a WithClose helper, and a withLock-inspired pattern—to ensure timely resource release.
This article explains Python's context manager mechanism, detailing how the with statement works, its __enter__ and __exit__ methods, and provides ten practical code examples ranging from file handling to network connections, database access, threading, and more.
This article explains Python's context manager protocol, detailing the roles of __enter__() and __exit__() methods, their typical use cases, and provides ten concrete code examples ranging from file handling and database connections to custom managers for networking, temporary files, and exception handling.
This article presents a collection of lesser‑known Python tricks—including string normalization, iterator slicing, keyword‑only functions, custom context managers, memory‑saving __slots__, CPU/memory limits, import control with __all__, and simplified ordering with total_ordering—to help developers write cleaner and more efficient code.
This article introduces a collection of lesser‑known Python tricks—including string cleaning with translate, iterator slicing via itertools.islice, skipping iterable headers, keyword‑only arguments, custom context managers, memory saving with __slots__, resource‑based CPU/memory limits, controlling module exports, and simplifying comparisons with total_ordering.
This article introduces a collection of lesser‑known Python tricks—including string cleaning with translate, iterator slicing via itertools, skipping header lines, keyword‑only functions, custom context managers, memory‑saving __slots__, resource limits, import control with __all__, and total_ordering—to help developers write cleaner, more efficient code.
This article explains the purpose and usage of Python's with statement, demonstrates how it simplifies resource management compared to manual try‑finally blocks, and shows how to implement custom context managers using magic methods or the contextlib decorator.
Python 3.10, released on October 4 2021, introduces concise Union type syntax, a strict mode for zip, parenthesized with‑statements, explicit TypeAlias declarations, structural pattern matching via match‑case, clearer syntax error messages, and several deprecations such as distutils, all illustrated with code examples.
This article presents a collection of practical Python techniques—including string cleaning with translation tables, iterator slicing with itertools, skipping file headers, keyword‑only arguments, custom context‑manager objects, memory‑saving __slots__, CPU and memory resource limits, export control via __all__, and simplified total ordering—illustrated with concise code examples.
This article explains Python's context manager mechanism, covering the basic with statement, custom __enter__/__exit__ classes, the contextlib.contextmanager decorator, nesting, combining multiple managers with ExitStack, and practical applications such as SQLAlchemy session handling, exception management, and persistent HTTP requests.
This article presents a comprehensive Python fundamentals guide covering common standard libraries, built‑in data types, the with statement, mutable vs immutable types, date handling, word counting, file deletion, custom exceptions, error handling, bug‑fix strategies, and key language feature differences between Python 2 and 3.
This article explains how Python uses the special __init__ and __del__ methods to emulate constructors and destructors, discusses the language's reference‑counting garbage collector, demonstrates common pitfalls with __del__, and presents safer alternatives such as context managers and weak references for resource cleanup.