Hacker rank linklist node deletion-one test case failing need to understand where is it going wrong

#!/bin/python3

import math
import os
import random
import re
import sys

class SinglyLinkedListNode:
    def __init__(self, node_data):
        self.data = node_data
        self.next = None

class SinglyLinkedList:
    def __init__(self):
        self.head = None
        self.tail = None

    def insert_node(self, node_data):
        node = SinglyLinkedListNode(node_data)

        if not self.head:
            self.head = node
        else:
            self.tail.next = node


        self.tail = node

def print_singly_linked_list(node, sep, fptr):
    while node:
        fptr.write(str(node.data))

        node = node.next

        if node:
            fptr.write(sep)

#
# Complete the 'deleteNode' function below.
#
# The function is expected to return an INTEGER_SINGLY_LINKED_LIST.
# The function accepts following parameters:
#  1. INTEGER_SINGLY_LINKED_LIST llist
#  2. INTEGER position
#

#
# For your reference:
#
# SinglyLinkedListNode:
#     int data
#     SinglyLinkedListNode next
#
#

def deleteNode(llist, position):
    # Write your code here
    if llist is None: 
        llist=None
        return llist
    else:
        temp=llist
        index=0
        while index<position-1:
            temp=temp.next
            index+=1
        new_node=temp.next
        temp.next=new_node.next 
            
    return llist
            
        
        

if __name__ == '__main__':
    fptr = open(os.environ['OUTPUT_PATH'], 'w')

    llist_count = int(input())

    llist = SinglyLinkedList()

    for _ in range(llist_count):
        llist_item = int(input())
        llist.insert_node(llist_item)

    position = int(input())

    llist1 = deleteNode(llist.head, position)

    print_singly_linked_list(llist1, ' ', fptr)
    fptr.write('\n')

    fptr.close()

Link: https://www.hackerrank.com/challenges/delete-a-node-from-a-linked-list/problem?isFullScreen=true

I was trying to solve this hacker rank challenge but only 1 of the test cases are failing, i'm not sure why is it failing can anyone point out the error?

Test case:

7
11
12
8
18
16
5
18
0

Expected o/p:

12 8 18 16 5 18

As the method is outside the class, hence i'm not able to use the self.tail veriable then it would have been easy

Your code does not work correctly when position is 0. In that case it acts as if position was 1 and removes the second node instead of the first. You'll have to deal with this case separately.

No problem, but:

• llist=None is useless where you have it, because the if condition had just asserted that llist was already None

• It is more pythonic to loop over a range than to have a while loop in which you increase a counter with += 1.

• There is no need to use the new_node name (which is a strange name for a node that is about to be removed), as you can make the assignment to the next attribute directly.

• After an if ... return there is no need to have an else block; you can save one level of indentation here.

• The challenge guarantees that the list will not be empty, so in theory you don't need the first if condition. Still, I think it is a good habit to keep it in.

• If position would be an index that is out of range, then your code would produce an error. This is not really a problem, because the challenge guarantees that there are no such test cases, but it is still a good habit to foresee such cases.

• temp is not a very meaningful name. I'd suggest prev or previous to indicate that we aim to identify the node that precedes the node to remove.

Proposed code:

def deleteNode(llist, position):
    if not llist: # will not happen here, but good to have it
        return
    if position == 0:  # need to deal with this case separately
        return llist.next
    if llist.next:  # otherwise position is out of range
        prev = llist
        for _ in range(1, position):  # pythonic loop
            prev = prev.next
            if not prev.next:
                break  # position is out of range
        else:  # position is in range
            prev.next = prev.next.next             
    return llist