[P4C] 파이썬 코딩 도장 : UNIT 8 ~ UNIT 12

unit 8. 불과 비교, 논리 연산자 알아보기

 

• 불과 비교 연산자 사용하기

불은True,False로 표현하며 1,3.6,'Python'처럼 값의 일종이다.

그리고 비교 연산자와 논리 연산자의 판단 결과로 True, False를 사용한다.

>>> 3 > 1
True

 

숫자 또는 문자열이 같은지 비교할 때  ==(equal), 다른지 비교할 때는 !=(not equal)을 사용한다.

>>> 10 == 10    # 10과 10이 같은지 비교
True
>>> 10 != 5     # 10과 5가 다른지 비교
True
>>> 'Python' == 'Python'
True
>>> 'Python' == 'python'
False
>>> 'Python' != 'python'
True

 

부등호는 큰지, 작은지, 크거나 같은지, 작거나 같은지를 판단한다.

 >은 초과, <은 미만, >=은 이상, <=은 이하로 비교 기준은 첫번째 값이다.

>>> 10 > 20    # 10이 20보다 큰지 비교
False
>>> 10 < 20    # 10이 20보다 작은지 비교
True
>>> 10 >= 10    # 10이 10보다 크거나 같은지 비교
True
>>> 10 <= 10    # 10이 10보다 작거나 같은지 비교
True

 

* is와 is not : 객체가 같은지 다른지 비교하기

==, !=는 값 자체를 비교하고, is, is not은 객체(object)를 비교한다.

>>> 1 == 1.0
True
>>> 1 is 1.0
False
>>> 1 is not 1.0
True

1과 1.0은 정수와 실수라는 차이점이 있지만 값은 같다. 따라서 ==로 비교해보면 True가 나온다.

하지만 1과 1.0을 is로 비교해보면 False가 나온다. 왜냐하면 1은 정수 객체, 1.0은 실수 객체이므로 두 객체는 서로 다르기 때문이다.

따라서 값 비교에 is를 사용하면 안된다.

 

 

• 논리 연산자 사용하기

논리 연산자에는 and, or, not이 있다.

and는 두 값이 모두 True라야 True이며, 하나라도 False이면 False가 나온다.

>>> True and True
True
>>> True and False
False
>>> False and True
False
>>> False and False
False
>>> 

 

or는 두 값 중 하나라도 True이면 True이며, 두 값이 모두 False라야 False가 된다.

>>> True or True
True
>>> True or False
True
>>> False or True
True
>>> False or False
False

 

not은 논릿값을 뒤집어, not True는 False가 되고, not False는 True가 된다.

>>> not True
False
>>> not False
True

 

여기서 and, or, not 논리 연산자가 식 하나에 들어있으면 어떠할까?

바로 연산자 우선순위에 따라 not, and, or 순으로 판단한다.

>>> not True and False or not False
True

이 식을 괄호로 표현하면 다음과 같은 모양이 된다.

>>> ((not True) and False) or (not False)
True

 

※ 논리 연산자와 비교 연산자를 함께 사용할 때

>>> 10 == 10 and 10 != 5    # True and True
True
>>> 10 > 5 or 10 < 3        # True or False
True
>>> not 10 > 5              # not True
False
>>> not 1 is 1.0            # not False
True

비교 연산자로 비교한 결과를 논리 연산자로 다시 판단하면 된다.

즉, 연산자의 우선순위에 따라 비교 연산자(is, is not, ==, !=, <, >, <=, >=)를 먼저 판단하고 논리 연산자(not, and, or)를 판단하게 된다.

 

 

참고 | 정수, 실수, 문자열을 불로 만들기

 

정수, 실수, 문자열을 불로 만들 때는 bool을 사용하면 된다.

>>> bool(1)
True
>>> bool(0)
False
>>> bool(1.5)
True
>>> bool('False')
True

이때, 정수는 0, 실수는 0.0이외의 모든 숫자는 True이다. 그리고 문자열의 경우 빈 문자열 '', ""를 제외한 모든 문자열은 True이다.

 

