Home Python Print List: Why Won’t It Show Letters?

Coding Best Practices

Python Print List: Why Won’t It Show Letters?

Learn how to fix a Python function that prints a list of numbers converted to letters. Understand common issues and best practices.

byDev Solutions

February 18, 2026

Developer confused why Python list prints as ['a', 'b', 'c'] instead of 'abc', featuring chr() and join() code examples.

🤖 Python’s default list printing adds brackets and quotes, which can confuse beginners.
🧠 Using "".join() transforms a list of characters into a readable string output.
🧮 chr() and ord() are important for converting between ASCII codes and letters.
🔠 Adding an offset like 97 or 65 allows conversion of 0–25 to alphabet ranges.
⚠️ Inefficient string concatenation in loops slows code; prefer join() for better performance.

You wrote a Python script to change numbers to letters. You expected a clean output like abc. But Python prints ['a', 'b', 'c'] instead. Maybe you wonder why this happens. Or you want to make Python print what you expect. Lots of people have these questions. How Python prints things can be confusing with lists and character codes. This guide will explain it simply.

Python Numbers and Letters: The ASCII Connection

To understand how Python changes numbers to letters, you need to know about character codes. These are ASCII and its newer version, Unicode.

In Python, each character has a number in ASCII code. For example:

chr(97)  # Returns 'a'
ord('a')  # Returns 97

chr() (character) takes a number and returns the matching character.
ord() (ordinal) does the reverse—turns a character into its numeric equivalent.

This relationship is simple for the English alphabet:

'a' to 'z' → ASCII 97 to 122
'A' to 'Z' → ASCII 65 to 90

These functions are very useful when you do things like:

Text encryption (Caesar cipher, substitution cipher)
Looking at single characters
Games to teach the alphabet
Putting commands into basic network messages

When you understand how these functions work together, you get useful tools for working with character data in Python.

How Lists Behave in Python Print Statements

Say you print a list of characters:

letters = ['a', 'b', 'c']
print(letters)

Result:

['a', 'b', 'c']

Rather than seeing abc, you see how Python shows the list:

Brackets [ ] show it is a list.
Quotes 'x' around each item show they are string elements.
Commas split the items.

This might surprise you if you wanted plain text. To fix this, we use Python’s .join() method.

Using join() for Plain String Output

Here’s how you can fix it:

letters = ['a', 'b', 'c']
print("".join(letters))  # Output: abc

What’s happening here:

Here, "".join(letters) puts all the items in letters together. It makes them one string, with nothing between them.
If you used " ".join(letters), the result would be 'a b c'.

Using join() is the right way to print list items as one string. This is true especially when you have many characters.

Convert Numbers to Letters the Right Way

You often need to turn numbers into letters. Here is how to do it right.

Step-by-Step Conversion:

nums = [97, 98, 99]
letters = [chr(n) for n in nums]
print("".join(letters))  # Output: abc

Explanation:

The code [chr(n) for n in nums] changes each ASCII number into a letter. It uses list comprehension to do this.
Then "".join(letters) puts all the characters together into one string.

One-Liner Version:

print("".join([chr(n) for n in [97, 98, 99]]))  # Output: abc

⚠️ One-liners are short. But they make code harder to read, especially for new people. Do not use them often.

Common Mistakes When Printing Letter Lists

Even people who code a lot get confused by Python’s lists and strings. Here are mistakes to avoid:

❌ Mistake #1: Forgetting to Use join()

Printing a list directly:

letters = ['a', 'b', 'c']
print(letters)  # ['a', 'b', 'c']

Correct approach:

print("".join(letters))  # abc

❌ Mistake #2: Mixing up ord() and chr()

It's easy to reverse these functions:

chr(97) → 'a'
ord('a') → 97

These only work with single characters:

ord('abc')  # ❌ Will raise a TypeError

❌ Mistake #3: Using Inefficient Loops for Concatenation

Bad practice:

result = ""
for n in nums:
    result += chr(n)

Why it's bad:

Each += makes a new string in the computer's memory.
Adding strings many times is slow if you have a lot of data.

Efficient alternative:

print("".join([chr(n) for n in nums]))

Use join()—it’s faster and more Pythonic.

Make Lists Print the Way You Want

Here are ways to print letters clearly:

Using join()

print("".join(['h', 'e', 'l', 'l', 'o']))  # hello

Using f-strings for Formatting

for c in ['h', 'e', 'l', 'l', 'o']:
    print(f"Letter: {c}")

Using map() with join()

nums = [97, 98, 99]
print("".join(map(chr, nums)))  # abc

