Skip to main content

Help my variables are changing when i don't want them to, and then they dont change when i want to...




 

 

 Title: 🐍 Demystifying Name, Object, and Mutability in Python πŸ§ πŸ’»


Welcome, Pythonistas! Today, we're delving deep into the core concepts of name, object, and mutability in Python – the building blocks that shape the behavior of our beloved language. πŸš€ Let's embark on this exciting journey together and unravel the mysteries behind these fundamental concepts! πŸ”


### Understanding Names and Objects


In Python, everything is an object – whether it's a simple integer like `1`, a list like `[1, 2]`, or even a function! 🎩 Objects in Python are entities that have data (attributes) and associated behaviors (methods). 


When we assign a value to a variable, we're essentially creating a name that references an object. Let's dive into an example:


```python

x = 1

y = x

y = 2

print(x, y)  # Output: 1 2

```


In this snippet, we create two names (`x` and `y`) that reference the same integer object initially (`1`). However, when we reassign `y` to `2`, it no longer refers to the same object as `x`. Thus, changing `y` does not affect `x`.


### Exploring Mutability


Now, let's talk about mutability – the ability of an object to be changed after it's created. In Python, some objects are mutable (modifiable), while others are immutable (unchangeable).


```python

L1 = [1, 2]

L2 = L1

L1[0] = 3

print(L1, L2)  # Output: [3, 2] [3, 2]

```


In this example, we create a list `L1` containing `[1, 2]`. Then, we assign `L2` to `L1`, meaning both names point to the same list object. When we modify `L1` by changing its first element to `3`, both `L1` and `L2` reflect this change. Why? Because lists are mutable objects in Python.


also:


```

L=[1,2,3]

for item in L:

  item += 1

print(L)

```


versus


```

n=len(L)

for i in range (n):

  L[i] += 1

print(L)

```


### Wrapping Up


And there you have it, folks! We've journeyed through the realms of names, objects, and mutability in Python. Armed with this knowledge, you'll be better equipped to understand the inner workings of Python code and wield its power with finesse. πŸ› ️


Remember, names are merely labels for objects, and mutability determines whether an object can be changed after creation. Embrace these concepts, experiment with Python's flexibility, and let your coding adventures flourish! 🌟


Until next time, happy coding! πŸ’»✨


Interactive example:

https://colab.research.google.com/drive/1hz1hluXb_B9Vx82kV6wNQJSO0hjIVUG3?usp=sharing

more raw examples:

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

Also try this on python-tutor


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...