[기초] 7강. 자료형

파이썬의 자료형은 크게 숫자(numbers), 시퀀스(sequence), 매핑(mapping) 등으로 나눌 수 있습니다.

숫자

숫자를 나타내는 자료형으로는 정수(int), 부동소수점수(float), 복소수(complex)가 있습니다.

int

int는 정수(integer)를 나타냅니다.

>>> type(100000000)              # 정수
<class 'int'>

float

float는 원래 부동소수점수(floating-point number)를 가리키는데, 지금은 단순히 소수점 이하를 표현할 수 있는 수라고 생각하셔도 좋습니다.

>>> type(2.8)                    # 부동소수점수
<type 'float'>

int끼리 연산한 결과가 float로 나오기도 합니다.

>>> 5 / 3
1.6666666666666667

 

 

시퀀스

문자열(str), 리스트(list), 튜플(tuple), 사용자 정의 클래스가 시퀀스에 속합니다.

>>> type("Love your Enemies, for they tell you your Faults.")
<class 'str'>
>>> type(['love', 'enemy', 'fault'])
<class 'list'>
>>> type(('love', 'enemy', 'fault'))
<class 'tuple'>

for 문에서 사용할 수 있는 것들이 바로 시퀀스입니다.

 

문자열이 시퀀스에 속하네요. 

 

문자열과 리스트를 좀 더 자세히 알아봅시다.

문자열

문자열에서는 요런 식으로 한 글자마다 번호를 매깁니다

>>> x = 'banana'
>>> x[0]            # 0번 글자는?
'b'
>>> x[2:4]          # 2번부터 4번 앞(3번)까지는?
'na'
>>> x[:3]           # 처음부터 3번 앞(2번)까지는?
'ban'
>>> x[3:]           # 3번부터 끝까지는?
'ana'

이렇게 문자열의 각 글자 위치(인덱스)를 이용해서 문자열을 써는 방법을 슬라이싱(slicing)이라고 합니다. 

banana를 nanana로 바꿀 수는 있을까요?

>>> x[0] = 'n'

위와 같이 하면… 될까요? 안 됩니다. 아래처럼 TypeError라는 오류가 나죠.

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

이렇듯, 문자열에 들어있는 글자는 바꿀 수가 없습니다.

 

아래처럼 할 수는 있지만,

>>> x = 'n' + x[1:]
>>> x
'nanana'

이건 문자열 x의 'b'를 'n'으로 바꾼 것이 아니라, 'n'과 'anana'를 합친 새로운 문자열 'nanana'에 x라는 이름을 붙인 것입니다.

---

문자열에 어떤 글자가 몇 번째 자리에 있는지 알고 싶을 때는 find()를 사용하면 됩니다.

>>> s = "hello Python!"
>>> s.find('P')
6

'P'가 6번 인덱스에 있다는 것을 알았으니, 다음과 같이 슬라이싱해서 다른 변수로 저장할 수도 있습니다

>>> s[0:6]
'hello '
>>> h = s[0:6]
>>> h
'hello '

위의 h 변수의 끝에는 공백이 포함되었는데, 다음과 같이 슬라이싱을 하거나 rstrip()으로 제거할 수 있습니다.

>>> h[0:5]
'hello'
>>> h.rstrip()
'hello'

또는 다음과 같이 주어진 문자열을 분할한 리스트를 생성하는 split()을 이용해 첫 번째 단어를 알아내는 방법도 있습니다.

>>> s.split()
['hello', 'Python!']
>>> s.split()[0]
'hello'

리스트

이번엔 리스트를 살펴보도록 하겠습니다. 원소를 추가하는 것부터 해보겠습니다.

>>> prime = [3, 7, 11]  # 3, 7, 11을 원소로 갖는 리스트 prime을 만듦
>>> prime.append(5)      # prime에 원소 5를 추가
>>> prime
[3, 7, 11, 5]