참고 | 단락 평가

 

단락 평가는 첫 번째 값만으로 결과가 확실할 때 두 번째 값은 확인(평가)하지 않는 방법을 말한다.

 

즉, and 연산자는 두 값이 모두 참이라야 참이므로 첫 번째 값이 거짓이면 두 번째 값은 확인하지 않고 바로 거짓으로 결정한다.

# 첫 번째 값이 거짓이므로 두 번째 값은 확인하지 않고 거짓으로 결정
print(False and True)     # False
print(False and False)    # False

 

or 연산자는 두 값 중 하나만 참이라도 참이므로 첫 번째 값이 참이면 두 번째 값은 확인하지 않고 바로 참으로 결정한다.

# 첫 번째 값이 참이므로 두 번째 값은 확인하지 않고 참으로 결정
print(True or True)     # True
print(True or False)    # True

 

특히 파이썬에서 논리 연산자는 이 단락 평가에 따라 반환하는 값이 결정된다. 

True, False를 논리 연산자로 확인하면 True, False가 나왔는데, 

True and 'Python'의 결과는 무엇이 나올까?

>>> True and 'Python'
'Python'
>>> 'Python' and True
True
>>> 'Python' and False
False

문자열 'Python'도 불로 따지면 True라서 True and True가 되어 True가 나올 것 같지만 'Python'이 나온다.

왜냐하면 파이썬에서 논리 연산자는 마지막으로 단락 평가를 실시한 값을 그대로 반환하기 때문이다. 따라서 논리 연산자는 무조건 불을 반환하지 않는다.

 

 

 

UNIT 9. 문자열 사용하기

 

• 문자열

파이썬에서는 문자열을 만드는 여러 가지 방법이 있다.

1. ' ' (작은따옴표)로 묶기

2. " " (큰 따옴표)로 묶기

3. ' ' '(작은따옴표 3개)로 묶기

4. " " " (큰따옴표 3개로 묶기)

>>> hello = '안녕하세요'
>>> hello
'안녕하세요'
>>> hello = "Hello, world!"
>>> hello
'Hello, world!'
>>> hello = '''Hello, Python!'''
>>> hello
'Hello, Python!'
>>> python = """Python Programming"""
>>> python
'Python Programming'

 

* 여러 줄로 된 문자열을 사용하고자 할 때

>>> hello = '''Hello, world!
안녕하세요.
Python입니다.'''
>>> print(hello)
Hello, world!
안녕하세요.
Python입니다.

여러 줄로 된 문자열은 '''(작은따옴표 3개)로 시작하여 '''로 끝나거나 """(큰따옴표 3개)로 시작하여 """로 끝내면 된다.

 

* 문자열 안에 작은따옴표나 큰 따옴표를 포함할 때

>>> s = "Python isn't difficult"
>>> s
"Python isn't difficult"

문자열 안에 '(작은따옴표)를 넣고 싶다면 문자열을 "(큰따옴표)로 묶어주면 된다. 이렇게 하면 문자열 안에 '를 그대로 사용할 수 있다. 또 반대로 문자열 안에 "(큰따옴표)를 넣고 싶다면 문자열을 '(작은따옴표)로 묶어준다.

하지만 작은따옴표 안에 작은따옴표를 넣거나 큰따옴표 안에 큰따옴표를 넣으면 구문 에러가 발생해 실행이 되지 않는다.

 

+ 그런데 여러 줄로 된 문자열의 경우엔 작은따옴표 안에 작은따옴표와 큰따옴표를 둘 다 넣을 수 있다. 또한, 큰따옴표 안에도 작은따옴표와 큰따옴표를 넣을 수 있다.

 

 

 

 

UNIT 10. 리스트와 튜플 사용하기

 

• 리스트 만들기

지금까지는 변수에 값을 한 개씩만 저장했다. 그렇지만, 여러 값을 저장할 땐 변수에 값을 일일히 한 개씩만 저장하는 것은 쉽지 않을 것이다.

