Skip to main content

remember when we could just print stuff without parentheses?




In Python, we often use print 🖨️ statements with parentheses to output values. However, there's a creative way to print values without using braces by leveraging properties in a custom class. Let's dive into how we can achieve this using a custom class design. 🔍

## Custom Class Design 🛠️

Here’s a simple class that allows printing values without the need for parentheses:

```python
class disp_cls():
    def __init__(self):
        return

    @property
    def out(self):
        return self

    @out.setter
    def out(self, other):
        print(other)
        return

disp = disp_cls()
disp.out = 1, 2, 3
```

### Breakdown 🧩

1. **Class Definition**: We define a class called `disp_cls`.
2. **Constructor**: The `__init__` method initializes the class but doesn't do anything special here.
3. **Property Getter**: The `out` property method returns the instance itself (`self`). This is necessary for the property to work correctly.
4. **Property Setter**: The `out` setter method is where the magic happens. It takes the value being assigned to `disp.out` (in this case, `1, 2, 3`) and prints it.
5. **Usage**: We create an instance of `disp_cls` called `disp` and assign a tuple `1, 2, 3` to `disp.out`. This triggers the setter method, which prints the tuple.

## How It Works 🚀

When we assign `disp.out = 1, 2, 3`, the following steps occur:

- The assignment triggers the `out` setter method.
- The setter method prints the assigned value (`1, 2, 3`).

This allows us to print values without explicitly calling the `print` function, thus avoiding the use of parentheses for the print statement. 🎉

## Conclusion 🏁

By using properties in a custom class, we can creatively bypass the need for parentheses when printing values in Python. This approach demonstrates the flexibility and power of Python's property decorators and can be a fun way to streamline your code. Give it a try and see how it works for you! Happy coding! 💻😊

 

interactive example

https://colab.research.google.com/drive/1MmkC9meGmONcEFwXimQKC8F0Q4TrNZWs

Comments

Popular posts from this blog

Getting started with FEOS, the framework for Equation of state by iit/univ Stuttgart and eth/zurich

     🌟 Exploring FEOS: The State-of-the-Art Equation of State Framework by IIT Stuttgart and ETH Zurich 🌟 Hey there, fellow science enthusiasts! 👋 Are you ready to dive into the captivating world of equation of state frameworks? Well, hold onto your lab coats because today, we're exploring FEOS – the cutting-edge framework developed by the brilliant minds at IIT Stuttgart and ETH Zurich! 🚀 ### Unraveling the Mysteries of FEOS 🔍 Equation of state (EOS) plays a pivotal role in various scientific disciplines, ranging from physics and chemistry to material science and engineering. It's the cornerstone for understanding the thermodynamic properties of matter under different conditions. And when it comes to precision and reliability, FEOS stands tall among its peers. 📏 ### The Powerhouse Collaboration: IIT Stuttgart & ETH Zurich 🤝 FEOS is not just another run-of-the-mill framework; it's the result of a powerhouse collaboration between the renowned institutions – IIT ...

creating numerical arrays with logic

  **Title: Navigating Numerical Spaces with NumPy: arange vs linspace vs logspace** When it comes to generating numerical sequences in Python, NumPy offers a plethora of options, each tailored to specific needs. Among these, `arange`, `linspace`, and `logspace` stand out as versatile tools for crafting arrays. Let’s embark on a journey through these functions, exploring their nuances and applications! 🚀 ### The Basics: arange NumPy’s `arange` function is akin to Python’s built-in `range`, but with the added capability of generating arrays with non-integer steps. It’s your go-to tool for creating sequences with regular spacing. ```python import numpy as np # Syntax: np.arange(start, stop, step) arr = np.arange(0, 10, 2) print(arr) # Output: [0 2 4 6 8] ``` think of it as points in an closed/open interval [a,b) with step s between each point  🧩 **Use Case**: When you need control over the step size and want a compact syntax. ### The Uniform Choice: linspace `linspace` divides...

what is @something on a function, i heard it is for decoration?!

  Title: 🎨 Exploring Python Decorators: Adding Magic to Your Code! ✨ Python decorators are like the fairy godmothers of programming—they sprinkle a little magic onto your functions, enhancing them with extra functionality. In this blog post, we'll dive into the enchanting world of decorators, exploring how they work and unleashing their powers with two whimsical examples. **Example 1: The Enigmatic @echo Decorator** Imagine a decorator that echoes the inputs and outputs of a function, adding a touch of sparkle to the console. Behold, the @echo decorator! ```python def echo(func):     def wrapper(*args, **kwargs):         print("✨ Echoing inputs:")         for arg in args:             print(f"\t- {arg}")         result = func(*args, **kwargs)         print("✨ Echoing output:")         print(f"\t- {result}")         return re...