Python ord() Function

Spread the love

The ord() function in Python is a built-in function that takes a single Unicode character as its argument and returns its corresponding Unicode code point, which is an integer. The function name ord stands for “ordinal,” as it essentially returns the ordinal position of a character in the Unicode character set.




character: The ord() function takes one parameter, which is a string representing a single Unicode character.

Return Value:

The function returns an integer representing the Unicode code point of the given character.

Basic Example

Here’s a simple example of how ord() can be used:

# Example of ord() function
char = 'a'
print(ord(char))  # Output: 97

The Unicode code point for the lowercase letter 'a' is 97, and that’s what the ord() function returns.

Understanding Unicode and Character Encodings

Before we dive deeper into the ord() function, it’s crucial to understand what Unicode and character encodings are.


Unicode is a standard designed to consistently encode, represent, and handle text expressed in most of the world’s writing systems. Unlike ASCII, which encodes 128 characters and is sufficient for English text, Unicode has a much wider range of characters and can represent scripts from all around the globe.

Character Encodings

A character encoding tells the computer how to interpret raw zeroes and ones into real characters. It is essentially a key that pairs a set of characters with their binary representations. Unicode uses different encoding forms like UTF-8, UTF-16, and UTF-32, which define how the Unicode code points are translated into a binary stream.

The Role of ord() in Python

Python’s ord() function is crucial when you need to deal with individual characters and their underlying numerical representations. This is often the case in:

  • Cryptography: Where characters are often converted to numerical values for encryption and decryption algorithms.
  • Sorting algorithms: Where characters are compared based on their ordinal values.
  • Data transformation: When characters need to be encoded or decoded for storage or transmission.

How ord() Works with Different Character Sets

ASCII Characters

For characters in the ASCII range, ord() returns values from 0 to 127.

print(ord('A'))  # Output: 65
print(ord('$'))  # Output: 36

Extended ASCII and Unicode Characters

For characters beyond the ASCII range, including extended ASCII and other Unicode characters, ord() returns the appropriate Unicode code point.

print(ord('ñ'))  # Output: 241
print(ord('€'))  # Output: 8364
print(ord('𝔘'))  # Output: 120088

Error Handling in ord()

Passing anything other than a single character string to ord() will result in a TypeError.

except TypeError as e:
    print(e)  # Output: ord() expected a character, but string of length 2 found

It’s essential to handle such errors when writing functions that utilize ord() to ensure robustness.

Practical Applications of ord()

Text Processing

In text processing, ord() can be used to convert characters into their numeric representation for various manipulations, like creating ciphers.

# Define the function
def caesar_cipher(text, shift):
    encrypted_text = ""
    for char in text:
        if char.isalpha():  # Check if the character is a letter
            shifted = ord(char) + shift  # Shift the character code
            if char.islower():  # If the character is lowercase
                encrypted_text += chr((shifted - 97) % 26 + 97)  # Wrap around the alphabet if needed
            else:  # If the character is uppercase
                encrypted_text += chr((shifted - 65) % 26 + 65)  # Wrap around the alphabet if needed
            encrypted_text += char  # Non-alphabetical characters remain unchanged
    return encrypted_text

# Use the function
original_text = "Hello, World!"
shift_amount = 3

# Encrypt the original text
encrypted_text = caesar_cipher(original_text, shift_amount)

# Display the encrypted text
print(encrypted_text)  # Output: "Khoor, Zruog!"

Data Encoding

When working with data encoding, ord() can be employed to convert characters before applying encoding algorithms.

def to_binary_string(text):
    return ' '.join(format(ord(char), 'b') for char in text)

print(to_binary_string("Hello"))  # Outputs the binary representation of "Hello"

Sorting Algorithms

Sorting algorithms that involve strings might use ord() to compare characters based on their Unicode code points.

def unicode_sort(strings):
    return sorted(strings, key=lambda x: [ord(char) for char in x])

print(unicode_sort(['banana', 'apple', 'orange']))


The ord() function may seem simple on the surface, but it serves as a fundamental building block for a variety of complex operations in Python. Whether you’re encrypting data, manipulating text, or sorting strings, understanding and using ord() effectively can greatly enhance the functionality and efficiency of your Python code.

Leave a Reply