이때, 리스트를 사용해 여러 값을 하나의 변수에 저장하면 편리하다.

리스트는 말 그대로 목록이라는 뜻이며 값을 일렬로 늘어놓은 형태이다.

 

 

*리스트 만들기

변수에 값을 저장할 때 [ ](대괄호)로 묶어주면 리스트가 되며 각 값은 ,(콤마)로 구분해준다.

>>> a = [38, 21, 53, 62, 19]
>>> a
[38, 21, 53, 62, 19]

리스트에 저장된 각 값은 요소(element)라고 부른다.

또한 리스트는 문자열, 정수, 실수, 불 등 모든 자료형을 저장할 수 있으며, 자료형을 섞어서 저장해도 된다.

>>> person = ['james', 17, 175.3, True]
>>> person
['james', 17, 175.3, True]

 

그리고 빈 리스트를 만들고자 할 때는 [ ]만 지정하거나 list를 사용하면 된다.

>>> a = []
>>> a
[]
>>> b = list()
>>> b
[]

 

* range를 사용하여 리스트 만들기

 

range는 연속된 숫자를 생성하는데 예를 들어 range에 10(횟수)을 지정하면 0부터 9까지 숫자를 생성한다.

>>> range(10)
range(0, 10)

참고로 range(0, 10)이라고 나와서 10까지 생성될 것 같지만 10은 포함되지 않는다.

 

그래서 list에 range(10)을 넣어보면 0부터 9까지 들어있는 리스트가 생성된다.

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

 

또한 range는 시작하는 숫자와 끝나는 숫자를 지정할 수도 있으며, 이때도 끝나는 숫자는 생성되는 숫자에 포함되지 않는다.

>>> b = list(range(5, 12))
>>> b
[5, 6, 7, 8, 9, 10, 11]

 

마지막으로 증가폭을 사용할 수도 있다.

range에 증가폭을 지정하면 해당 값만큼 증가하면서 숫자를 생성한다.

>>> c = list(range(-4, 10, 2))
>>> c
[-4, -2, 0, 2, 4, 6, 8]

 

 

• 튜플 사용하기

파이썬에서는 튜플이라는 자료형도 제공한다.

튜플은 리스트처럼 요소를 일렬로 저장하지만, 안에 저장된 요소를 변경, 추가, 삭제를 할 수 없다. 그래서 읽기 전용 리스트라고 할 수 있다.

 

변수에 값을 저장할 때 ( )(괄호)로 묶어주면 튜플이 되며 각 값은 ,(콤마)로 구분해준다.

>>> a = (38, 21, 53, 62, 19)
>>> a
(38, 21, 53, 62, 19)

튜플도 리스트처럼 여러 자료형을 섞어서 저장해도 된다.

 

보통 튜플은 요소가 절대 변경되지 않고 유지되어야 할 때 사용하며, 반면 요소를 자주 변경해야 할 때는 리스트를 사용한다.

또한 요소가 한 개인 튜플을 만들 때는 ( )(괄호) 안에 값 한 개를 넣고 ,(콤마)를 붙이는데 괄호로 묶지 않고 값 한 개에 ,를 붙여도 된다.

 

• 튜플 = (값, )

• 튜플 = 값,

 

* range를 사용하여 튜플 만들기

tuple 안에 range를 넣으면 튜플이 생성되는데, 리스트에서 했던 것과 동일하다.

 

• 튜플 = tuple(range(횟수))

• 튜플 = tuple(range(시작, 끝))

• 튜플 = tuple(range(시작, 끝, 증가폭))

 

 

* 튜플을 리스트로 만들고 리스트를 튜플로 만들기

튜플과 리스트는 요소를 변경, 추가, 삭제할 수 있는지 없는지만 다를 뿐 기능과 형태는 같다. 따라서 튜플을 리스트로 만들거나 리스트를 튜플로 만들 수도 있다.

tuple 안에 리스트를 넣으면 새 튜플이 생긴다.

>>> a = [1, 2, 3]
>>> tuple(a)
(1, 2, 3)