sort 함수를 사용하면 정렬을 간단하게 할 수 있구요.

>>> prime.sort()           # prime을 원소 크기 순으로 정렬
>>> prime
[3, 5, 7, 11]

맨 앞(0번)에 2를 삽입(insert)하겠습니다.

>>> prime.insert(0, 2)
>>> prime
[2, 3, 5, 7, 11]

원소를 삭제하는 것도 되지요. 4번 원소를 삭제해 보겠습니다.

>>> del prime[4]           # prime의 4번 원소를 삭제
>>> prime
[2, 3, 5, 7]

원소를 삭제할 때 pop()을 사용할 수도 있습니다. 

pop()은 리스트에서 삭제한 원소를 반환(return)하므로 변수로 받아서 나중에 사용할 수도 있죠.

>>> a = prime.pop() # 삭제한 원소를 a 변수로 받음
>>> prime
[2, 3, 5]
>>> a
7

다음과 같이 리스트의 원소에 새로운 값을 지정할 수도 있습니다.

>>> prime[0] = 1
>>> prime
[1, 3, 5]

리스트에 리스트를 집어넣을 수도 있지요. 피자가게에서 주문할 음식 리스트를 보겠습니다

>>> orders = ['potato', ['pizza', 'Coke', 'salad'], 'hamburger']
>>> orders[1]
['pizza', 'Coke', 'salad']
>>> orders[1][2]
'salad'

마찬가지로 리스트를 사용해서 간단히 행렬을 표현할 수도 있습니다. 

>>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

문자열을 리스트로 바꾸기

지금까지 문자열과 리스트를 따로따로 알아봤는데요, 이번엔 둘 다 갖고 놀아봅시다.

문자열을 리스트로 바꿔보도록 하죠.

>>> characters = []
>>> sentence = 'Be happy!'
>>> for char in sentence:
...     characters.append(char)
... 
>>> print(characters)
['B', 'e', ' ', 'h', 'a', 'p', 'p', 'y', '!']

처음에 characters라는, 비어있는 리스트를 만들었습니다.

그리고, sentence라는 변수를 만들어서 Be happy!라는 문자열을 가리키도록 했지요.

전에 for 문을 배울 때에는 리스트를 이용해서 이터레이션을 수행하였는데, 이번에는 문자열을 이용해 보았습니다.

여기선 sentence가 가리키는 Be happy!의 글자 하나하나에 대해서 어떤 일을 수행하게 되죠.

첫번째 글자인 B를 characters라는 리스트의 첫번째 원소로 넣고,

두번째 글자인 e를 characters의 두번째 원소로 넣는 식입니다.

 

사실은 아래처럼 문자열을 바로 리스트로 변환해도 같은 결과를 얻을 수 있답니다.

>>> list('Be happy!')
['B', 'e', ' ', 'h', 'a', 'p', 'p', 'y', '!']

숫자를 문자열로 바꾸기

정수(int) 123을 가리키는 my_int 변수가 있다고 합시다.

>>> my_int = 123
>>> type(my_int)
<class 'int'>

문자열 '123'을 얻고 싶다면 다음과 같이 할 수 있습니다.

>>> str(my_int)
'123'

위 출력 결과를 보시면 작은따옴표가 붙어 있습니다. 타입을 확인해 보면 더 정확히 알 수 있죠.

>>> type(str(my_int))
<class 'str'>

이렇게 얻은 문자열을 다음과 같이 변수에 할당하는 것도 가능합니다.

>>> my_str = str(my_int)

엄밀히 말하자면 '숫자를 문자열로 바꾼' 것이라기보다는, '숫자값을 가지고 새로운 문자열을 얻었다'고 표현하는 것이 맞겠죠.

문자열을 숫자로 바꾸기

역으로, 숫자를 나타낸 문자열에서 숫자를 얻어낼 수도 있습니다.

>>> int('123')
123
>>> float('123')
123.0

리스트 원소들의 합 구하기

