자료구조

자료구조(data structure)는 기본적으로 자료(data)를 함께 담을 수 있는 구조(structure)를 말합니다. 다시 말해, 관련된 데이터의 모음을 저장하는 데 사용됩니다.

파이썬에는 리스트(list), 튜플(tuple), 딕셔너리(dictionary), 세트(set)라는 4가지 내장 자료구조가 있습니다. 이번 장에서는 각 자료구조를 어떻게 사용하고 어떻게 프로그래머의 삶을 편리하게 만들어주는지 알아보겠습니다.

리스트

리스트(list)는 순서가 있는 항목의 모음을 담은 자료구조입니다. 즉, 리스트에는 순차적으로 나열된 항목들을 보관할 수 있습니다. 구매해야 할 품목의 목록이 담긴 쇼핑 목록을 생각하면 쉽게 상상할 수 있습니다. 이때 실제 쇼핑 목록과 다른 점은 쇼핑 목록에는 한 줄에 하나씩 각 항목을 나열하지만 파이썬에서는 각 항목 사이에 콤마를 둬서 구분한다는 것입니다.

파이썬에서 리스트를 만들려면 항목의 목록을 대괄호([])로 감싸야 합니다. 리스트를 만들고 나면 항목을 추가, 제거, 검색할 수 있습니다. 항목을 추가하거나 제거할 수 있기 때문에 리스트를 가변 데이터 타입이라 합니다. 즉, 리스트 같은 타입은 변경 가능합니다.

객체와 클래스에 대한 간단 소개

지금껏 객체와 클래스에 대한 논의를 미뤄왔는데 지금 당장은 리스트를 좀 더 잘 이해할 수 있도록 조금 설명할 필요가 있습니다. 이 주제에 대해서는 이후 장에서 자세히 살펴보겠습니다.

리스트는 객체와 클래스를 사용하는 한 가지 예입니다. i라는 변수를 사용하고, 여기에 값, 가령 5를 할당한다고 했을 때 이를 int라는 클래스(타입)의 객체(인스턴스) i를 생성하는 것으로 생각해도 됩니다. 사실 이를 더 잘 이해하려면 help(int)를 실행해 읽어봐도 됩니다.

클래스는 메서드(method), 즉 해당 클래스에 대해서만 사용하도록 정의된 함수도 가질 수 있습니다. 이러한 기능 조각은 해당 클래스의 객체가 있을 때만 이용할 수 있습니다. 예를 들어, 파이썬에서는 list 클래스에 대해 리스트 끝에 항목을 하나 추가할 수 있는 append 메서드를 제공합니다. 예를 들어, mylist.append('an item')를 실행하면 mylist 리스트에 해당 문자열이 추가됩니다. 객체의 메서드에 접근하기 위해 점 표기법을 사용한다는 점에 유의하세요.

클래스는 해당 클래스에 대해서만 사용하도록 정의된 필드(field)도 가질 수 있습니다. 이러한 변수/이름은 해당 클래스의 객체가 있을 때만 이용할 수 있습니다. 필드에도 점 표기법을 통해 접근합니다(예: mylist.field).

예제(ds_using_list.py):

# 다음은 쇼핑 목록입니다
shoplist = ['apple', 'mango', 'carrot', 'banana']

print('I have', len(shoplist), 'items to purchase.')

print('These items are:', end=' ')
for item in shoplist:
    print(item, end=' ')

print('\nI also have to buy rice.')
shoplist.append('rice')
print('My shopping list is now', shoplist)

print('I will sort my list now')
shoplist.sort()
print('Sorted shopping list is', shoplist)

print('The first item I will buy is', shoplist[0])
olditem = shoplist[0]
del shoplist[0]
print('I bought the', olditem)
print('My shopping list is now', shoplist)

출력 결과:

