Skip to main content

How to Print Alternate Characters in a Python String

This guide explains how to extract and print alternate characters from a string in Python. We'll cover the most efficient and Pythonic method using string slicing, and we'll also look at a less efficient approach using enumerate() for comparison.

String slicing is the most concise and efficient way to get alternate characters. The general syntax is string[start:stop:step]. For alternate characters, we'll use a step of 2.

Starting from the First Character (Index 0)​

To get every other character starting from the first character (index 0), use a step of 2 and omit the start and stop indices:

my_str = 'tutorialreference'
result = my_str[::2]  # Start at 0, go to the end, step by 2
print(result)  # Output: ttrarfrne
  • [::2]: This slice says:
    • Start at the beginning (omitted start index defaults to 0).
    • Go to the end (omitted stop index defaults to the end).
    • Take every second character (step of 2).

Starting from the Second Character (Index 1)​

To get every other character starting from the second character (index 1), set the start index to 1:

my_str = 'tutorialreference'
result = my_str[1::2]  # Start at 1, go to the end, step by 2
print(result)  # Output: uoileeec
  • The [1::2] specifies that the string slice should begin at index 1.

Printing Alternate Characters with enumerate() (Less Efficient)​

While slicing is the preferred method, you can use enumerate() and the modulo operator (%) to achieve the same result. This is less efficient and less readable, but it demonstrates a different approach:

my_str = 'tutorialreference'
result = ''

for index, char in enumerate(my_str):
    if index % 2 == 0:  # Check for even indices
        result += char

print(result)  # Output: ttrarfrne
  • enumerate(my_str): This returns pairs of (index, character) for each character in the string.
  • if index % 2 == 0: This checks if the index is even. If it is, we append the character to the result string.
note

Why slicing is better: Slicing directly operates on the string's internal representation, making it much faster than iterating character by character. The enumerate() approach, while functional, is unnecessarily complex for this task.

Table of Contents