Python Tutorial



Python Tutorial

Lexicographical Order in Python


Python, as a versatile language, offers varied methods to sort data. One notable and frequently utilized method is the lexicographical sort. This technique, while straightforward, is of paramount importance in real-world data processing and offers insights distinct from numerical sorting. In this tutorial we’ll dive deep into the Lexicographical order in Python and its workings. 


Delving into Python’s string sorting capabilities, we find that the lexicographical approach stands distinct. This method, while inherent in many programming languages, exhibits unique nuances in Python which, when understood, can lead to efficient and effective data processing.

What is a Lexicographical Order in Python?

Lexicographical ordering is an essential aspect of Python's extensive string operations library. To dive deeper into this:

  • Definition: At its essence, lexicographical order, in the context of string operations, provides a method to arrange words or strings in a sequence akin to how words are aligned in a dictionary or a phonebook. It goes beyond mere alphabetical order to consider the full sequence of characters in strings.

  • Comparison Mechanism: Python's approach to determining the lexicographical order of strings or characters is rooted in the ASCII (American Standard Code for Information Interchange) values of characters. Every character has a corresponding ASCII value, and when Python makes a comparison, it's these values that are evaluated. For instance, uppercase letters have different ASCII values than their lowercase counterparts, influencing their position in a lexicographical sort.

  • Python's Built-In Support: Python inherently supports lexicographical comparison. This means that the language uses lexicographical ordering whenever strings are compared in Python, without explicit instruction. It provides a seamless and intuitive way for developers to handle and manipulate string data.

Table: ASCII Value Examples for Characters











Why is a Lexicographical Order important?

The significance of lexicographical order transcends its basic linguistic utility and proves pivotal in various computational realms. Delving into its importance:

  • Efficient Data Organization: As the realm of data grows and becomes more intricate, organizing this data efficiently becomes paramount. Lexicographical order offers a structured and consistent manner to categorize vast datasets. This organization method not only aids in better comprehension but also streamlines data analysis processes. Data presented in a lexicographical sequence is more intuitively readable, making it easier for users and algorithms alike to comprehend and navigate.

  • Ease in Searching: For many algorithms, particularly those involved in searching, the data structure plays a decisive role in their efficiency. When datasets are lexicographically sorted, search algorithms can swiftly locate data points, ensuring reduced computational time and resource usage, thus optimizing performance and cost-effectiveness.

  • Compatibility with International Standards: In an era of globalization, ensuring data is coherent and interpretable across borders is crucial. Lexicographical order's alignment with various international encoding standards ensures that data remains robust and interoperable globally, facilitating smoother international data exchanges and collaborations.

Summary Table: Benefits of Lexicographical Order



Efficient Data Representation

Data, structured lexicographically, becomes easily readable and facilitates enhanced management.

Streamlined Search Process

Empowers search algorithms with heightened speed and efficiency.

Alignment with International Encoding Norms

Ensures consistent and coherent data interpretation across various global standards.

Sorting Strings With Lexicographic Order

Example of Python Lexicographic Order Using sort()


# Sorting a list of strings in-place
fruits = ['apple', 'banana', 'cherry', 'date', 'blueberry']

print("Sorted List of Fruits:")
for fruit in fruits:

In this example, we have a list of fruits, and we use the sort() method to sort the list in lexicographic (alphabetical) order in-place. The sorted list is then printed.

Example of Python Lexicographic Order Using sorted()


# Sorting a list of strings using the sorted() function
fruits = ['apple', 'banana', 'cherry', 'date', 'blueberry']
sorted_fruits = sorted(fruits)

print("Original List of Fruits:")
for fruit in fruits:

print("\nSorted List of Fruits:")
for fruit in sorted_fruits:

In this example, we use the sorted() function to create a new sorted list (sorted_fruits) from the original list of fruits (fruits). This preserves the original list and sorts the new list lexicographically.

Sorting Lists in Python With Lexicographic Order


# Sorting a list of strings in lexicographic order
fruits = ['apple', 'banana', 'cherry', 'date', 'blueberry']
fruits.sort(key=lambda x: x.lower())

print("Sorted List of Fruits (case-insensitive):")
for fruit in fruits:

In this example, we sort the list of fruits in a case-insensitive manner by using the key argument with the sort() method. The key function lambda x: x.lower() converts each string to lowercase for comparison, ensuring a case-insensitive lexicographic sort.

Example of Lexicographical Order in Java

Method 1: Applying any sorting method


import java.util.Arrays;