$ python ds_using_list.py
I have 4 items to purchase.
These items are: apple mango carrot banana
I also have to buy rice.
My shopping list is now ['apple', 'mango', 'carrot', 'banana', 'rice']
I will sort my list now
Sorted shopping list is ['apple', 'banana', 'carrot', 'mango', 'rice']
The first item I will buy is apple
I bought the apple
My shopping list is now ['banana', 'carrot', 'mango', 'rice']

동작 원리

shoplist 변수는 어떤 사람의 쇼핑 목록입니다. shoplist에서는 구입하려는 품목의 이름을 나타내는 문자열만 저장하지만 리스트에는 숫자 또는 심지어 다른 리스트 같은 어떤 종류의 객체도 추가할 수 있습니다.

또한 예제에서는 for..in 문을 이용해 리스트의 각 항목을 순회했습니다. 지금쯤이면 리스트 또한 시퀀스의 일종이라는 점을 깨달았을 것입니다. 시퀀스의 특징은 이후 절에서 살펴보겠습니다.

print 함수를 호출할 때 end 매개변수를 사용해 출력 결과의 끝에 일반적인 줄바꿈이 아닌 공백을 출력한 것을 눈여겨봅시다.

다음으로 앞에서 이미 살펴본 리스트 객체의 append 메서드를 이용해 항목을 하나 추가합니다. 그런 다음, 전달된 항목을 깔끔하게 출력하는 print 함수에 리스트를 전달해 리스트의 내용을 출력해 보면서 새로 추가한 항목이 실제로 추가됐는지 확인합니다.

그러고 나서 리스트의 sort 메서드를 이용해 리스트를 정렬합니다. 중요한 것은 이 메서드는 리스트 자체를 변경하고 변경된 리스트를 반환하지 않는다는 점입니다. 이것은 문자열이 동작하는 방식과 다릅니다. 즉, 리스트는 가변적(mutable)이고 문자열은 불변적(immutable)이라는 것입니다.

다음으로 쇼핑 목록의 품목을 구입하고 나면 리스트에서 해당 항목을 제거하고 싶습니다. del 문을 이용해 이를 처리합니다. 여기서는 리스트에서 어떤 항목을 제거하고 싶은지 언급하고, del 문에서는 해당 항목을 리스트에서 제거합니다. 예제에서는 첫 번째 항목을 리스트에서 제거하고 싶으므로 del shoplist[0]을 사용합니다(파이썬에서는 숫자를 0부터 센다는 점을 기억하세요).

리스트 객체에 정의된 모든 메서드를 알고 싶다면 help(list)를 통해 자세한 내용을 확인하세요.

튜플

튜플(tuple)은 여러 객체를 함께 담는 데 사용합니다. 튜플은 리스트와 비슷하지만 리스트 클래스만큼 폭넓은 기능을 제공하지 않습니다. 튜플의 한 가지 주요 특징은 문자열처럼 불변적이라는 것입니다. 즉, 튜플은 변경할 수 없습니다.

튜플은 괄호 쌍 안에 각 항목을 콤마로 구분해서 지정하는 방식으로 정의합니다(참고로 괄호는 선택사항입니다).

보통 튜플은 어떤 문장이나 사용자가 정의한 함수에서 값의 모음(즉, 값의 튜플)이 확실히 변경되지 않으리라 전제할 수 있는 경우에 사용됩니다.

예제(ds_using_tuple.py):

# 괄호를 반드시 써야 하는 것이 아니더라도
# 항상 괄호를 써서 튜플의 시작과 끝을
# 나타내는 방법을 권장합니다.
# 명시적인 것이 암묵적인 것보다 낫습니다.
zoo = ('python', 'elephant', 'penguin')
print('Number of animals in the zoo is', len(zoo))

new_zoo = 'monkey', 'camel', zoo    # parentheses not required but are a good idea
print('Number of cages in the new zoo is', len(new_zoo))
print('All animals in new zoo are', new_zoo)
print('Animals brought from old zoo are', new_zoo[2])
print('Last animal brought from old zoo is', new_zoo[2][2])
print('Number of animals in the new zoo is',
      len(new_zoo)-1+len(new_zoo[2]))

