To get the output you have listed at the end of your question, you would need to create a linked list. For instance, if you define the following class:

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

    def __repr__(self):
        return f"ListNode{{val: {self.val}, next: {self.next}}}"

And if you then define list1 as follows:

list1 = ListNode(1, ListNode(2, ListNode(4, None)))

Then the "commands" will give the output that you listed.

List to Linked List

If you want to create the above linked list from the list [1,2,4], then use this function:

def createLinkedList(values):
    head = None
    for val in reversed(values):
        head = ListNode(val, head)
    return head

Now you can convert a plain list to a linked list as follows:

list1 = createLinkedList([1,2,4])

Linked List to list

If you want to do the opposite, and create a standard list from a linked list, then define this function:

def linkedListIterator(head):
    while head:
        yield head.val
        head = head.next

Now, if you have a linked list, you can pass it to the above function. For instance:

list1 = createLinkedList([1,2,4])
lst = list(linkedListIterator(list1))

lst will be [1,2,4]

You could do something like this:

def print_linked_list(item):
    # base case
    if item == None:
        return
    # lets print the current node 
    print(item.item)
    # print the next nodes
    print_linked_list(item.next)

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

If readability is a concern, why use single-character variable names? Replace them with something a bit more meaningful: v -> value, n -> next_, etc.

If you followed Python's data model your class could be used more easily and conventionally. For example, implementing size as a method seems a bit odd - if you called it __len__, then it would behave correctly with len and in a boolean context. Looking at the documentation for other, similar data structures can help with picking sensible names (I would expect an insert to take an index, for example, like the other sequences); in your case, maybe start with the deque's interface.

If you follow the conventional implementation, any of the following should work in a predictable way:

• if thing in linked_list:
• for thing in linked_list:
• list(linked_list) (which would really simplify your __str__ implementation)
• if linked_list:

You could also leverage Python's abstract base classes; if you inherit from Sequence and implement the required methods, for example, you get some additional behaviour for free.

In general you're following the style guide, but Node as a temporary variable name sticks out. It shadows the class you just instantiated and naming a variable in CamelCase is not the convention, it should be snake_case. In fact, it's entirely pointless; why not just self.node = Node(v, self.head)?

The problem is that you are missing the reference to the head of your list, because you are overwriting it. Start with this instead:

list1 = [4,5,1,2,0,4]
head = ListNode(list1[0])
tail = head

Then tail will be a reference to the last element of the linked list. Now in your loop you do:

while e < len(list1):
      print(head)
      tail.next = ListNode(list1[e])
      tail = tail.next
      e+=1

So you add an element to the list as before, but now we are modifying the tail variable. At the end:

return head

You will now be returning the head node of the list.

No, but you can use a list:

def make_nodes(n):
    nodes = []
    nodes.append(Node(0,None))    # head node
    for i in range(1, n):
        nodes.append(Node(i, None))
        nodes[i-1].next = nodes[i]    #somehow link them          
    return nodes

nodes = make_nodes()
head = nodes[0]
second = nodes[1]
last = nodes[-1]

You could also use a dictionary, and use the node number as the key. But a list seems more natural in this case.

But why would you want to do this? You might as well just use a Python list of Nodes. Creating the node list can be easily done with a list comprehension. Iterating over the list could then be done with a simple for loop:

nodes = [Node(i) for i in range(n)]

for node in nodes:
    print(node.payload)

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]