반대로 list 안에 튜플을 넣으면 새 리스트가 생성된다.

 

 

 

unit 11. 시퀀스 자료형 활용하기

 

• 시퀀스 자료형의 공통 기능 사용하기

시퀀스 자료형(sequence types)? 리스트, 튜플, range, 문자열처럼 값이 연속적으로 이어진 자료형

시퀀스 자료형의 가장 큰 특징은 공통된 동작과 기능을 제공한다는 것이다.

 

시퀀스 자료형으로 만든 객체를 시퀀스 객체라고 하며, 시퀀스 객체에 들어있는 각 값을 요소(element)라고 한다.

 

* 특정 값이 있는지 확인할 때

시퀀스 객체 안에 특정 값이 있는지 확인할 때는 in 연산자를 사용한다.

in 연산자를 사용했을 때 특정 값이 있으면 True, 없으면 False가 나오며, 반대로 in 앞에 not을 붙이면 특정 값이 없는지 확인한다.

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> 30 in a
True
>>> 100 in a
False

물론 튜플, range, 문자열도 같은 방법으로 활용할 수 있습니다.

>>> 43 in (38, 76, 43, 62, 19)
True
>>> 1 in range(10)
True
>>> 'P' in 'Hello, Python'
True

 

* 시퀀스 객체 연결하기

시퀀스 객체는 + 연산자를 사용하여 객체를 서로 연결하여 새 객체를 만들 수 있다.

 

• 시퀀스객체1 + 시퀀스객체2

>>> a = [0, 10, 20, 30]
>>> b = [9, 8, 7, 6]
>>> a + b
[0, 10, 20, 30, 9, 8, 7, 6]

단, 시퀀스 자료형 중에서 range는 + 연산자로 객체를 연결할 수 없어 range를 리스트 또는 튜플로 만들어서 연결해야 한다.

>>> list(range(0, 10)) + list(range(10, 20))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> tuple(range(0, 10)) + tuple(range(10, 20))
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)

또 문자열과 문자열은 + 연산자로 연결될 수 있으며,

문자열에 숫자를 연결하고자 할 때는 str()을 통해 숫자를 문자열로 변환한 뒤 연결해줄 수 있다.

• '문자열' + str(정수)

• '문자열' + str(실수)

 

* 시퀀스 객체 반복하기

연산자는 시퀀스 객체를 특정 횟수만큼 반복하여 새 시퀀스 객체를 만든다. (단, 음수나 0, 실수는 곱할 수 없음)

>>> [0, 10, 20, 30] * 3
[0, 10, 20, 30, 0, 10, 20, 30, 0, 10, 20, 30]

앞에서 range는 + 연산자로 객체를 연결할 수 없었던 것처럼 range는 * 연산자를 사용하여 반복할 수 없다.

이때는 range를 리스트 또는 튜플로 만들어서 반복하면 됩니다.

>>> list(range(0, 5, 2)) * 3
[0, 2, 4, 0, 2, 4, 0, 2, 4]
>>> tuple(range(0, 5, 2)) * 3
(0, 2, 4, 0, 2, 4, 0, 2, 4)

 

 

• 시퀀스 객체의 요소 개수 구하기

시퀀스 객체의 요소의 개수(길이)를 구할 때는 len 함수를 사용한다.

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> len(a)
10

>>> b = (38, 76, 43, 62, 19)
>>> len(b)
5

>>> len(range(0, 10, 2))
5

실무에서는 보통 range 등을 사용하여 리스트(튜플)를 생성하거나, 다양한 방법으로 요소를 추가, 삭제, 반복하므로 요소의 개수가 한눈에 보이지 않는다. 그래서 요소의 개수를 구하는 len 함수를 자주 활용하게 될 것이다.

문자열도 시퀀스 자료형이므로 len 함수를 사용하면 되는데, 공백도 문자열의 길이에 포함한다.

>>> hello = 'Hello, world!'
>>> len(hello)
13

 

 

• 인덱스 사용하기

