문자열

11. 문자열#

문자열은 여러 개의 문자와 기호를 하나로 묶어 나열한 값이며 작은 따옴표(') 또는 큰 따옴표(")로 감싸인다.

hello_python = 'Hello, Python!'

like_python = "파이썬 좋아!"

문자열을 화면에 출력하기 위해 print() 함수를 문자열과 함께 호출하면 문자열을 감싸는 따옴표는 보여주지 않는다.

print(hello_python)

Hello, Python!

print(like_python)

파이썬 좋아!

어떤 문자나 기호도 포함하지 않은 문자열 ''은 빈 문자열이라 부른다. 빈 문자열을 만드는 방법은 다음 세 가지 방법이 있다.

empty_str1 = ''
empty_str2 = ""
empty_str3 = str()

빈 문자열을 출력하면 아무 것도 보이지 않는다.

print(empty_str1)

'' vs. ' '

빈 문자열empty string '' 는 아무런 문자도 포함하지 않았기 때문에 문자열의 길이 즉, 문자열에 포함된 문자의 개수가 0이다. 반면 ' ' 는 눈에 보이지는 않지만 스페이스 여백 하나를 포함하는 문자열이며, 따라서 길이가 1이다.

C, 자바 등의 언어에서는 길이가 1인 문자열을 character 자료형으로 별도 관리하며, 보통 char 로 표기한다. 하지만 파이썬은 character 자료형을 제공하지 않는다.

11.1. 화이트 스페이스#

화이트 스페이스whitespace는 화면상 보이지 않는 여백을 가리키는 문자를 의미한다. string 모듈의 whitespace 변수가 화이트 스페이스 문자로 구성된 문자열을 가리킨다.

import string

string.whitespace

' \t\n\r\x0b\x0c'

' \t\n\r\x0b\x0c' 의 맨 왼쪽에는 스페이스 바를 한 번 누른 효과를 가리키는 여백 문자 ' '가 위치한다. 위 문자열에 포함된 기호 각각의 의미는 다음과 같다.

기호

설명

' '

스페이스space

'\t'

탭tab

'\n'

줄 변경new line

\r

캐리지 리턴carriage return

'\v' 또는 '\x0b'

수직탭vertical tab

'\f' 또는 '\x0c

폼피드form feed

이중에 스페이스, 줄 변경, 탭 세 종류의 화이트 스페이스가 가장 많이 사용되며, 다른 화이트 스페이스는 여기서는 다루지 않는다.

print(' 1\n2\t3')

 1
2	3

백슬래시 기호(\)와 원화 기호(₩)

백슬래시back slash 키 \는 키보드의 Enter 키 바로 위에 위치하는데 한글 키보드의 경우 원화 기호 키 ₩ 가 대신 자리잡고 있을 수 있다. 그리고 모니터 화면에도 사용하는 운영체제의 언어 설정에 따라 원화 기호(₩)와 백슬래시 기호(\) 둘 중에 하나로만 보인다. 하지만 단순한 언어 설정의 차이일 뿐 기능은 동일하다. 참고로 현재 강의노트는 우분투 리눅스 운영체제에서 작성되었기에 원화 기호 대신 백슬래시 기호로 표현된다.

11.2. 이스케이프 시퀀스#

큰따옴표로 감싸인 문자열에 작은따옴표가 포함될 수 있다. 이는 큰따옴표를 이용한 문자열의 시작과 끝이 작은따옴표가 포함되었음에도 불구하고 명확하기 때문이다.

fan_python = "I'am a fan of python"
print(fan_python)

I'am a fan of python

동일한 이유로 작은따옴표로 감싸인 문자열이 큰따옴표를 포함할 수 있다.

me_too = '나도 "그렇다" 라고 답했다.'
print(me_too)

나도 "그렇다" 라고 답했다.

반면에 큰따옴표로 감싸진 문자열에 큰따옴표를, 작따옴표로 감싸진 문자열에 작은따옴표를 그냥 사용할 수는 없다. 이유는 문자열의 끝이 명확하지 않기 때문이다.

fan_python_1 = 'I'am a fan of python'

  Cell In[12], line 1
    fan_python_1 = 'I'am a fan of python'
                                        ^
SyntaxError: unterminated string literal (detected at line 1)

me_too_1 = "나도 "그렇다" 라고 답했다."

  Cell In[13], line 1
    me_too_1 = "나도 "그렇다" 라고 답했다."
                    ^
SyntaxError: invalid syntax

위와 같은 오류를 방지하기 위해 문자열을 감싸는 문자열과 포함된 문자열을 항상 다르게 할 수는 없다. 예를 들어 아래의 경우처럼 큰따옴표와 작은 따옴표가 모두 사용되는 경우가 그렇다.

"I've also said "yes"!"

또는

'I've also said "yes"!'

이런 경우엔 이스케이프 문자를 사용한다. 이스케이스 문자escape character는 문자와 기호의 원래 기능과는 다르게 작동하도록 하는 문자열이다. 모든 이스케이프 문자는 백슬래시 기호 \ (또는 원화 기호 ₩)로 시작하며 다음 이스케이프 문자가 많이 사용된다.

이스케이프 문자

의미

\'

작은따옴표

\"

큰따옴표

\\

백슬래시(원화) 기호

\n

줄바꿈

\t

탭추가

인용부호 활용

이스케이프 문자를 이용하면 큰따옴표와 작은따옴표를 제한없이 활용할 수 있다. print() 함수는 또한 이스케이프 문자의 기능을 적절히 반영해서 화면에 출력한다.

said_yes_1 = "I\'ve also said \"yes\"!"
print(said_yes_1)

I've also said "yes"!

said_yes_2 = 'I\'ve also said \"yes\"!'
print(said_yes_2)

I've also said "yes"!

백슬래시(원화) 기호

백슬래시(원화) 기호를 이스케이프 문자의 기능이 아닌 백슬래시(원화) 기호 자체로 문자열에 포함시키고자 할 때는 백슬래시(원화) 기호를 두 번 연속 사용한다.

using_backslash = '백슬래시(원화) 기호 \\는 이스케이프 문자를 만들 때 사용함.'

\\에서 첫째 백슬래시(원화) 기호는 이스케이프 기능으로, 둘째 백슬래시(원화) 기호는 백슬래시(원화) 기호 자체로 이해된다.

print(using_backslash)

백슬래시(원화) 기호 \는 이스케이프 문자를 만들 때 사용함.

줄바꿈

\n은 줄바꿈을 의미하는 이스케이프 문자다.

two_lines = '첫째줄\n둘째줄.'

print() 함수를 이용하면 실제 의도한 대로 두 줄로 표현된다.

print(two_lines)

첫째줄
둘째줄.

탭 추가

\t는 두 문자열 사이에 탭을 추가하는 이스케이프 문자다. 탭은 보통 네 개의 스페이스키를 누르는 것에 해당한다.

using_tabs = '하나\t둘\t셋'

print() 함수를 이용하면 탭이 두 번 사용되었음을 확인할 수 있다.

print(using_tabs)

하나	둘	셋

날 문자열

특수 문자에 대해 백슬래시(원화) 기호를 사용할지 여부를 고민하는 대신 많은 경우 날 문자열raw string을 사용할 수도 있다. 문자열 앞에 가공되지 않았다 라는 의미를 뜻하는 영어 단어 raw 의 첫 글자인 r을 추가하면 날 문자열이 된다. 날 문자열은 특수 문자들의 기능을 모두 무시한다.

print(r"Hello\ World")

Hello\ World

print(r"Hello\n World")

Hello\n World

print(r"Hello\t World")

Hello\t World

날 문자열은 특히 파일과 폴더의 경로를 작성할 때 유용하다.

  • 일반 문자열: 특수 문자의 기능 유지

print('C:\some\name')

C:\some
ame

  • 날 문자열 사용: 특수 문자 기능 없음

print(r'C:\some\name')

C:\some\name

11.3. 문자열 포매팅#

문자열 포매팅string formatting은 문자열 내부에 표현식을 사용할 수 있도록 한다. 문자열 포매팅을 처리하는 여러 방식이 있지만 여기서는 가장 편리한 방법인 f-문자열f-string을 활용법만 소개한다.

f-문자열

f-문자열은 문자열 앞에 f를 붙이며, 문자열 중간에 중괄호 {}로 감싸인 표현식을 사용할 수 있다. 예를 들어, 아래 코드는 name과 age 두 변수를 이용한 표현식을 문자열에 포함시킨다. 그러면 name과 age 가 가리키는 값에 따라 다른 문자열이 지정된다.

name = '강현'
age = 3
s = f'{name}의 나이는 {age}살이다.'
print(s)

s1 = f'{name}의 동생은 {age - 2}살이다'
print(s1)

강현의 나이는 3살이다.
강현의 동생은 1살이다

name = '정우'
age = 10
s = f'{name}의 나이는 {age}살이다.'
print(s)

s1 = f'{name}의 동생은 {age - 2}살이다'
print(s1)

정우의 나이는 10살이다.
정우의 동생은 8살이다

문자열 좌우 정렬 출력

출력되는 문자열이 차지하는 총 길이를 지정하고 좌우로 정렬할 수 있다. 길이가 다른 여러 개의 문자열을 출력할 때 매우 유용하다. 아래 코드는 총 10칸의 자리를 이용할 때 길이가 2인 문자열을 좌, 우, 중앙에 위치시키는 방법을 소개한다.

s1 = 'hi'
s2 = 'hello'

  • 왼쪽으로 정렬

print(f'{s1:<10}')
print(f'{s2:<10}')

hi        
hello

  • 오른쪽으로 정렬

print(f'{s1:>10}')
print(f'{s2:>10}')

        hi
     hello

  • 중앙에 정렬

print(f'{s1:^10}')
print(f'{s2:^10}')

    hi    
  hello

정렬 후 남은 빈 자리를 지정된 문자로 채울 수 있다.

  • + 기호로 채우기

print(f'{s1:+<10}')
print(f'{s2:+<10}')

hi++++++++
hello+++++

  • 0 기호로 채우기

print(f'{s1:0>10}')
print(f'{s2:0>10}')

00000000hi
00000hello

  • - 기호로 채우기

print(f'{s1:-^10}')
print(f'{s2:-^10}')

----hi----
--hello---

부동소수점 자릿수 지정

부동소수점의 소수점 이하 자릿수를 지정하려면 {표현식:.1f} 와 같은 형식을 사용한다.

num1 = 17.153742
num2 = 2.778

print(f'소수점 둘째 자리에서 반올림: {num1:.1f}')
print(f'소수점 둘째 자리에서 반올림: {num2:.1f}')

소수점 둘째 자리에서 반올림: 17.2
소수점 둘째 자리에서 반올림: 2.8

print(f'소수점 셋째 자리에서 반올림: {num1:.2f}')
print(f'소수점 셋째 자리에서 반올림: {num2:.2f}')

소수점 셋째 자리에서 반올림: 17.15
소수점 셋째 자리에서 반올림: 2.78

print(f'소수점 넷째 자리에서 반올림: {num1:.3f}')
print(f'소수점 넷째 자리에서 반올림: {num2:.3f}')

소수점 넷째 자리에서 반올림: 17.154
소수점 넷째 자리에서 반올림: 2.778

전체 자릿수를 지정하려면 {표현식:15.2f} 와 같은 형식을 사용한다.

print(f'총 15칸을 차지할 때: {num1:15.2f}')
print(f'총 15칸을 차지할 때: {num2:15.2f}')

총 15칸을 차지할 때:           17.15
총 15칸을 차지할 때:            2.78

좌우 정렬, 기호로 채우기 등도 가능하다.

print(f'총 15칸 사용: {num1:<15.5f}')
print(f'총 15칸 사용: {num2:<15.5f}')

총 15칸 사용: 17.15374       
총 15칸 사용: 2.77800        

print(f'총 15칸 사용: {num1:0<15.5f}')
print(f'총 15칸 사용: {num2:0<15.5f}')

총 15칸 사용: 17.153740000000
총 15칸 사용: 2.7780000000000

print(f'총 15칸 사용: {num1:^15.5f}')
print(f'총 15칸 사용: {num2:^15.5f}')

총 15칸 사용:    17.15374    
총 15칸 사용:     2.77800    

print(f'총 15칸 사용: {num1:-^15.5f}')
print(f'총 15칸 사용: {num2:-^15.5f}')

총 15칸 사용: ---17.15374----
총 15칸 사용: ----2.77800----

print(f'총 15칸 사용: {num1:>15.5f}')
print(f'총 15칸 사용: {num2:>15.5f}')

총 15칸 사용:        17.15374
총 15칸 사용:         2.77800

print(f'총 15칸 사용: {num1:+>15.5f}')
print(f'총 15칸 사용: {num2:+>15.5f}')

총 15칸 사용: +++++++17.15374
총 15칸 사용: ++++++++2.77800

11.4. 문자열 연산#

+와 * 연산자

연산자

의미

+

이어붙이기

*

복제 후 이어붙이기

+ 연산자는 두 문자열을 이어붙인다.

'hello' + 'python'

'hellopython'

'hello, ' + 'python'

'hello, python'

* 연산자는 정수와 문자열을 인자로 받아 정수 만큼 복제해서 이어붙인다.

3 * 'hello'

'hellohellohello'

2 * 'hello, ' + "python"

'hello, hello, python'

in 연산자

문자열의 일부로 포함된 부분 문자열인지 여부를 판단하는 논리 연산자이다.

'app' in 'apple'

True

'h' in 'banana' 

False

'ca' not in 'coconut'

True

빈 문자열과 함께 in 연산자를 사용하면 항상 거짓이 된다.

'a' in ""

False

'b' in str()

False

크기 비교 연산

두 문자열의 크기비교는 사전식 알파벳 순서를 사용한다. 대문자가 소문자보다 작음에 주의한다.

'A' <= 'a'

True

'apple' < 'Hello, World!'

False

'Hello, World!' < ' hello'

False

빈 문자열은 다른 문자열보다 항상 작다.

'' < 'a'

True

len() 함수

문자열의 길이, 즉 문자열에 포함된 기호의 개수를 반환한다.

len('apple')

5

len('hello, world!')

13

화이트 스페이스는 모두 하나의 기호로 간주된다.

import string

whites = string.whitespace
whites

' \t\n\r\x0b\x0c'

len('whites')

6

빈 문자열의 길이는 0이다.

len('')

0

11.5. 순차 자료형: 문자열#

문자열은 포함된 문자와 기호의 순서를 중요하게 여기는 순차 자료형sequence type이다. 따라서 문자열의 항목으로 포함된 문자와 기호의 순서가 다르거나 사용된 문자열의 길이가 다르면 서로 다른 문자열로 처리된다.

'ab' == 'ba'

False

'aa' == 'aaa'

False

대소문자도 구별된다.

"python" == "Python"

False

11.5.1. 문자열 인덱싱#

문자열은 문자 여러 개의 나열이며 문자들 사이의 순서가 중요하다. 이때 문자열 왼편에 위치한 문자부터 차례대로 0, 1, 2, 3 등의 인덱스index를 부여받는다. 인덱싱indexing은 인덱스를 이용하여 문자열의 항목을 확인하는 기능이다.

colors = 'red, blue, yellow'

  • 0 번 인덱스 값

colors[0]

'r'

  • 3 번 인덱스 값

colors[3]

','

인덱스를 문자열 오른쪽에서부터 차례대로 -1, -2, -3 등 음수로 지정할 수도 있다.

colors[-1] # 오른쪽 끝에 위치한 문자

'w'

colors[-2] # 오른쪽 끝에서 두 번째 문자

'o'

문자열의 길이에 따라 사용할 수 있는 인덱스의 기간이 정해진다. colors 변수가 가리키는 문자열은 길이가 17이기에 0부터 16까지의 정수 또는 -1부터 -17까지의 정수를 인덱스로 사용할 수 있다.

len(colors)

17

-17보다 작거나 16보다 큰 경우 IndexError 오류가 발생한다.

colors[50]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[79], line 1
----> 1 colors[50]

IndexError: string index out of range

colors[-20]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[80], line 1
----> 1 colors[-20]

IndexError: string index out of range

11.5.2. 문자열 슬라이싱#

인덱스의 특정 구간에 해당하는 부분 문자열을 확인하려 할 때는 슬라이싱slicing을 사용한다. 슬라이싱은 다음과 같이 실행한다.

문자열[시작인덱스:끝인덱스:보폭]

시작과 끝은 슬라이싱 구간의 시작과 끝 인덱스를 가리키며 보폭은 항목 선택 규칙을 의미한다.

  • 시작인덱스 : 시작 인덱스부터 문자 확인

  • 끝인덱스 : 끝 인덱스 이전까지의 문자 확인

  • 보폭: 시작 인덱스부터 몇 보폭씩 건너뛰며 문자를 추출할지 결정. 보폭의 크기가 1이면 생략 가능.

colors에서 red를 추출하고 싶다면 다음과 같이 하면 된다. 이유는 r의 인덱스는 0이고, d의 인덱스는 2이기 때문이다.

colors = 'red, blue, yellow'

colors[0:3]

'red'

보폭을 1로 지정해도 동일한 결과를 얻는다.

colors[0:3:1]

'red'

colors에서 5번 인덱스의 문자인 b부터 끝까지 하나씩 건너 뛰면서 추출하려면 다음과 같이 하면 된다.

colors[5:len(colors):2]

'bu,ylo'

양의 정수와 음의 정수를 섞어서 인덱스로 사용할 수 있다. -1은 오른쪽 끝의 문자를 가리키는 인덱스임에 주의한다.

colors[5:-1:2]

'bu,ylo'

슬라이싱 인덱스의 기본값

시작인덱스, 끝인덱스, 보폭 각각의 인자는 경우에 따라 생략될 수도 있다. 그럴 때는 다음과 같이 지정된 기본값이 적용된다.

  • 시작인덱스의 기본값 : 0

  • 끝인덱스의 기본값 : 문자열의 길이

  • 보폭의 기본값 : 1

  • colors[0:3:1]

colors[:3:]

'red'

보폭을 생략할 떄는 둘 째 콜론(:)도 함께 생략할 수 있다.

  • colors[0:3]

colors[:3]

'red'

  • colors[5:len(colors):2]

colors[5::2]

'bu,ylo'

슬라이싱 인덱스의 범위

문자열의 인덱스 범위를 벗어나는 값으로 슬라이싱을 실행해도 오류가 발생하지 않는다. 대신 문자열의 좌 또는 우 끝까지만 슬라이싱이 적용된다.

colors[-30:100]

'red, blue, yellow'

colors[5:100:3]

'beyl'

역순 슬라이싱

슬라이싱은 기본적으로 작은 인덱스에서 큰 인덱스 방향으로 확인한다. 하지만 보폭을 음의 정수로 지정하면 역순으로 항목을 확인한다. 역순으로 슬라이싱을 지정하려면 시작인덱스가 끝인덱스보다 크면 된다.

colors[-2:-8:-3]

'oe'

보폭이 -1이고, 시작 인덱스와 끝 인덱스를 생략하면 문자열 전체를 역순으로 확인한다.

colors[::-1]

'wolley ,eulb ,der'

11.5.3. 불변 자료형: 문자열#

문자열은 불변immutable 자료형이다. 즉, 한 번 생성된 문자열은 수정할 수 없다. 따라서 인덱싱 또는 슬라이싱을 사용하여 값의 일부를 변경하려 시도하면 수정을 허용하지 않는 자료형을 수정하려 시도한다는 의미에서 TypeError가 발생한다.

예를 들어 아래 코드는 소문자 h를 인덱싱을 이용하여 대문자 H로 수정하려 하지만 허용되지 않는다.

word = 'hello'
word[0] = 'H'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[92], line 2
      1 word = 'hello'
----> 2 word[0] = 'H'

TypeError: 'str' object does not support item assignment

소문자를 대문자로 교체하는 일이 허용되지 않지만 주어진 문자열을 이용하여 새로운 문자열을 생성하는 방식으로 원하는 모양의 문자열을 생성할 수 있다. 이를 위해 문자열 인덱싱과 슬라이싱, 그리고 문자열 연산을 활용한다.

예를 들어 대문자 H로 시작하는 Hello를 word 변수를 이용하여 다음과 같이 생성할 수 있다.

'H' + word[1:]

'Hello'

11.6. 문자열 메서드#

문자열 자료형에만 사용하는 함수들이 있다. 이와같이 특정 자료형에만 사용하는 함수들을 메서드method라 부른다. 메서드는 일반적인 함수와는 달리 특정 자료형의 값을 먼저 언급하고 바로 이어서 점(.)을 찍은 다음 호출한다.

문자열 자료형은 다양한 메서드를 제공한다. 여기서는 아래 메서드의 기능만 살펴 본다.

Table 11.1 문자열 주요 메서드#

기능

메서드

설명

탐색

count()

지정된 문자열이 등장한 횟수 반환

find()

지정된 문자열이 시작하는 인덱스 반환. 지정된 문자열이 없다면 -1 반환

index()

지정된 문자열이 시작하는 인덱스 반환. 지정된 문자열이 없다면 오류 발생

startswith()

지정된 문자열로 시작하는지 여부 판단

endswith()

지정된 문자열로 끝나는지 여부 판단

소문자/대문자

lower()

모든 영어 알파벳을 소문자로 바꾼 문자열 반환

upper()

모든 영어 알파벳을 대문자로 바꾼 문자열 반환

교체/삭제

replace()

지정된 부분 문자열이 다른 문자열로 교체된 문자열 반환

strip()

양끝에서 지정된 모든 문자가 최대한 많이 삭제된 문자열 반환.

쪼개기/결합

split()

문자열을 쪼개서 생성된 부분 문자열들로 구성된 리스트 반환.

join()

여러 개의 문자열을 결합해서 생성한 문자열 반환

11.6.1. 탐색#

아래 문자열을 이용하여 먼저 탐색과 관련된 메서드의 기능을 살펴 본다.

words = " \tMy life is so so cool! \n"

count() 메서드

인자로 지정된 문자열이 몇 번 등장하는지를 확인한다. 예를 들어 'so' 문자열은 words에 두 번 등장한다.

words.count('so')

2

반면에 'soo' 문자열은 words 문자열에 등장하지 않는다.

words.count('soo')

0

find() 메서드

지정된 문자열이 처음 시작하는 곳의 인덱스를 확인한다. 예를들어, 'cool' 문자열은 words 문자열의 13 번 인덱스부터 시작한다.

words.find('cool')

19

등장하지 않으면 -1을 반환한다. 예를 들어 'col' 문자열은 words 문자열에 등장하지 않는다.

words.find('col')

-1

index() 메서드

지정된 문자열이 처음 시작하는 곳의 인덱스를 확인한다. 'cool' 문자열은 words 문자열의 13 번 인덱스부터 시작한다.

words.index('cool')

19

등장하지 않으면 오류가 발생한다. 예를 들어 'col' 문자열은 words 문자열에 등장하지 않는다.

words.index('col')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[100], line 1
----> 1 words.index('col')

ValueError: substring not found

startswith() 메서드

지정된 문자열로 시작하는지 여부를 판정한다. 예를 들어 words 문자열은 ' \tMy' 문자열로 시작한다.

words.startswith(' \tMy')

True

반면에 'My' 문자열로 시작하진 않는다.

words.startswith('My')

False

endswith() 메서드

지정된 문자열로 끝나는지 여부를 판정한다. 예를 들어 words 문자열은 'cool!' 문자열로 끝나지 않는다.

words.endswith('cool!')

False

대신 'cool! \n' 문자열로 끝난다.

words.endswith('cool! \n')

True

11.6.2. 문자열 생성#

지금부터 언급되는 메서드는 word 문자열 자체를 수정하는 게 아니라 새로운 문자열을 생성한다. 앞서 언급한 대로 문자열 자체는 수정될 수 없음에 주의한다.

words = " \tMy life is so so cool! \n"

lower() 메서드

모든 영어 알파벳을 소문자로 변경한 문자열을 반환한다. 예를 들어 아래 코드는 word 문자열에 포함된 모든 문자열을 소문자로 변경한 문자열을 생성한다.

words.lower()

' \tmy life is so so cool! \n'

upper() 메서드

모든 영어 알파벳을 소문자로 변경한 문자열을 반환한다. 예를 들어 아래 코드는 word 문자열에 포함된 모든 문자열을 대문자로 변경한 문자열을 생성한다.

words.upper()

' \tMY LIFE IS SO SO COOL! \n'

replace() 메서드

지정된 부분 문자열이 지정된 다른 문자열로 교체된 문자열을 반환한다. 예를 들어 아래 코드는 word 문자열에 포함된 so 문자열을 모두 that 으로 변경한 문자열을 생성한다.

words.replace('so', 'that')

' \tMy life is that that cool! \n'

strip() 메서드

인자를 지정하지 않으면 문자열 양끝에 위치한 모든 화이트 스페이스를 삭제한 문자열을 반환한다.

words_stripped = words.strip()
words_stripped

'My life is so so cool!'

새로운 문자열을 생성하는 메서드에 다른 문자열 메서드를 연속해서 적용할 수도 있다. 예를 들어, 아래 코드는 문자열 양끝에서 화이트 스페이스를 제거하면 'My'로 시작함을 확인해준다.

words.strip().startswith('My')

True

인자 문자열을 지정하면 인자에 포함된 모든 기호를 문자열 양끝에서 최대한 많이 삭제한 문자열을 반환한다. 아래 코드는 양끝에서 공백 ' ', 탭 '\t', 줄바꿈 '\n', 느낌표 '!', 소문자 와이 'y', 대문자 엠 'M'을 최대한 많이 삭제한다.

words.strip(' \t\n!yM')

'life is so so cool'

split() 메서드

인자를 지정하지 않으면 공백 기준으로 쪼갠 문자열들로 구성된 리스트를 반환한다. 이 과정에서 문자열 양끝에 있는 화이트 스페이스는 모두 제거된다.

words.split()

['My', 'life', 'is', 'so', 'so', 'cool!']

문자열을 인자로 지정하면 해당 문자열을 기준으로 쪼개진 단어들의 리스트를 생성한다. 예를 들어 아래 문자열은 단어들 사이에 하이픈 "-"이 위치한다.

hyphen_words = 'My-life-is-so-so-cool!'

위 문자열을 "-"을 기준으로 쪼개면 다음과 같다.

hyphen_words.split("-")

['My', 'life', 'is', 'so', 'so', 'cool!']

join() 메서드

여러 개의 문자열을 결합한다. 인자로 문자열을 포함하여 문자열로 구성된 리스트, 튜플 등이 사용된다. join() 메서드를 호출하는 문자열은 지정된 항목들을 이어붙이는 연결고리 역할을 수행한다.

예를 들어 아래 코드는 hello 문자열에 포함된 모든 문자열들 사이에 별표 기호를 추가하여 새로운 문자열을 생성한다.

'*'.join('hello')

'h*e*l*l*o'

문자열로 구성된 리스트가 인자로 사용되면 항목으로 포함된 모든 문자열을 결합한다. 예를 들어 아래 코드는 하이픈을 공백으로 대체하여 정상적인 문자열을 생성한다.

words_splitted = hyphen_words.split("-")
words_splitted

['My', 'life', 'is', 'so', 'so', 'cool!']

' '.join(words_splitted)

'My life is so so cool!'

아래처럼 한 줄 표현식도 가능하다.

' '.join(hyphen_words.split("-"))

'My life is so so cool!'

11.7. 필수 예제#

참고: (필수 예제) 문자열

11.8. 연습문제#

참고: (실습) 문자열

Contents