The short answer to this is that, Python is a pass-by-object-reference language, not pass-by-reference as implied in the question. It means that:

1. result and result_tail are two variables that happen to point at the same value
2. Mutation / Changing of the underlying value (result_tail.next = ListNode(1)) will affect the value shown by result
3. However, assigning / pointing the variable result_tail to another value will NOT affect the value of result
4. result_tail = result_tail.next is assigning the next node of the node that is currently assigned by the variable

The following is an visualization of the values that are assigned to the variables (r = result, rt = result_tail):

result = ListNode(0)
#r
#0 -> None

result_tail = result
#r
#0 -> None
#rt

result_tail.next = ListNode(1)
#r
#0 -> 1 -> None
#rt

result_tail = result_tail.next
#r
#0 -> 1 -> None
#     rt

result_tail.next = ListNode(2)
#r
#0 -> 1 -> 2 -> None
#     rt

result_tail = result_tail.next
#r
#0 -> 1 -> 2 -> None
#          rt

References for additional reading:

• An article explaining the Python pass-by-object reference style in detail https://robertheaton.com/2014/02/09/pythons-pass-by-object-reference-as-explained-by-philip-k-dick/
• An answer explaining Python's pass-by-object reference style https://stackoverflow.com/a/33066581/12295149
• Question asking on Python's object reference style Understanding Python's call-by-object style of passing function arguments

The question doesn't require you to use regular lists. Since the lists are stored in "reverse order", that actually helps because you would add digits individually between both lists, then calculate/carry overflows moving left-to-right. For example, adding linkedlists [5, 1] + [5] would cause you to add one node to the resulting list [0, , then you iterate to the next position, carrying forward the 10s digit, then do 1 from your input plus 1 from the carry of the previous iteration, getting 2 , so the result is [0, 2]. If you carry a 1 into a 9, then you bring the carry digit forward again

Besides, if you're going to build a regular list, you might as well convert to an int, instead, do the math, then turn the int into the linked list...

But to convert a LinkedList into a regular list, without that LinkedList class being an iterable type itself, would look like this

ll = ListNode(...)

l = []
n = ll
while n is not None:
    l.append(n.val)
    n = n.next

Otherwise, if it were a proper Python iterable type, [n.val for n in ll]

You need two functions:

1. One to turn a standard list into a linked list (for calling the middleNode)
2. One to turn a linked list back into a list (for printing the result)

I would suggest to add methods to the ListNode class. The second one could actually be __iter__ so that a linked list becomes iterable, and then you just have to put the * operator in your print statement:

class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

    @classmethod
    def of(Cls, lst):
        head = None
        for val in reversed(lst):
            head = Cls(val, head)
        return head

    def __iter__(self):
        head = self
        while head:
            yield head.val
            head = head.next

class Solution(object):
    def middleNode(self, head):
        slow = fast = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        return slow


head = ListNode.of([1,2,3,4,5])
print(*Solution().middleNode(head))

Drawing diagrams helps. Here's your linked list:

[   ]
  |
  v
[   ]
  |
  V
[   ]
  |
  V
 None

Each arrow leading from a box represents the next attribute of that node.

Here are the three variables a, b, and c:

         [   ] <-- a
           |
           v
         [   ] <-- b
           |
           V
         [   ] <-- c
           |
           V
          None

Each of these variables also points to a particular node.

If you say b.next = None, the next attribute of the node referenced by b is modified, like this:

         [   ] <-- a
           |
           v
None <-- [   ] <-- b


         [   ] <-- c
           |
           V
          None

This modifies the structure of the list. If you just set b itself to a different value, though, this is what happens:

         [   ] <-- a
           |
           v
None <-- [   ]     b --> None


         [   ] <-- c
           |
           V
          None

You changed b, but the node that b used to point to stays right where it was. Note that this is similar to how the c node continued to exist even after you set b.next = None.

So yes, you are correct, on your while list1 and list2 this evaluates to True.

You can solve it like this, being more explicit:

def mergeTwoLists(list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
    prehead = ListNode(-1)

    prev = prehead
    while (list1.next is not None) and (list2.next is not None):
        if list1.val <= list2.val:
            prev.next = list1
            list1 = list1.next
        else:
            prev.next = list2
            list2 = list2.next
        prev = prev.next

    prev.next = list1 if list1 is not None else list2

    return prehead.next

It probably works in leetcode because they defined another method to the class. If you define the class like this:

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
    def __bool__(self):
        """Return bool(self)."""
        return self.next is not None

Then the __bool__ method will be called when you try to do list1 and list2, and it does the same behavior.