# How To Alternate Turns Python

When creating turn-based games or applications in Python, you need a reliable method to alternate turns between players or participants. In this blog post, we will discuss a simple approach to achieve this using a loop and modulus operation. Let’s dive in.

## Using a loop and modulus operator

The most straightforward technique to alternate turns in Python is to use a loop (such as for or while) and the modulus operator (%). The modulus operator returns the remainder of the division between two numbers. This can be used to determine if the current iteration is an even or odd number, which can represent the turn of player 1 or player 2, respectively.

Here’s a simple example using a for loop and the modulus operator:

for i in range(10):
if i % 2 == 0:
print(“Player 1’s turn”)
# Player 1’s code goes here
else:
print(“Player 2’s turn”)
# Player 2’s code goes here

In this code snippet, we use a for loop that iterates through the range from 0 to 9 (10 total iterations). If the current iteration number (i) is divisible by 2 (i.e., it’s an even number), it’s player 1’s turn. Otherwise, it’s player 2’s turn.

## Using a while loop

You can also use a while loop to achieve the same result. Instead of specifying the range upfront, you keep track of the turn count using a variable and increment it in each iteration. The loop continues until a specified condition is met (e.g., a certain number of turns have been played).

Here’s an example using a while loop:

turn_count = 0
max_turns = 10

while turn_count < max_turns:
if turn_count % 2 == 0:
print(“Player 1’s turn”)
# Player 1’s code goes here
else:
print(“Player 2’s turn”)
# Player 2’s code goes here

turn_count += 1

In this example, we use a while loop that continues until the turn_count reaches the max_turns (10 in this case). The logic for determining the current player’s turn is the same as in the for loop example.

## Conclusion

Alternating turns in Python can be easily achieved by using loops and the modulus operator. This simple approach can be applied to different scenarios and adapted to accommodate more than two players or participants. As you develop more complex games or applications, remember to keep your code modular and maintainable, so it’s easier to scale and extend your project.