public class LexicographicalSort {
    public static void main(String[] args) {
        String[] names = {"apple", "banana", "cherry", "date", "blueberry"};

        // Sort the array lexicographically using any sorting method (e.g., Arrays.sort())

        System.out.println("Sorted Names:");
        for (String name : names) {

In this Java program, we have an array of names. We use the Arrays.sort() method to sort the array in lexicographical (alphabetical) order. The sorted names are then printed.

Method 2: Applying sort() function


import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class LexicographicalSort {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();

        // Sort the list lexicographically using the Collections.sort() function

        System.out.println("Sorted Names:");
        for (String name : names) {

In this Java example, we use an ArrayList to store the names. We then use the Collections.sort() function to sort the list in lexicographical order. The sorted names are printed afterward.

Using Lexicographical Order in Java to Compare Two Strings


public class LexicographicalComparison {
    public static void main(String[] args) {
        String str1 = "apple";
        String str2 = "banana";

        // Compare two strings lexicographically
        int result = str1.compareTo(str2);

        if (result < 0) {
            System.out.println("str1 comes before str2");
        } else if (result > 0) {
            System.out.println("str1 comes after str2");
        } else {
            System.out.println("str1 and str2 are equal");

In this Java program, we compare two strings, str1 and str2, lexicographically using the compareTo() method. The result of the comparison indicates whether str1 comes before, after, or is equal to str2.

Advanced Example of Lexicographical Order in Python


# Define a list of book titles with varying formats
book_titles = [
    "The Catcher in the Rye",
    "To Kill a Mockingbird",
    "Brave New World",
    "The Great Gatsby",
    "The Hobbit",
    "Harry Potter and the Sorcerer's Stone",

# Define a custom function to extract a sorting key
def sorting_key(title):
    # Remove leading articles (e.g., "The", "A", "An") for sorting
    articles = ["The", "A", "An"]
    for article in articles:
        if title.startswith(article + " "):
            return title[len(article) + 1:]  # Skip the article and space
    return title

# Sort the list of book titles lexicographically, ignoring leading articles
sorted_titles = sorted(book_titles, key=sorting_key)

# Display the sorted titles
print("Sorted Book Titles (Ignoring Leading Articles):")
for title in sorted_titles:

In the above example, we have a list of book titles stored in the book_titles list, and these titles may start with leading articles like "The," "A," or "An." We define a custom sorting_key function that extracts a sorting key for each title. The function removes leading articles from the titles before sorting. This ensures that titles are sorted based on the words following the leading articles.

We use the sorted() function with the key argument to sort the book_titles list using the custom sorting key provided by the sorting_key function. Finally, we print the sorted book titles, demonstrating how to sort strings lexicographically while ignoring leading articles.


Understanding the lexicographical order in Python not only elevates one's data handling capabilities but also offers refined insights into string operations. For professionals aiming to elevate their Python prowess, mastering this order is a stepping stone. As the world of data continues to grow, the tools we utilize to interpret and manage this information must be sharpened. We encourage those eager to expand their horizons further to explore upGrad's advanced courses, ensuring a thorough grasp of foundational and cutting-edge Python concepts alike.


1. What is the difference between lexicographic order Python and lexicographical order Python?

Both "lexicographic order Python" and "lexicographical order Python" refer to the same concept: the method of sorting strings based on dictionary order within the Python language. The terms are often used interchangeably, although "lexicographical" is the more grammatically accurate term.

2. How does Python sort lexicographically when numbers and letters coexist?

In Python, the lexicographical sorting mechanism is based on the ASCII values of characters. As per ASCII standards, numerical characters have a lower value than alphabetic ones. Hence, when sorting a string containing both numbers and letters, Python will place numbers before letters.

3. Is numerical sort distinguishable from sort lexicographically Python?

Certainly. Lexicographical sorting in Python evaluates data character by character based on ASCII values. On the other hand, numerical sorting exclusively evaluates the numerical value of entities. This distinction becomes evident when sorting items like "10" and "2", where lexicographically "10" comes before "2", but numerically it's the opposite.

4. How to sort a set in Python lexicographically?

To sort a set lexicographically in Python, one can convert the set into a list first, as sets inherently do not maintain order. Post conversion, the list can be sorted using Python's built-in sort function, and if necessary, it can be converted back to a set afterwards.

5. Can lexicographical order in Python sometimes confuse users?

Indeed, the lexicographical ordering in Python, based on ASCII values, can occasionally puzzle users. This is particularly true when comparing uppercase and lowercase letters since their ASCII values are different. For example, uppercase letters sort before lowercase ones, which might seem counterintuitive to some.

Leave a Reply

Your email address will not be published. Required fields are marked *