Python 기본
파이썬(Python) 문자열 메서드 총정리: 효율적인 문자열 처리 방법
나루하루001
2025. 5. 16. 00:25
반응형
목차
파이썬 문자열 메서드 소개
파이썬에서 문자열(string)은 가장 많이 사용되는 데이터 타입 중 하나입니다.
문자열 처리는 거의 모든 프로그램에서 필수적인 작업이며,
파이썬은 이를 위한 다양한 내장 메서드를 제공합니다.
이 포스팅에서는 파이썬의 문자열 메서드를 카테고리별로 정리하고
각 메서드의 기능과 사용법을 자세히 알아보겠습니다.
효율적인 문자열 처리는 코드의 가독성과 성능을 향상시키는 데 큰 도움이 됩니다.
💡 알아두세요!
파이썬에서 문자열은 불변(immutable) 객체입니다. 따라서 문자열 메서드는 원본 문자열을 변경하지 않고 항상 새로운 문자열을 반환합니다.
파이썬에서 문자열은 불변(immutable) 객체입니다. 따라서 문자열 메서드는 원본 문자열을 변경하지 않고 항상 새로운 문자열을 반환합니다.
대소문자 변환 메서드
문자열의 대소문자를 변환하는 메서드는 텍스트 처리에서 매우 유용합니다.
특히 사용자 입력을 표준화하거나 특정 형식에 맞게 출력할 때 자주 사용됩니다.
| 메서드 | 설명 | 예제 |
|---|---|---|
capitalize() |
문자열의 첫 글자를 대문자로 변환 | "hello".capitalize() → "Hello" |
lower() |
문자열 전체를 소문자로 변환 | "HELLO".lower() → "hello" |
upper() |
문자열 전체를 대문자로 변환 | "hello".upper() → "HELLO" |
swapcase() |
대소문자를 서로 반전 | "Hello".swapcase() → "hELLO" |
title() |
각 단어의 첫 글자를 대문자로 변환 | "hello world".title() → "Hello World" |
casefold() |
대소문자 구분 없이 비교할 수 있는 형태로 변환(lower()보다 더 강력) | "ß".casefold() → "ss" |
대소문자 메서드 활용 예시
# 사용자 입력 표준화
user_input = "PyThOn"
if user_input.lower() == "python":
print("파이썬을 입력하셨습니다!")
# 이름 형식 지정
name = "john doe"
formatted_name = name.title() # "John Doe"
# 국제화 문자열 비교 (독일어 예시)
german_word1 = "straße" # 독일어 거리
german_word2 = "STRASSE" # 대문자 표기
print(german_word1.casefold() == german_word2.casefold()) # True
문자열 검색 메서드
문자열 내에서 특정 패턴이나 부분 문자열을 찾는 것은 텍스트 처리의 기본 작업입니다.
파이썬은 다양한 검색 메서드를 제공하여 이러한 작업을 쉽게 수행할 수 있게 합니다.
| 메서드 | 설명 | 예제 |
|---|---|---|
find(sub[, start[, end]]) |
부분 문자열의 가장 낮은 인덱스를 반환, 없으면 -1 반환 | "hello".find("l") → 2 |
rfind(sub[, start[, end]]) |
부분 문자열의 가장 높은 인덱스를 반환, 없으면 -1 반환 | "hello".rfind("l") → 3 |
index(sub[, start[, end]]) |
find()와 유사하지만 부분 문자열이 없으면 ValueError 발생 | "hello".index("e") → 1 |
rindex(sub[, start[, end]]) |
rfind()와 유사하지만 부분 문자열이 없으면 ValueError 발생 | "hello".rindex("l") → 3 |
count(sub[, start[, end]]) |
부분 문자열이 나타나는 횟수를 반환 | "hello".count("l") → 2 |
startswith(prefix[, start[, end]]) |
문자열이 지정된 접두사로 시작하면 True 반환 | "hello".startswith("he") → True |
endswith(suffix[, start[, end]]) |
문자열이 지정된 접미사로 끝나면 True 반환 | "hello".endswith("lo") → True |
검색 메서드 활용 예시
# 이메일 주소 검증
email = "user@example.com"
if "@" in email and email.endswith(".com"):
print("유효한 이메일 형식입니다.")
# 파일 확장자 확인
filename = "document.pdf"
if filename.endswith((".pdf", ".doc", ".docx")):
print("문서 파일입니다.")
# 특정 패턴 위치 찾기
text = "파이썬 프로그래밍은 재미있습니다. 파이썬은 쉽습니다."
first_python = text.find("파이썬") # 0
last_python = text.rfind("파이썬") # 15
문자열 수정 메서드
문자열 자체는 불변이지만,
파이썬은 문자열을 변형하여 새로운 문자열을 생성하는
다양한 메서드를 제공합니다.
이러한 메서드는 문자열 처리 작업에서 매우 유용합니다.
| 메서드 | 설명 | 예제 |
|---|---|---|
replace(old, new[, count]) |
모든 old 부분 문자열을 new로 대체 | "hello".replace("l", "L") → "heLLo" |
strip([chars]) |
문자열 양쪽 끝의 공백 또는 지정된 문자 제거 | " hello ".strip() → "hello" |
lstrip([chars]) |
문자열 왼쪽 끝의 공백 또는 지정된 문자 제거 | " hello ".lstrip() → "hello " |
rstrip([chars]) |
문자열 오른쪽 끝의 공백 또는 지정된 문자 제거 | " hello ".rstrip() → " hello" |
removeprefix(prefix) |
문자열 시작 부분에서 지정된 접두사 제거 | "TestCase".removeprefix("Test") → "Case" |
removesuffix(suffix) |
문자열 끝 부분에서 지정된 접미사 제거 | "filename.txt".removesuffix(".txt") → "filename" |
expandtabs([tabsize]) |
탭 문자를 공백으로 확장 | "hello\tworld".expandtabs(4) → "hello world" |
zfill(width) |
지정된 너비에 맞게 문자열 왼쪽에 0을 채움 | "42".zfill(5) → "00042" |
문자열 수정 메서드 활용 예시
# 사용자 입력 정리
user_input = " 파이썬 프로그래밍 "
cleaned_input = user_input.strip() # "파이썬 프로그래밍"
# 파일 확장자 변경
filename = "document.txt"
new_filename = filename.removesuffix(".txt") + ".pdf" # "document.pdf"
# 전화번호 형식 변경
phone = "010-1234-5678"
formatted_phone = phone.replace("-", "") # "01012345678"
# 일련번호 형식 지정
serial_number = "42"
formatted_serial = serial_number.zfill(8) # "00000042"
문자열 확인 메서드
문자열의 특성을 확인하는 메서드는 입력 검증이나 데이터 처리에 매우 유용합니다.
이러한 메서드는 모두 불리언(True/False) 값을 반환합니다.
| 메서드 | 설명 | 예제 |
|---|---|---|
isalnum() |
문자열이 알파벳과 숫자로만 구성되었는지 확인 | "Python3".isalnum() → True |
isalpha() |
문자열이 알파벳으로만 구성되었는지 확인 | "Python".isalpha() → True |
isascii() |
문자열이 ASCII 문자로만 구성되었는지 확인 | "hello".isascii() → True |
isdecimal() |
문자열이 10진수 문자로만 구성되었는지 확인 | "123".isdecimal() → True |
isdigit() |
문자열이 숫자로만 구성되었는지 확인 | "123".isdigit() → True |
isidentifier() |
문자열이 유효한 파이썬 식별자인지 확인 | "variable_name".isidentifier() → True |
islower() |
문자열이 소문자로만 구성되었는지 확인 | "hello".islower() → True |
isnumeric() |
문자열이 숫자 문자로만 구성되었는지 확인 | "123".isnumeric() → True |
isprintable() |
문자열이 출력 가능한 문자로만 구성되었는지 확인 | "Hello\n".isprintable() → False |
isspace() |
문자열이 공백 문자로만 구성되었는지 확인 | " ".isspace() → True |
istitle() |
문자열이 제목 형식인지 확인 (각 단어의 첫 글자가 대문자) | "Hello World".istitle() → True |
isupper() |
문자열이 대문자로만 구성되었는지 확인 | "HELLO".isupper() → True |
문자열 확인 메서드 활용 예시
# 사용자 입력 검증
user_age = input("나이를 입력하세요: ")
if user_age.isdigit():
age = int(user_age)
print(f"입력하신 나이는 {age}세입니다.")
else:
print("숫자만 입력해주세요.")
# 비밀번호 검증
def validate_password(password):
if len(password) < 8:
return "비밀번호는 최소 8자 이상이어야 합니다."
if password.isalpha() or password.isdigit():
return "비밀번호는 문자와 숫자를 모두 포함해야 합니다."
if password.islower():
return "비밀번호는 대문자를 포함해야 합니다."
return "유효한 비밀번호입니다."
# 변수명 검증
variable_name = "my_var"
if variable_name.isidentifier():
print("유효한 변수명입니다.")
반응형
문자열 형식 지정 메서드
문자열 형식 지정은 데이터를 특정 형식으로 출력하거나 표현할 때 매우 유용합니다.
파이썬은 다양한 형식 지정 메서드를 제공합니다.
| 메서드 | 설명 | 예제 | |
|---|---|---|---|
center(width[, fillchar]) |
지정된 너비에서 문자열을 중앙에 배치 | "hello".center(11, "-") → "---hello---" |
|
ljust(width[, fillchar]) |
지정된 너비에서 문자열을 왼쪽에 정렬 | "hello".ljust(10, "-") → "hello-----" |
|
rjust(width[, fillchar]) |
지정된 너비에서 문자열을 오른쪽에 정렬 | "hello".rjust(10, "-") → "-----hello" |
|
format(*args, **kwargs) |
format(*args, **kwargs) |
형식 지정자를 사용하여 문자열 형식 지정 | "{} {}".format("Hello", "World") → "Hello World" |
format_map(mapping) |
매핑을 사용하여 문자열 형식 지정 | "{name}".format_map({"name": "Python"}) → "Python" |
|
join(iterable) |
반복 가능한 객체의 요소들을 문자열로 결합 | "-".join(["a", "b", "c"]) → "a-b-c" |
|
partition(sep) |
구분자를 기준으로 문자열을 3부분으로 분할 | "a-b-c".partition("-") → ("a", "-", "b-c") |
|
rpartition(sep) |
오른쪽에서부터 구분자를 기준으로 문자열을 3부분으로 분할 | "a-b-c".rpartition("-") → ("a-b", "-", "c") |
|
split(sep=None, maxsplit=-1) |
구분자를 기준으로 문자열을 분할하여 리스트로 반환 | "a,b,c".split(",") → ["a", "b", "c"] |
|
rsplit(sep=None, maxsplit=-1) |
오른쪽에서부터 구분자를 기준으로 문자열을 분할 | "a,b,c".rsplit(",", 1) → ["a,b", "c"] |
|
splitlines([keepends]) |
줄 바꿈 문자를 기준으로 문자열을 분할 | "a\nb\nc".splitlines() → ["a", "b", "c"] |
|
translate(table) |
변환 테이블을 사용하여 문자열의 문자를 변환 | "hello".translate(str.maketrans("e", "a")) → "hallo" |
|
maketrans(x[, y[, z]]) |
translate() 메서드에 사용할 변환 테이블 생성 | str.maketrans("abc", "123") |
문자열 형식 지정 활용 예시
# 테이블 형식으로 데이터 출력
headers = ["이름", "나이", "직업"]
data = [
["김철수", "25", "개발자"],
["이영희", "28", "디자이너"],
["박지민", "32", "매니저"]
]
print(headers[0].ljust(10) + headers[1].ljust(6) + headers[2])
print("-" * 30)
for row in data:
print(row[0].ljust(10) + row[1].ljust(6) + row[2])
# 실행 결과:
# 이름 나이 직업
# ------------------------------
# 김철수 25 개발자
# 이영희 28 디자이너
# 박지민 32 매니저
# 문자열 형식 지정
name = "홍길동"
age = 30
print("이름: {}, 나이: {}세".format(name, age))
print("이름: {name}, 나이: {age}세".format(name=name, age=age))
print(f"이름: {name}, 나이: {age}세") # f-string (Python 3.6+)
# 리스트를 문자열로 변환
words = ["파이썬", "프로그래밍", "언어"]
sentence = " ".join(words) # "파이썬 프로그래밍 언어"
# 문자열 분할 및 결합
path = "C:\\Users\\username\\Documents\\file.txt"
parts = path.split("\\") # ['C:', 'Users', 'username', 'Documents', 'file.txt']
filename = parts[-1] # "file.txt"
directory = "\\".join(parts[:-1]) # "C:\\Users\\username\\Documents"
실전 예제로 배우는 문자열 메서드
이제 여러 문자열 메서드를 조합하여 실제 프로그래밍에서 자주 사용되는 예제를 살펴보겠습니다.
예제 1: 텍스트 정제 및 분석
def analyze_text(text):
# 텍스트 정제
text = text.lower() # 소문자로 변환
text = text.replace(",", "").replace(".", "").replace("!", "").replace("?", "") # 구두점 제거
# 단어 분할 및 분석
words = text.split()
word_count = len(words)
unique_words = len(set(words))
# 가장 많이 사용된 단어 찾기
word_freq = {}
for word in words:
if word in word_freq:
word_freq[word] += 1
else:
word_freq[word] = 1
most_common = max(word_freq.items(), key=lambda x: x[1])
return {
"총 단어 수": word_count,
"고유 단어 수": unique_words,
"가장 많이 사용된 단어": most_common[0],
"해당 단어 빈도": most_common[1]
}
sample_text = """
파이썬은 프로그래밍을 쉽고 재미있게 만들어주는 언어입니다.
파이썬은 다양한 분야에서 사용되며, 특히 데이터 과학과 인공지능 분야에서 인기가 많습니다.
파이썬의 간결한 문법과 풍부한 라이브러리는 개발자들에게 큰 도움이 됩니다.
"""
result = analyze_text(sample_text)
for key, value in result.items():
print(f"{key}: {value}")
# 실행 결과:
# 총 단어 수: 34
# 고유 단어 수: 28
# 가장 많이 사용된 단어: 파이썬은
# 해당 단어 빈도: 2
예제 2: 로그 파일 분석
def parse_log_line(line):
if not line.strip():
return None
# 로그 형식: [날짜 시간] [로그레벨] 메시지
parts = line.strip().split("] [", 1)
if len(parts) < 2:
return None
timestamp = parts[0].lstrip("[")
remaining = parts[1].split("] ", 1)
if len(remaining) < 2:
return None
log_level = remaining[0]
message = remaining[1]
return {
"timestamp": timestamp,
"level": log_level,
"message": message
}
def analyze_log_file(log_content):
lines = log_content.splitlines()
parsed_logs = [parse_log_line(line) for line in lines]
parsed_logs = [log for log in parsed_logs if log] # None 제거
# 로그 레벨별 개수
level_counts = {}
for log in parsed_logs:
level = log["level"]
level_counts[level] = level_counts.get(level, 0) + 1
# 에러 메시지 추출
error_logs = [log for log in parsed_logs if log["level"] == "ERROR"]
return {
"총 로그 수": len(parsed_logs),
"로그 레벨별 개수": level_counts,
"에러 로그": error_logs
}
sample_log = """
[2023-05-16 10:15:32] [INFO] 애플리케이션 시작
[2023-05-16 10:15:35] [DEBUG] 설정 파일 로드 중
[2023-05-16 10:15:36] [INFO] 데이터베이스 연결 성공
[2023-05-16 10:16:42] [ERROR] 파일을 찾을 수 없음: config.json
[2023-05-16 10:17:15] [WARNING] 메모리 사용량 80% 초과
[2023-05-16 10:18:27] [ERROR] 데이터베이스 쿼리 실패: 테이블 없음
"""
result = analyze_log_file(sample_log)
print(f"총 로그 수: {result['총 로그 수']}")
print("\n로그 레벨별 개수:")
for level, count in result['로그 레벨별 개수'].items():
print(f" {level}: {count}")
print("\n에러 로그:")
for error in result['에러 로그']:
print(f" [{error['timestamp']}] {error['message']}")
# 실행 결과:
# 총 로그 수: 6
#
# 로그 레벨별 개수:
# INFO: 2
# DEBUG: 1
# ERROR: 2
# WARNING: 1
#
# 에러 로그:
# [2023-05-16 10:16:42] 파일을 찾을 수 없음: config.json
# [2023-05-16 10:18:27] 데이터베이스 쿼리 실패: 테이블 없음
예제 3: URL 파싱
def parse_url(url):
# 프로토콜 분리
if "://" in url:
protocol, rest = url.split("://", 1)
else:
protocol = "http"
rest = url
# 도메인과 경로 분리
if "/" in rest:
domain, path = rest.split("/", 1)
path = "/" + path
else:
domain = rest
path = "/"
# 쿼리 파라미터 분리
if "?" in path:
path_part, query_string = path.split("?", 1)
else:
path_part = path
query_string = ""
# 쿼리 파라미터 파싱
query_params = {}
if query_string:
params = query_string.split("&")
for param in params:
if "=" in param:
key, value = param.split("=", 1)
query_params[key] = value
# 도메인에서 포트 분리
if ":" in domain:
domain_name, port = domain.split(":", 1)
else:
domain_name = domain
port = "80" if protocol == "http" else "443"
return {
"protocol": protocol,
"domain": domain_name,
"port": port,
"path": path_part,
"query_params": query_params
}
test_url = "https://www.example.com:8080/path/to/resource?name=value&page=1&sort=desc"
parsed = parse_url(test_url)
print("URL 구성 요소:")
print(f" 프로토콜: {parsed['protocol']}")
print(f" 도메인: {parsed['domain']}")
print(f" 포트: {parsed['port']}")
print(f" 경로: {parsed['path']}")
print(" 쿼리 파라미터:")
for key, value in parsed['query_params'].items():
print(f" {key}: {value}")
# 실행 결과:
# URL 구성 요소:
# 프로토콜: https
# 도메인: www.example.com
# 포트: 8080
# 경로: /path/to/resource
# 쿼리 파라미터:
# name: value
# page: 1
# sort: desc
요약 및 정리
이 포스팅에서는 파이썬의 문자열 메서드를 다양한 카테고리로 나누어 살펴보았습니다:
- 대소문자 변환 메서드: capitalize(), lower(), upper(), swapcase(), title(), casefold()
- 문자열 검색 메서드: find(), rfind(), index(), rindex(), count(), startswith(), endswith()
- 문자열 수정 메서드: replace(), strip(), lstrip(), rstrip(), removeprefix(), removesuffix(), expandtabs(), zfill()
- 문자열 확인 메서드: isalnum(), isalpha(), isascii(), isdecimal(), isdigit(), isidentifier(), islower(), isnumeric(), isprintable(), isspace(), istitle(), isupper()
- 문자열 형식 지정 메서드: center(), ljust(), rjust(), format(), format_map(), join(), partition(), rpartition(), split(), rsplit(), splitlines(), translate(), maketrans()
💡 핵심 포인트
- 문자열은 불변(immutable) 객체이므로 메서드는 항상 새로운 문자열을 반환합니다.
- 문자열 메서드는 체이닝(chaining)이 가능합니다. 예:
text.strip().lower().replace("a", "b") - 문자열 처리는 데이터 정제, 분석, 형식 지정 등 다양한 작업에 필수적입니다.
- 파이썬 3.9부터는
removeprefix()와removesuffix()메서드가 추가되었습니다. - 대부분의 문자열 메서드는 O(n) 시간 복잡도를 가지므로 대용량 데이터 처리 시 성능을 고려해야 합니다.
파이썬의 문자열 메서드는
텍스트 처리 작업을 효율적으로 수행하는 데 필수적인 도구입니다.
이 메서드들을 잘 활용하면 코드를 더 간결하고 읽기 쉽게 작성할 수 있으며,
다양한 문자열 처리 작업을 효과적으로 수행할 수 있습니다.
위에서 살펴본 실전 예제처럼 여러 메서드를 조합하여 복잡한 텍스트 처리 작업도 쉽게 해결할 수 있습니다.
파이썬 문자열 메서드를 마스터하면 데이터 처리, 웹 개발, 파일 처리 등 다양한 분야에서
더 효율적인 코드를 작성할 수 있을 것입니다.
[ 파이썬 관련 블로그 글 목록 ]
파이썬(Python) 블로그 목록
반응형