Skip to main content

Python Text Processing

Text data is everywhere - in emails, documents, web pages, social media, and more. Being able to effectively process and manipulate text is a fundamental skill for any programmer. In this tutorial, we'll explore how Python makes text processing both powerful and accessible.

Introduction to Text Processing​

Text processing refers to the manipulation and analysis of text data. In Python, strings come with built-in methods that make text processing straightforward. We'll learn how to:

  • Clean and normalize text
  • Extract information from text
  • Transform text in useful ways
  • Analyze textual content

Let's dive into these essential text processing techniques!

Basic String Operations for Text Processing​

Case Conversion​

Changing text case is often needed when standardizing data:

python
# Convert to uppercase and lowercase
text = "Python is Amazing"
print(text.upper())  # PYTHON IS AMAZING
print(text.lower())  # python is amazing
print(text.title())  # Python Is Amazing
print(text.capitalize())  # Python is amazing

Removing Whitespace​

Cleaning up excess whitespace is a common requirement:

python
# Removing whitespace
messy_text = "   Python text processing   \n"
print(messy_text.strip())  # "Python text processing"
print(messy_text.lstrip())  # "Python text processing   \n"
print(messy_text.rstrip())  # "   Python text processing"

Replacing Text​

Replacing parts of text is fundamental to text processing:

python
# Replace specific text
sentence = "Python is difficult to learn, Python is complex"
print(sentence.replace("difficult", "easy"))  # Python is easy to learn, Python is complex
print(sentence.replace("Python", "JavaScript", 1))  # JavaScript is difficult to learn, Python is complex

Text Analysis Techniques​

Finding Text​

Locating specific content within text:

python
message = "Learn Python programming today!"

# Check if text contains a substring
print("Python" in message)  # True

# Find the position of a substring
print(message.find("Python"))  # 6
print(message.find("JavaScript"))  # -1 (not found)

# Count occurrences
print(message.count("a"))  # 2

Splitting and Joining Text​

Breaking text into parts or combining parts into text:

python
# Split text into a list
sentence = "Python is a great programming language"
words = sentence.split()
print(words)  # ['Python', 'is', 'a', 'great', 'programming', 'language']

# Split with a different delimiter
csv_data = "apple,banana,orange,grape"
fruits = csv_data.split(",")
print(fruits)  # ['apple', 'banana', 'orange', 'grape']

# Join items into a string
print(" ".join(words))  # "Python is a great programming language"
print("-".join(fruits))  # "apple-banana-orange-grape"

Practical Text Processing​

Example 1: Cleaning User Input​

Let's say we have a user registration form and want to clean the input:

python
def clean_username(username):
    # Remove leading/trailing spaces, convert to lowercase
    username = username.strip().lower()
    # Replace spaces with underscores
    username = username.replace(" ", "_")
    return username

# Example usage
raw_usernames = ["  John Doe ", "MARY SMITH", " david_jones "]
clean_usernames = [clean_username(name) for name in raw_usernames]
print(clean_usernames)  # ['john_doe', 'mary_smith', 'david_jones']

Example 2: Extracting Information from Text​

Let's extract email addresses from text:

python
def extract_emails(text):
    words = text.split()
    emails = []
    for word in words:
        word = word.strip('.,;:!?')  # Remove punctuation
        if '@' in word and '.' in word:
            emails.append(word)
    return emails

sample_text = "Contact us at support@example.com or sales@company.org for more information."
print(extract_emails(sample_text))  # ['support@example.com', 'sales@company.org']

Example 3: Text Analysis​

Let's build a simple word frequency counter:

python
def word_frequency(text):
    # Convert to lowercase and split
    words = text.lower().split()
    
    # Remove punctuation
    clean_words = []
    for word in words:
        clean_word = word.strip('.,;:!?"\'()')
        if clean_word:  # If not empty after stripping
            clean_words.append(clean_word)
    
    # Count frequencies
    frequency = {}
    for word in clean_words:
        if word in frequency:
            frequency[word] += 1
        else:
            frequency[word] = 1
    
    return frequency

sample = "Python is amazing. Python is also easy to learn. I love Python programming!"
print(word_frequency(sample))
# Output: {'python': 3, 'is': 2, 'amazing': 1, 'also': 1, 'easy': 1, 'to': 1, 'learn': 1, 'i': 1, 'love': 1, 'programming': 1}

Real-World Application: Text Summarization​

A practical application of text processing is creating a simple text summarizer. Let's create a function that extracts the most important sentences:

python
def simple_summarize(text, num_sentences=3):
    # Split into sentences
    sentences = text.split('. ')
    
    # Count word frequency
    word_count = {}
    for sentence in sentences:
        words = sentence.lower().split()
        for word in words:
            word = word.strip('.,;:!?"\'()')
            if word and len(word) > 3:  # Ignore short words
                word_count[word] = word_count.get(word, 0) + 1
    
    # Score sentences based on word frequency
    sentence_scores = []
    for sentence in sentences:
        score = 0
        words = sentence.lower().split()
        for word in words:
            word = word.strip('.,;:!?"\'()')
            if word in word_count:
                score += word_count[word]
        sentence_scores.append((score, sentence))
    
    # Get top sentences
    sentence_scores.sort(reverse=True)
    top_sentences = [sentence for _, sentence in sentence_scores[:num_sentences]]
    
    # Return summary
    return '. '.join(top_sentences) + '.'

article = """Python is a popular programming language. It was created by Guido van Rossum and released in 1991. 
Python is designed for readability using significant indentation. It is dynamically typed and garbage-collected. 
Python supports multiple programming paradigms, including structured, object-oriented, and functional programming. 
Its features and extensive standard library make it very attractive for Rapid Application Development as well as 
for use as a scripting or glue language to connect existing components. Python is widely used in data science, 
machine learning, web development, and automation tasks."""

summary = simple_summarize(article, 3)
print(summary)
# Output will contain the 3 most important sentences based on word frequency

Working with Text Files​

Text processing often involves reading from and writing to files:

python
# Writing to a file
with open('sample.txt', 'w') as file:
    file.write("Python makes text processing easy!\n")
    file.write("You can manipulate strings in many ways.\n")
    file.write("Text analysis is powerful with Python.")

# Reading from a file
with open('sample.txt', 'r') as file:
    content = file.read()
    print(content)

# Reading line by line
with open('sample.txt', 'r') as file:
    for line in file:
        print(f"Line: {line.strip()}")

Summary​

In this tutorial, we've covered the essentials of text processing in Python:

  • Basic string operations like case conversion, whitespace removal, and text replacement
  • Text analysis techniques including finding, splitting, and joining text
  • Practical examples of cleaning user input and extracting information
  • A simple text analysis application that counts word frequency
  • An introduction to text summarization through a basic algorithm
  • Reading and writing text files

Python's string methods provide a powerful toolkit for manipulating and analyzing text data. As you continue your programming journey, you'll find these text processing skills invaluable for handling various types of textual information.

Exercises​

  1. Create a function that counts the number of vowels and consonants in a string.
  2. Write a program that checks if a string is a palindrome (reads the same backward as forward).
  3. Implement a simple encryption/decryption function using character replacement.
  4. Build a function that validates whether a string is a valid email address.
  5. Create a text formatter that takes a paragraph and wraps it to a specified line length.

Additional Resources​


If you spot any mistakes on this website, please let me know at feedback@compilenrun.com. I’d greatly appreciate your feedback! :)