{"id":2242,"date":"2025-04-21T19:02:37","date_gmt":"2025-04-21T19:02:37","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=2242"},"modified":"2025-04-21T19:02:41","modified_gmt":"2025-04-21T19:02:41","slug":"exploring-pythons-new-partial-and-functools-cache_property","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/exploring-pythons-new-partial-and-functools-cache_property\/","title":{"rendered":"Exploring Python’s New partial and functools.cache_property for Efficient Code Design"},"content":{"rendered":"\n

Python has always been a language that prioritizes readability and developer happiness. Over the years, its standard library has grown with tools that help developers write more expressive, concise, and efficient code. One such area of the standard library that deserves attention\u2014especially with Python 3.12 and beyond\u2014is the functools<\/code> module.<\/p>\n\n\n\n

You might already know functools.partial<\/code>. It\u2019s been around for a while and allows partial function application\u2014essentially \u201cpre-loading\u201d certain arguments of a function and creating a new callable. But Python 3.12 introduced a new, more flexible version: partial<\/code> as a class. This opens the door to subclassing and some really powerful custom behaviors.<\/p>\n\n\n\n

Alongside that, Python has gifted us another gem: functools.cache_property<\/code>. If you\u2019ve ever used @property<\/code> in a class and found yourself wishing it could cache its result automatically\u2014without having to use @functools.lru_cache<\/code> hacks\u2014this is exactly what you were dreaming of.<\/p>\n\n\n\n

In this tutorial, we’ll dig deep into both these tools\u2014step by step\u2014and build up your intuition and your toolbox for writing more efficient, readable, and Pythonic code.<\/p>\n\n\n\n

\n\n\n\n

Part 1: Understanding partial<\/code> (the new class-based version)<\/h2>\n\n\n\n

Let\u2019s kick things off with a refresher.<\/p>\n\n\n\n

A Quick Refresher on functools.partial<\/code><\/h3>\n\n\n\n

The classic partial<\/code> function has been around since Python 2.5. It\u2019s often used to freeze some portion of a function\u2019s arguments and keywords, resulting in a new function.<\/p>\n\n\n\n

Here\u2019s a basic example:<\/p>\n\n\n

from<\/span> functools import<\/span> partial\n\ndef<\/span> multiply<\/span>(x, y)<\/span>:<\/span>\n    return<\/span> x * y\n\ndouble = partial(multiply, 2<\/span>)\n\nprint(double(5<\/span>))  # Output: 10<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
This is great for simplifying higher-order functions or preparing pre-filled versions of a function for reuse. But it was limited\u2014partial<\/code> was just a function, not something you could subclass or extend easily.<\/p>\n\n\n\n
Enter functools.partial<\/code> as a Class<\/h3>\n\n\n\n
As of Python 3.12, partial<\/code> is now implemented as a class<\/strong>, not just a function.<\/p>\n\n\n\n
So what does that mean for us?<\/p>\n\n\n\n
    \n
  1. We can subclass it.<\/strong><\/li>\n\n\n\n
  2. We can customize its behavior.<\/strong><\/li>\n\n\n\n
  3. We can introspect and manipulate it more flexibly.<\/strong><\/li>\n<\/ol>\n\n\n\n
    Let\u2019s see how.<\/p>\n\n\n\n
    \n\n\n\n
    Creating Custom Partial Functions (Subclassing)<\/h3>\n\n\n\n
    Let\u2019s say you\u2019re working in a large codebase and want to track all the calls made through a certain subset of pre-configured functions\u2014maybe for logging or analytics.<\/p>\n\n\n\n
    You can now subclass partial<\/code> like so:<\/p>\n\n\n
    from<\/span> functools import<\/span> partial\n\nclass<\/span> LoggingPartial<\/span>(partial)<\/span>:<\/span>\n    def<\/span> __call__<\/span>(self, *args, **kwargs)<\/span>:<\/span>\n        print(f\"Calling {self.func.__name__}<\/span> with {args}<\/span> and {kwargs}<\/span>\"<\/span>)\n        return<\/span> super().__call__(*args, **kwargs)\n\ndef<\/span> greet<\/span>(greeting, name)<\/span>:<\/span>\n    return<\/span> f\"{greeting}<\/span>, {name}<\/span>!\"<\/span>\n\nhi = LoggingPartial(greet, \"Hi\"<\/span>)\nprint(hi(\"Alice\"<\/span>))  # Output includes logging<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    This is powerful. You now have an easy way to inject cross-cutting concerns (like logging, timing, metrics, etc.) into your partials.<\/p>\n\n\n\n
    Want to track performance? Easy.<\/p>\n\n\n
    import<\/span> time\n\nclass<\/span> TimedPartial<\/span>(partial)<\/span>:<\/span>\n    def<\/span> __call__<\/span>(self, *args, **kwargs)<\/span>:<\/span>\n        start = time.perf_counter()\n        result = super().__call__(*args, **kwargs)\n        end = time.perf_counter()\n        print(f\"{self.func.__name__}<\/span> took {end - start:.4<\/span>f}<\/span> seconds\"<\/span>)\n        return<\/span> result<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    This kind of subclassing was not possible before 3.12.<\/p>\n\n\n\n
    \n\n\n\n
    Exploring Attributes of partial<\/code><\/h3>\n\n\n\n
    When you use the new class-based partial<\/code>, you can inspect its arguments and the original function easily:<\/p>\n\n\n
    p = partial(multiply, 2<\/span>)\nprint(p.func)       # <function multiply><\/span>\nprint(p.args)       # (2,)<\/span>\nprint(p.keywords)   # {}<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    This can be especially useful for debugging or building higher-order utilities that inspect and adapt function behavior dynamically.<\/p>\n\n\n\n
    \n\n\n\n
    Composition with partial<\/code><\/h3>\n\n\n\n
    Ever needed to create factory-like behavior? Combine partial<\/code> with higher-order functions:<\/p>\n\n\n
    def<\/span> make_tag<\/span>(tag_name)<\/span>:<\/span>\n    def<\/span> wrapper<\/span>(content)<\/span>:<\/span>\n        return<\/span> f\"<{tag_name}<\/span>>{content}<\/span><\/{tag_name}<\/span>>\"<\/span>\n    return<\/span> wrapper\n\nbold = partial(make_tag, \"strong\"<\/span>)\n\nprint(bold()(\"hello\"<\/span>))  # <strong>hello<\/strong><\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    This is elegant and lends itself well to DSLs (Domain Specific Languages), web frameworks, and UI generation.<\/p>\n\n\n\n
    \n\n\n\n
    Partial in Functional Programming Pipelines<\/h3>\n\n\n\n
    Let\u2019s take a slightly more complex example\u2014a data transformation pipeline.<\/p>\n\n\n
    from<\/span> functools import<\/span> partial\n\ndef<\/span> transform<\/span>(data, multiplier=1<\/span>, offset=0<\/span>)<\/span>:<\/span>\n    return<\/span> [x * multiplier + offset for<\/span> x in<\/span> data]\n\n# Now build different pipelines<\/span>\ndouble_and_add_1 = partial(transform, multiplier=2<\/span>, offset=1<\/span>)\nscale_down = partial(transform, multiplier=0.5<\/span>)\n\ndata = [10<\/span>, 20<\/span>, 30<\/span>]\nprint(double_and_add_1(data))  # [21, 41, 61]<\/span>\nprint(scale_down(data))       # [5.0, 10.0, 15.0]<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    By preconfiguring partials, you can clean up the logic in your code, reduce duplication, and keep your business logic clean.<\/p>\n\n\n\n
    \n\n\n\n
    Part 2: functools.cache_property<\/code> \u2014 Caching Made Beautiful<\/h2>\n\n\n\n
    We all love @property<\/code> for its elegant way of encapsulating logic behind attribute-like access. But when the computation is expensive and doesn\u2019t need to be re-run every time, caching becomes necessary.<\/p>\n\n\n\n
    Historically, this meant using @functools.lru_cache<\/code>, or writing your own boilerplate inside the getter. But no more.<\/p>\n\n\n\n
    \n\n\n\n
    Introducing @functools.cache_property<\/code><\/h3>\n\n\n\n
    As of Python 3.12, we get a beautiful decorator: @cache_property<\/code>.<\/p>\n\n\n\n
    Let\u2019s see it in action.<\/p>\n\n\n
    from<\/span> functools import<\/span> cache_property\n\nclass<\/span> DataFetcher<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, source)<\/span>:<\/span>\n        self.source = source\n\n    @cache_property<\/span>\n    def<\/span> expensive_computation<\/span>(self)<\/span>:<\/span>\n        print(\"Running expensive computation...\"<\/span>)\n        # Simulate some heavy lifting<\/span>\n        return<\/span> sum(i * i for<\/span> i in<\/span> range(100000<\/span>))\n\ndf = DataFetcher(\"db\"<\/span>)\nprint(df.expensive_computation)  # Triggers computation<\/span>\nprint(df.expensive_computation)  # Cached result, no print<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    Boom. No need for custom caching code. It\u2019s like @property<\/code>, but with built-in memory.<\/p>\n\n\n\n
    \n\n\n\n
    How It Works Behind the Scenes<\/h3>\n\n\n\n
    cache_property<\/code> is basically a read-only, one-time-computed property.<\/p>\n\n\n\n
      \n
    • It’s non-overridable: You can’t assign to it later.<\/li>\n\n\n\n
    • It stores the value in the instance’s __dict__<\/code> the first time it’s called.<\/li>\n\n\n\n
    • After that, accessing the property is as fast as a dictionary lookup.<\/li>\n<\/ul>\n\n\n\n
      You can verify that by checking __dict__<\/code>:<\/p>\n\n\n
      print(df.__dict__)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
      You\u2019ll see that expensive_computation<\/code> is now just stored like any other attribute.<\/p>\n\n\n\n
      \n\n\n\n
      Comparison with @cached_property<\/code><\/h3>\n\n\n\n
      Python 3.8 introduced @functools.cached_property<\/code>. You might be wondering\u2014how is cache_property<\/code> different?<\/p>\n\n\n\n
        \n
      • cached_property<\/code><\/strong> is writable. You can manually override or delete it.<\/li>\n\n\n\n
      • cache_property<\/code><\/strong> is strict: read-only after the first calculation.<\/li>\n<\/ul>\n\n\n\n
        This small difference can be crucial for making sure properties aren\u2019t accidentally mutated in large codebases.<\/p>\n\n\n\n
        Example:<\/p>\n\n\n
        from<\/span> functools import<\/span> cached_property\n\nclass<\/span> Example<\/span>:<\/span>\n    @cached_property<\/span>\n    def<\/span> val<\/span>(self)<\/span>:<\/span>\n        return<\/span> 42<\/span>\n\ne = Example()\ne.val = 100<\/span>  # Allowed!<\/span>\n\nclass<\/span> Example2<\/span>:<\/span>\n    @cache_property<\/span>\n    def<\/span> val<\/span>(self)<\/span>:<\/span>\n        return<\/span> 42<\/span>\n\ne2 = Example2()\ne2.val = 100<\/span>  # Raises AttributeError<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
        If immutability matters to you, cache_property<\/code> is the way to go.<\/p>\n\n\n\n
        \n\n\n\n
        Practical Use Cases<\/h3>\n\n\n\n
        1. Expensive File Reads<\/h4>\n\n\n
        class<\/span> Config<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, path)<\/span>:<\/span>\n        self.path = path\n\n    @cache_property<\/span>\n    def<\/span> contents<\/span>(self)<\/span>:<\/span>\n        with<\/span> open(self.path, 'r'<\/span>) as<\/span> f:\n            return<\/span> f.read()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
        2. One-time Data Initialization<\/h4>\n\n\n
        class<\/span> User<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, user_id)<\/span>:<\/span>\n        self.user_id = user_id\n\n    @cache_property<\/span>\n    def<\/span> profile<\/span>(self)<\/span>:<\/span>\n        return<\/span> self._load_profile_from_db()\n\n    def<\/span> _load_profile_from_db<\/span>(self)<\/span>:<\/span>\n        print(\"Fetching from DB\"<\/span>)\n        return<\/span> {\"name\"<\/span>: \"Alice\"<\/span>, \"age\"<\/span>: 30<\/span>}<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
        No more accidentally triggering multiple DB calls just because someone accessed user.profile<\/code> more than once.<\/p>\n\n\n\n
        \n\n\n\n
        Use with Dataclasses and __post_init__<\/code><\/h3>\n\n\n\n
        Want to pair cache_property<\/code> with dataclasses<\/code>?<\/p>\n\n\n
        from<\/span> dataclasses import<\/span> dataclass\nfrom<\/span> functools import<\/span> cache_property\n\n@dataclass<\/span>\nclass<\/span> Inventory<\/span>:<\/span>\n    items: list\n\n    @cache_property<\/span>\n    def<\/span> total_value<\/span>(self)<\/span>:<\/span>\n        print(\"Computing total value...\"<\/span>)\n        return<\/span> sum(item[\"price\"<\/span>] * item[\"quantity\"<\/span>] for<\/span> item in<\/span> self.items)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
        \n\n\n\n
        Real-World Strategy: Combining partial<\/code> and cache_property<\/code><\/h3>\n\n\n\n
        What happens when you combine both of these tools? Magic.<\/p>\n\n\n\n
        Imagine this scenario:<\/p>\n\n\n\n
          \n
        • You have an object with a @cache_property<\/code> that computes a value.<\/li>\n\n\n\n
        • You use partial<\/code> to bind various configuration options to a generator of that value.<\/li>\n<\/ul>\n\n\n\n
          Here\u2019s a toy version:<\/p>\n\n\n
          class<\/span> Simulator<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self, factor)<\/span>:<\/span>\n        self.factor = factor\n\n    @cache_property<\/span>\n    def<\/span> base_data<\/span>(self)<\/span>:<\/span>\n        print(\"Generating base data...\"<\/span>)\n        return<\/span> [i * self.factor for<\/span> i in<\/span> range(1000<\/span>)]\n\n    def<\/span> run<\/span>(self, transform)<\/span>:<\/span>\n        return<\/span> transform(self.base_data)\n\nfrom<\/span> functools import<\/span> partial\n\ndef<\/span> normalize<\/span>(data, divisor)<\/span>:<\/span>\n    return<\/span> [x \/ divisor for<\/span> x in<\/span> data]\n\nsim = Simulator(2<\/span>)\nnormalize_half = partial(normalize, divisor=2<\/span>)\nprint(sim.run(normalize_half))  # base_data computed once, reused<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
          You\u2019ve now built a caching pipeline using native tools\u2014minimal boilerplate, maximum readability.<\/p>\n\n\n\n
          \n\n\n\n
          Part 3: Deeper Patterns with partial<\/code> and cache_property<\/code><\/h2>\n\n\n\n
          Let\u2019s stretch our thinking beyond simple wrappers and into more architectural use cases.<\/p>\n\n\n\n
          \n\n\n\n
          Pattern 1: Strategy Pattern with partial<\/code><\/h3>\n\n\n\n
          You can use partial<\/code> to implement the strategy pattern<\/strong> in a super clean and declarative way. Imagine you have different pricing strategies:<\/p>\n\n\n
          def<\/span> base_price<\/span>(product)<\/span>:<\/span>\n    return<\/span> product[\"price\"<\/span>]\n\ndef<\/span> discount_price<\/span>(product, discount)<\/span>:<\/span>\n    return<\/span> product[\"price\"<\/span>] * (1<\/span> - discount)\n\ndef<\/span> premium_price<\/span>(product, multiplier)<\/span>:<\/span>\n    return<\/span> product[\"price\"<\/span>] * multiplier\n\n# Pre-configured strategies<\/span>\nstandard = base_price\nsummer_sale = partial(discount_price, discount=0.2<\/span>)\nvip = partial(premium_price, multiplier=1.5<\/span>)\n\ndef<\/span> calculate_total<\/span>(cart, strategy)<\/span>:<\/span>\n    return<\/span> sum(strategy(item) for<\/span> item in<\/span> cart)\n\ncart = [{\"price\"<\/span>: 100<\/span>}, {\"price\"<\/span>: 200<\/span>}]\n\nprint(calculate_total(cart, summer_sale))  # Applies discount<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
          This keeps your logic open for extension (add new strategies), but closed for modification. Just pass a different partial, no need to rewrite your function logic.<\/p>\n\n\n\n
          \n\n\n\n
          Pattern 2: Lazy Initialization with cache_property<\/code><\/h3>\n\n\n\n
          Suppose you\u2019re loading a large model or dataset. You can make it lazy and one-time with cache_property<\/code>.<\/p>\n\n\n
          class<\/span> MLModel<\/span>:<\/span>\n    @cache_property<\/span>\n    def<\/span> model<\/span>(self)<\/span>:<\/span>\n        print(\"Loading model...\"<\/span>)\n        # Simulate heavy loading<\/span>\n        return<\/span> {\"model\"<\/span>: \"Large model object\"<\/span>}\n\n    def<\/span> predict<\/span>(self, x)<\/span>:<\/span>\n        return<\/span> f\"Predicted {x}<\/span> using {self.model}<\/span>\"<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
          This pattern is especially useful for keeping memory usage in check when working in data pipelines or services with a lot of optional heavy features.<\/p>\n\n\n\n
          \n\n\n\n
          Part 4: Edge Cases and Gotchas<\/h2>\n\n\n\n
          You\u2019ve seen how great these tools can be\u2014but let\u2019s talk about a few caveats<\/strong> that could trip you up.<\/p>\n\n\n\n
          \n\n\n\n
          1. partial<\/code> Doesn\u2019t Always Preserve Function Signatures<\/h3>\n\n\n\n
          Here\u2019s a subtle but important detail: a partial<\/code> object doesn\u2019t inherit the full signature of the original function.<\/p>\n\n\n
          from<\/span> functools import<\/span> partial\n\ndef<\/span> greet<\/span>(name, greeting=\"Hello\"<\/span>)<\/span>:<\/span>\n    return<\/span> f\"{greeting}<\/span>, {name}<\/span>!\"<\/span>\n\nhello = partial(greet, greeting=\"Hi\"<\/span>)\nprint(hello(\"Alice\"<\/span>))  # Works<\/span>\n\nhelp(hello)  # But won't show nice signature<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
          This makes things a little weird for introspection, help systems, or tools like FastAPI<\/code> that rely on function signatures.<\/p>\n\n\n\n
          \u2705 Fix:<\/strong> Use functools.update_wrapper<\/code> or use functools.wraps<\/code> manually if wrapping a function.<\/p>\n\n\n\n
          \n\n\n\n
          2. cache_property<\/code> is not thread-safe (by design)<\/h3>\n\n\n\n
          In multi-threaded environments (like web servers), simultaneous first access to a cache_property<\/code> could result in the property being computed multiple times. Example:<\/p>\n\n\n
          # Thread 1 and Thread 2 both hit this at the same time<\/span>\n@property<\/span>\ndef<\/span> computed_value<\/span>(self)<\/span>:<\/span>\n    print(\"Heavy computation happening twice!\"<\/span>)\n    ...<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
          \u2705 Fix:<\/strong> Use locks or other thread-safe patterns if needed.<\/p>\n\n\n\n
          \n\n\n\n
          3. Be Careful With Side Effects in Cached Properties<\/h3>\n\n\n\n
          Because cache_property<\/code> runs once<\/strong>, any side effects you include (like logging, analytics, or resource access) will only happen on the first call. That might surprise you if you forget.<\/p>\n\n\n\n
          \n\n\n\n
          4. partial<\/code> and Mutable Defaults<\/h3>\n\n\n\n
          This old Python gotcha still applies:<\/p>\n\n\n
          def add_to_list(value, target=[]):\n    target.append(value)\n    return<\/span> target\n\nbad_partial = partial(add_to_list, 10<\/span>)\nprint<\/span>(bad_partial())  # [10]<\/span>\nprint<\/span>(bad_partial())  # [10, 10]<\/span><\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
          \u2705 Fix:<\/strong> Avoid mutable defaults like the plague. You already knew that, but it\u2019s worth a reminder.<\/p>\n\n\n\n
          \n\n\n\n
          Part 5: Testing Strategies<\/h2>\n\n\n\n
          You\u2019re probably thinking: \u201cOkay, I love these tools, but how do I test them properly?\u201d<\/em><\/p>\n\n\n\n
          Let\u2019s look at testing best practices for both.<\/p>\n\n\n\n
          \n\n\n\n
          Testing partial<\/code> Functions<\/h3>\n\n\n\n
          A partial is just a callable, so you can test it directly.<\/p>\n\n\n
          from<\/span> functools import<\/span> partial\n\ndef<\/span> multiply<\/span>(x, y)<\/span>:<\/span>\n    return<\/span> x * y\n\ndouble = partial(multiply, 2<\/span>)\n\ndef<\/span> test_double<\/span>()<\/span>:<\/span>\n    assert<\/span> double(3<\/span>) == 6<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
          But what if you subclassed partial<\/code>?<\/p>\n\n\n\n
          Then you may want to test internal attributes:<\/p>\n\n\n
          class<\/span> LoggingPartial<\/span>(partial)<\/span>:<\/span>\n    def<\/span> __call__<\/span>(self, *args, **kwargs)<\/span>:<\/span>\n        print(f\"Calling {self.func.__name__}<\/span> with {args}<\/span> and {kwargs}<\/span>\"<\/span>)\n        return<\/span> super().__call__(*args, **kwargs)\n\np = LoggingPartial(multiply, 3<\/span>)\n\ndef<\/span> test_logging_partial<\/span>()<\/span>:<\/span>\n    assert<\/span> p.func == multiply\n    assert<\/span> p.args == (3<\/span>,)\n    assert<\/span> p(4<\/span>) == 12<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
          \n\n\n\n
          Testing cache_property<\/code><\/h3>\n\n\n\n
          You want to test both:<\/p>\n\n\n\n
            \n
          1. The correctness<\/strong> of the computed result<\/li>\n\n\n\n
          2. That it only computes once<\/strong><\/li>\n<\/ol>\n\n\n
            class<\/span> Demo<\/span>:<\/span>\n    def<\/span> __init__<\/span>(self)<\/span>:<\/span>\n        self.counter = 0<\/span>\n\n    @cache_property<\/span>\n    def<\/span> cached<\/span>(self)<\/span>:<\/span>\n        self.counter += 1<\/span>\n        return<\/span> 42<\/span>\n\ndef<\/span> test_cached_property<\/span>()<\/span>:<\/span>\n    d = Demo()\n    assert<\/span> d.cached == 42<\/span>\n    assert<\/span> d.cached == 42<\/span>\n    assert<\/span> d.counter == 1<\/span>  # Confirm it only ran once<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
            This is an excellent pattern for when you\u2019re dealing with resource-heavy setups and want to be confident about memory and performance.<\/p>\n\n\n\n
            \n\n\n\n
            Part 6: Using These Tools in FastAPI<\/h2>\n\n\n\n
            Use Case: Dependency Injection with partial<\/code><\/h3>\n\n\n\n
            FastAPI relies heavily on dependency injection<\/strong>, and partial<\/code> is a great tool for injecting preconfigured behavior.<\/p>\n\n\n
            from<\/span> functools import<\/span> partial\nfrom<\/span> fastapi import<\/span> Depends, FastAPI\n\napp = FastAPI()\n\ndef<\/span> get_user_service<\/span>(prefix: str)<\/span>:<\/span>\n    def<\/span> _get_user_service<\/span>()<\/span>:<\/span>\n        return<\/span> {\"prefix\"<\/span>: prefix}\n    return<\/span> _get_user_service\n\nuser_service_prod = partial(get_user_service, prefix=\"prod\"<\/span>)\nuser_service_dev = partial(get_user_service, prefix=\"dev\"<\/span>)\n\n@app.get(\"\/users\")<\/span>\ndef<\/span> read_users<\/span>(service=Depends(user_service_prod()<\/span>)<\/span>)<\/span>:<\/span>\n    return<\/span> {\"service\"<\/span>: service}<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
            This makes it super clean to switch environments, without rewriting dependencies.<\/p>\n\n\n\n
            \n\n\n\n
            Use Case: Lazy Loading in FastAPI with cache_property<\/code><\/h3>\n\n\n\n
            For example, lazy loading a machine learning model:<\/p>\n\n\n
            from<\/span> fastapi import<\/span> FastAPI\n\napp = FastAPI()\n\nclass<\/span> Predictor<\/span>:<\/span>\n    @cache_property<\/span>\n    def<\/span> model<\/span>(self)<\/span>:<\/span>\n        print(\"Loading model...\"<\/span>)\n        return<\/span> {\"loaded_model\"<\/span>: True<\/span>}\n\npredictor = Predictor()\n\n@app.get(\"\/predict\")<\/span>\ndef<\/span> predict<\/span>()<\/span>:<\/span>\n    model = predictor.model\n    return<\/span> {\"status\"<\/span>: \"ok\"<\/span>}<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
            Even under load, model<\/code> is only initialized once.<\/p>\n\n\n\n
            \n\n\n\n
            Part 7: Using These Tools in Django<\/h2>\n\n\n\n
            In Django, cache_property<\/code> can be used to improve ORM access efficiency, and partial<\/code> is great for forms, views, or signal configuration.<\/p>\n\n\n\n
            \n\n\n\n
            cache_property<\/code> in Django Models or Views<\/h3>\n\n\n
            class<\/span> MyView<\/span>(View)<\/span>:<\/span>\n    @cache_property<\/span>\n    def<\/span> expensive_lookup<\/span>(self)<\/span>:<\/span>\n        return<\/span> SomeModel.objects.select_related(\"something\"<\/span>).get(id=self.kwargs[\"id\"<\/span>])\n\n    def<\/span> get<\/span>(self, request, *args, **kwargs)<\/span>:<\/span>\n        data = self.expensive_lookup  # Only queried once<\/span>\n        return<\/span> JsonResponse({\"name\"<\/span>: data.name})<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
            This avoids hitting the database multiple times in a single request.<\/p>\n\n\n\n
            \n\n\n\n
            partial<\/code> in Django Form Factories<\/h3>\n\n\n\n
            Want to preconfigure certain fields dynamically?<\/p>\n\n\n
            def<\/span> make_custom_form<\/span>(label_text)<\/span>:<\/span>\n    class<\/span> CustomForm<\/span>(forms.Form)<\/span>:<\/span>\n        name = forms.CharField(label=label_text)\n    return<\/span> CustomForm\n\nShortForm = partial(make_custom_form, label_text=\"Short Name\"<\/span>)\nLongForm = partial(make_custom_form, label_text=\"Full Legal Name\"<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
            Now you have customizable forms without repeating yourself.<\/p>\n\n\n\n
            \n\n\n\n
            partial<\/code> for Signal Handlers<\/h3>\n\n\n\n
            Need signal handlers with custom behavior?<\/p>\n\n\n
            from<\/span> django.db.models.signals import<\/span> post_save\n\ndef<\/span> notify_user<\/span>(action, instance, **kwargs)<\/span>:<\/span>\n    print(f\"{action}<\/span> -> {instance}<\/span>\"<\/span>)\n\nnotify_created = partial(notify_user, \"created\"<\/span>)\npost_save.connect(notify_created, sender=MyModel)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
            \n\n\n\n
            Final Thoughts<\/h2>\n\n\n\n
            With the upgrades in Python 3.12, functools.partial<\/code> becomes subclassable, inspectable, and customizable\u2014meaning it\u2019s not just a shortcut anymore, it\u2019s a real design tool. And cache_property<\/code> offers a long-awaited, elegant solution to a common performance issue without hacks or third-party packages.<\/p>\n\n\n\n
            These aren\u2019t flashy features\u2014but they\u2019re quietly powerful<\/strong>. They let you build faster<\/strong>, more expressive<\/strong>, and bug-resistant<\/strong> systems, whether you\u2019re prototyping or scaling production services.<\/p>\n\n\n\n
            If you’re designing APIs, building ML pipelines, crunching data, or wrangling legacy codebases\u2014these tools will make your life easier.<\/p>\n\n\n\n
            <\/p>\n","protected":false},"excerpt":{"rendered":"
            Python has always been a language that prioritizes readability and developer happiness. Over the years, its standard library has grown with tools that help developers write more expressive, concise, and efficient code. One such area of the standard library that deserves attention\u2014especially with Python 3.12 and beyond\u2014is the functools module. You might already know functools.partial. […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[4,6],"tags":[],"class_list":["post-2242","post","type-post","status-publish","format-standard","category-programming-languages","category-python","entry"],"yoast_head":"\nExploring Python's New partial and functools.cache_property<\/title>\n<meta name=\"description\" content=\"A comprehensive Python tutorial on partial and cache_property. Perfect for developers looking to modernize their code and apply advanced patterns in real-world applications.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/exploring-pythons-new-partial-and-functools-cache_property\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Exploring Python's New partial and functools.cache_property\" \/>\n<meta property=\"og:description\" content=\"A comprehensive Python tutorial on partial and cache_property. Perfect for developers looking to modernize their code and apply advanced patterns in real-world applications.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/exploring-pythons-new-partial-and-functools-cache_property\/\" \/>\n<meta property=\"article:published_time\" content=\"2025-04-21T19:02:37+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-04-21T19:02:41+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"6 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/exploring-pythons-new-partial-and-functools-cache_property\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/exploring-pythons-new-partial-and-functools-cache_property\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"Exploring Python’s New partial and functools.cache_property for Efficient Code Design\",\"datePublished\":\"2025-04-21T19:02:37+00:00\",\"dateModified\":\"2025-04-21T19:02:41+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/exploring-pythons-new-partial-and-functools-cache_property\\\/\"},\"wordCount\":1383,\"articleSection\":[\"Programming Languages\",\"Python\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/exploring-pythons-new-partial-and-functools-cache_property\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/exploring-pythons-new-partial-and-functools-cache_property\\\/\",\"name\":\"Exploring Python's New partial and functools.cache_property\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2025-04-21T19:02:37+00:00\",\"dateModified\":\"2025-04-21T19:02:41+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"A comprehensive Python tutorial on partial and cache_property. Perfect for developers looking to modernize their code and apply advanced patterns in real-world applications.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/exploring-pythons-new-partial-and-functools-cache_property\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/exploring-pythons-new-partial-and-functools-cache_property\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/exploring-pythons-new-partial-and-functools-cache_property\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Exploring Python’s New partial and functools.cache_property for Efficient Code Design\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Exploring Python's New partial and functools.cache_property","description":"A comprehensive Python tutorial on partial and cache_property. Perfect for developers looking to modernize their code and apply advanced patterns in real-world applications.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.w3computing.com\/articles\/exploring-pythons-new-partial-and-functools-cache_property\/","og_locale":"en_US","og_type":"article","og_title":"Exploring Python's New partial and functools.cache_property","og_description":"A comprehensive Python tutorial on partial and cache_property. Perfect for developers looking to modernize their code and apply advanced patterns in real-world applications.","og_url":"https:\/\/www.w3computing.com\/articles\/exploring-pythons-new-partial-and-functools-cache_property\/","article_published_time":"2025-04-21T19:02:37+00:00","article_modified_time":"2025-04-21T19:02:41+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"6 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/exploring-pythons-new-partial-and-functools-cache_property\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/exploring-pythons-new-partial-and-functools-cache_property\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"Exploring Python’s New partial and functools.cache_property for Efficient Code Design","datePublished":"2025-04-21T19:02:37+00:00","dateModified":"2025-04-21T19:02:41+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/exploring-pythons-new-partial-and-functools-cache_property\/"},"wordCount":1383,"articleSection":["Programming Languages","Python"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/exploring-pythons-new-partial-and-functools-cache_property\/","url":"https:\/\/www.w3computing.com\/articles\/exploring-pythons-new-partial-and-functools-cache_property\/","name":"Exploring Python's New partial and functools.cache_property","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2025-04-21T19:02:37+00:00","dateModified":"2025-04-21T19:02:41+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"A comprehensive Python tutorial on partial and cache_property. Perfect for developers looking to modernize their code and apply advanced patterns in real-world applications.","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/exploring-pythons-new-partial-and-functools-cache_property\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/exploring-pythons-new-partial-and-functools-cache_property\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/exploring-pythons-new-partial-and-functools-cache_property\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"Exploring Python’s New partial and functools.cache_property for Efficient Code Design"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/2242","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=2242"}],"version-history":[{"count":2,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/2242\/revisions"}],"predecessor-version":[{"id":2244,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/2242\/revisions\/2244"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=2242"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=2242"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=2242"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}