시퀀스 객체의 각 요소는 순서가 정해져 있으며, 이 순서를 인덱스라고 부른다.

시퀀스 객체에 [ ](대괄호)를 붙이고 [ ] 안에 각 요소의 인덱스를 지정하면 해당 요소에 접근할 수 있다.

>>> a = [38, 21, 53, 62, 19]
>>> a[0]    # 리스트의 첫 번째(인덱스 0) 요소 출력
38
>>> a[2]    # 리스트의 세 번째(인덱스 2) 요소 출력
53
>>> a[4]    # 리스트의 다섯 번째(인덱스 4) 요소 출력
19

인덱스(index, 색인)는 위치 값을 뜻하는데 주의할 점은 시퀀스 객체의 인덱스는 항상 0부터 시작한다는 것이다.

그리고 튜플, range, 문자열도 [ ]에 인덱스를 지정하면 해당 요소를 가져올 수 있다.

>>> b = (38, 21, 53, 62, 19)
>>> b[0]        # 튜플의 첫 번째(인덱스 0) 요소 출력
38
>>> r = range(0, 10, 2)
>>> r[2]        # range의 세 번째(인덱스 2) 요소 출력
4
>>> hello = 'Hello, world!'
>>> hello[7]    # 문자열의 여덟 번째(인덱스 7) 요소 출력
'w'

 

* 음수 인덱스 지정하기

시퀀스 객체에 인덱스를 음수로 지정하면 뒤에서부터 요소에 접근하게 된다.

>>> a = [38, 21, 53, 62, 19]
>>> a[-1]   # 리스트의 뒤에서 첫 번째(인덱스 -1) 요소 출력
19
>>> a[-5]   # 리스트의 뒤에서 다섯 번째(인덱스 -5) 요소 출력
38

튜플, range, 문자열에도 동일하게 적용된다.

 

 

* 인덱스의 범위를 벗어나면?

리스트의 인덱스가 범위를 벗어났다는 IndexError가 발생하기 때문에, 마지막 요소의 인덱스는 시퀀스 객체의 요소 개수보다 1 작다는 걸 생각해야 한다.

 

 

* 마지막 요소에 접근할 때

시퀀스 객체에 인덱스를 -1로 지정하면 된다. 

한 가지 방법이 더 있는데 len으로 시퀀스 객체의 길이를 구한 다음 거기서 1을 뺀 값을 인덱스로 지정하면 된다.

>>> a = [38, 21, 53, 62, 19]
>>> len(a)    # 리스트의 길이를 구함
5
>>> a[len(a) - 1]    # 마지막 요소(인덱스 4) 출력
19

 

* 요소에 값 할당하기

시퀀스 객체는 [ ]로 요소에 접근한 뒤 =로 값을 할당하면 된다.

 

• 시퀀스객체[인덱스] = 값

>>> a = [0, 0, 0, 0, 0]    # 0이 5개 들어있는 리스트
>>> a[0] = 38
>>> a[1] = 21
>>> a[2] = 53
>>> a[3] = 62
>>> a[4] = 19
>>> a
[38, 21, 53, 62, 19]

이때, 튜플은 안에 저장된 요소를 변경할 수 없기 때문에, 다음과 같이 튜플의 [ ]에 인덱스를 지정한 뒤 값을 할당하면 에러가 발생한다.

>>> b = (0, 0, 0, 0, 0)
>>> b[0] = 38
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    b[0] = 38
TypeError: 'tuple' object does not support item assignment 

마찬가지로 range와 문자열도 안에 저장된 요소를 변경할 수 없다.

 

* del로 요소 삭제하기

요소 삭제는 다음과 같이 del 뒤에 삭제할 요소를 지정해주면 된다.

 

• del 시퀀스객체[인덱스]

>>> a = [38, 21, 53, 62, 19]
>>> del a[2]
>>> a
[38, 21, 62, 19]

리스트와는 달리 튜플은 요소를 삭제할 수 없다.

>>> b = (38, 21, 53, 62, 19)
>>> del b[2]
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    del b[2]
TypeError: 'tuple' object doesn't support item deletion 

