반응형

Python에는 여러 값을 처리하는 것(컨테이너)가 일부 포함되어 있다. 그 기본적인 사용법에 대해 설명한다.


배열 = 리스트?

프로그래밍 언어는 여러 값을 한곳에 모아 처리하는 특별한 변수 같은 것이 대부분 준비되어 있다. 일반적으로 '배열'로 불리는 것으로, 이것은 번호를 붙여 값을 관리 할 수 있다. 예를 들어, "1번의 값을 XX로 변경" 또는 "3번 값을 꺼내기"라고 하여, 많은 값을 번호로 관리한다.

Python에서 제공되는 배열 기능은 "목록"라는 것이다. 이것은 다음과 같은 형태로 작성된다.

변수 = [값1, 값2, ...]

[] 안에는 각각의 값을 쉼표로 구분하여 작성한다. 이것으로 그 값을 순서에 번호를 매긴 목록이 만들어 진다. 이 번호는 일반적으로 "인덱스"라고 한다.

중요한 것은 "인덱스는 0부터 시작한다"라는 점이다. 즉, 첫 번째 값은 "0번"이 되고 두 번째 값이 "1번", 세 번째 값이 "2번" .....와 같은 식으로 넘버링이 된다. 10개의 값이 있었다면, 인덱스 번호는 0~9이다 (1~10이 아니다!).

목록에 있는 개별 요소를 꺼낼 경우, "변수[번호]"라는 식으로 작성한다. 예를 들어,

arr[0] = "OK"
val = arr[1]

이런 식으로 사용할 수 있다. 이것으로 목록에 지정된 번호의 요소를 변경하거나 제거할 수 있다.

아래에는 간단한 사용 예제를 살펴보자.

arr = ['hello','welcome','good-bye']
for n in arr:
    print(n)
 
print("....end.")

여기에서는 이전에 소개한 "for ~ in ..."구문을 사용하여 목록에있는 모든 요소를 반복해 나가고 있다. 이 구문은

for 변수 in 목록 :

이런 식으로 작성하여 목록에서 순서대로 값을 꺼내서 변수로 얻어서 반복을 실행한다. 목록과 for는 매우 잘 사용되므로, 두 세트 꼭 기억하도록 하자.


리스트와 텍스트의 관계

목록은 다양한 곳에서 사용되지만, 실제로는 뜻밖의 곳에서 사용될 수 있다. 그것은 "텍스트"이다.

Python에서 텍스트의 값은 "문자 목록"으로 처리 할 수 있다. 예를 들어 "Hello"라는 텍스트는

str = ['H', 'e', 'l', 'l', 'o']

이런 식으로 5개의 문자 목록으로 생각할 수도 있는 거다. 예를 들면, str[0] 이것으로 'H'의 문자를 꺼낼 수 있다.

그러나 이렇게 하는 경우는 "문자를 꺼낼 때"뿐이다. 같은 방법으로 문자를 변경할 수 없다. 즉, 텍스트와 목록이 같은 것은 아니다. 어디까지나 "텍스트 내의 문자를 꺼내기 위해 목록을 이용할 수 있도록 하고 있다"고 생각하면 된다. 이렇게 하면 매우 알기 쉽게 텍스트 내의 문자를 검색 할 수 있다.

아래에 간단한 사용 예제를 보도록 하자. "Hello"텍스트부터 문자를 제거하고, 새 텍스트를 생성하는 샘플이다.

str = "Hello"
str2 = ""
for n in str:
    str2 = str2 + (n * 2) + '~'
print(str2)

실행해 보면 "HH~ee~ll~ll~oo~"와 텍스트가 표시된다. 텍스트 내의 문자를 다루기 위하여 목록을 사용할 수 있다. 이를 기억해두면 꽤 편리할 거다.


튜플은 변경 불가능한 리스트?

이 목록에 비슷 "튜플"라는 것도 Python에 있다. 이것은 다음과 같이 작성한다.

변수 = (값1, 값2, ...)