1부터 10까지의 정수를 원소로 갖는 리스트 one_to_ten이 있습니다.

>>> one_to_ten = list(range(1, 11))
>>> one_to_ten
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

1부터 10까지를 더한 값은 얼마일까요?

 

for 문을 사용해서 계산할 수도 있겠지만, sum()을 이용하면 손쉽게 구할 수 있답니다.

>>> sum(one_to_ten)
55

성적표

오늘의 종합편! 우리 반 성적표를 만들어 봅시다! 학생 이름에 국, 영, 수 성적을 넣어주고,

>>> chulsu = [90, 85, 70]
>>> younghee = [88, 79, 92]
>>> yong = [100, 100, 100]  # 바로 접니다..
>>> minsu = [90, 60, 70]

우리 반 학생들을 전부 students 리스트에 넣어줍니다.

>>> students = [chulsu, younghee, yong, minsu]

학생들의 성적이 어떤지 불러내볼까요?

>>> for scores in students:
...     print(scores)
... 
[90, 85, 70]
[88, 79, 92]
[100, 100, 100]
[90, 60, 70]

개인의 성적을 더해서 총점, 평균도 내 보세요.

>>> for scores in students:
...     total = 0
...     for s in scores:
...         total = total + s
...     average = total / 3
...     print(scores, total, average)
...
[90, 85, 70] 245 81.66666666666667
[88, 79, 92] 259 86.33333333333333
[100, 100, 100] 300 100.0
[90, 60, 70] 220 73.33333333333333

 

 

문자열 슬라이싱

아래와 같이 문자열 인덱스를 이용해 문자열의 일부를 복사할 수 있습니다.

>>> p = 'Python'
>>> p[0:2]
'Py'

슬라이싱할 첫 인덱스가 0일 때는 아래처럼 콜론(:) 앞의 0을 생략할 수도 있습니다.

>>> p[:2]
'Py'

문자열 일부를 슬라이싱해서 다른 문자열과 붙일 수 있습니다.

>>> h = 'Hello world!'
>>> h[:6] + p + '!'
'Hello Python!'

음수 인덱스를 사용해 문자열의 뒷부분을 복사할 수도 있습니다.

>>> h[-1:]
'!'
>>> h[:6] + p + h[-1:]
'Hello Python!'

tipreplace() 메서드를 써서 특정 단어를 다른 단어로 바꿀 수도 있어요.

>>> h.replace('world', 'Python')
'Hello Python!'

다음과 같이 콤마의 앞뒤 숫자를 모두 생략하면 문자열 전부를 복사할 수 있습니다.

>>> p[:]
'Python'

역순으로 복사하는 것도 가능합니다.

>>> p[::-1]
'nohtyP'

리스트 슬라이싱

 

리스트로도 슬라이싱할 수 있어요. 위에서 설명한 것과 원리는 같습니다. 인덱스가 0부터 시작한다는 점에 유의하세요.

>>> N = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> N[0]  # 0번(첫 번째) 원소
1
>>> N[0:5]  # 0번부터 5번 앞(4번)까지
[1, 2, 3, 4, 5]
>>> N[:5]  # 처음부터 5번 앞까지
[1, 2, 3, 4, 5]
>>> N[5:]  # 5번부터 끝까지
[6, 7, 8, 9, 10]
>>> N[-3:]  # 뒤에서 3번째부터 끝까지
[8, 9, 10]
>>> N[::-1]  # 역순으로
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

문자열의 리스트도 만들어서 실험해 보세요.

>>> fruit = ['apple', 'banana', 'cherry', 'mango', 'orange']
>>> fruit[0:2]
['apple', 'banana']
>>> fruit[2]
'cherry'
>>> fruit[2:]
['cherry', 'mango', 'orange']

 

 

튜플

이제 튜플이라는 자료형이 어떤 쓸모가 있는지 알아보도록 하죠.

