Python - String 함수

참고 : https://docs.python.org/3/library/stdtypes.html#string-methods

str.capitalize()

첫 글자만 대문자로 바꾸고 나머지는 소문자로 변경

print("capitalize() : ", "abcabcAbCd".capitalize())
# capitalize() :  Abcabcabcd

str.casefold()

문자열을 모두 Unicode로 변환하고 소문자로 변경

print("casefold() : ", "abcAbCdßß".casefold())
# casefold() :  abcabcdssss

str.center(width [, fillchar])

width 의 길이를 가지는 문자열로 변환, 원래 문자열보다 width 가 작으면 원래 문자열 반환.

원래 문자열이 전체 문자열에 가운데 위치하며 fillchar 가 없으면 문자열 양 옆에 공백 처리

※ \t 등과 같은 문자는 1글자로 처리

print("center(35) : ", "abcd1234ABCD".center(35))
print("center(35, '*') : ", "abcd1234ABCD".center(35, "*"))
# center(35) :              abcd1234ABCD
# center(35, '*') :  ************abcd1234ABCD***********

str.count(sub[, strt[, end]])

strt ~ end 사이에 해당 문자열(sub)가 몇번 나오는지 반환

print ("count('a') : ", "abcdabcAbCd".count("a"))
print ("count('a', 0, 3) : ", "abcdabcAbCd".count("a", 0, 3))
print ("count('ABC') : ", "abcdabcABC".count("ABC"))
# count('a') :  2
# count('a', 0, 3) :  1
# count('ABC') :  1

str.encode(encoding="utf-8", error="strict")

encoding

str.endswith(suffix[, start[, end]])

start ~ end 사이의 문자열이 suffix로 끝나는지 반환 (True / False)

print ("endswith('다') : ", "abcd1234가나다".endswith("다"))
print ("endswith('다', 0, 4) : ", "abcd1234가나다".endswith("다", 0, 4))
# endswith('다') :  True
# endswith('다', 0, 4) :  False

str.expandtabs(tabsize=8)

tab ("\t") 사이즈 조절 (기본 8칸)

print("expandtabs(4) : ", "1\t1".expandtabs(4))
print("expandtabs(10) : ", "1\t1".expandtabs(10))
# expandtabs(4) :  1   1
# expandtabs(10) :  1         1

str.find(sub[, start[, end]])

start ~ end 사이에 sub 문자열이 존재 하는지 반환 (True / False)

str.format(*args, **kwargs)

*args, **kwargs 의 의미를 알고 싶다면 -> Python - 파라미터 앞에 *, ** 의 의미? (*args, **kwargs)

문자열 템플릿에 args 변수들을 값 들을 대입한다.

print("'format : ", "{0} is {1}. Hello {0}".format('JH', 'Korean'))
# format :  JH is Korean. Hello JH

# print("'format : ", "{} is {}. Hello {}".format('JH', 'Korean')) #Error!! - {} 갯수와 값의 수가 다름!!

str.format_map(mapping)

format 함수와 비슷함, 문자열 템플릿에 {} 대신 {key} 형태로 작성하고 mapping 에서 key 값을 찾아서 대입함. (mapping 은 dict 타입.)

print('format_map : ', "{name} is {country}. Hello {name}".format_map({"name": "jh", "country": "Korean"}))
# format_map :  jh is Korean. Hello jh

# print('format_map : ', "{name} is {country}. Hello {name}".format_map({"name": "jh"})) #Error!! - country 값이 없음

str.index(sub[, start[, end]])

sub 문자열이 몇번째 index에 위치하고 있는지 반환.

find() 함수와 비슷하지만 sub 문자열이 발견되지 않으면 ValueError 를 발생함

str.index(sub[, start[, end]])

sub 문자열이 몇번째 index에 위치하고 있는지 반환.

find() 함수와 비슷하지만 sub 문자열이 발견되지 않으면 ValueError 를 발생함

print('"12345".index("3") : ', "12345".index("3"))
# "12345".index("3") :  2

# print('"12345".index("3", 3, 5) : ', "12345".index("3", 3, 5)) #Error!! - V alueError: substring not found

str.isalnum()

문자열이 "문자" 또는 "숫자"로 만 이루어 져 있는지 반환 (True / False)

print('"abc123가나다".isalnum() : ', "abc123가나다".isalnum())
print('"!@".isalnum() : ', "!@".isalnum())
# "abc123가나다".isalnum() :  True
# "!@".isalnum() :  False

str.isalpha()