값을 꺼낼 때는 변수와 마찬가지로 []에 인덱스를 지정한다. 예를 들어, str[0]와 같은 식으로 쓰면 된다.

그럼 기존 목록과 튜플은 무엇이 다른가? 그것은 "튜플 값을 변경할 수 없다"는 점이다. 즉, '변수'가 아니라 '상수'이다.

프로그래밍 세계에서는 변수처럼 값을 자유롭게 변경할 수 있는 것도 중요하지만, 반대로 "값을 변경할 수 없다"는 것도 중요하다. 어디선가 마음대로 값이 갱신 된다면 문제가 발생하게 된다 ...... 그런 중요한 값을 배열처럼 많이 이용하려면 목록으로는 곤란한다.

튜플은 값이 변하지 않는 것이 보증된 목록이다. 그렇게 생각하면, 이 튜플을 사용하는 경우가 없지 않나?라고 생각 할 수 있을 것이다.

이런 "변경 불가능한 컨테이너"는 튜플 외에도 있다. 앞장에서 잠깐 나온 레인지(range) 등이 있다. 이러한 변경 불가 것을 "불변 객체(immutable)"라고 한다.

이에 대해 변경이 가능한 것은 "가변 객체(mutable)"라고 한다. 목록는 mutable 컨테이너의 대표라고 할 수 있다.

그럼 "튜플로 제공한 값을 나중에 목록으로 사용하고 싶다"라고 하는 경우는 어떻게 해야 하나? 이러한 경우에는 변환을 해주는 함수를 사용하면 된다.

튜플을 목록으로 변환

변수 = list(튜플)

목록을 튜플로 변환

변수 = tuple(목록)

그럼 아래 튜플과 리스트의 사용 예제를 보도록 하자.

tp = (0,1,2,3,4)
ls = list(tp)
for n in range(0,5):
    ls[n] = ls[n] * 2
for n in tp:
    print(ls[n])

튜플 tp를 준비해서 거기에서 목록 ls를 만들고, 목록의 값을 변경한다. 출력 결과를 보면서 ls값과 tp값이 어떻게 사용되고 있는지 생각해 보자.



수열을 다루는 레인지

시퀀스 동료의 마지막은 "레인지(range)"이다. 이것은 이전에 등장 했었다. for 등에서 숫자의 범위를 지정하는데,

for n in range(10)

이런 식으로 쓰기도 했다. 이 range(10)라는 것이 레인지이다. 레인지는 다음과 같이 만든다. 알기 쉽게 예로서, 생성된 레인지에 포함되는 수열을 리스트로 표시해 두었다.

0부터 지정한 값의 직전까지의 범위

변수 = range(종료 값)

예)

range (10)
↓
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

지정된 값부터 지정한 값의 직전까지의 범위

변수 = range (시작 값, 종료 값)

예)

range(10, 20)
↓
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

지정된 값부터 지정된 값의 앞까지 일정한 간격으로 값을 얻는 범위

변수 = range(시작 값, 종료 값 간격)

예)

range(10, 50, 5)
↓
[10, 15, 20, 25, 30, 35, 40, 45]

레인지는 차례를 잘 늘어놓은 수열을 만들기 위한 것이다. 이것은 물론 일반적인 용도로도 사용할 수 있지만, 가장 많이 사용하는 것은 for일 것이다. for문으로 반복 처리할 때, 반복 범위 지정을 위해 레인지를 사용하는 경우가 가장 많은 것이다.

그럼 아래의 목록 란에 간단한 사용 예제를 보도록 하자.

for n in range(10): 
    print(n)

range 값을 for으로 순서대로 출력하고 있다.



시퀀스 기능

목록 등의 "여러 값을 한꺼번에 처리한다"라는 것은 매우 유용하지만, 그러나 처음부터 고정된 수의 요소 밖에 사용할 수 없다면 조금 융통성이 없어 보인다.

하지만 염려하지 말자. 목록에는 요소를 추가하거나 제거하는 기능이 제대로 마련되어 있다.

