Short answer: Not really, but there might be something close enough.

The problem is, under the covers, a is a pointer-to-a-list, and l is a pointer-to-a-list-of-pointers-to-lists. When you a = l[0], what that actually translates to at the CPU is "dereference the pointer l, treat the resulting region of memory as a list object, get the first object (which will be the address of another list), and set the value of pointer a to that address". Once you've done that, a and l[0] are only related by concidence; the are two separate pointers that happen, for the moment, to point at the same object. If you assign to either variable, you're changing the value of a pointer, not the contents of the pointed-to object.

Broadly speaking, there's a few ways the computer could practically do what you ask.

1. Modify the pointed-to object (list) without modifying either pointer. That's what the append function does, along with the many other mutators of python lists. If you want to do this in a way that perhaps more clearly expresses your intent, you could do l[0][:] = [1,2]. That's a list copy operation, copying into the object pointed to by both l[0] and a. This is your best bet as a developer, though note that copy operations are O(n).
2. Implement a as a pointer-to-a-pointer-to-a-list that is automatically dereferenced (to merely a pointer-to-list) when accessed. This is not, AFAIK, something Python provides any support for; almost no language does. In C you could say list ** a = &(l[0]); but then any time you want to actually do anything with a you'd have to use *a instead.
3. Tell the interpreter to observe that a is an alias to l[0], rather than its own, separate variable. As far as I know, Python doesn't support this either. In C, you could do it as #define a (l[0]) though you'd want to #undef a when it went out of scope.
4. Rather than making a a list variable (which is implemented as a pointer-to-list), make it a function: a = lambda: l[0]. This means you have to use a() instead of a anywhere you want to get the actual content of l[0], and you can't assign to l[0] through a() (or through a directly). But it does work, in Python. You could even go so far as to use properties, which would let you skip the parentheses and assign through a, but at the cost of writing a bunch more code to wrap the lists (I'm not aware of a way to attach properties to lists directly, though one might exist, so you'd instead have to create a new object wrapping the list).

The explanations already here are correct. However, since I have wanted to abuse python in a similar fashion, I will submit this method as a workaround.

Calling a specific element from a list directly returns a copy of the value at that element in the list. Even copying a sublist of a list returns a new reference to an array containing copies of the values. Consider this example:

>>> a = [1, 2, 3, 4]
>>> b = a[2]
>>> b
3
>>> c = a[2:3]
>>> c
[3]
>>> b=5
>>> c[0]=6
>>> a
[1, 2, 3, 4]

Neither b, a value only copy, nor c, a sublist copied from a, is able to change values in a. There is no link, despite their common origin.

However, numpy arrays use a "raw-er" memory allocation and allow views of data to be returned. A view allows data to be represented in a different way while maintaining the association with the original data. A working example is therefore

>>> import numpy as np
>>> a = np.array([1, 2, 3, 4])
>>> a
array([1, 2, 3, 4])
>>> b = a[2]
>>> b
3
>>> b=5
>>> a
array([1, 2, 3, 4])
>>> c = a[2:3]
>>> c
array([3])
>>> c[0]=6
>>> a
array([1, 2, 6, 4])
>>> 

While extracting a single element still copies by value only, maintaining an array view of element 2 is referenced to the original element 2 of a (although it is now element 0 of c), and the change made to c's value changes a as well.

Numpy ndarrays have many different types, including a generic object type. This means that you can maintain this "by-reference" behavior for almost any type of data, not only numerical values.

It's not possible, because integers are immutable, while list are mutable.

In b = a[1] you are actually assigning a new value to b

Demo:

>>> a = 2
>>> id(a)
38666560
>>> a += 2
>>> id(a)
38666512

You can like this,

>>> a = [1,2,3]
>>> b = a
>>> a[1] = 3
>>> b
[1, 3, 3]
>>> a
[1, 3, 3]
>>> id(a)
140554771954576
>>> id(b)
140554771954576

You can read this document.

Let's start with the second case. You write

c = random.choice(a)

so the name c gets bound to some element of a, then

c = b

so the name c gets bound to some other object (the one to which the name b is referring - the float 0.1).

Now to the first case. You start with

c = random.choice(a)

So the name c gets bound to an object in a, which is a list itself. Then you write

c[:] = b

which means, replace all items in the list bound to by the name c, by some other list. In fact, this is called slice assignment, and is basically syntactic sugar for calling a method of the object to which c is bound.

The difference, then, is that in the first case, it doesn't just bind a name first to one object, then to another. It binds a name to a list, then uses this name to indirectly call a method of the list.

Everything in python is a reference. After all those statements are executed, listB[1] and listA[1] are literally the same object. (you can check, by calling id(listB[1]) and id(listA[1]).

The reason listA[0] and listB[0] are different is merely because you put a different reference into that spot.

Judging from your description, you don't want to a listA that stores references to the objects in listB. What you want is a listA that is a view of listB. I believe you have only two options:

• Create a special sequence that internally stores a reference to listA, and whose __getitem__ and __setitem__ methods perform lookups into listA when invoked.

• Create special a special reference types that contains something like a "sequence and index". Put these references into listA. But, to modify listB through listA, you'll have to invoke some sort of "get" and "set" members of these reference objects.

Lists are already passed by reference, in that all Python names are references, and list objects are mutable. Use slice assignment instead of normal assignment.

def add(L1, L2, L3):
    L3[:] = L1 + L2

However, this isn't a good way to write a function. You should simply return the combined list.

def add(L1, L2):
    return L1 + L2

L3 = add(L1, L2)

You cannot pass anything by value in Python. If you want to make a copy of a, you can do so explicitly, as described in the official Python FAQ:

b = a[:]

You misunderstood. There are 5 distinct references. If those 5 references all point to the same nested list and you alter that nested list, you can see the change reflected through all those references.

You didn't change a nested list here. You changed one of the references.

Think of references as nametags. You can put more than one nametag on an object:

nametag_a+-----------+
                 +---v--+
                 |object|
                 +---^--+
                     |
nametag_b+-----------+

You can 'look' at the object through either reference. Assignment is simply attaching a reference to an object. If a reference pointed to an object before, it is detached from that object and now points to another object:

nametab_b = another_object

results in

nametag_a+-----------+
                 +---v--+
                 |object|
                 +------+

nametag_b    +--------------+
    +-------->another_object|
             +--------------+

The numbered indices in a list are references to; so instead of nametag_a, you have 0, and 1, etc.

The other question talks about nested lists. There you have multiple references to a single list object:

# indices in a list on the left referencing another list

0+---------------------------+
                             |
                             |
1+------------------------+  |
                          |  |
                +---------v--v-----------+
2+--------------> list with more indices |
                +---------^--^-----------+
                          |  |
3+------------------------+  |
                             |
                             |
4+---------------------------+

If you make a change to the list with more indices contents, then you'll see those changes through any of the 5 references in the outer list

Please read Facts and myths about Python names and values by Ned Batchelder, which explains this in more detail.

In Python, assignment operator binds the result of the right hand side expression to the name from the left hand side expression.

So, when you say

a = Foo(2)
b = [a]

you have created a Foo object and refer it with a. Then you create a list b with the reference to the Foo object (a). That is why b[0].value prints 2.

But,

a = Foo(3)

creates a new Foo object and refers that with the name a. So, now a refers to the new Foo object not the old object. But the list still has reference to the old object only. That is why it still prints 2.