문자열이 "문자" 로 만 이루어 져 있는지 반환  (True / False)

print('"abcABC가나다".isalpha() : ', "abcABC가나다".isalpha())
print('"123".isalpha() : ', "123".isalpha())
# "abcABC가나다".isalpha() :  True
# "123".isalpha() :  False

str.isascii()

문자열의 모든 문자가 ASCII 인지 확인 (True / False)

print('"fdw e \tr".isascii() : ', "fdw e \tr".isascii())
print('"ßß".isascii() : ', "ßß".isascii())
# "fdw e  r".isascii() :  True
# "ßß".isascii() :  False

str.isdecimal()

문자열의 모든 문자가 숫자인지(Unicode 의 ND(Number, Decimal Digit) 카테고리 기준) 확인 (True / False)

print('"123".isdecimal() : ', "123".isdecimal())
print('"꘦".isdecimal() : ', "꘦".isdecimal())
# "123".isdecimal() :  True
# "꘦".isdecimal() :  True

str.isdigit()

문자열이 숫자로 인식 될 수 있는 것 인지 확인 (True / False)

isdecimal() 로 확인했을때 True 인 것들 + 숫자로 읽힐 수 있는 모든 문자들을 확인 할 수 있다.

print('"①⑼".isdigit() : ', "①⑼".isdigit())
"①⑼".isdigit() :  True

str.isidentifier()

문자열이 식별자로 사용 될 수 있는지 확인 (Python에서 식별자(변수명, 클래스명)로 사용할 수 있다면 True)

print('"var_name".isidentifier()', "var_name".isidentifier())
print('"ClassName".isidentifier()', "ClassName".isidentifier())
print('"_underbar".isidentifier()', "_underbar".isidentifier())
print('"0_number".isidentifier()', "0_number".isidentifier())
print('"-_var_name".isidentifier()', "-_var_name".isidentifier())
# "var_name".isidentifier() True
# "ClassName".isidentifier() True
# "_underbar".isidentifier() True
# "0_number".isidentifier() False
# "-_var_name".isidentifier() False

str.islower()

모든 문자가 소문자로만 되어 있는지 확인 (True / False)

str.isnumeric()

문자열이 최소 1글자 이상이며 숫자로 인식 될 수 있는지 확인 (True / False)

isdigit()으로 확인했을 때 True 인 것들 + 유니코드

print('"①⑼".isnumeric()', "①⑼".isnumeric())
print('"1".isnumeric()', "1".isnumeric())
print('"꘦".isnumeric()', "꘦".isnumeric())
print('"⅕".isnumeric()', "⅕".isnumeric())
# "①⑼".isnumeric() True
# "1".isnumeric() True
# "꘦".isnumeric() True
# "⅕".isnumeric() True

str.isprintable()

 문자열이 비어있거나 모든 문자열이 프린트 가능한지 확인 (True / False)

Unicode 의 "Other", "Separator" 가 프린트 불가능 문자로 분류된다 (공백 제외)

print('" ".isprintable()', " ".isprintable())
print('"\\t".isprintable()', "\t".isprintable())
print('"\\n".isprintable()', "\n".isprintable())
# " ".isprintable() True
# "\t".isprintable() False
# "\n".isprintable() False

str.isspace()

모든 문자열이 공백으로 되어 있는지 확인 (True / False)

print('" ".isspace()', " ".isspace())
print('"\\t".isspace()', "\t".isspace())
print('"\\n".isspace()', "\n".isspace())
# " ".isspace() True
# "\t".isspace() True
# "\n".isspace() True

str.istitle()

해당 문자열이 제목 형식(모든 단어의 첫 글자가 대문자) 으로 입력 되었는지 확인 (True / False)

print('"this is test".istitle()', "this is test".istitle())
print('"This is test".istitle()', "This is test".istitle())
print('"This Is Test".istitle()', "This Is Test".istitle())
print('"한글 테스트".istitle()', "한글 테스트".istitle())
# "this is test".istitle() False
# "This is test".istitle() False
# "This Is Test".istitle() True
# "한글 테스트".istitle() False

str.isupper()

모든 문자열이 대문자 인지 확인 (True / False)

str.join(iterable)

iterable 문자열을 합친다. 문자열을 합칠 때 iterable 값 들 사이의 구분자로 str 을 사용한다.

iterable 에 bytes 타입과 같은 string 값으로 변환이 불가능한 값이 오면 에러가 발생된다.

print('"--".join(["a", "b", "c"])', "--".join(['a', 'b', 'c']))
# "--".join(["a", "b", "c"]) a--b--c