그 대부분은 "순서"에 포함되어 있는 기능이다. 즉, 리스트, 튜플, 범위 중에서도 사용할 수 있는 기능이라는 것이다. 그럼 시퀀스의 기본적인 기능에 대해 정리해 보자.

새로운 요소를 추가

목록.append(값)

목록의 가장 마지막에 값을 추가한다.

지정된 인덱스 위치에 값을 삽입

목록.insert(인덱스, 값)

목록의 지정된 인덱스 번호의 위치에 값을 삽입한다.

지정된 값을 제거

목록.remove(값)

지정된 값을 목록에서 제거한다.

지정된 인덱스 번호의 요소 제거

del 목록 [번호]

목록 정해진 번호의 값을 제거하는 것이다. 이것은 del 후에 목록 삭제하는 인덱스 번호를 지정하여 작성한다. del 다음에, () 필요 없다.

여기까지 "추가", "삽입", "삭제"라는 것은 시컨스라고 해도 목록 밖에 대응되지 않는다. 왜냐하면, 이것은 목록 수정하는 작업이기 때문이다. 튜플과 레인지는 불변 객체 (변경 불가)이므로 이러한 작업은 할 수 없다.

이후에는 3개의 컨테이너에 공통되는 것이다. "시퀀스 전반에서 사용할 수 있는 기능"이다.

컨테이너의 덧셈

변수 = 컨테이너 + 컨테이너

목록과 튜플은 "+"로 덧셈을 할 수 있다. 2개의 컨테이너를 1개에 연결한 것을 만들 수 있다. 레인지는 수열이라는 이유로 해당하지 않는다.

컨테이너의 곱셈

변수 = 컨테이너 * 정수

컨테이너의 값을 지정한 수 만큼 연결 한 것을 만든다. 예를 들어, 아래와 같다.

[1, 2, 3] * 3
↓
[1, 2, 3, 1, 2, 3, 1, 2, 3]

인덱스의 범위를 반환

변수 = 컨테이너[시작 값:종료 값]

인덱스 번호로 지정된 범위의 값을 꺼내기 위한 것이다. 예를 들어, [2:5]라고 하면 2~5의 인덱스 번호의 요소를 컨테이너에서 반환한다.

값이 포함되어 있는지?

in 컨테이너
값 not in 컨테이너

이것은 값이 컨테이너에 포함되어 있는지 여부를 확인한다. 결과는 부울이다. in은 값이 포함되어 있으면 True, 없으면 False이다. not in 반대로 포함되어 있으면 False, 없으면 True이다.

요소의 개수 얻기

변수 = len(컨테이너)

그 컨테이너에 몇개의 값이 저장되어 있는지를 정수로 반환한다.

최대 값, 최소값 얻기

변수 = max(컨테이너)
변수 = min(컨테이너)

컨테이너에 저장되어 있는 값 중에서 가장 큰 것, 가장 작은 것을 찾아서 반환한다.

대충 이것들을 사용해 리스트 내의 요소를 사용할 수 있게 되면 매우 편리하다.

아래에 간단한 사용 예를 들어 둡니다.

arr = ['hello','bye'] 
arr.append('finish!') 
arr.insert(1, 'welcome') 
arr.remove('bye') 
for n in arr: 
    print(n)

목록 arr에 새로운 값을 추가하거나 삭제한 결과를 출력한다. 최초의 입력한 목록과는 대부분 저장된 값이 변화하고 있는 것을 알 수 있을 거다.



집합을 다루는 세트

여기까지의 리스트, 튜플, 범위는 모든 시퀀스라는 것이었다. 바꿔 말하면, 인덱스 번호를 사용하여 값에 일련 번호를 할당하고 순차적으로 정리하는 컨테이너였다.

하지만, Python에는 "값이 순차적이지 않는 컨테이너"도 있다. 그 중 하나가 "세트(set)"이다.

세트는 집합의 컨테이너이다. 세트는 값을 순서대로 정리하지 않는다. 세트 안에는 동일한 값을 여러개로 가질 수 없다. 저장되어 있는 값과 같은 값은 세트에 존재하지 않는 것이다.

이 세트는 {} 기호를 붙여 작성한다.