다른 언어를 공부해 보신 분은 두 변수의 값을 서로 바꾸어 본 적이 있으실 텐데요,

보통 다음과 같은 방법을 사용합니다.

>>> a = 10
>>> b = 20
>>> temp = a               # a 값을 temp에 저장   (temp = 10)
>>> a = b                  # b 값을 a에 저장      (a = 20)
>>> b = temp               # temp 값을 b에 저장   (b = 10)
>>> print(a, b)
20 10

이렇게 두 변수 값을 맞바꾸기 위해선 또 다른 변수 temp가 필요합니다.

그런데 파이썬에는 이런 일을 간단하게 할 수 있는 기막힌 방법이 있습니다.

>>> c = 10
>>> d = 20
>>> c, d = d, c
>>> print(c, d)
20 10

너무 간단하지요? 

 

세 번째 줄에서 등호 왼쪽은 c, d라는 변수가 담긴 튜플이구요, 오른쪽은d와 c의 값이 담긴 튜플입니다. 그래서 d의 값은 c로 들어가고, c의 값은 d로 들어갑니다. 이런 일들이 차례차례 일어나는 것이 아니고, 동시에 처리된다는군요.

이번엔 함수에서 튜플이 요긴하게 쓰이는 것을 보여드리지요. 아래의 함수는 인자(매개변수)를 주는 대로 받아먹는 함수입니다.

>>> def magu_print(x, y, *rest):        # 마구 찍어 함수
...     print(x, y, rest)
...
>>> magu_print(1, 2, 3, 5, 6, 7, 9, 10)
1 2 (3, 5, 6, 7, 9, 10)

위 함수는 인자를 두 개 이상만 주면 나머진 다 알아서 처리한답니다. 함수를 정의할 때 인자에 별표를 붙여두면 그 이후에 들어오는 것은 모두 튜플에 집어넣는 것이죠. 위에선 (3, 5, 6, 7, 9, 10)가 하나의 튜플로 묶였습니다. 꽤 쓸만할 것 같죠? 다른 언어로 이런 함수를 만들려면 고생 꽤나 해야 할 거예요. 인자를 두 개, 세 개 넣어서도 실험해 보세요.

튜플의 좋은 점들을 구경했으니 이제 문법을 살펴봅시다.

>>> t = ('a', 'b', 'c')

튜플을 만들 때는 위와 같이 괄호를 써도 되고 안 써도 됩니다. 다만, 원소가 없는 튜플을 만들 때는 괄호를 꼭 써주세요.

>>> empty = ()

원소를 하나만 가진 튜플을 만들 땐 원소 뒤에 콤마(,)를 꼭 찍어주시고요.

>>> one = 5,
>>> one
(5,)

그리고 튜플은 리스트와 달리 원소값을 직접 바꿀 수 없기 때문에, 문자열에서 했던 것처럼 오려붙이는 방법을 써야 한다는 것을 알아두세요.

>>> p = (1,2,3)
>>> q = p[:1] + (5,) + p[2:]
>>> q
(1, 5, 3)
>>> r = p[:1], 5, p[2:]
>>> r
((1,), 5, (3,))

튜플을 리스트로, 리스트를 튜플로 쉽게 바꿀 수도 있답니다.

>>> p = (1, 2, 3)
>>> q = list(p)                  # 튜플 p로 리스트 q를 만듦
>>> q
[1, 2, 3]
>>> r = tuple(q)                 # 리스트 q로 튜플 r을 만듦
>>> r
(1, 2, 3)

 

 

 

매핑

딕셔너리(dict)는 키(key)와 값(value)의 짝으로 이뤄집니다. 이런 것을 매핑이라고 합니다.

>>> type({'one': 1, 'two': 2, 'three': 3})
<class 'dict'>

 

딕셔너리 자료형은 아래와 같이 사용할 수 있습니다.