str.ljust(width[, fillchar])

문자열을 왼쪽으로 정렬하고 width 길이 보다 문자열이 짧으면 공백 또는 fillchar 로 문자열을 채운다.

print("가".ljust(20) + "나")
print("가".ljust(20, "-") + "나")
print("가나다라마".ljust(2) + "!!!!")
# 가                   나
# 가-------------------나
# 가나다라마!!!!

str.lower()

모든 문자를 소문자로 변환한다.

print("AbcDE".lower())
print("가a나b다C".lower())
print("!@#abC".lower())
# abcde
# 가a나b다c
# !@#abc

str.lstrip([chars])

왼쪽에 있는 문자를 제거함.

chars에 아무값도 전달하지 않으면 공백을 삭제하고, chars 가 None이 아니면 chars의 값 중 제일 왼쪽에 있는 문자를 삭제함(예제 확인)

print("    lstrip   ".lstrip())
print("aabbccddaabbccdd".lstrip("a")) # 제일 왼쪽에 a 가 있으므로 삭제됨
print("aabbccddaabbccdd".lstrip("ab")) # 제일 왼쪽에 a 가 있어서 삭제되고, 삭제된 후 b 도 있어서 삭제됨
print("aabbccddaabbccdd".lstrip("abc")) # 제일 왼쪽에 a 가 있어서 삭제되고, 삭제된 후 b 도 있어서 삭제됨, 그리고 c 도 있어서 삭제됨
print("aabbccddaabbccdd".lstrip("ad")) # 제일 왼쪽에 a 가 있어서 삭제되고, 삭제된 후 첫 글자가 b 인데 b는 없어서 삭제가 안됨
print("aabbccddaabbccdd".lstrip("bc")) # 제일 왼쪽에 a 가 있는데 a 가 없음 (b, c만 있음). 그래서 아무것도 삭제되지 않음
# lstrip
# bbccddaabbccdd
# ccddaabbccdd
# ddaabbccdd
# bbccddaabbccdd
# aabbccddaabbccdd

str.partition(sep)

sep 을 기준으로 sep 왼쪽, sep, sep오른쪽을 튜플 형태로 반환한다.

print("a=b=aa=bbb".partition("="))
# ('a', '=', 'b=aa=bbb')

str.replace(old, new[, count])

old 문자를 new 문자로 count 만큼 바꾼다.

print("abacadae".replace("a", " "))
print("abacadae".replace("a", " ", 3))
#  b c d e
#  b c dae

str.rfind(sub[, start[, end]])

문자열의 start ~ end 사이에서 sub문자열을 오른쪽부터 찾아 그 시작 index를 반환한다.

sub를 못 찾으면 -1을 반환한다.

print("0123401234".rfind('23'))
print("0123401234".rfind('23', 0, 5))
print("0123401234".rfind('23', 0, 2))
# 7
# 2
# -1

str.rindex(sub[, start[, end]])

rfind()하고 동일하게 동작하지만, sub를 못찾으면 ValueError 를 발생시킨다.

str.rjust(width[, fillchar])

문자열을 오른쪽으로 정렬하고 width 길이 보다 문자열이 짧으면 공백 또는 fillchar 로 문자열을 채운다.

print("가".rjust(20) + "나")
print("가".rjust(20, "-") + "나")
print("가나다라마".rjust(2) + "!!!!")
#                    가나
# -------------------가나
# 가나다라마!!!!

str.rpartition(sep)

sep 을 오른쪽 부터 찾아서 이를 기준으로 sep 왼쪽, sep, sep오른쪽을 튜플 형태로 반환한다. 

print("a=b=aa=bbb".rpartition("="))
# ('a=b=aa', '=', 'bbb')

str.rsplit(sep=None, maxsplit=-1)

문자열을 오른쪽에서 부터 sep 기준으로 maxsplit 만큼 분리한 list 를 반환한다.

print("ab-cd-ef-gh".rsplit("-"))
print("ab-cd-ef-gh".rsplit("-", 2))
# ['ab', 'cd', 'ef', 'gh']
# ['ab-cd', 'ef', 'gh']

str.rstrip([chars])

오른쪽에 있는 문자를 제거함.

chars에 아무값도 전달하지 않으면 공백을 삭제하고, chars 가 None이 아니면 chars의 값 중 제일 오른쪽에 있는 문자를 삭제함(예제 확인)