출력 결과:

$ python ds_using_tuple.py
Number of animals in the zoo is 3
Number of cages in the new zoo is 3
All animals in new zoo are ('monkey', 'camel', ('python', 'elephant', 'penguin'))
Animals brought from old zoo are ('python', 'elephant', 'penguin')
Last animal brought from old zoo is penguin
Number of animals in the new zoo is 5

동작 원리

zoo 변수는 항목의 튜플을 가리킵니다. len 함수를 이용해 튜플의 길이를 구할 수 있다는 사실을 확인할 수 있습니다. 이것은 튜플 또한 시퀀스라는 점을 나타냅니다.

이제 기존 동물원은 폐쇄되므로 동물들을 새로운 동물원으로 옮깁니다. 따라서 new_zoo 튜플에는 원래 있던 동물들과 함께 폐쇄된 동물원에서 데려온 동물들까지 담습니다. 실제로 어떻게 처리되는지 살펴보면 튜플 내의 튜플은 원래 형태를 그대로 유지합니다.

리스트에서 했던 것과 마찬가지로 대괄호 안에 항목의 위치를 지정해서 튜플 내 항목에 접근할 수 있습니다. 이를 인덱싱(indexing) 연산자라 합니다. 예제에서는 new_zoo[2]를 지정해 new_zoo의 세 번째 항목에 접근하고, new_zoo[2][2]를 지정해 new_zoo 튜플의 세 번째 항목인 튜플의 세 번째 항목에 접근합니다. 이 같은 사용법만 이해하고 나면 인덱싱은 꽤나 간단합니다.

0개 또는 1개의 항목을 담은 튜플

빈 튜플은 myempty = ()처럼 빈 괄호를 지정해 만들 수 있습니다. 하지만 항목이 하나인 튜플을 만드는 것은 그리 간단하지 않습니다. 항목이 하나인 튜플을 만들려면 첫 번째(그리고 유일한) 항목 다음에 콤마를 사용해 파이썬에게 그것이 튜플인지 아니면 표현식 내에서 객체를 괄호로 감싼 것에 불과한지를 구분할 수 있게 해야 합니다. 즉, 2라는 항목이 하나 담긴 튜플을 만들고 싶다는 것을 나타내려면 singleton = (2 , )라고 작성해야 합니다.

펄 프로그래머를 위한 메모

리스트 안의 리스트는 원래 형태를 그대로 유지합니다. 즉, 펄에서는 리스트가 풀어지지만 파이썬에서는 그렇지 않습니다. 이 같은 규칙은 튜플 안의 튜플, 또는 리스트 안의 튜플, 또는 튜플 안의 리스트 등에도 동일하게 적용됩니다. 파이썬에서는 객체가 다른 객체를 이용해 저장된 것에 불과합니다.

딕셔너리

딕셔너리(dictionary)는 어떤 사람의 이름만 알고 있는 상태에서 그 사람의 주소나 자세한 연락처 정보를 찾을 수 있는 주소록과 같습니다. 즉, 키(이름)와 값(자세한 연락처 정보)을 연관시키는 것입니다. 이때 키는 반드시 유일해야 하는데, 이는 어떤 두 사람의 이름이 정확히 같을 경우 올바른 정보를 찾을 수 없는 것과 마찬가지입니다.

딕셔너리의 키에는 불변 객체(문자열 같은)만 사용할 수 있는 반면 딕셔너리의 값에는 가변 객체나 불변 객체를 사용할 수 있다는 데 주의합니다. 이것은 기본적으로 키에는 단순 객체만 사용해야 한다는 것을 의미합니다.

키와 값의 쌍은 d = {key1 : value1, key2 : value2 } 같은 표기법을 이용해 딕셔너리에 지정합니다. 참고로 키와 값은 콜론으로 구분하고, 각 키-값 쌍 자체는 콤마로 구분하고, 이 모든 것들을 중괄호({})로 감쌉니다.

