Python 中多个 while 循环退出条件的模式

Question

I spent some time looking through similarly named questions on here, but none seem to address the question of what to do if you have multiple exit conditions, each with their own logical path after exit. Here's what I mean.

I got started thinking about this while writing a function to add an element to a unique-element linked list:

class Node:
    def __init__(self, key, next=None, count=1):
        self.key = key       # Unique key corresponding to this node
        self.next = next     # Reference to next node in linked list
        self.count = count   # Occurrences of key above in data


node = get_prepopulated_list()

# Iterate over linked list until element is found or list is exhausted
while node.key != key and node.next is not None:
    node = node.next

# If found element, increment counter for that element
if node.key == key:
    node.count += 1

# Else, add new node to end
else:
    node.next = Node(key)

Notice how at least one of the two exit conditions is checked again after exit, leading to code duplication. Sure, we could flip which condition is being checked, but still there will remain code duplication.

In this case, we could use something like this, which might be a bit cleaner:

node = get_prepopulated_list()

# Iterate over linked list until element is found or list is exhausted
while node.key != key and node.next is not None:
    try:
        node = node.next
    # Break out on 'None' condition
    except AttributeError:
        break

# Use implicit 'None' check from try-except to add new node to end on None
else:
    node.next = Node(key)
    return

# Otherwise, found element, so increment counter for that element
node.count += 1

But this isn't really any better, first because it adds a required escape during the else of the while-else , second because it adds some bloated error handling inside the loop, and finally because it breaks rule 2 of the Zen of Python: "Explicit is better than implicit". Beyond that, it's also not extensible to more than 2 exit conditions.

So I have two questions:

1. Is there a better way of handling such a case with 2 exit conditions and matching logical paths?
2. Is there a better way of handling the case with 3 or more exit conditions and matching logical paths?

Answer 1

while node.next is not None:
    if node.key != key: 
        node = node.next
    else:
        node.count += 1
        return

node.next = Node(key)

Note: will work only if get_prepopulated_list() is not None

Minimal, Reproducible Example

class Node:
    def __init__(self,key):
        self.key = key
        self.next = None
        self.count = 1

class LinkedList:
    def  __init__(self):
        self.head = None

    def add(self,key):
        if self.head is None:
            self.head = Node(key)
        else:
            node = self.head
            while node.next is not None:
                if node.key != key: 
                    node = node.next
                else:
                    node.count += 1
                    return

            node.next = Node(key)

    def show(self):
        node = self.head
        while node is not None:
            print(node.key,'-->',node.count)
            node  = node.next

ll = LinkedList()

ll.add(5)
ll.add(6)
ll.add(2)
ll.add(5)
ll.add(7)
ll.show()