파이썬 자료형 - 문자열(String)

문자열이란 문장을 뜻한다. 예를 들어 다음과 같은 것들이 문자열이다.

"Life is too short, You need Python"  
"a"  
"123"

위의 예를 보면 이중 인용부호(")로 둘러싸인 것은 모두다 문자열이 되는 것을 알 수 있다. "123"은 숫자인데 왜 문자열인가? 라는 의문이 드는 독자는 인용부호(")로 둘러싸인 것은 모두 문자열이라고 생각하면 될 것이다.

[저자주] 만약 PDF문서로 이 문서를 보고 계신다면 단일인용부호, 이중인용부호 기호가 조금 이상하게 표시되어 있을 수 있습니다. PDF는 여는 따옴표와 닫는 따옴표를 구분하기 때문인데 변환과정이 매끄럽지 못한 점 양해 부탁드립니다. 여는 따옴표, 닫는 따옴표 구분없이 모두 같은 따옴표라고 생각하시고 읽어 주시면 감사하겠습니다.

문자열 만드는 방법 4가지

위의 예에서는 문자열을 만들 때 이중인용부호(")만을 사용했지만 이 외에도 문자열을 만드는 방법은 세 가지가 더 있다. 파이썬에서 문자열을 만드는 방법은 다음과 같이 네 가지로 구분된다.

"Hello World"  
'Python is fun'  
"""Life is too short, You need python"""  
'''Life is too shor, You need python'''

문자열을 만들기 위해서는 위의 예에서 보듯이 이중 인용부호(")로 문자열의 양쪽을 둘러싸거나 단일 인용부호(') 또는 이중 인용부호나 단일 인용부호 세 개를 연속으로 쓰는(""", ''')를 양쪽으로 둘러싸면 된다. 그렇다면 왜 단순함을 좋아하는 파이썬에서 이렇듯 다양한 문자열 만드는 방법을 가지게 되었을까? 그 이유에 대해서 알아보도록 하자.

문자열 내에 (') 또는 (") 을 포함시키고 싶을 때

문자열을 만들어주는 주인공은 (') 와 (")이다. 하지만 문자열 내에 (') 와 (")를 포함시켜야 할 경우가 있다. 이 때는 좀 더 특별한 기술이 필요하다. 예제를 하나씩 살펴보면서 원리를 익혀보도록 하자.

예 1) 단일 인용부호(')를 포함시키고 싶을 때

Python's favorite food is perl

예 1과 같은 문자열을 변수에 저장하고 싶다고 가정해보자. Python's에서 보듯이 '가 포함되어 있다. 이럴 때는 다음과 같이 문자열을 이중 인용부호(")로 둘러싸야 한다. 이중 인용부호(")안에 들어 있는 단일 인용부호(')는 문자열을 나타내기 위한 기호로 인식되지 않는다.

>>> food = "Python's favorite food is perl"

시험삼아 다음과 같이 (")이 아닌 (')로 문자열을 둘러싼 뒤 실행시켜 보자. 'Python' 이 문자열로 인식되어 에러(Syntax Error)가 날 것이다.

>>> food = 'Python's favorite food is perl'

예 2) 이중 인용부호(")를 포함시키고 싶을 때

"Python is very easy." he says.

예 2와 같이 이중 인용부호(")가 포함된 문자열이라면 어떻게 해야 (") 이 제대로 표현될까?
다음과 같이 그 문자열을 (')으로 둘러싸면 된다.

>>> say = '"Python is very easy." he says.'

이렇게 단일인용 부호(')안에 사용된 이중인용부호(")는 문자열을 나타내는 기호로 인식되지 않는다.

예 3) \ (역슬래시)로 (')과 (")를 문자열에 포함시키기

>>> food = 'Python\'s favorite food is perl'
>>> say = "\"Python is very easy.\" he says."

(')나 (")를 문자열에 포함시킬 수 있는 또 다른 방법은 '\'(역슬래시)를 이용하는 것이다. 즉 (\') 가 문자열 내에 삽입되면 그것은 문자열을 둘러싸는 기호의 의미가 아니라 문자 (') 그 자체를 뜻하게 된다. (\") 역시 마찬가지이다. 어떤 것을 사용할 것인지는 각자의 선택이다. 대화형 인터프리터를 실행시킨 뒤 위의 예를 꼭 직접 실행해 보도록 하자.

여러 줄 짜리 문자열 처리

문자열이 항상 한 줄 짜리만 있는 것은 아니다. 다음과 같이 여러 줄 짜리 문자열이 있을 때는 어떻게 처리해야 할까?

Life is too short  
You need python  
Python is powerful language

이러한 문자열을 변수에 대입하려면 어떻게 하겠는가?

예1) 줄바꿈 문자인 '\n' 삽입

>>> multiline = "Life is too short\nYou need python"

위의 예처럼 줄바꿈 문자인 '\n'을 삽입하는 방법이 있지만 읽기에 너무 불편하고 너무 줄이 길어지는 단점이 있다. 이것을 극복하기 위해 파이썬에서는 다음과 같이 (""")를 이용한다.

예 2) 연속된 이중인용부호 세 개(""") 이용

multiline="""
Life is too short
You need python
"""

위 예에서도 확인할 수 있듯이 문자열이 여러줄일 경우 위와같은 방식이 상당히 유리하고 깔끔하다는 것을 알 수 있을 것이다.

[참고] 이스케이프 코드

여러 줄 짜리 문장을 처리할 때 '\n'과 같은 역슬래시 문자를 이용한 이스케이프 코드를 사용했다. 이와 같은 문자를 이스케이프 코드라고 부르는데, 출력물을 보기 좋게 정렬하거나 그 외 특별한 용도로 자주이용된다. 몇 가지 이스케이프 코드를 정리하면 다음과 같다.

코드	설명
\n	개행 (줄바꿈)
\v	수직 탭
\t	수평 탭
\r	캐리지 리턴
\f	폼 피드
\a	벨 소리
\b	백 스페이스
\000	널문자
\\	문자 "\"
\'	단일 인용부호(')
\"	이중 인용부호(")

이중에서 활용빈도가 높은 것은 \n, \t, \\, \', \"이다. 나머지는 대부분의 프로그램에서 잘 쓰이지 않는다.

문자열 연산

파이썬에서는 문자열을 더하고 곱할 수 있다. 이것은 다른 언어에서는 쉽게 찾아 볼 수 없는 재미있는 기능이다. 우리의 생각을 그대로 반영해주는 파이썬만의 장점이라고 할 수 있다.

문자열을 더하거나 곱하는 방법에 대해 알아보기로 하자.

예 1) 문자열 합치기(Concatenation)

>>> head = "Python"
>>> tail = " is fun!"
>>> print(head + tail)
Python is fun!

예 1의 세번 째 라인을 보자. 복잡하게 생각하지 말고 눈에 보이는 대로 생각해보자. “Python"이라는 head변수와 " is fun"이라는 tail변수를 더한 것이다. 결과는 ‘Python is fun!’이다. 즉, head와 tail변수가 "+"에 의해 합쳐진 것이다.

직접 실행해보고 결과값이 제시한 것과 똑같이 나오는 지 확인해보자.

예 2) 문자열 곱하기

>>> a = "python"
>>> print(a * 2)
pythonpython

여기도 마찬가지로 "*"의 의미는 숫자 곱하기의 의미와는 다르게 사용되었다. 여기서 사용된 ‘*’는 문자열의 반복을 뜻하는 의미로 사용되었다. 굳이 예를 설명할 필요가 없을 정도로 직관적이다. "print(a * 2)"라는 문장은 a를 두번 반복해 출력하라는 뜻이다.

문자열 곱하기를 좀 더 응용해보자. 다음과 같은 소스를 에디터로 작성해 실행시켜보자.

# multistring.py

print("=" * 50)
print("My Program")
print("=" * 50)

결과값은 다음과 같이 나타날 것이다.

==================================================  
My Program  
==================================================

위와 같은 표현은 자주 사용하게 된다. 프로그램을 만들고 실행시켰을 때 출력되는 화면 제일 상단에 프로그램 제목으로 위처럼 만들면 보기 좋지 않겠는가?

인덱싱과 슬라이싱

인덱싱(indexing)이란 무엇인가를 ‘가리킨다’는 의미이고, 슬라이싱(slicing)은 무엇인가를 ‘잘라낸다’라는 의미이다. 이것들을 생각하면서 다음의 예를 따라해 보도록 하자.

>>> a = "Life is too short, You need Python"

각 문자열의 문자마다 번호를 매겨 보았다.

Life is too short, You need Python
0         1         2         3 
0123456789012345678901234567890123

즉 "Life is too short, You need Python"이라는 문자열에서 'L'은 첫 번째 자리를 뜻하는 숫자인 0을 바로 다음인 'i'는 1을 이런식으로 계속 번호를 붙인 것이다. 중간쯤에 있는 "short"의 s는 12라는 번호가 된다.

그리고 다음 예를 실행해 보자.

>>> a = "Life is too short, You need Python"
>>> a[3]
'e'

a[3] 이 뜻하는 것은 a라는 문자열의 네 번째 문자인 'e'를 말한다. 프로그래밍을 처음 접하는 독자라면 a[3]에서 3이란 숫자는 세 번째인데 왜 네 번째 문자를 말한다는 것인지 의아할 것이다.

이 부분이 사실 필자도 가끔 많이 헷갈리는 부분인데, 이렇게 생각하면 쉽게 알 수 있을 것이다.

"파이썬은 0부터 숫자를 센다"

위의 문자열을 파이썬은 이렇게 바라보고 있는 것이다.

a[0]: 'L', a[1]: 'i', a[2]: 'f', a[3]: 'e', a[4]: ' ',....

0부터 숫자를 센다는 것이 처음에는 익숙하지 않겠지만 이것도 하다 보면 자연스럽게 될 것이다. 위의 예에서 보듯이 a[3]이란 것은 문자열 내 특정한 값을 뽑아내는 역할을 해준다. 이러한 것을 인덱싱(Indexing)이라고 부른다.

몇가지를 인덱싱을 더 해 보도록 하자.

>>> a[0]
'L'
>>> a[12]
's'
>>> a[-1]
'n'

마지막의 a[-1]이 뜻하는 것은 뭘까? 눈치 빠른 독자는 이미 알겠지만 바로 문자열을 뒤에서부터 읽기 위해서 마이너스(-)기호를 붙이는 것이다. 즉 a[-1]은 뒤에서부터 세어서 첫 번째가 되는 문자를 말한다. a는 "Life is too short, You need Python"이라는 문장이므로 뒤에서부터 첫 번째 문자는 가장 마지막 문자인 'n'이 될 것이다.

뒤에서부터 첫 번째 문자를 표시 할 때 a[-0]이라고 해야 하지 않겠는가? 라는 의문이 들수도 있겠지만 잘 생각해 보자. 0과 -0은 똑같은 것이기 때문에 a[-0]이라는 것은 a[0]과 똑같은 값을 보여준다.

>>> a[-0]
'L'

계속해서 몇가지 예를 더 보자.

>>> a[-2]
'o'
>>> a[-5]
'y'

위의 첫 번째 예는 뒤에서부터 두 번째 문자를 가리키는 것이고 두 번째 예는 뒤에서부터 다섯 번째 문자를 가리키는 것이다. 그렇다면 "Life is too short, You need Python"이라는 문자열에서 단순히 한 문자만을 뽑아내는 것이 아니라 'Life'또는 'You'같은 단어들을 뽑아낼 수 있는 방법은 없을까?

다음과 같이 하면 될 것이다.

>>> b = a[0] + a[1] + a[2] + a[3]
>>> b
'Life'

위의 방법처럼 할 수도 있겠지만 파이썬에서는 보다 더 좋은 방법을 제공한다. 바로 슬라이싱(Slicing)이라는 기법이다.

위의 예는 슬라이싱 기법으로 다음과 같이 간단하게 처리할 수 있다. (주의 - 지금까지의 예제는 계속 이어지는 것이기 때문에 이미 인터프리터를 닫고 다시 시작하는 독자라면 >>> a = "Life is too short, You need Python"이라는 것을 먼저 수행한 뒤 다음의 예제들을 따라하도록 하자)

>>> a[0:4]
'Life'

a[0:4]가 뜻하는 것은 a라는 문자열 즉, "Life is too short, You need Python"이라는 문장에서 0부터 4까지의 문자를 뽑아낸다는 뜻이다. 하지만 다음과 같은 의문이 들 것이다.

a[0]은 'L', a[1]은 'i', a[2]은 'f', a[3]은 'e'이니까 a[0:3]만으로도 'Life'라는 단어를 뽑아낼 수 있지 않을까?

다음의 예를 보도록 하자.

>>> a[0:3]
'Lif'

이렇게 되는 이유는 간단하다. a[시작번호: 끝번호] 처럼 쓰면 끝번호에 해당하는 것은 포함이 되지 않는다.

a[0:3]을 수식으로 나타내면 다음과 같다.

0 <= a < 3

즉 위의 수식을 만족하는 a는 a[0], a[1], a[2] 일 것이다. 따라서 a[0:3]은 'Lif'이고 a[0:4]는 'Life'가 되는 것이다. 이 부분이 문자열 연산에서 가장 혼동하기 쉬운 부분이니 스스로 많이 연습해 보기를 바란다.

슬라이싱의 예를 조금 더 보도록 하자.

>>> a[0:5]
'Life '

위의 예는 a[0] + a[1] + a[2] + a[3] + a[4]와 동일하다. a[4]라는 것은 공백문자 ' '이기 때문에 'Life'가 아닌 'Life '가 되는 것이다. 공백문자 역시 'L', 'i' , 'f', 'e'와 동일하게 취급되는 것을 잊지 말도록 하자. 'Life'와 'Life '는 완전히 다른 문자열이다.

항상 시작번호가 '0'일 필요는 없다.

>>> a[0:2]
'Li'
>>> a[5:7]
'is'
>>> a[12:17]
'short'

a[시작번호:끝번호]에서 끝번호 부분을 생략하면 시작번호부터 그 문자열의 끝까지를 뽑아내게 된다.

>>> a[19:]
'You need Python'

a[시작번호:끝번호]에서 시작번호를 생략하면 그 문자열의 처음부터 끝번호까지 뽑아내게 된다.

>>> a[:17]
'Life is too short'

a[시작번호:끝번호]에서 시작번호와 끝번호를 생략하면

>>> a[:]
'Life is too short, You need Python'

a[시작번호:끝번호]에서 시작번호와 끝번호를 모두 생략했기 때문에 이것은 처음부터 끝까지를 말하게 되므로 위와 같은 결과를 보여주는 것이다.

슬라이싱에서 역시 인덱싱과 마찬가지로 '-'기호를 사용할 수가 있다.

>>> a[19:-7]
'You need'

a[19:-7]이 뜻하는 것은 a[19]에서부터 a[-7]까지를 말한다. 이것 역시 a[-7]은 포함하지 않는다.

자주 사용되는 슬라이싱 예

다음은 자주 사용하게 되는 슬라이싱 기법 중의 하나이다.

>>> a = "20010331Rainy"
>>> date = a[:8]
>>> weather = a[8:]
>>> date
'20010331'
>>> weather
'Rainy'

a 라는 문자열을 두 부분으로 나누는 기법이다. 동일한 숫자 '8'을 기준으로 a[:8], a[8:]처럼 사용을 하였다. a[:8]은 a[8]이 포함이 안되고 a[8:]은 a[8]을 포함하기 때문에 8을 기준으로 해서 두 부분으로 나누게 된 것이다. 위의 예에서는 "20010331Rainy" 라는 문자열을 날짜를 나타내는 부분인 '20010331'과 날씨를 나타내는 부분인 'Rainy'로 나누는 방법을 보여준다.

위의 문자열 "20010331Rainy"라는 것을 연도인 2001과 월과 일을 나타내는 0331 그리고 날씨를 나타내는 Rainy를 세 부분으로 나누려면 다음과 같이 할 수 있다.

>>> a = "20010331Rainy"
>>> year = a[:4]
>>> day = a[4:8]
>>> weather = a[8:]
>>> year
'2001'
>>> day
'0331'
>>> weather
'Rainy'

위의 예는 4와 8이란 숫자로 "20010331Rainy"라는 문자열을 세 부분으로 나누는 방법을 보여준다.

이상과 같이 인덱싱과 슬라이싱에 대해서 살펴 보았다. 인덱싱과 슬라이싱은 프로그래밍을 할 때 매우 자주 사용되는 기법이니 꼭 반복해서 연습을 해 두도록 하자.

“Pithon”이란 문자열을 “Python"으로 바꾸려면?

위의 제목과 같이 "Pithon"이란 문자열을 "Python"으로 바꾸려면 어떻게 해야 할까? 제일 먼저 떠오르는 생각은 다음과 같을 것이다.

>>> a = "Pithon"
>>> a[1]
'i'
>>> a[1] = 'y'
>

위의 예에서 보듯이 우선 a라는 변수에 "Pithon"이란 문자열을 대입하고 a[1]이란 값이 'i'니까 a[1]을 위의 예처럼 'y'로 바꾸어 준다는 생각이다. 하지만 결과는 어떻게 나올까?

당연히 에러가 나고 실패하게 될 것이다. 에러가 나는 이유는 문자열의 요소 값은 바꿀 수 있는 값이 아니기 때문이다. 왜 바꿀 수 없는가? 라는 질문을 하지는 말자. 그냥 바꿀 수 없는 것이다. 하지만 앞서 살펴보았던 슬라이싱 기법을 이용해서 "Pithon"이란 문자열을 "Python"으로 바꿀 수 있는 방법이 있다.

다음의 예를 보자.

>>> a = "Pithon"
>>> a[:1]
'P'
>>> a[2:]
'thon'
>>> a[:1] + 'y' + a[2:]
'Python'

위의 예에서 보듯이 슬라이싱을 이용해서 먼저 'Pithon'이라는 문자열을 'P'부분과 'thon'부분으로 나눌 수 있기 때문에 그 사이에 'y'라는 문자를 추가하여 'Python'이라는 문자열을 만들면 된다.

문자열 포매팅(Formatting)

문자열에서 알아야 할것으로는 또하나, 문자열 포매팅이라는 것이 있다. 이것을 공부하기에 앞서 다음과 같은 문자열을 출력하는 프로그램을 작성했다고 가정해보자.

“현재 온도는 18도입니다.”

하지만 시간이 지나서 20도가 된다면 아래와 같은 문장을 출력하는 프로그램.

“현재 온도는 20도입니다”

이러한 프로그램을 어떻게 만들 수 있는지에 대해서는 생각하지 말고 출력해주는 문자열에만 주목해 보자. 출력된 문자열은 모두 같은데 20이라는 숫자와 18이라는 숫자만이 다르다. 이렇게 문자열 내의 어떤 특정한 값을 변화시키는 것이 필요한 경우가 생기는데 이것을 가능하게 해 주는 것이 바로 문자열 포매팅 기법이다.

문자열 포매팅이란 문자열 내에 어떤 값을 삽입하는 방법이다. 다음의 예들을 따라해 보면서 그 사용법을 알아보자.

예 1) 숫자 바로 대입

>>> print("I eat %d apples." % 3)
I eat 3 apples.

위의 예제 결과 값을 보면 알겠지만 위의 예는 문자열 내에 3이라는 정수값을 삽입하는 방법을 보여준다. 삽입할 3이라는 숫자는 가장 뒤에 “%” 문자 다음에 쓰였다. 그리고 문자열 내에 3이라는 값을 넣고 싶은 자리에 "%d"라는 문자를 넣어주었다. 하지만 꼭 문자열 내에 숫자만 넣으라는 법은 없다. 이번에는 숫자 대신 문자열을 넣어 보자.

예 2)문자열 바로 대입

>>> print("I eat %s apples." % "five")
I eat five apples.

위와 예에서 보는 것과 같이 문자열 내에 또다른 문자열을 삽입하기 위해서는 앞서 사용했던 %d 가 아닌 %s를 썼음을 알 수 있다. 그렇다면 위와 같은 사실로 독자는 유추할 수 있을 것이다. 숫자를 삽입하게 위해서는 %d를 써야 하고 문자열을 삽입하기 위해서는 %s를 써야 한다는 사실을.

예 3) 숫자 변수로 대입

>>> number = 3
>>> print("I eat %d apples." % number)
I eat 3 apples.

예 1처럼 숫자를 바로 대입하나 예 3처럼 숫자값을 나타내는 변수를 대입하나 같은 결과가 나온다. 하지만 실제 프로그래밍에서 문자열 포매팅을 이용하는 대부분의 경우는 변수를 사용한다.

그렇다면 문자열 안에 한 개가 아닌 여러개의 값을 삽입하고 싶다면 어떻게 해야 할까?

예 4) 두 개 이상의 값을 치환

>>> number = 10
>>> day = "three"
>>> print("I eat %d apples. so I was sick for %s days." % (number, day))
I eat 10 apples. so I was sick for three days.

예 4처럼 두 개 이상의 값을 치환하려면 위에서 보듯이 마지막 % 다음에 ( ) 사이에 콤마로 구분하여 변수를 넣어 주어야만 한다.

문자열 포맷 코드

예 4는 대입시키는 자료형으로 정수와 문자열을 사용했지만 이 이외에도 다양한 것들을 대입시킬 수 있다. 문자열 포맷 코드로는 다음과 같은 것들이 있다.

코드	설명
%s	문자열 (String)
%c	문자 한개(character)
%d	정수 (Integer)
%f	부동소수 (floating-point)
%o	8진수
%x	16진수
%%	Literal % (문자 '%s' 자체)

여기서 재미있는 것은 %s 포맷 코드로 이것은 어떤 형태로든 변환이 가능하다. 무슨 말인지 예를 통해 확인해 보자.

>>> print("I have %s apples" % 3)
I have 3 apples
>>> print("Todays rate is %s" % 3.234)
Todays rate is 3.234

3을 문자열 내에 삽입하려면 문자열 내에 %d가 있어야 하고 3.234를 삽입하려면 문자열 내에 %f가 있어야 하지만 %s를 사용하면 이런 것을 생각하지 않아도 된다. 왜냐하면 %s는 자동으로 % 뒤의 파라미터 값을 문자열로 치환하기 때문이다. 따라서 항상 %s를 사용하면 프로그램 소스를 읽을 때 조금 헷갈리겠지만 에러는 나지 않을 것이다.

[참고] 포맷팅 연산자 %d와 %를 같이 쓸 때는 %%를

>>> print("Error is %d%." % 98)

당연히 결과값으로 "Error is 98%."가 출력될 것이라고 예상하겠지만 파이썬은 에러 메시지를 보여준다. 이유는 문자열 포맷코드인 %d 와 % 가 같은 문자열 내에 존재하면 %를 나타내기 위해서는 반드시 %%로 해야 %로 되는 법칙이 있다. 이건 꼭 기억해두어야 한다. 하지만 문자열 내에 %d 같은 포맷팅 연산자가 없으면 %는 홀로 쓰여도 상관이 없다. 따라서 위 예를 제대로 실행될 수 있게 하려면 다음과 같이 해야 한다.

>>> print("Error is %d%%." % 98)
Error is 98%.

포맷 코드의 또 다른 기능

위에서 보았듯이 %d, %s등의 포맷코드는 문자열 내에 어떤 값을 삽입하기 위해서 사용됨을 알 수 있었다. 하지만 포맷코드를 숫자와 함께 사용하면 더 유용하게 사용할 수 있다. 다음의 예를 보고 따라해 보도록 하자.

예 1) 정렬과 공백

>>> print("%10s" % "hi")
        hi
^^^^^^^^^^

즉 "%10s"의 의미는 길이가 10개인 문자열 공간에서 오른쪽으로 정렬하고 그 앞의 나머지는 공백으로 남겨 두라는 의미이다. 그렇다면 반대쪽인 왼쪽 정렬은 "%-10s"가 될 것이다.

확인해 보자.

>>> print("%-10sjane." % 'hi')
hi        jane.
^^^^^^^^^^

왼쪽으로 정렬하고 나머지는 공백으로 채웠음을 볼 수 있다.

예 2) 소숫점 표현

>>> print("%0.4f" % 3.42134234)
3.4213

즉, 3.42134234를 소수점 4번째까지만 나타내고 싶을 경우에 위와 같이 하였다. 즉 여기서 '.'의 의미는 소수점 포인트를 말하고 그 뒤의 숫자 4는 뒤에 나올 숫자의 개수를 말한다. '.'앞의 숫자는 이전의 예에서와 같이 오른쪽 또는 왼쪽 정렬을 말하는 숫자이다.

>>> print("%10.4f" % 3.42134234)
    3.4213
^^^^

위의 예는 3.42134234라는 숫자를 10개의 문자열 공간에 오른쪽으로 정렬하고 소수점은 4번째 자리까지만 표시하게 하는 예를 보여준다. 위의 예와의 차이점은 숫자를 오른쪽으로 정렬했다는 점이다. 위에서 알아본 것들은 주로 결과값을 깔끔하게 정리할 목적으로 많이 사용한다.

지금까지 문자열을 가지고 할 수 있는 일들에 대해서 대부분 알아보았지만 문자열을 가지고 할 수 있는 일들에 대해서 공부해야 할 사항들이 아직 많이 남아 있다. 지겹다면 잠시 책을 접고 휴식을 취하도록 하자.

소문자를 대문자로 바꾸기(upper)

>>> a = "hi"
>>> a.upper()
'HI'

앞서 복소수에서 복소수가 자체적으로 가지고 있는 복소수 관련함수가 있었던 것처럼 문자열 역시 자체적으로 가지고 있는 관련함수들이 몇 개 있다. 그 것들을 사용하기 위해서는 문자열 변수이름 뒤에 '.'을 붙인 다음에 관련함수 이름을 써 주면 된다. 위의 예의 upper()함수는 소문자를 대문자로 바꾸어준다. 만약 문자열이 이미 대문자라면 아무런 변화도 일어나지 않을 것이다.

문자 갯수 세기(count)

>>> a = "hobby"
>>> a.count('b')
2

문자열 중 문자 ‘b’의 개수를 반환한다.

위치 알려주기1(find)

>>> a = "Python is best choice"
>>> a.find('b')
10

문자열 중 문자 'b'가 처음으로 나온 위치를 반환한다. 만약 찾는 문자나 문자열이 존재하지 않는다면 -1을 반환한다.

위치 알려주기2(index)

>>> a = "Life is too short"
>>> a.index('t')
8

문자열 중 문자 't'가 처음으로 나온 위치를 반환한다. 만약 찾는 문자나 문자열이 존재하지 않는다면 에러를 발생시킨다. 위의 find함수와 다른 점은 없는 문자를 찾으려고 하면 에러가 발생한다는 점이다.

문자열 삽입 (join)

>>> a= ","
>>> a.join('abcd')
'a,b,c,d'

"abcd"라는 문자열의 각각의 문자사이에 변수 a의 값인 ','을 삽입한다.

대문자를 소문자로 바꾸기(lower)

>>> a = "HI"
>>> a.lower()
'hi'

대문자를 소문자로 바꾸어준다.

왼쪽 공백 지우기 (lstrip)

>>> a = " hi"
>>> a.lstrip()
'hi'

문자열중 가장 왼쪽의 연속된 공백들을 모두 지운다. 여기서 lstrip에서 'l'이 의미하는 것은 left이다.

오른쪽 공백 지우기 (rstrip)

>>> a= "hi "
>>> a.rstrip()
'hi'

문자열중 가장 오른쪽의 연속된 공백들을 모두 지운다. 여기서 rstrip에서 'r'이 의미하는 것은 right이다.

양쪽 공백 지우기 (strip)

>>> a = " hi "
>>> a.strip()
'hi'

양쪽의 연속된 공백을 모두 지운다.

문자열 바꾸기 (replace)

>>> a = "Life is too short"
>>> a.replace("Life", "Your leg")
'Your leg is too short'

replace(바뀌게 될 문자열, 바꿀 문자열)처럼 사용해서 문자열 내의 특정한 값을 다른 값으로 치환해 준다.

문자열 나누기 (split)

>>> a = "Life is too short"
>>> a.split()
['Life', 'is', 'too', 'short']
>>> a = "a:b:c:d"
>>> a.split(':')
['a', 'b', 'c', 'd']

a.split()처럼 괄호안에 아무런 값도 넣어주지 않으면 공백을 기준으로 문자열을 나누어 준다.

만약 a.split(':')처럼 괄호안에 특정한 값이 있을 경우에는 괄호안의 값을 구분자로 해서 문자열을 나누어 준다. 이 나눈 값은 리스트에 하나씩 들어가게 된다. ['Life', 'is', 'too', 'short']나 ['a', 'b', 'c', 'd']는 리스트라는 것인데 조금 후에 자세히 알아볼 것이니 너무 신경쓰지 말도록 하자.

대문자와 소문자를 서로 바꾸기(swapcase)

>>> a = "Hi man"
>>> a.swapcase()
'hI MAN'

대문자와 소문자를 서로 바꾸어 준다.

위에서 소개한 문자열 관련 함수들은 문자열 처리에서 매우 사용 빈도가 높은 것들이고 유용한 것들이다. 이 외에도 몇 가지가 더 있지만 자주 사용되는 것들은 아니다.