딕셔너리의 키-값 쌍에는 순서가 없습니다. 어떤 순서를 지정하고 싶다면 키-값 쌍을 사용하기 전에 직접 정렬해야 할 것입니다.

파이썬에서 사용하게 될 딕셔너리는 dict 클래스의 인스턴스/객체입니다.

예제(ds_using_dict.py):

# 'ab'는 주소록('a'ddress 'b'ook)의 약자입니다

ab = {
    'Swaroop': 'swaroop@swaroopch.com',
    'Larry': 'larry@wall.org',
    'Matsumoto': 'matz@ruby-lang.org',
    'Spammer': 'spammer@hotmail.com'
}

print("Swaroop's address is", ab['Swaroop'])

# 키-값 쌍을 삭제
del ab['Spammer']

print('\nThere are {} contacts in the address-book\n'.format(len(ab)))

for name, address in ab.items():
    print('Contact {} at {}'.format(name, address))

# 키-값 쌍을 추가
ab['Guido'] = 'guido@python.org'

if 'Guido' in ab:
    print("\nGuido's address is", ab['Guido'])

출력 결과:

$ python ds_using_dict.py
Swaroop's address is swaroop@swaroopch.com

There are 3 contacts in the address-book

Contact Swaroop at swaroop@swaroopch.com
Contact Matsumoto at matz@ruby-lang.org
Contact Larry at larry@wall.org

Guido's address is guido@python.org

동작 원리

앞에서 살펴본 표기법을 이용해 ab라는 딕셔너리를 생성합니다. 그런 다음 리스트와 튜플을 다룰 때 설명했던 것과 같이 인덱싱 연산자를 이용해 키를 지정해 키-값 쌍에 접근합니다. 생각보다 문법이 복잡하지 않다는 것을 눈여겨봅시다.

del 문을 이용하면 키-값 쌍을 삭제할 수 있습니다. 단순히 딕셔너리와 삭제할 키를 인덱싱 연산자에 지정하고 이를 del 문에 전달하기만 하면 됩니다. 이때 키에 해당하는 값을 몰라도 이 연산을 수행할 수 있습니다.

다음으로 딕셔너리의 items 메서드를 이용해 딕셔너리의 각 키-값 쌍에 접근합니다. 이 메서드는 튜플의 리스트를 반환하는데, 각 튜플에는 항목의 쌍, 즉 키와 값으로 구성된 항목이 담겨 있습니다. 다음으로 for..in 문을 이용해 항목의 쌍을 받아 각 쌍의 키-값을 name과 address 변수에 각각 할당하고 for 블록에서 이러한 값을 출력합니다.

'Guido'에 대해 한 것과 같이 키에 접근해서 값을 할당하는 인덱싱 연산자를 이용해 새로운 키-값 쌍을 추가할 수 있습니다.

in 연산자를 이용하면 특정 키-값 쌍이 존재하는지 확인할 수 있습니다.

dict 클래스의 메서드 목록을 보려면 help(dict)를 실행합니다.

키워드 인수와 딕셔너리

함수에서 키워드 인수를 사용해 본 적이 있다면 이미 딕셔너리를 사용해본 것입니다! 함수 정의에서 매개변수 목록 안에 키-값 쌍을 지정하고, 함수 내에서 변수에 접근하는 것은 딕셔너리의 키에 접근한 것에 해당합니다(이를 컴파일러 설계 용어로 심벌 테이블(symbol table)이라 합니다).

시퀀스

리스트, 튜플, 문자열은 시퀀스의 예입니다. 그런데 시퀀스란 무엇이고 무엇이 그렇게 특별한 것일까요?

시퀀스의 주요 특징은 멤버십 테스트(즉, in과 not in 표현식)와 시퀀스 안의 특정 항목을 곧바로 가져올 수 있는 인덱싱 연산자입니다.