print("    rstrip   ".rstrip())
print("aabbccddaabbccdd".rstrip("d")) # 제일 오른에 d 가 있으므로 삭제됨
print("aabbccddaabbccdd".rstrip("dc")) # 제일 오른에 d 가 있어서 삭제되고, 삭제된 후 c 도 있어서 삭제됨
print("aabbccddaabbccdd".rstrip("dcb")) # 제일 오른에 d 가 있어서 삭제되고, 삭제된 후 c 도 있어서 삭제됨, 그리고 b 도 있어서 삭제됨
print("aabbccddaabbccdd".rstrip("db")) # 제일 오른에 d 가 있어서 삭제되고, 삭제된 후 첫 글자가 b 인데 b는 없어서 삭제가 안됨
print("aabbccddaabbccdd".rstrip("bc")) # 제일 오른에 d 가 있는데 d 가 없음 (b, c만 있음). 그래서 아무것도 삭제되지 않음
#     rstrip
# aabbccddaabbcc
# aabbccddaabb
# aabbccddaa
# aabbccddaabbcc
# aabbccddaabbccdd

str.split(sep=None, maxsplit=-1)

문자열을 sep 기준으로 maxsplit 만큼 분리한 list 를 반환한다.

print("ab-cd-ef-gh".split("-"))
print("ab-cd-ef-gh".split("-", 2))
# ['ab', 'cd', 'ef', 'gh']
# ['ab', 'cd', 'ef-gh']

str.splitlines([keepends])

개행 단위로 문자열을 분리하여 list 로 반환한다. 개행 문자를 마지막에 붙이고 싶으면 keepends = True로 하면 된다.

str.startswith(prefix[, start[, end]])

start ~ end 사이의 문자열이 prefix로 시작하면 True 그렇지 않으면 False

print("0123456".startswith("01"))
print("0123456".startswith("34", 3, 5))
print("0123456".startswith("34", 3, 4))
# True
# True
# False

str.strip([chars])

양쪽에 있는 문자를 제거함.

chars에 아무값도 전달하지 않으면 공백을 삭제하고, chars 가 None이 아니면 chars의 값 중 제일 끝에 있는 문자를 삭제함(예제 확인)

print("    strip   ".strip())
print("aabbccddaabbccdd".strip("d")) # 제일 오른에 d 가 있으므로 삭제됨
print("aabbccddaabbccdd".strip("ad")) # 제일 오른에 d 가 있고, 제일 왼쪽에 a가 있어서 삭제됨
print("aabbccddaabbccdd".strip("adc")) # 제일 오른에 d 가 있어서 삭제되고, 제일 왼쪽에 a 가 있어 삭제된 후 c 도 있어서 삭제됨
print("aabbccddaabbccdd".strip("ac")) # 제일 왼쪽에 a 가 있어서 삭제되고, 삭제된 후 첫 글자가 b 인데 b는 없어서 삭제가 안됨
print("aabbccddaabbccdd".strip("bc")) # 제일 오른에 d, 제일 왼쪽에 a 가 있는데 a, d 가 없음 (b, c만 있음). 그래서 아무것도 삭제되지 않음
# strip
# aabbccddaabbcc
# bbccddaabbcc
# bbccddaabb
# bbccddaabbccdd
# aabbccddaabbccdd

str.swapcase()

대소문자를 전환하여 반환한다.

print("abCdEf".swapcase())
print("ABCDE".swapcase())
print("abcde".swapcase())
print("가나다".swapcase())
# ABcDeF
# abcde
# ABCDE
# 가나다

str.title()

문자열을 제목 형태(모든 단어의 첫 글자가 대문자)로 변환한다.

print("hello world~".title())
print("hello 파이썬 world~".title())
# Hello World~
# Hello 파이썬 World~

str.translate(table)

문자열의 모든 문자를 변환표(table)을 기초로 변환함. table은 __getitem__ 함수를 가지고 있어야 함. (나중에 한번 해봤으면)

str.upper()

모든 문자를 대문자로 변환한다.

print("abc".upper())
print("ABC".upper())
print("AbC".upper())
print("가b나".upper())
# ABC
# ABC
# ABC
# 가B나

str.zfill(width)

문자열을 width 만큼 확장하는데 모자라는 문자열 만큼 앞에 "0"을 붙인다.

문자열 맨 앞에 "+", "-" 가 있으면 부호로 인식하여 문자열 맨 앞에 붙는다.

print("10".zfill(5))
print("+10".zfill(5))
print("-10".zfill(5))
print("+-10".zfill(5))
print("a+bc".zfill(5))
print("+abc".zfill(5))