파이썬 문자열 메서드
- 2019. 9. 24. 18:40
파이썬 문자열
문자열 메서드
파이썬에서는 문자열에 사용할 수 있는 메서드가 많이 존재합니다. 이 메서드들로 인하여 다른 프로그래밍 언어에 비하여 코드가 짧아지고 데이터를 유연하게 처리할 수 있습니다. 파이썬 3.7 버전에서 사용할 수 있는 메서드 개수를 세어보니 45개나 되는 것으로 확인되었습니다.
현업에서 파이썬으로 코드를 작성하다 보면 희한스러운 데이터들을 많이 접하게 됩니다. 그럴 때 가치 있는 데이터로 가공하기 위해서 이 문자열 메서드 들을 잘 활용해야 합니다. 그러기 위해서는 파이썬에서 어떤 문자열 메서드들을 제공하는지 메서드들을 어떻게 사용하는지 알아볼 필요가 있습니다.
본 포스트에서는 이 45개의 파이썬 문자열 메서드에 대하여 예제와 함께 알아보도록 하겠습니다.
참고로 45개의 메서드를 일일이 세지 않았습니다. 간단히 손가는대로 코드를 작성하여 메서드를 카운트하였습니다. 혹시나 어떻게 알아볼 수 있는지 궁금해하시는 분들을 위해 남겨 놓겠습니다.
>>> tmp_var = "CaptainBIN"
>>> cnt=0
>>> for i in dir(tmp_var):
... if "__" not in i:
... cnt += 1
... print(str(cnt), i)
하위에 설명하는 메서드들은 메서드 이름순으로 정렬되어 있습니다. 하지만 글을 작성하다 보니 순서를 바꿔야 하는 경우가 발생하여 2군데 정도 이름 순서와 다른 경우가 있음을 미리 알려 드립니다.
capitalize
| Signature |
| capitalize() |
문자열이 영문자일 때 첫 문자가 대문자, 나머지는 소문자로 문자열을 생성합니다. 단, 문자열의 첫 글자가 알파벳일 경우에만 변환합니다.
밑의 예제를 보면 아시겠지만 문자열의 첫 문자가 알파벳일 때를 제외하고는 대문자로 변경되지 않으며 뒤의 모든 영문자는 모두 소문자로 변경됩니다.
# 문자열 첫글자가 알파멧 소문자일 경우
>>> 'captainBIIN'.capitalize()
'Captainbiin'
# 소문자로 시작한 경우
>>> 'c캡틴aptainBIIN'.capitalize()
'C캡틴aptainbiin'
# 숫자로 시작할 경우
>>> '1captainBIIN'.capitalize()
'1captainbiin'
# 공백으로 시작할 경우
>>> ' captainBIIN'.capitalize()
' captainbiin'
# 특수문자로 시작할 경우
>>> '_captainBIIN'.capitalize()
'_captainbiin'
# 한글로 시작할 경우
>>> '블로그captainBIIN'.capitalize()
'블로그captainbiin'
# 문자열 중간에 공백이 있을 경우
>>> '1.captain BIIN'.capitalize()
'1.captain biin'
casefold
| Signature |
| casefold() |
파이썬 버전 3.3에서 추가된 메서드로 lower() 메서드와 결과가 비슷하지만 독일어 소문자 'ß'같은 문자는 'ss'로 변환합니다. 한글과 영어만 사용하는 곳에서는 casefold() 메서드는 그다지 필요한 기능은 아닌 것 같습니다. 하지만 이러한 메서드가 있는 이유를 생각해보면 역시 글로벌한 언어라는 것을 알 수 있습니다.
# 문자열을 모두 소문자로 변환
>>> 'CaptainBIN'.casefold()
'captainbin'
# 공백이 있어도 소문자로 변환
>>> 'Captain BIN'.casefold()
'captain bin'
# 독일어 문자 ß가 소문자 ss로 변환
>>> 'Captain BIN ß'.casefold()
'captain bin ss'
center
| Signature |
| center(width[, fillchar]) |
문자열을 폭(width) 값을 기준으로 가운데 정렬을 합니다. 이때 fillchar값은 선택사항이며 fillchar값을 지정 시 공백은 fillchar값으로 채워집니다.
# 길이 30에 가운데 정렬
>>> ' CaptainBIN '.center(30)
' CaptainBIN '
# 길이 30에 '*' 케릭터 공백 채움
>>> ' CaptainBIN '.center(30, '*')
'********* CaptainBIN *********'
##################################
# 다른 코드 동일 결과
##################################
# f 리터럴을 사용한 동일 결과 산출
>>> f"{' CaptinBIN ':^30}"
' CaptinBIN '
>>> f"{' CaptinBIN ':*^30}"
'********* CaptinBIN **********'
count
| Signature |
| count(sub[, start[, end]]) |
문자열에서 선택 사항인 start와 end 값 구간에서 지정한 sub값의 개수를 세어줍니다.
# 대소문자를 구분하는 count
>>> 'CaptainBIN captainbin'.count('C')
1
# 0인덱스에만 존재하는 대문자 C
>>> 'CaptainBIN captainbin'.count('C', 1, 12)
0
# 한글 count
>>> '한글도 한글도 카운트 될까?'.count('한글')
2
encode
| Signature |
| encode(encoding="locale"[, errors="options"]) |
문자열을 지정한 locale 형식으로 인코딩합니다. 파이썬에서 기본 인코딩은 utf-8을 사용합니다. errors는 선택사항으로 사용할 수 있는 옵션은 기본값인 'strict'가 있으며 이는 인코딩 오류가 있으면 UnicodeError를 발생하는 옵션입니다.
다른 옵션으로는 'ignore', 'replace', 'backslashreplace'와 같은 옵션이 있습니다.
# 한글 encoding
>>> '반갑습니다.'.encode('utf-8')
b'\xeb\xb0\x98\xea\xb0\x91\xec\x8a\xb5\xeb\x8b\x88\xeb\x8b\xa4.'
# 인코딩 문자열은 다시 디코딩 하여 확인
>>> '반갑습니다.'.encode('utf-8').decode('utf-8')
'반갑습니다.'
>>> b'\xeb\xb0\x98\xea\xb0\x91\xec\x8a\xb5\xeb\x8b\x88\xeb\x8b\xa4.'\
... .decode('utf-8')
'반갑습니다.'
#####################################
# decode error (\xff)
#####################################
# 변환 불가능한 코드가 있을 경우 에러 발생
>>> b'\xeb\xb0\x98\xea\xb0\x91\xec\x8a\xb5\xeb\x8b\x88\xeb\x8b\xa4.\xff'\
... .decode('utf-8')
# UnicodeDecodeError 에러 발생
# UnicodeDecodeError: 'utf-8' codec can't decode byte 0xff in position 16: invalid start byte
# ignore 옵션으로 에러 캐릭터를 무시
>>> b'\xeb\xb0\x98\xea\xb0\x91\xec\x8a\xb5\xeb\x8b\x88\xeb\x8b\xa4.\xff'\
... .decode('utf-8', 'ignore')
'반갑습니다.'
# replace 옵션으로 에러 캐릭터를 다른 캐릭터로 변환
>>> b'\xeb\xb0\x98\xea\xb0\x91\xec\x8a\xb5\xeb\x8b\x88\xeb\x8b\xa4.\xff'\
... .decode('utf-8', 'replace')
'반갑습니다.�'
# backslashreplace 옵션으로 에러 케릭터 값을 \\x 처리
>>> b'\xeb\xb0\x98\xea\xb0\x91\xec\x8a\xb5\xeb\x8b\x88\xeb\x8b\xa4.\xff'\
... .decode('utf-8', 'backslashreplace')
'반갑습니다.\\xff'
endswith
| Signature |
| endswith(suffix[, start[, end]]) |
문자열이 지정한 suffix로 끝나는지의 여부를 Boolean값으로 리턴합니다. suffix는 단일 문자열 혹은 접미사들을 모은 튜플이 될 수 있습니다.
# 'BIN'으로 끝나는지 확인
>>> 'Captain BIN'.endswith('BIN')
True
# 'N '으로 끝나는지 확인
>>> 'Captain BIN '.endswith('N ')
True
# 문자열의 0~7범위가 'n'으로 끝나는지 확인
>>> 'Captain BIN'.endswith('n',0,7)
True
# 한글도 확인 가능
>>> 'CaptainBIN 블로그'.endswith('그')
True
>>> 'CaptainBIN 블로그'.endswith('블로그')
True
# 라인개행도 확인 가능
>>> 'CaptainBIN 블로그\n'.endswith('\n')
True
expandtabs
| Signature |
| expandtabs([tabsize=8]) |
탭 문자(\t)에 대해 지정한 tabsize만큼 공백으로 대체합니다. tabsize의 기본값은 8입니다. 만약 지정한 tabsize만큼 표현할 캐릭터 수가 동일할 경우 expandtabs는 \t문자를 표현하기 위해 tabsize만큼 공백을 찍는 다소 엉뚱한 결과 값을 초래할 수도 있습니다. 이는 데이터가 붙어 화면에 출력될 경우 마치 하나의 데이터처럼 보이는 것을 방지하기 위한 조치입니다.
예를 들어 탭 사이즈가 4로 지정되어 있고 "1234\t1234"의 문자열을 화면에 출력할 때, 탭 사이즈와 데이터 사이즈가 동일하여 탭을 처리하지 않으면 화면에 "12341234"가 출력되어 마치 하나의 필드처럼 보이게 됩니다. 그래서 데이터가 탭 사이즈와 동일하다면 데이터 출력 후 탭 공백을 찍어 "1234 1234" 정확히 두 개의 필드 데이터라는 것을 표시합니다.
# 탭을 공백 3으로 변환
>>> '1 12 123 1234 12345'.expandtabs(3)
'1 12 123 1234 12345'
# 탭을 공백 4로 변환
>>> '1\t12\t123\t1234\t12345'.expandtabs(tabsize=4)
'1 12 123 1234 12345'
#0123012301230123012301230 <-자릿수 확인용
find
| Signature |
| find(sub[, start[, end]]) |
선택 사항인 시작과 끝 값의 범위 중 인자로 전달한 sub 값의 위치 인덱스를 넘겨줍니다. 만약 문자열에서 sub을 찾을 수 없다면 -1 값을 리턴합니다.
# 'cap'의 위치를 찾습니다.
>>> 'CaptainBIN captainBIN'.find('cap')
11
# 왼쪽부터 'a'의 위치를 찾습니다.
>>> 'CaptainBIN captainBIN'.find('a')
1
# 위치 2 이후 부터 'a'를 찾습니다.
>>> 'CaptainBIN captainBIN'.find('a', 2)
4
# 5~8 범위 안의 문자열 중 'a'를 찾습니다.
# 없으므로 -1 리턴
>>> 'CaptainBIN captainBIN'.find('a', 5, 8)
-1
# 한글 문자열 find
>>> 'CaptainBIN 블로그'.find('로')
12
format
| Signature |
| format(*args, **kwargs) |
문자열의 중괄호로 구분된 치환 필드를 format() 메서드로 정의한 값으로 치환합니다. 이 메서드의 예제는 많은 시간을 들여 작성한 포스트 ("파이썬 문자열 포맷")에서 확인하실 수 있습니다
본 포스트에서는 format 예제를 추가하지 않겠습니다. 다양한 예제를 원하시면 위의 링크를 참조 바랍니다.
format_map
| Signature |
| format_map(mapping) |
파이썬 버전 3.2에서 추가된 메서드로 format 메서드와 유사하지만 전달받은 dict형태의 자료형을 dict로 복사하지 않고 mapping을 직접 사용합니다.
>>> str="Kind={kind} Name={name}"
>>> mk_dict={'name':'CaptainBIN', 'kind':'BLOG'}
# format 메서드 사용
>>> str.format(**mk_dict)
'Kind=BLOG Name=CaptainBIN'
# format_map 메서드 사용
>>> str.format_map(mk_dict)
'Kind=BLOG Name=CaptainBIN'
사실 위의 예제만 놓고 보면 굳이 format_map 메서드를 왜 만들었을까? 하는 생각이 들기도 합니다. 혹시나 성능이 개선되었을까? 하는 궁금증이 생기기도 합니다. 그래서 format과 format_map의 실행 속도를 체크해 보겠습니다.
# 테스트할 코드를 준비합니다.
>>> from timeit import timeit as tt
>>>
>>> fmt_src="""
... str="Kind={kind} Name={name}"
... mk_dict={'name':'CaptainBIN', 'kind':'BLOG'}
... str.format(**mk_dict)"""
>>>
>>> fmt_map_src="""
... str="Kind={kind} Name={name}"
... mk_dict={'name':'CaptainBIN', 'kind':'BLOG'}
... str.format_map(mk_dict)"""
>>>
# 각각 번갈아 가며 실행합니다.
>>> tt(fmt_src)
1.4900932000000466
>>> tt(fmt_map_src)
1.1560857000004034
>>> tt(fmt_src)
1.523563800001284
>>> tt(fmt_map_src)
1.4971220999996149
>>> tt(fmt_src)
1.3594193999997515
>>> tt(fmt_map_src)
1.0235733999998047
>>> tt(fmt_src)
1.033203200000571
>>> tt(fmt_map_src)
0.7947631000006368
>>> tt(fmt_src)
1.102449300000444
>>> tt(fmt_map_src)
1.2271375999989687
>>> tt(fmt_src)
1.2330829000002268
>>> tt(fmt_map_src)
1.366292100001374
결과를 보면 도토리 키재기와 마찬가지로 차이가 별로 없습니다.
그렇다면 format_map의 메서드는 언제 그 빛을 발휘할까요? 바로 인자로 넘겨주는 mapping이 dict의 서브 클래스 일 때 알 수 있습니다. 그리고 출력 포맷에 대응하는 키값이 없을 때 __missing__ 메서드가 호출되어 조금 더 유연하게 코드가 수행되는 것을 확인할 수 있습니다.
>>> class MapDict(dict):
... def __missing__(self, key):
... return "Missing"
...
>>>
>>> str="Kind={kind} Name={name}"
>>> mk_dict={'name':'CaptainBIN', 'kind':'BLOG'}
# format 메서드 사용
>>> print(str.format(**MapDict(mk_dict)))
Kind=BLOG Name=CaptainBIN
# format_map 메서드 사용
>>> print(str.format_map(MapDict(mk_dict)))
Kind=BLOG Name=CaptainBIN
# foramt 메서드에 name값만 전달
>>> print(str.format(MapDict(name="CaptainBIN")))
# 에러 발생
# KeyError: 'kind'
# format_map 메서드에 name값만 전달
>>> print(str.format_map(MapDict(name='CaptainBIN')))
Kind=Missing Name=CaptainBIN
index
| Signature |
| index(sub[, start[, end]]) |
index 메서드의 사용법 및 결과는 find메서드와 유사하지만, find 메서드와는 달리 index 메서드는 찾는 문자열 sub의 값이 없을 때 ValueError를 발생시킵니다.
# 문자열에서 'a'의 위치 반환
>>> 'CaptainBIN'.index('a')
1
# 문자열의 2~5 범위의 'a'의 위치 반환
>>> 'CaptainBIN'.index('a', 2, 5)
4
# 한글 index 찾기
>>> '한글 찾기'.index('글')
1
# 찾는 sub이 없을 경우
>>> 'CaptainBIN'.index('ca')
# 에러 발생
# ValueError: substring not found
isalnum
| Signature |
| isalnum() |
확인하고자 하는 문자열이 적어도 한 개 이상이고 알파벳과 숫자로 구성되어 있는지의 여부를 Boolean값으로 반환합니다.
# 영문자,숫자,한글의 문자열
>>> 'abc123한글'.isalnum()
True
# 공백이 있을 경우
>>> 'abc 123한글'.isalnum()
False
# 앞과 뒤에 공백에 있을 경우
>>> ' abc123한글'.isalnum()
False
>>> 'abc123한글 '.isalnum()
False
# 특수 문자가 있을 경우
>>> 'abc_123한글'.isalnum()
False
isalpha
| Signature |
| isalpha() |
확인하고자 하는 문자열이 적어도 한 개 이상이고 모든 문자가 알파벳 인지의 여부를 Boolean값으로 반환합니다. 알파벳 문자라 함은 유니코드 문자 데이터베이스에서 "Letter"로 정의된 문자를 말하며 유니코드 표준에서 정의된 "Alphabetic"속성과 다름에 주의해야 합니다.
# 영문자, 숫자, 한글
>>> 'abc123한글'.isalpha()
False
# 영문자, 숫자
>>> 'abc123'.isalpha()
False
# 순수 영문자
>>> 'abc'.isalpha()
True
# 공백 포함 영문자
>>> 'a bc'.isalpha()
False
# 영문자, 한글
>>> 'abc한글'.isalpha()
True
# 한글
>>> '한글'.isalpha()
True
# 1byte 특수 문자
>>> '!'.isalpha()
False
# 2bytes 특수 문자
>>> 'Δ'.isalpha()
True
isascii
| Signature |
| isascii() |
파이썬 버전 3.7에서 추가된 메서드로 확인하고자 하는 문자열이 비어 있거나 모든 문자가 아스키 문자인지의 여부를 Boolean값으로 반환합니다. 참고로 아스키 문자는 U+0000 ~ U+007F 범위를 말합니다.
# 아스키 범주내의 문자열
>>> 'abc~!@#$ CaptainBIN'.isascii()
True
# 아스키 범주 이외의 문자 포함
>>> '★CaptainBIN★'.isascii()
False
# 한글은 당연히 아스키로 표현 불가
>>> '한글'.isascii()
False
isdecimal
| Signature |
| isdecimal() |
확인하고자 하는 문자열이 적어도 한자 이상 존재하고 모든 문자가 십진수 인지의 여부를 Boolean값으로 반환합니다. 얼핏 보면 하위에 설명할 isdigit 메서드와 역할이 비슷해 보입니다. isdecimal 메서드와 isdigit 메서드와 관련된 좀 더 자세한 사항은 하위 isdigit에서 설명하겠습니다.
하지만 결론을 미리 말씀드리면 문자열을 int 자료형으로 형 변환을 위한 문자열 체크라면 isdecimal 메서드를 사용해야 합니다.
# 숫자만 있는 문자열
>>> '123'.isdecimal()
True
# 특수문자의 숫자 포함
>>> '0123０１２３'.isdecimal()
True
# 특수문자 숫자 int변환
>>> int('0123０１２３')
1230123
# 부동소수점 문자열
>>> '123.11'.isdecimal()
False
# 2의 제곱 표현식
>>> '2²'.isdecimal()
False
# 2의 제곱 int변환
>>> int('2²')
# 에러 발생
# ValueError: invalid literal for int() with base 10: '2²'
# 분수 표현 특수문자
>>> '½'.isdecimal()
False
# 분수 표현 특수문자 int변환
>>> int('½')
# 에러 발생
# ValueError: invalid literal for int() with base 10: '½'
isdigit
| Signature |
| isdigit() |
위에서 언급한 바와 같이 숫자 여부를 판단하는 데 있어서 isdecimal 메서드와 isdigit 메서드의 기능이 서로 비슷해 보입니다. 하지만 예제를 자세히 보시면 2의 제곱을 표현한 특수 문자가 isdigit 메서드에서는 True로 반환되고 isdecimal 메서드에서는 False를 반환하였습니다. 즉, 숫자를 인식하는 범위가 isdecimal 메서드가 좀 더 작다라는 것을 알 수 있습니다.
그러므로 일반적인 상황에서 문자열이 숫자인지를 판단하는 것은 int형으로 데이터 타입을 변경하기 위함일 것입니다. 이때 isdigit 메서드 보다 isdecimal 메서드를 사용하는 것이 정신 건강에 조금 도움이 될 것입니다.
# 숫자만 있는 문자열
>>> '123'.isdigit()
True
# 특수문자의 숫자 포함
>>> '0123０１２３'.isdigit()
True
# 특수문자 숫자 int변환
>>> int('0123０１２３')
1230123
# 부동소수점 확인
>>> '0123.11'.isdigit()
False
# 2의 2제곱
>>> '2²'.isdigit()
True
# 2의 제곱 int변환
>>> int('2²')
# 에러 발생
# ValueError: invalid literal for int() with base 10: '2²'
# 분수 표현 특수문자
>>> '½'.isdigit()
False
# 분수 표현 특수문자 int변환
>>> int('½')
# 에러 발생
# ValueError: invalid literal for int() with base 10: '½'
isnumeric
| Signature |
| isnumeric() |
위에서 설명한 isdecimal 메서드와 isdigit 메서드 그리고 isnumeric 메서드 이렇게 3개의 메서드가 모두 숫자를 판별하는 메서드입니다. 얼핏 보면 모두 같은 메서드라 착각하기 쉽지만 isdecimal 메서드와 isdigit 메서드의 차이점은 위에서 설명하였습니다.
그리고 이 3개의 계층 분류 중 최 상위에 있는 메서드가 바로 이 isnumeric 메서드입니다. 이 isnumeric 메서드는 다른 두 개의 메서드에서 False를 반환한 분수를 표현한 특수 문자를 True로 반환하였습니다. 즉, isnumeric 메서드는 문자열이 digit과 unicode가 숫자 속성을 갖는지를 판단합니다.
여기서 "속성"이란 단어에 주목하셔야 하는데 결국 분수를 표현하는 유니코드는 int 자료형으로 형 변환을 못할 뿐 숫자의 속성을 가지고 있으므로 True를 반환합니다.
그러므로 만약 문자열이 int 자료형으로 변경하기 위해 isdecimal, isdigit, isnumeric을 고민 중이시라면 뒤도 돌아보지 마시고 isdecimal 메서드를 사용하시면 됩니다.
# 숫자만 있는 문자열
>>> '123'.isnumeric()
True
# 특수문자의 숫자 포함
>>> '0123０１２３'.isnumeric()
True
# 특수문자 숫자 int변환
>>> int('0123０１２３')
1230123
# 부동 소수점 확인
>>> '0123.11'.isnumeric()
False
# 2의 제곱
>>> '2²'.isnumeric()
True
# 2의 제곱 int변환
>>> int('2²')
# 에러 발생
# ValueError: invalid literal for int() with base 10: '2²'
# 분수 표현 특수문자
>>> '½'.isnumeric()
True
# 분수 표현 특수문자 int변환
>>> int('½')
# 에러 발생
# ValueError: invalid literal for int() with base 10: '½'
isidentifier
| Signature |
| isidentifier() |
문자열이 유효한 식별자 인지의 여부를 Boolean값으로 반환합니다. 참고로 예약된 식별자인지를 검사하려면 keyword.iskeyword()를 사용해야 합니다.
다시 말하면 isidentifier 메서드는 확인하고자 하는 문자열이 파이썬 식별자로 사용될 수 있는지의 여부를 판단하는 메서드입니다. 참고로 파이썬 식별자 생성 규칙은 이전에 작성한 게시글 "파이썬 키워드 및 파이썬 식별자 생성 규칙"을 참고하시면 True와 False를 반환하는 이유를 좀 더 쉽게 이해할 수 있습니다.
####################################
# True 반환
####################################
# 순수 영문자
>>> "CaptainBIN".isidentifier()
True
# 중간에 '_' 특수문자 사용
>>> "captain_bin".isidentifier()
True
# 영문자, '_', 숫자 사용
>>> "captain_bin_1".isidentifier()
True
# 맨 앞에 '_' 1개 사용
>>> "_captain_bin".isidentifier()
True
# 맨 앞에 '_' 2개 사용
>>> "__captain_bin".isidentifier()
True
# 맨 앞에 '_' 4개 사용
>>> "____captain_bin".isidentifier()
True
####################################
# False 반환
####################################
# 공백으로 시작
>>> " captain_bin".isidentifier()
False
# 숫자로 시작
>>> "1captain_bin".isidentifier()
False
# '_' 이외의 특수 문자 사용 (1)
>>> "!captain_bin".isidentifier()
False
# '_' 이외의 특수 문자 사용 (2)
>>> "-captain_bin".isidentifier()
False
참고로 위에서 잠깐 언급한 예약어를 확인하는 keyword.iskeyword() 예제를 살펴보도록 하겠습니다.
>>> import keyword
# True 반환 예약어 문자열
>>> keyword.iskeyword('if')
True
>>> keyword.iskeyword('for')
True
>>> keyword.iskeyword('while')
True
>>> keyword.iskeyword('def')
True
>>> keyword.iskeyword('class')
True
#False 반환 일반 문자열
>>> keyword.iskeyword('captainbin')
False
islower
| Signature |
| islower() |
적어도 하나 이상의 문자가 존재하고 모든 문자가 소문자 인지의 여부를 Boolean값으로 반환합니다.
# 소문자 문자열
>>> 'abc'.islower()
True
# 마지막 공백 포함 문자열
>>> 'abc '.islower()
True
# 앞 뒤 공백 문자 포함 문자열
>>> ' abc '.islower()
True
# 특수문자 포함 문자열 (1)
>>> ' abc_def '.islower()
True
# 특수문자 포함 문자열 (2)
>>> ' *abc_def* '.islower()
True
# 특수문자 포함 문자열 (3)
>>> '★*abc_def* '.islower()
True
# 한글 포함 문자열
>>> '★*abc_def*한글'.islower()
True
# 대문자 G가 포함되어 False
>>> '★*abc_defG*한글'.islower()
False
isprintable
| Signature |
| isprintable() |
문자열이 비어 있거나 확인하려는 문자열이 인쇄할 수 있는지의 여부를 Boolean값으로 반환합니다. 인쇄할 수 없는 문자는 유니코드 문자 데이터 베이스에 "Other" 또는 "Separator"로 정의된 문자를 말합니다.
즉, isprintable 메서드는 문자열이 깨끗하게 한 줄에 print 할 수 있는 문자열 인지 아닌지를 판단하는 메서드입니다.
# 빈 문자열
>>> ''.isprintable()
True
# unicode로 SP(Space)
>>> chr(0x0020).isprintable()
True
# unicode로 NMSP(No-Break Space)
>>> chr(0x00a0).isprintable()
False
# 순수 문자열
>>> 'CaptainBIN_블로그 '.isprintable()
True
# 특수 문자 백슬러시 (1)
>>> 'abc\\def'.isprintable()
True
# 특수 문자 백슬러시 (2)
>>> 'abc\def'.isprintable()
True
# 라인개행 문자를 입력
>>> 'abc\ndef'.isprintable()
False
isspace
| Signature |
| isspace() |
확인하고자 하는 문자열이 공백만 있는지의 여부를 Boolean값으로 반환합니다.
# 빈 문자열
>>> ''.isspace()
False
# 1byte 스페이스 문자
>>> ' '.isspace()
True
# 2bytes 스페이스 특수 기호
>>> ' '.isspace()
True
# 스페이스와 숫자
>>> '1 '.isspace()
False
istitle
| Signature |
| istitle() |
연속된 문자열 중 알파벳이 아닌 문자로 알파벳을 구분하고 구분된 알파벳 문자열의 첫 알파벳만 대문자 인지를 판단하여 Boolean값으로 반환합니다.
# 공백 구분 첫 문자 대문자
>>> 'Captain Bin'.istitle()
True
# 특수문자 구분 첫 문자 대문자
>>> 'Captain_Bin'.istitle()
True
>>> 'Captain&Bin'.istitle()
True
# 공백없는 가운데 대문자
>>> 'CaptainBin'.istitle()
False
# 공백 구분 뒷문자열 대문자
>>> 'Captain BIN'.istitle()
False
# 한글 포함
>>> 'Captain Bin 한글'.istitle()
True
# 한글, 특수기호 포함
>>> 'Captain Bin 한글★'.istitle()
True
# 공백으로 시작
>>> ' Captainbin'.istitle()
True
# 한글로 시작 및 모두 소문자
>>> '한글captainbin'.istitle()
False
#한글로 시작하고 첫 알파벳 대문자
>>> '한글Captainbin'.istitle()
True
>>>
isupper
| Signature |
| isupper() |
판별하는 문자열 중 알파벳만 모두 대문자 인지 여부를 Boolean 값으로 반환합니다.
# 대문자 문자열
>>> 'CAPTAINBIN'.isupper()
True
# 공백 포함 대문자 문자열
>>> 'CAPTAIN BIN'.isupper()
True
# '_' 포함 대문자 문자열
>>> 'CAPTAIN_BIN'.isupper()
True
# 한글 포함 대문자 문자열
>>> 'CAPTAIN_BIN_한글'.isupper()
True
# 2bytes 특수문자 포함 문자열
>>> 'CAPTAIN_BIN_한글★'.isupper()
True
#소문자 포함 문자열
>>> 'CaPTAIN_BIN_한글★'.isupper()
False
join
| Signature |
| join(iterable) |
iterable 한 문자열을 하나로 붙인 문자열을 반환합니다.
# 리스트 자료형을 한 문자열로 join
>>> "_".join(['Captain','BIN','BLOG'])
'Captain_BIN_BLOG'
# 공백도 가능
>>> " ".join(['Captain','BIN','BLOG'])
'Captain BIN BLOG'
# 공백 없이도 가능
>>> "".join(['Captain','BIN','BLOG'])
'CaptainBINBLOG'
# 응용하면 이와 같은 문자열도 생성 가능
>>> "CaptainBIN".join('_' * 3)
'_CaptainBIN_CaptainBIN_'
ljust
| Signature |
| ljust(width[, fillchar]) |
문자열을 정의한 width길이로 하는 문자열을 반환합니다. 이때 문자열은 왼쪽 정렬이 되며 나머지는 공백이 됩니다. 선택사항인 fillchar를 세팅하였을 경우 공백이 fillchar로 채워집니다.
# 길이가 30인 문자열
>>> 'CaptainBIN'.ljust(30)
'CaptainBIN '
# 공백을 *로 채운 문자열
>>> 'CaptainBIN'.ljust(30, '*')
'CaptainBIN********************'
# 다른 코드 동일 기능 수행 (1)
>>> f"{'CaptainBIN':<30}"
'CaptainBIN '
# 다른 코드 동일 기능 수행 (2)
>>> f"{'CaptainBIN':*<30}"
'CaptainBIN********************'
lower
| Signature |
| lower() |
주어진 문자열에서 알파벳만 모두 소문자로 변경한 문자열을 반환합니다.
# 알파벳만 소문자로 변경
>>> '한글Captain_BIN★'.lower()
'한글captain_bin★'
lstrip
| Signature |
| lstrip([chars]) |
문자열의 선행 문자를 제거합니다. 선택사항인 chars는 값을 주지 않을 경우 왼쪽의 공백을 제거합니다. chars를 인자 값으로 주게 되면 왼쪽의 문자가 chars인 경우 제거합니다.
# 앞 뒤 공백
>>> ' CaptainBIN '.lstrip()
'CaptainBIN '
# 눈에 잘 보이지는 않지만
# 앞쪽에 2bytes 공백 특수문자 포함
>>> ' CaptainBIN '.lstrip()
'CaptainBIN '
# 캐릭터 하나씩 비교 제거
>>> ' CaptainBIN '.lstrip("t paC")
'inBIN '
maketrans
translate
| Signature |
| maketrans(x[, y[, z]]) |
| Signature |
| translate(table) |
본 메서드는 사용 방법이 다소 복잡합니다. maketrans 메서드는 문자를 치환하기 위한 매핑 정보를 생성합니다. 생성한 매핑 정보는 translate 메서드를 통해서 문자열을 변환할 수 있습니다.
maketrans 메서드는 위에 Signature에서 확인할 수 있듯이 x, y, z 3개의 인자를 전달받습니다. 첫 번째 x인자는 필수 사항입니다. 단, x만을 인자로 주었을 경우 값은 dict 형태이어야 합니다.
인자를 x, y 두 개를 전달할 때는 x와 y에 전달되는 문자열 길이가 같아야 합니다.
마지막으로 x, y, z 세 개의 인자를 전달할 때 x, y는 바로 윗줄에 정의한 내용과 같으며 z는 문자열에서 None으로 대체될 문자열을 전달합니다.
이렇게 maketrans 메서드에 인자를 전달하여 생성한 매핑 정보를 translate에 인자 값으로 넘겨주어 문자열을 변환합니다.
다음 예제를 통해 사용 방법을 알아보겠습니다.
########################################
# maketrans 메서드의 매핑 정보 생성
########################################
# x 인자값 단독 사용
>>> str.maketrans({'c':'C'})
{99: 'C'}
>>> str.maketrans({'c':'C','b':'B'})
{99: 'C', 98: 'B'}
# x, y 인자 사용
>>> str.maketrans('c','C')
{99: 67}
>>> str.maketrans('cb','CB')
{99: 67, 98: 66}
# x, y, z 인자 사용
>>> str.maketrans('c','C','|')
{99: 67, 124: None}
>>> str.maketrans('cb','CB','|')
{99: 67, 98: 66, 124: None}
########################################
# translate 메서드 문자열 치환
########################################
# maketrans 에서 생성한 매핑정보 사용
>>> '|captain|bin|'.translate({99: 67, 98: 66, 124: None})
'CaptainBin'
# translate와 maketrans 동시 사용
>>> '|captain|bin|'.translate(str.maketrans('cb','CB','|'))
'CaptainBin'
partition
| Signature |
| partition(sep) |
문자열을 지정한 sep값을 찾아 항상 sep값을 포함하는 3개의 요소를 갖는 튜플 값을 반환합니다. 만약 sep값을 찾지 못했다면 빈 문자열로 구성되어 3개의 요소를 갖는 튜플 값을 반환합니다.
partition 메서드의 특징이라면 무조건 3개의 요소를 갖는 튜플로 반환한다는 것입니다.
# '|' 값을 찾지 못하였을 때
>>> 'captainbin'.partition('|')
('captainbin', '', '')
# '|' 값을 찾았을 때
>>> 'cap|tain|bin'.partition('|')
('cap', '|', 'tain|bin')
replace
| Signature |
| replace(old, new[,count]) |
문자열 내에서 지정한 old문자열을 new문자열로 치환합니다. 선택적인 count값을 지정하게 되면 지정한 count만큼만 치환 작업이 이루어집니다.
# 문자열 내의 모든 old를 new로 변환
>>> 'old old captain bin'.replace('old','new')
'new new captain bin'
# 문자열 내에 1회만 old를 new로 변환
>>> 'old old captain bin'.replace('old','new', 1)
'new old captain bin'
rfind
| Signature |
| rfind(sub[, start[, end]]) |
문자열을 오른쪽부터 지정한 sub값을 찾아 위치한 인덱스 값을 반환합니다. 선택적인 start와 end값은 지정한 범위 내에서만 sub값을 찾습니다. 만약 찾을 수 없으면 -1 값을 반환합니다.
# 'ap'의 위치를 찾습니다.
>>> 'CaptainBIN captainBIN'.rfind('ap')
12
# 오른쪽부터 'a'의 위치를 찾습니다.
>>> 'CaptainBIN captainBIN'.rfind('a')
15
# 위치 2 이후 부터 'a'를 찾습니다.
>>> 'CaptainBIN captainBIN'.rfind('a', 2)
15
# 5~8 범위 안의 문자열 중 'a'를 찾습니다.
# 없으므로 -1 리턴
>>> 'CaptainBIN captainBIN'.rfind('a', 5, 8)
-1
# 한글 문자열 rfind
>>> '블로그CaptainBIN 블로그'.rfind('로')
15
rindex
| Signature |
| rindex(sub[, start[, end]]) |
rfind() 메서드와 비슷한 기능을 구현하지만 지정한 sub을 찾을 수 없을 경우 ValueError를 발생시킵니다.
# 문자열 오른쪽 에서 부터 'a'의 위치 반환
>>> 'CaptainBIN'.rindex('a')
4
# 문자열의 2~5 범위의 'a'의 위치 반환
>>> 'CaptainBIN'.rindex('a', 2, 5)
4
# 한글 rindex 찾기
>>> '한글 찾기 한글 찾기'.rindex('글')
7
# 찾는 sub이 없을 경우
>>> 'CaptainBIN'.rindex('ca')
# 에러 발생
# ValueError: substring not found
rjust
| Signature |
| rjust(width[, fillchar]) |
지정한 width값만큼의 공백을 추가하여 기존의 문자열을 오른쪽 정렬한 문자열을 반환합니다. 선택사항인 fillchar에 값을 지정하면 지정한 fillchar가 공백을 대신합니다.
# 길이가 30인 문자열
>>> 'CaptainBIN'.rjust(30)
' CaptainBIN'
# 공백을 *로 채운 문자열
>>> 'CaptainBIN'.rjust(30, '*')
'********************CaptainBIN'
# 다른 코드 동일 기능 수행 (1)
>>> f"{'CaptainBIN':>30}"
' CaptainBIN'
# 다른 코드 동일 기능 수행 (2)
>>> f"{'CaptainBIN':*>30}"
'********************CaptainBIN'
rpartition
| Signature |
| rpartition(sep) |
partition 메서드와 기능이 동일하며 지정한 sep의 값을 문자열 오른쪽에서부터 찾습니다. 또한 반환되는 튜플의 순서가 partition 메서드와 다소 차이가 있습니다.
# '|' 값을 찾지 못하였을 때
>>> 'captainbin'.rpartition('|')
('', '', 'captainbin')
# '|' 값을 찾았을 때
>>> 'cap|tain|bin'.rpartition('|')
('cap|tain', '|', 'bin')
rsplit
| Signature |
| rsplit([sep=None[, maxsplit=-1]]) |
sep과 maxsplit인자 값은 선택사항이며 아무런 인자를 주지 않을 경우 문자열의 오른쪽부터 공백을 기준으로 문자열 나눈 리스트 자료형을 반환합니다. sep를 지정하면 공백 대신 지정한 sep값의 기준으로 문자열을 나누며 maxsplit을 지정하게 되면 해당 값만큼 문자열을 나눕니다.
# 인자가 없을 경우 공백으로 분리
>>> 'captain bin'.rsplit()
['captain', 'bin']
# 일치하는 sep이 없을 경우
>>> 'c|a|p|t|a|i|n|b|i|n'.rsplit('x')
['c|a|p|t|a|i|n|b|i|n']
# '|'을 기준으로 문자열 분리
>>> 'c|a|p|t|a|i|n|b|i|n'.rsplit('|')
['c', 'a', 'p', 't', 'a', 'i', 'n', 'b', 'i', 'n']
# '|'을 기준으로 오른쪽 부터 5회만 분리
>>> 'c|a|p|t|a|i|n|b|i|n'.rsplit('|', 5)
['c|a|p|t|a', 'i', 'n', 'b', 'i', 'n']
rstrip
| Signature |
| rstrip([chars]) |
chars를 지정하지 않으면 문자열 오른쪽에 있는 공백을 제거합니다. 만약 chars를 지정하면 지정한 chars를 오른쪽부터 제거한 문자열을 반환합니다.
# 앞 뒤 공백
>>> ' CaptainBIN '.rstrip()
' CaptainBIN'
# 눈에 잘 보이지는 않지만
# 뒷쪽에 2bytes 공백 특수문자 포함
>>> ' CaptainBIN '.rstrip()
' CaptainBIN'
# 캐릭터 하나씩 비교 제거
>>> ' CaptainBIN '.rstrip("B NI")
' Captain'
split
| Signature |
| split([sep=None[, maxsplit=-1]]) |
아무런 인자를 주지 않았을 경우 문자열을 공백으로 나눈 리스트 자료형으로 반환합니다. sep값을 지정할 경우 공백 대신 sep값을 기준으로 문자열을 나누며 maxsplit값을 지정하게 되면 지정한 값만큼 문자열을 나누게 됩니다.
# 인자가 없을 경우 공백으로 분리
>>> 'captain bin'.split()
['captain', 'bin']
# 일치하는 sep이 없을 경우
>>> 'c|a|p|t|a|i|n|b|i|n'.split('x')
['c|a|p|t|a|i|n|b|i|n']
# '|'을 기준으로 문자열 분리
>>> 'c|a|p|t|a|i|n|b|i|n'.split('|')
['c', 'a', 'p', 't', 'a', 'i', 'n', 'b', 'i', 'n']
# '|'을 기준으로 오른쪽 부터 5회만 분리
>>> 'c|a|p|t|a|i|n|b|i|n'.split('|', 5)
['c', 'a', 'p', 't', 'a', 'i|n|b|i|n']
splitlines
| Signature |
| splitlines([True/False]) |
문자열에 포함된 라인 개행 단위로 문자열을 나눈 리스트 자료형으로 값을 반환합니다. 아무런 인자 값을 주어지지 않으면 인자의 기본 값은 False이며 다음 표에 정의한 표현 값을 모두 구분합니다. 만약 인자 값을 True로 지정하게 되면 표에 정의한 표현 값을 기준으로 문자열을 나누되 나눈 표현 값도 같이 문자열에 포함이 됩니다.
| 표현 | 설명 |
| \r\n | 캐리지 리턴 + 라인 개행 |
| \r | 캐리지 리턴 |
| \n | 라인 개행 |
| \x0b | 수직 탭 |
| \x0c | 폼 피드 |
| \v | 수직 탭 (파이썬 3.2 추가) |
| \f | 폼 피드 (파이썬 3.2 추가) |
| \x1c | 파일 구분 |
| \x1d | 그룹 구분 |
| \x1e | 레코드 구분 |
| \x85 | C1 제어 코드 (다음 라인) |
| \u2028 | 줄 구분 |
| \u2029 | 문단 구분 |
# 기본값 False
>>> 'captain\r\nBIN\r123\n'.splitlines()
['captain', 'BIN', '123']
# False를 인자로 전달
>>> 'captain\r\nBIN\r123\n'.splitlines(False)
['captain', 'BIN', '123']
# True를 인자로 전달
>>> 'captain\r\nBIN\r123\n'.splitlines(True)
['captain\r\n', 'BIN\r', '123\n']
startswith
| Signature |
| startswith(prefix[, start[, end]]) |
prefix로 지정한 값이 문자열이 시작되는지의 여부를 Boolean값으로 반환합니다. 선택 사항인 start와 end값은 해당 범위 내에서 문자열이 prefix로 시작하는지의 여부를 판단합니다.
# 소문자 c로 시작하는지 판단
>>> 'captainBIN'.startswith('c')
True
# 대문자 C로 시작하는지 판단
>>> 'captainBIN'.startswith('C')
False
# 문자열로 판단
>>> 'captainBIN'.startswith('ca')
True
# 공백도 판단함
>>> ' captainBIN'.startswith('ca')
False
# 문자열 7자리가 'B'로 시작하는지 판단
>>> 'captainBIN'.startswith('B',7)
True
strip
| Signature |
| strip([chars]) |
아무런 인자 값이 주어지지 않으면 문자열의 앞 뒤 공백을 모두 제거합니다. 만약 chars에 인자 값을 주게 되면 문자열의 왼쪽과 오른쪽에 해당하는 chars값을 제거한 문자열을 반환합니다.
# 앞 뒤 공백
>>> ' CaptainBIN '.strip()
'CaptainBIN'
# 눈에 잘 보이지는 않지만
# 앞쪽과 뒷쪽에 2bytes 공백 특수문자 포함
>>> ' CaptainBIN '.strip()
'CaptainBIN'
# 캐릭터 하나씩 비교 제거
>>> ' CaptainBIN '.strip("CB NIa")
'ptain'
swapcase
| Signature |
| swapcase() |
문자열에 있는 대문자는 소문자로 소문자는 대문자로 변경합니다. 단, 문자열에 swapcase()를 두 번 진행한 결과 값이 기존의 문자열과 동일하지 않을 수 있습니다.
# 독일어 ß 문자가 대문자 SS로 변환
>>> '한글Captain_Bin(ß)'.swapcase()
'한글cAPTAIN_bIN(SS)'
# swapcase가 2번 수행해도
# 최초 문자열과 불일치
>>> '한글Captain_Bin(ß)'.swapcase().swapcase()
'한글Captain_Bin(ss)'
title
| Signature |
| title() |
문자열에서 첫 알파벳이 대문자 나머지는 소문자가 되도록 변환한 문자열을 반환합니다. 변환할 알파벳 문자열 판단은 알파벳이 아닌 문자를 기준으로 판단합니다.
>>> '한글captain_bin blog&story'.title()
'한글Captain_Bin Blog&Story'
upper
| Signature |
| upper() |
문자열의 모든 알파벳을 대문자로 변환합니다. 참고로 2 bytes 특수문자인 소문자 y도 동일한 특수문자 대문자 Y로 변경합니다.
>>> '한글captain_bin blog&story-ｙ'.upper()
'한글CAPTAIN_BIN BLOG&STORY-Ｙ'
zfill
| Signature |
| zfill(width) |
인자로 주어지는 width값만큼의 길이로 문자열을 오른쪽 정렬 후 왼쪽의 값을 zero로 채웁니다. 만약 부호가 있는 경우 부호는 맨 앞에 위치합니다.
>>> '채움'.zfill(7)
'00000채움'
>>> '-90'.zfill(7)
'-000090'
>>> '90'.zfill(7)
'0000090'