앞에서 언급한 세 가지 유형의 시퀀스, 즉 리스트와 튜플, 문자열은 시퀀스 조각, 즉 시퀀스의 일부를 가져올 수 있는 슬라이싱(slicing) 연산을 지원합니다.

예제(ds_seq.py):

shoplist = ['apple', 'mango', 'carrot', 'banana']
name = 'swaroop'

# 인덱싱 또는 첨자 연산
print('Item 0 is', shoplist[0])
print('Item 1 is', shoplist[1])
print('Item 2 is', shoplist[2])
print('Item 3 is', shoplist[3])
print('Item -1 is', shoplist[-1])
print('Item -2 is', shoplist[-2])
print('Character 0 is', name[0])

# 리스트 슬라이싱
print('Item 1 to 3 is', shoplist[1:3])
print('Item 2 to end is', shoplist[2:])
print('Item 1 to -1 is', shoplist[1:-1])
print('Item start to end is', shoplist[:])

# 문자열 슬라이싱
print('characters 1 to 3 is', name[1:3])
print('characters 2 to end is', name[2:])
print('characters 1 to -1 is', name[1:-1])
print('characters start to end is', name[:])

출력 결과:

$ python ds_seq.py
Item 0 is apple
Item 1 is mango
Item 2 is carrot
Item 3 is banana
Item -1 is banana
Item -2 is carrot
Character 0 is s
Item 1 to 3 is ['mango', 'carrot']
Item 2 to end is ['carrot', 'banana']
Item 1 to -1 is ['mango', 'carrot']
Item start to end is ['apple', 'mango', 'carrot', 'banana']
characters 1 to 3 is wa
characters 2 to end is aroop
characters 1 to -1 is waroo
characters start to end is swaroop

동작 원리

먼저 인덱스를 이용해 시퀀스의 개별 항목을 가져옵니다. 이를 첨자 연산(subscription operation)이라고도 합니다. 예제에 나온 것처럼 시퀀스에 대해 대괄호 안에 숫자를 지정할 때마다 파이썬은 그 위치에 해당하는 항목을 가져옵니다. 파이썬은 숫자를 0부터 센다는 점을 기억하세요. 따라서 shoplist[0]은 shoplist 시퀀스에서 첫 번째 항목을 가져오고, shoplist[3]은 4번째 항목을 가져옵니다.

인덱스는 음수로도 지정할 수 있습니다. 이 경우 위치를 시퀀스 끝에서부터 계산합니다. 따라서 shoplist[-1]은 시퀀스의 마지막 항목을 가리키고, shoplist[-2]는 끝에서 2번째 항목을 가져옵니다.

슬라이싱 연산은 시퀀스 이름 다음의 대괄호 안에 콜론으로 구분된 숫자 쌍을 지정하는 방법으로 사용할 수 있습니다. 슬라이싱 연산은 지금까지 사용해온 인덱싱 연산과 흡사하다는 점에 주의합니다. 다만 숫자는 선택사항이지만 콜론은 선택사항이 아니라는 점을 기억하세요.

슬라이싱 연산에서 첫 번째 숫자(콜론 앞의)는 슬라이싱을 시작할 위치를 나타내고, 두 번째 숫자(콜론 다음의)는 슬라이싱을 어디서 멈출지를 나타냅니다. 첫 번째 숫자를 지정하지 않으면 파이썬은 시퀀스가 시작하는 위치부터 시작합니다. 두 번째 숫자를 비워두면 파이썬은 시퀀스 끝에서 슬라이싱을 멈춥니다. 슬라이싱은 시작 위치에서 시작해서 끝 위치 바로 앞에서 끝난다는 점에 유의합니다. 즉, 시작 위치는 포함되지만 끝 위치는 슬라이싱 결과에서 제외됩니다.