마찬가지로 range와 문자열도 안에 저장된 요소를 삭제할 수 없다. 

 

 

• 슬라이스 사용하기

슬라이스(slice)는 무엇인가의 일부를 잘라낸다는 뜻인데, 시퀀스 슬라이스도 말 그대로 시퀀스 객체의 일부를 잘라낸다.

시퀀스객체[시작인데스:끝인덱스]

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[0:4]     # 인덱스 0부터 3까지 잘라서 새 리스트를 만듦
[0, 10, 20, 30]

여기서 주의할 점이 있는데, 끝 인덱스는 가져오려는 범위에 포함되지 않는다. 따라서 끝 인덱스는 실제로 가져오려는 인덱스보다 1을 더 크게 지정해야 한다.

예를 들어 요소가 10개 들어있는 리스트를 처음부터 끝까지 가져오려면 [0:9]가 아닌 [0:10]이라야 한다.

>>> a[0:10]    # 인덱스 0부터 9까지 잘라서 새 리스트를 만듦
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]

정리하자면 슬라이스를 했을 때 실제로 가져오는 요소는 시작 인덱스부터 끝 인덱스 - 1까지이다.

또한 음수를 인덱스로 지정할 수도 있는데, 표현방법만 다를 뿐 양수 인덱스와 똑같이 생각하면 된다.

>>> a[4:-1]    # 인덱스 4부터 -2까지 요소 5개를 가져옴
[40, 50, 60, 70, 80]

 

* 인덱스 증가폭 사용하기

슬라이스는 인덱스의 증가폭을 지정하여 범위 내에서 인덱스를 건너뛰며 요소를 가져올 수 있다.

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[2:8:3]    # 인덱스 2부터 3씩 증가시키면서 인덱스 7까지 가져옴
[20, 50]

 

* 인덱스 생략하기

슬라이스를 사용할 때 시작 인덱스와 끝 인덱스를 생략할 수도 있다.

먼저 시작 인덱스를 생략하면 다음과 같다.

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[:7]    # 리스트 처음부터 인덱스 6까지 가져옴
[0, 10, 20, 30, 40, 50, 60]

반대로 끝 인덱스를 생략하면 시작 인덱스(인덱스 7)부터 마지막 요소까지 가져온다.

>>> a[7:]    # 인덱스 7부터 마지막 요소까지 가져옴
[70, 80, 90]

또는, a[:]와 같이 시작 인덱스와 끝 인덱스를 둘다 생략하면 리스트 전체를 가져옵니다.

>>> a[:]     # 리스트 전체를 가져옴
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]

 

* 인덱스를 생략하면서 증가폭 사용하기

 

• 시퀀스객체[:끝인덱스:증가폭]
• 시퀀스객체[시작인덱스::증가폭]
• 시퀀스객체[::증가폭]

 

 

리스트 a에서 a[:7:2]와 같이 시작 인덱스를 생략하면서 인덱스 증가폭을 2로 지정하면 리스트의 처음부터 인덱스를 2씩 증가시키면서 끝 인덱스 - 1(인덱스 6)까지 요소를 가져온다.

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[:7:2]    # 리스트의 처음부터 인덱스를 2씩 증가시키면서 인덱스 6까지 가져옴
[0, 20, 40, 60]

 

참고 | 슬라이스의 인덱스 증가폭을 음수로 지정하면?

인덱스 증가폭을 음수로 지정하면 요소를 뒤에서부터 가져올 수 있다.

여기서 주의할 점은 인덱스가 감소하므로 끝 인덱스보다 시작 인덱스를 더 크게 지정해야 한다는 점이다.

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[5:1:-1]
[50, 40, 30, 20]

 

* len 응용하기

len을 응용하여 리스트 전체를 가져올 수 있다.