변수 = {값1, 값2, ...}

또는 set 함수를 사용하여 만들 수 있다. 인수에는 목록 등의 컨테이너를 제공한다.

변수 = set(값1, 값2, ...)

이제 세트를 만들 수 있다. 그러나! 인덱스가 없기 때문에, 여기에서 필요한 값을 뺄 수 없다. 그럼, 무엇을 위해 있는지?라고 생각할 수도 있다. 세트는 집합이다. 따라서 어떤 값이 이 집합에 포함되어 있는지에 대한 여부를 확인할때 사용을 한다.

세트 조작

세트에서도 세트를 조작하는 기능이 여러가지 준비되어 있다. 그러나 주의하지 않으면 안되는 것은, "세트는 값의 순서가 없다"는 점이다. 이것을 잊지 말고 가보도록 하자.

값 추가

세트.add(값)

값 추가는 "add"라는 것을 사용한다. 이것으로 ()안에 값이 세트에 추가된다. 그러나 이미 세트에 동일한 값이 있는 경우는 아무런 변화가 없다.

값을 삭제

세트.remove(값)

값 삭제는 remove를 사용한다. 이것은 시컨스와 같다. 이것으로 ()안의 값이 세트에서 삭제된다.

요소의 개수 얻기

변수 = len(세트)

그 세트에 몇개의 값이 저장되어 있는지를 정수를 반환다. 이것은 이미 나왔던 거다.

최대 값, 최소값 얻기

변수 = max(세트)
변수 = min(세트)

세트에 저장되어 있는 값 중에서 가장 큰 것, 작은 것을 찾아서 반환해 준다. 이것도 시컨스에서 사용했었다.

세트의 뺄셈

세트1 - 세트2

세트는 덧셈과 곱셈은 없지만, 뺄셈은 있다. 이것으로 "세트1"에서 "세트2" 요소를 제거한 나머지를 새로운 세트로 얻을 수 있다.

세트의 비교 연산

세트1 == 세트2 등

세트는 비교 연산이 가능하다. = <> 등의 기호 류를 사용한 비교 식을 사용하여 두 세트를 비교할 수 있다. 다만, <>는 "어느 쪽의 세트가 크거나 작다"는 의미는 아니다. 이것은 "어딘가가 어딘가에 포함되어 있는지"를 나타낸다. 예를 들어 A>B라고 하면, "A세트에 B세트가 포함되어 있는지"를 나타낸다.

세트의 논리 연산

 세트1 & 세트2
 세트1 | 세트2
 세트1 ^ 세트2

이 논리 연산은 집합인 세트 특유의 것이다. 이것들은 두개의 세트(집합)을 연산하여 새로운 세트를 만든다. 이것은 다음의 연산자를 사용해서 세트를 만들어 낸다.

기호설명
&2개의 세트에 공통되는 요소만을 가진 세트를 생성한다. (논리적)
|2개의 세트에 있는 모든 요소를 가진 세트를 생성한다. (논리합)
^두 세트의 어느 한쪽에만 있는 요소로 구성된 세트를 생성한다. (배타적 논리합)

 

마지막 논리 연산은 조금 이해하기 어려울지도 모른다. 실제 사용 예제를 참고하여 여러가지를 시도해 보자.

a = {'a', 'b'} 
b = {'b', 'c'} 
c1 = a & b 
c2 = a | b 
c3 = a ^ b 
print(c1) 
print(c2) 
print(c3)



키 값을 관리하는 사전

목록도 튜플도 인덱스라는 번호를 사용하여 값을 관리한다는 점에서는 같았다. 이 숫자가 아닌 "이름"을 사용하여 값을 관리하는 것도 Python에는 제공이 되어 있다. 그것은 "사전(dictionary)"이 라는 것이다.

사전은 '키워드'라는 이름을 붙여 값을 관리한다. 그리고 값을 제거하거나 변경하는 경우에는 그 값의 키를 지정한다. 사전은 다음과 같은 형태로 만든다.

변수 = {키1:값1, 키2:값2, ...}