따라서 shoplist[1:3]은 시퀀스의 1번째 위치에서 시작해서 2번째 위치는 포함하지만 3번째 위치에서 멈추고 슬라이싱 결과를 반환하므로 결과적으로 두 개의 항목으로 구성된 조각(slice)이 반환됩니다. 이와 비슷하게 shoplist[:]는 전체 시퀀스의 사본을 반환합니다.

슬라이싱할 때도 음수 위치를 지정할 수 있습니다. 음수는 시퀀스 끝에서부터 시작하는 위치를 나타내는 데 사용됩니다. 예를 들어, shoplist[:-1]은 시퀀스의 마지막 항목은 제외하고 나머지 항목은 모두 포함하는 시퀀스 조각을 반환합니다.

슬라이싱할 때 세 번째 인수를 지정할 수도 있는데, 이것은 슬라이싱 간격(step)을 나타냅니다(기본적으로 간격의 크기는 1입니다).

>>> shoplist = ['apple', 'mango', 'carrot', 'banana']
>>> shoplist[::1]
['apple', 'mango', 'carrot', 'banana']
>>> shoplist[::2]
['apple', 'carrot']
>>> shoplist[::3]
['apple', 'banana']
>>> shoplist[::-1]
['banana', 'carrot', 'mango', 'apple']

간격을 2로 지정하면 0, 2, ... 위치의 항목이 반환된다는 점에 주의합니다. 간격 크기를 3으로 지정하면 0, 3, ... 위치의 항목이 반환됩니다.

결과를 곧바로 확인할 수 있는 파이썬 인터프리터, 즉 프롬프트를 실행해 다양한 슬라이싱 조합을 실험해 보세요. 시퀀스의 가장 좋은 점은 튜플, 리스트, 문자열에 모두 동일한 방법으로 접근할 수 있다는 것입니다!

세트

세트(set)는 단순 객체들의 순서 없는 컬렉션(collection)입니다. 세트는 컬렉션 안의 객체의 존재가 객체들의 순서 또는 특정 객체가 몇 번 등장하느냐보다 중요할 때 사용됩니다.

세트를 이용하면 세트가 다른 세트의 부분집합인지 검사하거나 두 집합의 교집합을 구하는 등이 가능합니다.

>>> bri = set(['brazil', 'russia', 'india'])
>>> 'india' in bri
True
>>> 'usa' in bri
False
>>> bric = bri.copy()
>>> bric.add('china')
>>> bric.issuperset(bri)
True
>>> bri.remove('russia')
>>> bri & bric # OR bri.intersection(bric)
{'brazil', 'india'}

동작 원리

학교에서 배운 기본적인 집합 이론을 기억하고 있다면 이 예제는 어렵지 않을 것입니다. 그렇지 않다면 구글에서 "집합 이론"이나 "벤 다이어그램"을 검색해서 파이썬에서 세트가 어떻게 사용되는지 좀 더 잘 이해할 수 있습니다.

참조

어떤 객체를 생성하고 그 객체를 변수에 할당할 때 변수는 해당 객체를 참조(refer)하기만 할 뿐 객체 자체를 나타내지 않습니다. 즉, 변수명은 객체가 저장된 컴퓨터 메모리의 일부분을 가리킬 뿐입니다. 이를 일컬어 이름과 객체를 바인딩(binding)한다고 합니다.

일반적으로 바인딩에 관해서는 신경 쓰지 않아도 되지만 참조에 따른 미묘한 효과에 대해서는 알아둘 필요가 있습니다.

예제(ds_reference.py):

print('Simple Assignment')
shoplist = ['apple', 'mango', 'carrot', 'banana']
# mylist는 단지 같은 객체를 가리키는 또 다른 이름일 뿐입니다!
mylist = shoplist

# 첫 번째 품목을 구입했으므로 리스트에서 제거합니다
del shoplist[0]

print('shoplist is', shoplist)
print('mylist is', mylist)
# shoplist와 mylist 모두 'apple'이 없는 같은 리스트를 출력한다는 점에
# 유의합니다. 이것은 두 리스트가 같은 객체를 가리킨다는 사실을 보여줍니다.