끝 인덱스는 가져오려는 인덱스보다 1을 더 크게 지정한다고 했으므로 len(a)을 인덱스로 지정하면 된다.

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[0:len(a)]    # 시작 인덱스에 0, 끝 인덱스에 len(a) 지정하여 리스트 전체를 가져옴
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[:len(a)]     # 시작 인덱스 생략, 끝 인덱스에 len(a) 지정하여 리스트 전체를 가져옴
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]

※ 파이썬에서는 튜플, range, 문자열도 시퀀스 자료형이므로 리스트와 같은 방식으로 슬라이스를 사용할 수 있다.

 

 

* 슬라이스에 요소 할당하기

시퀀스 객체는 슬라이스로 범위를 지정하여 여러 요소에 값을 할당할 수 있다.

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[2:5] = ['a', 'b', 'c']    # 인덱스 2부터 4까지 값 할당
>>> a
[0, 10, 'a', 'b', 'c', 50, 60, 70, 80, 90]

단, 앞에서와 마찬가지로 튜플, range, 문자열은 슬라이스 범위를 지정하더라도 요소를 할당할 수 없다.

 

 

* del로 슬라이스 삭제하기

슬라이스 삭제는 다음과 같이 del 뒤에 삭제할 범위를 지정해주면 된다.

 

• del 시퀀스객체[시작인덱스:끝인덱스]

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> del a[2:5]    # 인덱스 2부터 4까지 요소를 삭제
>>> a
[0, 10, 50, 60, 70, 80, 90]

또 물론 튜플, range, 문자열은 del로 슬라이스를 삭제할 수 없다.

 

 

 

 

unit 12. 딕셔너리 사용하기

 

• 딕셔너리 만들기

지금까지 살펴봤던 리스트와 튜플은 값 여러 개를 일렬로 저장할 뿐 값끼리 연관 관계가 없었다.

-> 파이썬은 연관된 값을 묶어서 저장하는 용도로 딕셔너리라는 자료형을 제공한다.

 

예를 들어 게임 캐릭터의 능력치를 딕셔너리에 저장해보겠다.