The map(chr, nums) command runs chr() on every item. It does this without you having to write a loop yourself.
It does the same thing as list comprehension. It is just a different way to write it.

Converting 0–25 to Alphabet Letters

This is a common thing to do, especially in code that makes ciphers or special alphabets. You change numbers from 0–25 to lowercase or uppercase letters.

Lowercase Letters

numbers = [0, 1, 2]
letters = [chr(n + 97) for n in numbers]
print("".join(letters))  # abc

Here’s why:

ASCII for 'a' is 97.
Adding 0, 1, 2 to 97 gives 97, 98, 99 → 'a', 'b', 'c'.

Uppercase Letters

letters = [chr(n + 65) for n in numbers]
print("".join(letters))  # ABC

Put this in a function so you can use it again:

def convert_to_letters(base, nums):
    return "".join([chr(n + base) for n in nums])

print(convert_to_letters(97, [0, 1, 2]))  # abc
print(convert_to_letters(65, [0, 1, 2]))  # ABC

Debugging When Python Print Still Looks Wrong

Your code runs, but the output looks wrong? Here is how to find the problem:

Check Data Type

letters = ['a', 'b', 'c']
print(type(letters))  # <class 'list'>

This helps you check what you are printing.

Use repr() To Examine Structure

print(repr(letters))  # ['a', 'b', 'c']

This makes Python show the actual way objects are written in code.

Loop Through Items Manually

for item in letters:
    print(item)

If you think there are hidden characters or badly formed data (like '\n', '\t'), this helps you see them.

Core Python Concepts at Work

Here is what you have used so far:

🔁 List Comprehension

A good way to make lists quickly:

[chr(n) for n in range(97, 100)]

🎛 Built-in Functions

These include:

chr()
ord()
type()
repr()

🔤 String Methods

.join() – Puts strings together
.strip(), .upper() – More tools for working with strings

🔢 ASCII & Unicode Encoding

Knowing ASCII helps you work with data one character at a time. And Unicode helps you work with many different alphabets from around the world.

Real-World Examples That Use This

Here are real ways people use Python to change numbers into letters:

🔐 Simple Ciphers

Make a Caesar shift cipher:

# Shift letters by +1
def caesar(text, shift=1):
    return "".join([chr((ord(c) - 97 + shift) % 26 + 97) for c in text])

print(caesar("abc"))  # bcd

👾 Coding Games

Change inputs like 1, 2, 3 into player names A, B, C.

🧠 Learning Tools

Learning software can change 0–25 into letters to help kids learn the alphabet.

🧹 Data Cleaning

Change ASCII-coded input logs into easy-to-read forms. Do this before you save them or show them visually.

Best Practices for Clear Output

Make your code better with these habits:

✅ Use clear variable names:

ascii_codes = [97, 98, 99]
char_list = [chr(code) for code in ascii_codes]

✅ Comment character math:

# 97 is ASCII for 'a'. This offset changes 0–25 to letters.
alphabet = [chr(i + 97) for i in range(26)]

✅ Do not guess types. Use type() to find problems.
✅ Keep inline code for clear, short statements.

ASCII, Unicode, and Beyond

Python works with more than just English alphabets. Python 3 uses Unicode all the time. This means:

print(chr(1040))  # Output: А (Cyrillic capital A)

You can print characters from many alphabets. Just make sure your computer screen or font can show them.

Try these other scripts:

Arabic: chr(1575) → 'ا'
Hebrew: chr(1488) → 'א'
Devanagari: chr(2309) → 'अ'

Just know about character codes when you save or move these characters between different systems.

Use Your Knowledge: Try Making the Alphabet

Test what you know with these practice tasks:

Full Lowercase Alphabet

alphabet = [chr(n) for n in range(97, 123)]
print("".join(alphabet))  # abcdefghijklmnopqrstuvwxyz

Indexed Alphabet Output

for i in range(26):
    print(f"{i}: {chr(i + 97)}")

Uppercase Alphabet

uppercase = [chr(n) for n in range(65, 91)]
print("".join(uppercase))  # ABCDEFGHIJKLMNOPQRSTUVWXYZ

This helps you remember ASCII ranges and how to use list comprehension well.

Do you want to get better at Python? Try making a Caesar cipher tool with what you learned here. Python is one of the most used programming languages today. More than 48% of developers love it (Stack Overflow, 2023). Solving data change problems like this is one reason why.

References

Python Software Foundation. (2023). Built-in Functions – chr(), ord(). https://docs.python.org/3/library/functions.html
Van Rossum, G., & Drake, F. L. (2009). Python 3 Reference Manual. Python Software Foundation.
Stack Overflow Developer Survey. (2023). https://survey.stackoverflow.co/2023/