print('Copy by making a full slice')
# 전체 슬라이스를 통해 사본을 만듭니다
mylist = shoplist[:]
# 첫 번째 항목 제거
del mylist[0]

print('shoplist is', shoplist)
print('mylist is', mylist)
# 이제 두 리스트가 다르다는 데 주의합니다

출력 결과:

$ python ds_reference.py
Simple Assignment
shoplist is ['mango', 'carrot', 'banana']
mylist is ['mango', 'carrot', 'banana']
Copy by making a full slice
shoplist is ['mango', 'carrot', 'banana']
mylist is ['carrot', 'banana']

동작 원리

대부분의 설명은 주석을 통해 확인할 수 있습니다.

리스트나 시퀀스 또는 복합 객체(정수 같은 단순 객체가 아닌)의 사본을 만들고 싶다면 슬라이싱 연산을 이용해 사본을 만들어야 합니다. 단순히 변수명을 다른 이름에 할당하기만 하면 둘 모두 같은 객체를 '가리키게' 되고 각별히 신경 쓰지 않으면 곤란한 상황이 발생할 수 있습니다.

펄 프로그래머를 위한 메모

리스트에 대한 할당문은 사본을 만들지 않는다는 점을 기억하세요. 시퀀스의 사본을 만들려면 슬라이싱 연산을 이용해야 합니다.

문자열에 관한 더 자세한 내용

문자열에 관해서는 앞에서 이미 자세히 다뤘습니다. 더 알아야 할 것으로 무엇이 있을까요? 문자열 또한 객체이고 문자열의 일부를 검사하는 것에서부터 공백을 제거하는 것까지 뭐든지 할 수 있는 메서드가 있다는 사실을 아시나요? 사실, 이미 문자열 메서드를 사용해 오고 있었습니다. 바로 format 메서드입니다!

프로그램에서 사용하는 문자열은 모두 str 클래스의 객체입니다. 이 클래스의 몇 가지 유용한 메서드를 다음 예제에서 볼 수 있습니다. 그러한 메서드의 전체 목록은 help(str)을 참고하세요.

예제(ds_str_methods.py):

# 다음은 문자열 객체입니다
name = 'Swaroop'

if name.startswith('Swa'):
    print('Yes, the string starts with "Swa"')

if 'a' in name:
    print('Yes, it contains the string "a"')

if name.find('war') != -1:
    print('Yes, it contains the string "war"')

delimiter = '_*_'
mylist = ['Brazil', 'Russia', 'India', 'China']
print(delimiter.join(mylist))

출력 결과:

$ python ds_str_methods.py
Yes, the string starts with "Swa"
Yes, it contains the string "a"
Yes, it contains the string "war"
Brazil_*_Russia_*_India_*_China

동작 원리

여기서 여러 문자열 메서드를 사용하는 예제를 볼 수 있습니다. startswith 메서드는 문자열이 지정한 문자열로 시작하는지 여부를 확인하는 데 사용합니다. in 연산자는 지정한 문자열이 대상 문자열의 일부인지 검사하는 데 사용합니다.

find 메서드는 문자열 내에서 지정한 부문자열의 위치를 구하는 데 사용합니다. 부문자열을 찾을 수 없으면 find 메서드는 -1을 반환합니다. str 클래스에는 시퀀스의 각 항목들을 지정한 문자열과 합치는 join 메서드도 있습니다. 이때 문자열은 시퀀스의 각 항목 사이에서 구분자 역할을 하고 이를 통해 생성된 결과 문자열을 반환합니다.

정리

지금까지 파이썬에 내장된 다양한 자료구조를 자세히 살펴봤습니다. 이러한 자료구조는 적당한 규모의 프로그램을 작성하는 데 반드시 필요할 것입니다.

이제 파이썬의 여러 기초적인 내용을 익혔으니 다음으로 실무 파이썬 프로그램을 설계하고 작성하는 방법을 살펴보겠습니다.