Как отфильтровать неалфавитно-цифровые символы из строк в Python

Введение

В программировании на Python работа со строками является фундаментальным навыком. Часто вам нужно очистить текстовые данные, удалив специальные символы, знаки препинания или другие неалфавитно-цифровые символы. Этот процесс важен для различных приложений, таких как анализ данных, обработка естественного языка и веб-разработка.

В этом руководстве вы узнаете о различных методах фильтрации неалфавитно-цифровых символов из строк Python. В конце вы сможете преобразовать запутанный текст в чистые, структурированные данные, которые легче обрабатывать в своих Python-приложениях.

Основы строк в Python и алфавитно-цифровые символы

Прежде чем мы приступим к фильтрации неалфавитно-цифровых символов, давайте разберемся, что такое строки и алфавитно-цифровые символы в Python.

Что такое строки в Python?

Строки в Python - это последовательности символов, заключенные в кавычки. Вы можете использовать одинарные ('), двойные ("), или тройные кавычки (''' или """) для определения строк.

Давайте создадим новый файл Python для экспериментов со строками. В WebIDE создайте новый файл в директории /home/labex/project, нажав на иконку "New File" в панели проводника. Назовите файл string_basics.py.

Добавьте следующий код в файл:

## Different ways to define strings in Python
string1 = 'Hello, World!'
string2 = "Python Programming"
string3 = '''This is a
multiline string.'''

## Display each string
print("String 1:", string1)
print("String 2:", string2)
print("String 3:", string3)

Чтобы запустить этот файл, откройте терминал (если он еще не открыт) и выполните:

python3 /home/labex/project/string_basics.py

Вы должны увидеть вывод, похожий на следующий:

String 1: Hello, World!
String 2: Python Programming
String 3: This is a
multiline string.

Что такое алфавитно-цифровые символы?

Алфавитно-цифровые символы включают:

• Буквы (A-Z, a-z)
• Цифры (0-9)

Любые другие символы (например, знаки препинания, пробелы, символы) считаются неалфавитно-цифровыми.

Давайте создадим еще один файл, чтобы проверить, является ли символ алфавитно-цифровым. Создайте новый файл с именем alphanumeric_check.py со следующим содержимым:

## Check if characters are alphanumeric
test_string = "Hello123!@#"

print("Testing each character in:", test_string)
print("Character | Alphanumeric?")
print("-" * 24)

for char in test_string:
    is_alnum = char.isalnum()
    print(f"{char:^9} | {is_alnum}")

## Check entire strings
examples = ["ABC123", "Hello!", "12345", "a b c"]
print("\nChecking entire strings:")
for ex in examples:
    print(f"{ex:10} | {ex.isalnum()}")

Запустите этот файл:

python3 /home/labex/project/alphanumeric_check.py

Вы должны увидеть вывод, показывающий, какие символы являются алфавитно-цифровыми, а какие - нет:

Testing each character in: Hello123!@#
Character | Alphanumeric?
------------------------
    H     | True
    e     | True
    l     | True
    l     | True
    o     | True
    1     | True
    2     | True
    3     | True
    !     | False
    @     | False
    ##     | False

Checking entire strings:
ABC123     | True
Hello!     | False
12345      | True
a b c      | False

Как вы можете видеть, метод isalnum() возвращает True для букв и цифр и False для любых других символов. Это будет полезно, когда нам нужно будет идентифицировать неалфавитно-цифровые символы.

Фильтрация с использованием методов строк

Python предоставляет несколько встроенных методов строк, которые могут помочь нам отфильтровать неалфавитно-цифровые символы. На этом этапе мы рассмотрим эти методы и создадим свою собственную функцию фильтрации.

Использование генератора строк

Одним из распространенных подходов к фильтрации символов является использование генератора строк. Давайте создадим новый файл с именем string_filter.py:

## Using string comprehension to filter non-alphanumeric characters

def filter_alphanumeric(text):
    ## Keep only alphanumeric characters
    filtered_text = ''.join(char for char in text if char.isalnum())
    return filtered_text

## Test the function with different examples
test_strings = [
    "Hello, World!",
    "Python 3.10 is amazing!",
    "Email: user@example.com",
    "Phone: (123) 456-7890"
]

print("Original vs Filtered:")
print("-" * 40)

for text in test_strings:
    filtered = filter_alphanumeric(text)
    print(f"Original: {text}")
    print(f"Filtered: {filtered}")
    print("-" * 40)

Запустите этот файл:

python3 /home/labex/project/string_filter.py

Вы должны увидеть вывод, похожий на следующий:

Original vs Filtered:
----------------------------------------
Original: Hello, World!
Filtered: HelloWorld
----------------------------------------
Original: Python 3.10 is amazing!
Filtered: Python310isamazing
----------------------------------------
Original: Email: user@example.com
Filtered: Emailuserexamplecom
----------------------------------------
Original: Phone: (123) 456-7890
Filtered: Phone1234567890
----------------------------------------

Функция filter_alphanumeric() проходит по каждому символу в строке и сохраняет только те, которые проходят проверку isalnum().

Использование функции filter()

Встроенная функция filter() в Python предоставляет другой способ достичь того же результата. Давайте добавим этот метод в наш файл:

## Add to the string_filter.py file

def filter_alphanumeric_using_filter(text):
    ## Using the built-in filter() function
    filtered_text = ''.join(filter(str.isalnum, text))
    return filtered_text

print("\nUsing the filter() function:")
print("-" * 40)

for text in test_strings:
    filtered = filter_alphanumeric_using_filter(text)
    print(f"Original: {text}")
    print(f"Filtered: {filtered}")
    print("-" * 40)

Откройте файл string_filter.py в WebIDE и добавьте приведенный выше код в конец файла. Затем запустите его снова:

python3 /home/labex/project/string_filter.py

Вы увидите, что оба метода дают одинаковые результаты.

Пользовательская фильтрация

Иногда вы можете захотеть сохранить некоторые неалфавитно-цифровые символы, удаляя при этом другие. Давайте добавим функцию, которая позволит нам указать, какие дополнительные символы сохранить:

## Add to the string_filter.py file

def custom_filter(text, keep_chars=""):
    ## Keep alphanumeric characters and any characters specified in keep_chars
    filtered_text = ''.join(char for char in text if char.isalnum() or char in keep_chars)
    return filtered_text

print("\nCustom filtering (keeping spaces and @):")
print("-" * 40)

for text in test_strings:
    filtered = custom_filter(text, keep_chars=" @")
    print(f"Original: {text}")
    print(f"Filtered: {filtered}")
    print("-" * 40)

Добавьте этот код в конец файла string_filter.py и запустите его снова:

python3 /home/labex/project/string_filter.py

Теперь вы увидите, что пробелы и символы @ сохраняются в отфильтрованных результатах, что может быть полезно, когда вам нужно сохранить определенный формат или специальные символы.

Использование регулярных выражений для очистки текста

Регулярные выражения (regex) предоставляют мощный способ идентификации и манипуляции шаблонами в тексте. Модуль re в Python предлагает функции для работы с регулярными выражениями.

Введение в базовые регулярные выражения для фильтрации символов

Давайте создадим новый файл с именем regex_filter.py:

## Using regular expressions to filter non-alphanumeric characters
import re

def filter_with_regex(text):
    ## Replace all non-alphanumeric characters with an empty string
    filtered_text = re.sub(r'[^a-zA-Z0-9]', '', text)
    return filtered_text

## Test the function with different examples
test_strings = [
    "Hello, World!",
    "Python 3.10 is amazing!",
    "Email: user@example.com",
    "Phone: (123) 456-7890"
]

print("Original vs Regex Filtered:")
print("-" * 40)

for text in test_strings:
    filtered = filter_with_regex(text)
    print(f"Original: {text}")
    print(f"Filtered: {filtered}")
    print("-" * 40)

Регулярное выражение [^a-zA-Z0-9] соответствует любому символу, который НЕ является заглавной буквой, строчной буквой или цифрой. Функция re.sub() заменяет все совпадающие символы на пустую строку.

Запустите файл:

python3 /home/labex/project/regex_filter.py

Вы должны увидеть вывод, похожий на следующий:

Original vs Regex Filtered:
----------------------------------------
Original: Hello, World!
Filtered: HelloWorld
----------------------------------------
Original: Python 3.10 is amazing!
Filtered: Python310isamazing
----------------------------------------
Original: Email: user@example.com
Filtered: Emailuserexamplecom
----------------------------------------
Original: Phone: (123) 456-7890
Filtered: Phone1234567890
----------------------------------------

Пользовательские шаблоны с использованием регулярных выражений

Регулярные выражения позволяют создавать более сложные шаблоны и замены. Давайте добавим функцию, которая позволяет использовать пользовательские шаблоны:

## Add to the regex_filter.py file

def custom_regex_filter(text, pattern=r'[^a-zA-Z0-9]', replacement=''):
    ## Replace characters matching the pattern with the replacement
    filtered_text = re.sub(pattern, replacement, text)
    return filtered_text

print("\nCustom regex filtering (keeping spaces and some punctuation):")
print("-" * 60)

## Keep alphanumeric chars, spaces, and @.
custom_pattern = r'[^a-zA-Z0-9\s@\.]'

for text in test_strings:
    filtered = custom_regex_filter(text, pattern=custom_pattern)
    print(f"Original: {text}")
    print(f"Filtered: {filtered}")
    print("-" * 60)

Шаблон [^a-zA-Z0-9\s@\.] соответствует любому символу, который НЕ является алфавитно-цифровым символом, пробелом (\s), символом @ или точкой. Добавьте этот код в файл regex_filter.py и запустите его снова:

python3 /home/labex/project/regex_filter.py

Идентификация неалфавитно-цифровых символов

Иногда вам может понадобиться определить, какие неалфавитно-цифровые символы присутствуют в строке. Давайте добавим функцию для идентификации этих символов:

## Add to the regex_filter.py file

def identify_non_alphanumeric(text):
    ## Find all non-alphanumeric characters in the text
    non_alphanumeric = re.findall(r'[^a-zA-Z0-9]', text)
    ## Return unique characters as a set
    return set(non_alphanumeric)

print("\nIdentifying non-alphanumeric characters:")
print("-" * 40)

for text in test_strings:
    characters = identify_non_alphanumeric(text)
    print(f"Text: {text}")
    print(f"Non-alphanumeric characters: {characters}")
    print("-" * 40)

Добавьте этот код в файл regex_filter.py и запустите его снова:

python3 /home/labex/project/regex_filter.py

Вывод покажет, какие неалфавитно-цифровые символы присутствуют в каждой строке, что может быть полезно для понимания, что нужно отфильтровать в ваших данных.

Применение очистки текста в реальных сценариях

Теперь, когда мы изучили различные методы фильтрации неалфавитно-цифровых символов, давайте применим эти техники в реальных сценариях.

Очистка пользовательского ввода

Пользовательский ввод часто содержит неожиданные символы, которые необходимо очистить. Давайте создадим файл с именем text_cleaning_app.py, чтобы продемонстрировать это:

## Text cleaning application for user input
import re

def clean_username(username):
    """Cleans a username by removing special characters and spaces"""
    return re.sub(r'[^a-zA-Z0-9_]', '', username)

def clean_search_query(query):
    """Preserves alphanumeric chars and spaces, replaces multiple spaces with one"""
    ## First, replace non-alphanumeric chars (except spaces) with empty string
    cleaned = re.sub(r'[^a-zA-Z0-9\s]', '', query)
    ## Then, replace multiple spaces with a single space
    cleaned = re.sub(r'\s+', ' ', cleaned)
    ## Finally, strip leading and trailing spaces
    return cleaned.strip()

## Simulate user input
usernames = [
    "john.doe",
    "user@example",
    "my username!",
    "admin_123"
]

search_queries = [
    "python   programming",
    "how to filter?!  special chars",
    "$ regex      examples $",
    "   string methods   "
]

## Clean and display usernames
print("Username Cleaning:")
print("-" * 40)
for username in usernames:
    cleaned = clean_username(username)
    print(f"Original: {username}")
    print(f"Cleaned:  {cleaned}")
    print("-" * 40)

## Clean and display search queries
print("\nSearch Query Cleaning:")
print("-" * 40)
for query in search_queries:
    cleaned = clean_search_query(query)
    print(f"Original: '{query}'")
    print(f"Cleaned:  '{cleaned}'")
    print("-" * 40)

Запустите этот файл:

python3 /home/labex/project/text_cleaning_app.py

Обработка данных из файла

Давайте создадим пример текстового файла и очистим его. Сначала создайте файл с именем sample_data.txt со следующим содержимым:

User1: john.doe@example.com (Active: Yes)
User2: jane_smith@example.com (Active: No)
User3: admin#123@system.org (Active: Yes)
Notes: Users should change their passwords every 90 days!

Вы можете создать этот файл с помощью редактора WebIDE. Теперь давайте создадим файл с именем file_cleaner.py, чтобы очистить эти данные:

## File cleaning application
import re

def extract_emails(text):
    """Extract email addresses from text"""
    ## Simple regex for email extraction
    email_pattern = r'[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+'
    return re.findall(email_pattern, text)

def extract_usernames(text):
    """Extract the username part from email addresses"""
    emails = extract_emails(text)
    usernames = [email.split('@')[0] for email in emails]
    return usernames

def clean_usernames(usernames):
    """Clean usernames by removing non-alphanumeric characters"""
    return [re.sub(r'[^a-zA-Z0-9]', '', username) for username in usernames]

## Read the sample data file
try:
    with open('/home/labex/project/sample_data.txt', 'r') as file:
        data = file.read()
except FileNotFoundError:
    print("Error: sample_data.txt file not found!")
    exit(1)

## Process the data
print("File Cleaning Results:")
print("-" * 50)
print("Original data:")
print(data)
print("-" * 50)

## Extract emails
emails = extract_emails(data)
print(f"Extracted {len(emails)} email addresses:")
for email in emails:
    print(f"  - {email}")

## Extract and clean usernames
usernames = extract_usernames(data)
cleaned_usernames = clean_usernames(usernames)

print("\nUsername extraction and cleaning:")
for i, (original, cleaned) in enumerate(zip(usernames, cleaned_usernames)):
    print(f"  - User {i+1}: {original} → {cleaned}")

print("-" * 50)

Запустите этот файл:

python3 /home/labex/project/file_cleaner.py

Сравнение производительности

Различные методы фильтрации могут иметь разные характеристики производительности. Давайте создадим файл с именем performance_test.py, чтобы сравнить их:

## Performance comparison of different filtering methods
import re
import time

def filter_with_loop(text):
    """Filter using a simple loop"""
    result = ""
    for char in text:
        if char.isalnum():
            result += char
    return result

def filter_with_comprehension(text):
    """Filter using list comprehension"""
    return ''.join(char for char in text if char.isalnum())

def filter_with_filter_function(text):
    """Filter using the built-in filter function"""
    return ''.join(filter(str.isalnum, text))

def filter_with_regex(text):
    """Filter using regular expressions"""
    return re.sub(r'[^a-zA-Z0-9]', '', text)

def filter_with_translate(text):
    """Filter using string.translate"""
    ## Create a translation table that maps all non-alphanumeric chars to None
    from string import ascii_letters, digits
    allowed = ascii_letters + digits
    translation_table = str.maketrans('', '', ''.join(c for c in map(chr, range(128)) if c not in allowed))
    return text.translate(translation_table)

## Generate test data (a string with a mix of alphanumeric and other characters)
test_data = "".join(chr(i) for i in range(33, 127)) * 1000  ## ASCII printable characters repeated

## Define the filtering methods to test
methods = [
    ("Simple Loop", filter_with_loop),
    ("List Comprehension", filter_with_comprehension),
    ("Filter Function", filter_with_filter_function),
    ("Regular Expression", filter_with_regex),
    ("String Translate", filter_with_translate)
]

print("Performance Comparison:")
print("-" * 60)
print(f"Test data length: {len(test_data)} characters")
print("-" * 60)
print(f"{'Method':<20} | {'Time (seconds)':<15} | {'Characters Removed':<20}")
print("-" * 60)

## Test each method
for name, func in methods:
    start_time = time.time()
    result = func(test_data)
    end_time = time.time()

    execution_time = end_time - start_time
    chars_removed = len(test_data) - len(result)

    print(f"{name:<20} | {execution_time:<15.6f} | {chars_removed:<20}")

print("-" * 60)

Запустите этот файл:

python3 /home/labex/project/performance_test.py

Вывод покажет, какой метод наиболее эффективен для фильтрации неалфавитно-цифровых символов, что может быть важно при обработке больших объемов текстовых данных.

Итоги

В этом практическом занятии (лабораторной работе) вы узнали несколько методов для фильтрации неалфавитно-цифровых символов из строк в Python:

1. Методы строк: Использование встроенных методов строк Python, таких как isalnum(), для проверки и фильтрации символов.
2. Генераторы списков и функция filter: Применение генераторов списков и встроенной функции filter() для создания чистых строк.
3. Регулярные выражения: Использование модуля re в Python для мощного сопоставления и замены шаблонов.
4. Применение в реальных сценариях: Применение этих методов в практических ситуациях, таких как очистка пользовательского ввода, обработка данных из файлов и сравнение производительности.

Эти методы являются фундаментальными для задач обработки текста в различных областях, включая:

• Очистка данных в анализе данных и машинном обучении
• Обработка естественного языка
• Веб-скрапинг и извлечение данных
• Валидация пользовательского ввода в веб-приложениях

Освоив эти методы, вы теперь обладаете навыками, позволяющими преобразовывать неструктурированные текстовые данные в чистые, структурированные форматы, которые легче анализировать и обрабатывать в ваших Python-приложениях.