Linked List, skipping every nth amount user inputs - python-3.x

Question

This code is part of a file where I am manipulating a linked list. This section is part of a function called alternate(head, skip_amt). The user will call the alternate function in a separate file to test my functions. The user will enter a list of nodes and the skip_amt. If the user enters skip_amt = 3, then my function needs to skip over 3 nodes in the linked list and return the 4th node until the end of the list.
My function below is doing this correctly for 0 steps, 1 step, and 3 steps. How can I change my function so that if the user wants me to skip every nth node and return the (n + 1)th node until the end of the list? I also feel like this code is too long and there must be a shorter way to accomplish what I am trying to do.
def alternate(head, skip_amt):
if (skip_amt == 0):
head = head.next
return head
if (skip_amt == 1):
temp = head
if (temp):
# if list has nodes
head = temp.next
temp = head
while (temp and temp.next):
# skips every other item in linked list a
# removes pointer so old_head returns every other item
temp.next = temp.next.next
temp = temp.next
return head
if (skip_amt > 1):
temp = head.next.next
if (temp):
# if list has nodes
head = temp.next
temp = head
while (temp and temp.next):
# skips every other item in linked list a
# removes pointer so old_head returns every other item
temp.next = temp.next.next
temp.next = temp.next.next.next
temp = temp.next
return head

Answer 1

Indeed, there is no reason why you should treat separately the case where skip_amt is 0, or is 1, or is 2... You can do this in one generic way.
Here is some code you could use. I have included utility functions to convert a sequence (i.e. list, range, tuple) to a linked list, and to iterate a linked list.
I would also define alternate as a method. Things become a bit easier if you also define a separate method that walks a given number of steps forward in the list.
class Node:
def __init__(self, val, next=None):
self.val = val
self.next = next
#staticmethod
def fromsequence(seq):
head = None
for val in reversed(seq):
head = Node(val, head)
return head
def __iter__(self): # allow iteration over this linked list
node = self
while node:
yield node.val
node = node.next
def forward(self, steps): # return the node that is `steps` ahead
node = self
for _ in range(steps):
if not node:
return
node = node.next
return node
def alternate(self, skip_amt):
head = self.forward(skip_amt)
node = head
while node:
node.next = node.forward(skip_amt+1)
node = node.next
return head
# demo
head = Node.fromsequence(range(17))
print(list(head)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
head = head.alternate(3)
print(list(head)) # [3, 7, 11, 15]

Answer 2

Needs some tweaking, but it would be along the lines of this
def alternate(list, skip_steps):
print('list head:', list.data)
if (skip_steps == 0):
while True:
print(list.data)
if(list.next == None):
print('end of list')
return
list = list.next
elif (skip_steps == 1):
while True:
print(list.data)
if((list.next== None or list.next.next== None)):
print('end of list')
return
list = list.next.next
else: # Means we have to skip steps > 1
while True:
for i in range(skip_steps):
if(list.next == None):
print('end of list reached before next node')
return
list = list.next
print(list.data)
You should be able to modify it to work for your needs