lux = {'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}

딕셔너리만 봐도 lux라는 캐릭터의 체력(health)은 490, 마나(mana)는 334, 사거리(melee)는 550, 방어력(armor)은 18.72라는 것을 쉽게 알 수 있다.

이처럼 딕셔너리는 값마다 이름을 붙여서 저장하는 방식이다.

 

 

* 딕셔너리 만들기

딕셔너리는 { }(중괄호) 안에 키: 값 형식으로 저장하며 각 키와 값은 ,(콤마)로 구분해준다. 그리고 키-값은 1:1 대응이 되어야한다.

 

• 딕셔너리 = {키1: 값1, 키2: 값2}

>>> lux = {'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}
>>> lux
{'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}

 

*키 이름이 중복될 땐?

>>> lux = {'health': 490, 'health': 800, 'mana': 334, 'melee': 550, 'armor': 18.72}
>>> lux['health']    # 키가 중복되면 가장 뒤에 있는 값만 사용함
800
>>> lux    # 중복되는 키는 저장되지 않음
{'health': 800, 'mana': 334, 'melee': 550, 'armor': 18.72}

딕셔너리에 키와 값을 저장할 때 키가 중복되면 가장 뒤에 있는 값만 사용한다.

 

 

* 딕셔너리 키의 자료형

딕셔너리의 키는 문자열뿐만 아니라 정수, 실수, 불도 사용할 수 있으며 자료형을 섞어서 사용해도 된다.

>>> x = {100: 'hundred', False: 0, 3.5: [3.5, 3.5]}
>>> x
{100: 'hundred', False: 0, 3.5: [3.5, 3.5]}
>>> x = {[10, 20]: 100}
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    x = {[10, 20]: 100}
TypeError: unhashable type: 'list'

단, 키에는 리스트와 딕셔너리를 사용할 수 없다. 반면 값에는 리스트, 딕셔너리 등을 포함하여 모든 자료형을 사용할 수 있다.

 

 

* 빈 딕셔너리 만들기

빈 딕셔너리를 만들 때는 { }만 지정하거나 dict를 사용하면 된다.

 

- 딕셔너리 = dict()

- 딕셔너리 = { }

 

 

* dict로 딕셔너리 만들기

dict는 다음과 같이 키와 값을 연결하거나, 리스트, 튜플, 딕셔너리로 딕셔너리를 만들 때 사용한다.

 

- 딕셔너리 = dict(키1=값1, 키2=값2)

- 딕셔너리 = dict(zip([키1, 키2], [값1, 값2]))

- 딕셔너리 = dict([(키1, 값1), (키2, 값2)])

- 딕셔너리 = dict({키1: 값1, 키2: 값2})

 

dict에서 키=값 형식으로 딕셔너리를 만들 수 있다. 이때 키에 ' '(작은따옴표)나 " "(큰따옴표)를 사용하지 않아야 한다.

>>> lux1 = dict(health=490, mana=334, melee=550, armor=18.72)    # 키=값 형식으로 딕셔너리를 만듦
>>> lux1
{'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}

두 번째 방법은 dict에서 zip 함수를 이용하는 방법이다. 다음과 같이 키가 들어있는 리스트와 값이 들어있는 리스트를 차례대로 zip에 넣은 뒤 다시 dict에 넣어주면 된다.

>>> lux2 = dict(zip(['health', 'mana', 'melee', 'armor'], [490, 334, 550, 18.72]))    # zip 함수로
>>> lux2                                                            # 키 리스트와 값 리스트를 묶음
{'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}

zip 함수는 반복 가능한 객체 여러 개를 넣으면 요소 순서대로 튜플로 묶어서 zip 객체를 반환한다.

세 번째 방법은 리스트 안에 (키, 값) 형식의 튜플을 나열하는 방법이다.

>>> lux3 = dict([('health', 490), ('mana', 334), ('melee', 550), ('armor', 18.72)])
>>> lux3                                                  # (키, 값) 형식의 튜플로 딕셔너리를 만듦
{'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72} 

네 번째 방법은 dict 안에서 중괄호로 딕셔너리를 생성하는 방법이다.

>>> lux4 = dict({'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72})     # dict 안에서
>>> lux4                                                           # 중괄호로 딕셔너리를 만듦
{'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}

 

 

• 딕셔너리의 키에 접근하고 값 할당하기

딕셔너리의 키에 접근할 때는 딕셔너리 뒤에 [ ](대괄호)를 사용하며 [ ] 안에 키를 지정해주면 된다.

>>> lux = {'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}
>>> lux['health']
490
>>> lux['armor']
18.72

 

딕셔너리의 키에 값 할당하기

딕셔너리는 [ ]로 키에 접근한 뒤 값을 할당한다.

>>> lux = {'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}
>>> lux['health'] = 2037    # 키 'health'의 값을 2037로 변경
>>> lux['mana'] = 1184      # 키 'mana'의 값을 1184로 변경
>>> lux
{'health': 2037, 'mana': 1184, 'melee': 550, 'armor': 18.72}

딕셔너리는 없는 키에 값을 할당하면 해당 키가 추가되고 값이 할당된다.

>>> lux['mana_regen'] = 3.28    # 키 'mana_regen'을 추가하고 값 3.28 할당
>>> lux
{'health': 2037, 'mana': 1184, 'melee': 550, 'armor': 18.72, 'mana_regen': 3.28}

 

* 딕셔너리에 키가 있는지 확인하기

딕셔너리에서 키가 있는지 확인하고 싶다면 in 연산자를 사용하면 된다.

 

- 키 in 딕셔너리

- 키 not in 딕셔너리

>>> lux = {'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}
>>> 'health' in lux
True
>>> 'attack_speed' in lux
False

 

* 딕셔너리의 키 개수 구하기

키의 개수는 len 함수를 이용해 구하며, 키와 값은 1:1 관계이므로 키의 개수는 곧 값의 개수이다.

>>> lux = {'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72}
>>> len(lux)
4
>>> len({'health': 490, 'mana': 334, 'melee': 550, 'armor': 18.72})
4