Python 프로그래밍에서 문자열 작업은 기본적인 기술입니다. 종종 특수 문자, 구두점 또는 기타 비 알파벳 숫자 문자를 제거하여 텍스트 데이터를 정리해야 합니다. 이 과정은 데이터 분석, 자연어 처리, 웹 개발 등 다양한 응용 분야에 필수적입니다.
이 튜토리얼은 Python 문자열에서 비 알파벳 숫자 문자를 필터링하는 다양한 방법을 안내합니다. 튜토리얼을 마치면 Python 응용 프로그램에서 처리하기 쉬운 깨끗하고 구조화된 데이터로 지저분한 텍스트를 변환할 수 있게 됩니다.
비 영숫자 문자를 필터링하기 전에 Python 에서 문자열과 영숫자 문자가 무엇인지 이해해 보겠습니다.
Python 의 문자열은 따옴표로 묶인 문자 시퀀스입니다. 작은 따옴표 ('), 큰 따옴표 ("), 또는 삼중 따옴표 (''' 또는 """) 를 사용하여 문자열을 정의할 수 있습니다.
문자열을 실험하기 위해 새로운 Python 파일을 만들어 보겠습니다. WebIDE 에서 탐색기 패널의 "New File" 아이콘을 클릭하여 /home/labex/project 디렉토리에 새 파일을 만듭니다. 파일 이름을 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.영숫자 문자는 다음을 포함합니다.
다른 모든 문자 (구두점, 공백, 기호 등) 는 비 영숫자로 간주됩니다.
문자가 영숫자인지 확인하기 위해 다른 파일을 만들어 보겠습니다. 다음 내용으로 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 comprehension) 을 사용하는 것입니다. 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() 함수 사용Python 의 내장 filter() 함수는 동일한 결과를 얻는 또 다른 방법을 제공합니다. 이 메서드를 파일에 추가해 보겠습니다.
## 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)WebIDE 에서 string_filter.py 파일을 열고 위의 코드를 파일 끝에 추가합니다. 그런 다음 다시 실행합니다.
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) 은 텍스트에서 패턴을 식별하고 조작하는 강력한 방법을 제공합니다. Python 의 re 모듈은 정규 표현식을 사용하기 위한 함수를 제공합니다.
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출력은 비 영숫자 문자를 필터링하는 데 가장 효율적인 방법을 보여줍니다. 이는 대량의 텍스트 데이터를 처리할 때 중요할 수 있습니다.
이 Lab 에서는 Python 문자열에서 비 영숫자 문자를 필터링하는 여러 가지 방법을 배웠습니다.
isalnum()과 같은 Python 의 내장 문자열 메서드를 사용하여 문자를 확인하고 필터링합니다.filter() 함수를 사용하여 정리된 문자열을 생성합니다.re 모듈을 활용합니다.이러한 기술은 다음과 같은 다양한 분야에서 텍스트 처리 작업에 필수적입니다.
이러한 방법을 숙달함으로써 이제 Python 애플리케이션에서 분석하고 처리하기 쉬운 깨끗하고 구조화된 형식으로 지저분한 텍스트 데이터를 변환하는 기술을 갖추게 되었습니다.
