An array is a fundamental data structure used to store collections of elements that can be accessed by indexes. Arrays are widely used in programming due to their efficiency and simplicity.

• Arrays are of course ordered, and in most programming languages, the index starts at 0.

• Arrays use a contiguous block of memory. This allows efficient random access with indexes.

• In many programming languages, you have to specify the size of an array at initialization time, so it can reserve the appropriate amount of memory from the start. (but not in Python)

• In many programming languages (again, not in Python) you can store only one type of objects inside.

In Python, arrays are implemented using a versatile data structure called lists.

Python variable is bound to a memory address. And under a given memory address, we store an object.

The majority of newly created variables will receive a unique memory address but not all of them. Some variables will be bound to the one memory address with exactly the same object.

After all, what is the point of keeping in memory more than one 313 number or more than one "devcuriosity" string?

Python memory optimization is a complex algorithm. It is hard to list all rules standing behind binding new variables to the existing memory addresses, but some of the general ideas would be: - Object needs to be immutable - Object needs to be a constant, known at the time Python parses the code. This allows the interpreter to recognize and deduplicate identical immutable objects during execution. - This optimization doesn't work in REPL (Python Standard Shell).

Python does that to optimize memory usage. Please keep in mind that there are some exceptions to these rules as well. In general, it can be dangerous to build your logic around those rules.

In Python, when we write x = "devcuriosity" we create a variable x assigned to the string object - devcuriosity.

We can say that a variable is bound to an object. That variable only exists in parts of our code.

The region of the code where a variable is defined and accessible is known as its lexical scope. Lexical scopes are managed through namespaces, which are mappings between variable names and the objects they reference.

Python follows the LEGB rule to resolve variable names:

• Local Scope: Names defined within a function.

• Enclosing Scope: Names defined in any enclosing functions.

• Global Scope: Names defined at the top-level of a module or script.

• Built-in Scope: Names preassigned in Python, such as len or print.