Your analogy is wrong. myTuple=(myInt,myList) is at any time: myTuple=(myInt,myList)在任何时候都是：

&myTuple[0]=myInt;
&myTuple[1]=myList;

因为在Python里一切都是对象，myInt也是。tuple是immutable的意思是你无法为其元素重新赋值。也就是你不能改变myTuple[0]和myTuple[1]这两个指针变量的值，所以它们永远指向myInt和myList，这一点是确定的。

但是你可以修改tuple中的每个元素所指向的对象本身，前提是这个对象必须是可变的。比如你能够修改myList，因为这是一个可变对象。但是myInt rrreee

You understand the pointer as a small piece of paper with a number written on it. The number on the paper tells you which numbered drawer you should go to get something from.

Then the Tuple is like this:

1. When you have a myTuple, you have a note named myTuple. According to the number, you can find a drawer with one or more other small notes in the drawer. And the number of these slips is certain, and it may not change until you throw away the slip myTuple (or replace the number on myTuple with another one).

2. myTuple The process from (myInt,)变成 (myInt, myList) is actually to rewrite the number on myTuple, and put two notes into another drawer corresponding to the new number: the first one is the original myInt note, and the second one is The newly added myList note.

3. When you add or delete any element to myList, you actually go to the corresponding drawer to do things based on the myList note. It has nothing to do with myTuple. It's just that there happens to be a number on the note in myTuple, which is different from the myTuple note. The numbers are the same.

It’s just the constant pointer.

I think it can be explained by the scenario of function passing parameters,
1. Variable object passing by reference: It can be changed on the original object. The pointer to the object is held both inside and outside the function. An object is used inside and outside the function. If it is changed inside the function The object will also be changed outside the function, similar to passing by reference.
2. Transfer copy of immutable objects: Immutable objects cannot change in the original memory space, so if you want to change its value, the interpreter will create a new object to store the new variables. At this time, the object used inside and outside the function is not the same object. --The previous object is still used outside the function, but a brand new object is used inside the function.

myInt = 5
myList = [3]
print id(myList)  #id: 37216584
myTuple = (myInt, myList)
print myTuple  #(5, [3])
myList.append(4)
print id(myList) #id: 37216584
print myTuple #(5, [3, 4])
myList = [4, 5]
print id(myList)# id: 37258584
print myTuple #(5, [3, 4])

First make sure that myList is a list object, pointing to an address (or reference, I think it is like a pointer), and myTuple stores this reference. Because myList is variable, it can be added and deleted, but its address has not changed. Look at the id twice. If you point myList to another object, the address changes. The changed myList at this time will not affect myTuple. Because the list object saved by Tuple has not changed, it has nothing to do with myTuple.

In python, your myInt here is also a reference, pointing to an integer entity. This is different from c/c++. In c/c++, myInt is the integer entity itself; in this way, everything stored in the Tuple is a reference. The difference is that Int is immutable and List is mutable;
So the contradiction you mentioned does not exist.