또는 dict라는 것을 사용하여 만들 수 있다. 다만, 이 경우는 작성 방식이 조금 다르기 때문에 주의해야 한다.

변수 = dict (키1=값1, 키2=값2, ...)

사전에서 값을 꺼내는 경우는 시퀀스와 마찬가지로 []를 사용한다. 다만, 인덱스가 아닌 키워드를 []로 지정한다.

변수 = 사전[키]
사전[키] = 값

사전을 이용했을 때, 초보자가 착각하기 쉬운 것은 "사전은 키를 사용해도 다른 것과 동일하게 값을 꺼낼 수 있다"라는 생각이다. 즉, 키로도 꺼낼수 있고, 번호로도 꺼낼 수 있다라고 생각할 수 있다. 하지만 사전은 "키"밖에 사용할 수 없다. 다시 말하면, 사전에 있는 값을 번호 순서대로 추출 할 수 없다.

for in 주의!

모든 요소를 처리하기 위한 "for ~ in"구문은 사전에서도 사용할 수 있지만, 그 동작이 미묘하게 다르므로 주의가 필요하다.

리스트나 튜플에서 "for 변수 in 목록"이라고 하면, 리스트의 값이 변수로 꺼낸진다. 하지만 사전의 경우 꺼내지는 것은 각각의 "값"이 아니고 "키"이다. 즉, 변수에 추출된 키를 사용하여 값을 꺼내 사용하는 형태가 되는 거다.

그럼, 아래에 간단한 사용 예를 보도록 하자.

dic = {'taro':'taro@yamada.com', 
       'hanako':'hanako@flower', 
       'ichiro':'ichiro@baseball'} 
for n in dic: 
    print(n + ' (' + dic[n] + ')') 

여기에서는 각각의 이름을 키로하여 이메일 주소를 설정하고 있다. for를 사용하여 사전의 모든 데이터를 표시하고 있다. 사전을 사용하면, 이 처럼 작은 데이터베이스와 같은 사용이 가능해 진다.

사전 조작

사전도 다른 컨테이너와 같은 방법으로 조작 할 수 있는 기능이 여러가지가 제공되어 있다. 주요한 것에 대해 정리하겠다.

· 값 추가

사전[키] = 값

사전에 새로운 값을 추가하는 것은 간단한다. []으로 추가할 키워드를 지정하고 값을 대입하면 된다. 사전에서 해당 키워드가 아직 사용되지 않고 있다면, 새로운 키워드 항목이 추가된다. append와 add와 같은 기능의 함수가 필요없다.

값 삭제

del 사전[키]

값을 삭제하려면, remove는 사용할 수 없다. del을 사용하여 삭제한다.

모든 키 얻기

변수 = 사전.keys()

모든 값 얻기

변수 = 사전.values()

모든 항목(키, 값) 얻기

변수 = 사전.items ()

사전에 키워드와 값을 함께 얻는 기능이 있다. keys/values는 사전에 저장되어 있는 모든 키워드/값을 컨테이너로 모와서 꺼낸다. 또한, items는 키워드와 값을 튜플에 정리한 것을 얻는 거다.

정리

사전는 목록 등에 비해 '키워드 값을 꺼내기'라는 특성상 다소 특수한 용도로 사용된다. 데이터의 순서가 중요하지 않는 경우라면, 데이터 이름을 붙여 관리하는 것이 번호로 관리하는 것보다 압도적으로 편리하다. 프로그램 작성에 있어서 경우에 따라 "리스트로 하는 것이 좋을지, 사전을 사용하는 편이 편리할지"를 생각해서 이용하도록 하자.

반응형

'Python' 카테고리의 다른 글

[Python] 클래스 사용  (0) 2017.12.22
[Python] 함수(function)  (0) 2017.12.22
[Python] 리스트, 튜플, 레인지, 세트, 사전  (0) 2017.12.22
[Python] 구문(statement)  (0) 2017.12.22
[Python] 우선 값과 계산의 기본  (0) 2017.12.22
[Python] Python 개발 환경  (0) 2017.12.22

+ Recent posts