>>> dic = {}               # dic이라는 이름으로 비어있는 딕셔너리를 만든다.
>>> dic['dictionary'] = '1. A reference book containing an ...'
>>> dic['python'] = 'Any of various nonvenomous snakes of the ...'
>>> dic['dictionary']      # dic아, 'dictionary'가 뭐니?
'1. A reference book containing an ...'

처음에 dic이라는 사전을 하나 만들고, 둘째, 셋째 줄에서는 dic에다가 자료를 좀 집어넣었지요.

그리고, 마지막 줄에선 dictionary의 뜻이 뭔지 조회를 해봤습니다.

 

포켓용 사전을 만들어 볼까요?

>>> smalldic = {'dictionary': 'reference', 'python': 'snake'}
>>> smalldic['python']        # 포켓용 사전아, 'python'이 뭐니??
'snake'                         
>>> smalldic
{'dictionary': 'reference', 'python': 'snake'}

좀 더 깔끔해졌죠? 유심히 보시면 아까와는 조금 다른 방법으로 딕셔너리를 만들었다는 것도 아실 수 있겠지요?

이와 같이 딕셔너리 자료형은 키(key)와 값(value)의 쌍으로 이루어진답니다. 아래의 표를 참고하세요.

 

키                                                                            값

dictionary	주절주절...
python	궁시렁궁시렁...
zoo	동물원

문자열, 리스트, 튜플은 숫자로 된 인덱스를 이용해 값을 조회하는데, 딕셔너리는 키를 이용한다는 것이 큰 차이점이죠. 또, 딕셔너리 자료형은 해싱(hashing) 기법을 이용하기 때문에 자료가 순서대로 저장되지 않는다고 하네요.

딕셔너리 자료형을 만들고, 원소를 추가하는 방법은 위에서 보신 대로이구요, 원소를 삭제할 땐 이렇게 하시면 됩니다.

>>> del smalldic['dictionary']

삭제가 잘 되었는지 한번 확인해 보세요.

 

이번에는 family라는 딕셔너리를 만들어 볼게요.

>>> family = {'mom': 'Kim', 'dad': 'Choi', 'baby': 'Choi'}
>>> family
{'mom': 'Kim', 'dad': 'Choi', 'baby': 'Choi'}

family의 키들을 얻으려면 딕셔너리 이름 뒤에 .keys()를 쓰면 됩니다.

>>> family.keys()
dict_keys(['mom', 'dad', 'baby'])

family의 값들을 얻으려면 딕셔너리 이름 뒤에 .values()를 쓰면 됩니다.

>>> family.values()
dict_values(['Kim', 'Choi', 'Choi'])

family의 원소(키/값 쌍)들을 얻으려면 이름 뒤에 .items()를 쓰면 됩니다.

>>> family.items()
dict_items([('mom', 'Kim'), ('dad', 'Choi'), ('baby', 'Choi')])

딕셔너리에 어떤 키가 있는지 없는지는 in을 써서 알아볼 수 있습니다. 있으면 True, 없으면 False라고 대답해주죠.

>>> 'dad' in family
True
>>> 'sister' in family
False

이런 것들을 외우려고 애쓰실 필요는 없습니다. 필요할 때마다 사용방법을 찾아서 쓰면 되는거지요.

 

 

 

불

참, 거짓을 표현하는 불(bool)도 있습니다.

>>> type(False)
<class 'bool'>
>>> type(3 >= 1)
<class 'bool'>
>>> type(True == 'True')
<class 'bool'>

 

 

출처:wikidocs

 

 

지금까지 배웠던 내용을 간단하게 실습해봅시다.

https://www.mycompiler.io/ko/new/python

새 Python 프로그램 만들기 - 마이컴파일러 - myCompiler

 

위 사이트에서는 별도의 파이썬프로그램 설치 없이도 파이썬 코드를 작성하고 실행시켜 볼 수 있습니다.

 

오늘 배운 내용으로 여러분이 마음껏 실습해보세요

 

 

실습 예시)