Python 기초 문법 (2)

Unit 8 불(boolean)과 비교, 논리 연산자

1) 불(boolean) & 비교 연산자

불은 True, False로 표현하며 1(정수), 3.6(실수), 'Python'(문자열)처럼 값의 일종

 

파이썬에서는 비교 연산자와 논리 연산자의 판단 결과로 True, False를 사용함.

즉, 비교 결과가 맞으면 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은 객체(object)를 비교

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

 

1과 1.0은 값은 같지만 1은 정수 객체, 1.0은 실수 객체이므로 두 객체는 서로 다르기 때문에 1 is 1.0은 False임.

 

2) 논리 연산자

논리 연산자는 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
False and False or True
False or True
True

 

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

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

 

 

 

Unit 9 문자열 사용하기

' '(작은따옴표) 혹은 " "(큰따옴표)로 묶어서 출력

>>> hello = '안녕하세요'
>>> hello
'안녕하세요'

>>> hello = "Hello, world!"
>>> hello
'Hello, world!'

 

'''(작은따옴표 3개)로 묶거나 """(큰따옴표 3개)로 묶을 수도 있음.

>>> hello = '''Hello, Python!'''
>>> hello
'Hello, Python!'
>>> python = """Python Programming"""
>>> python
'Python Programming'

 

'''나 """은 여러줄로 된 문자열도 출력 가능함.

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

 

문자열 안에 '(작은따옴표)를 넣고 싶다면 문자열을 "(큰따옴표)로 묶어줌.

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

 

반대로 문자열 안에 "(큰따옴표)를 넣고 싶다면 문자열을 '(작은따옴표)로 묶어줌.

>>> s = 'He said "Python is easy"'
>>> s
'He said "Python is easy"'

 

💡참고

[문자열에 따옴표를 포함하는 다른 방법]

작은따옴표 앞에 \(역슬래시)를 붙이면 작은따옴표 안에 작은따옴표를 넣을 수 있음. 큰따옴표도 마찬가지임.

>>> 'Python isn\'t difficult'
"Python isn't difficult"

 

 

Unit 10 리스트와 튜플

1) 리스트

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

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

 

리스트는 문자열, 정수, 실수, 불(bool) 등 모든 자료형을 저장할 수 있으며 자료형을 섞어서 저장 가능

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

 

빈 리스트를 만들 때는 [ ]만 지정하거나 list를 사용함.

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

 

range는 연속된 숫자를 생성하는데 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]

 

만약 증가폭을 음수로 지정하면 해당 값만큼 숫자가 감소함.

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

 

2) 튜플

튜플은 리스트처럼 요소를 일렬로 저장하지만, 안에 저장된 요소를 변경, 추가, 삭제를 할 수 없음.

간단하게 읽기 전용 리스트라고 할 수 있음.

 

변수에 값을 저장할 때 ( )(괄호)로 묶어주면 튜플이 되며 각 값은 ,(콤마)로 구분해줌. 또는, 괄호로 묶지 않고 값만 콤마로 구분해도 튜플이 됨.

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

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

 

튜플도 리스트처럼 여러 자료형을 섞어서 저장 가능

>>> person = ('james', 17, 175.3, True)
>>> person
('james', 17, 175.3, True)

 

보통 튜플은 요소가 절대 변경되지 않고 유지되어야 할 때 사용

튜플을 만든 상태에서 요소를 변경하게 되면 에러가 발생함. 따라서 요소를 실수로 변경하는 상황을 방지할 수 있음.

반면 요소를 자주 변경해야 할 때는 리스트를 사용함. 보통 실무에서는 요소를 변경하는 경우가 많기 때문에 튜플보다 리스트를 더 자주 사용하는 편임.

 요소가 한 개 들어있는 튜플 만들기

지금까지 요소가 여러 개 들어있는 튜플을 만들었습니다. 그럼 요소가 한 개 들어있는 튜플은 어떻게 만들까요? 다음과 같이 값 한 개를 괄호로 묶으면 튜플이 아니라 그냥 값이 됩니다.

>>> (38)
38

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

• 튜플 = (값, )
• 튜플 = 값,

>>> (38, )
(38,)
>>> 38,
(38,)

튜플은 요소를 변경, 추가, 삭제할 수도 없는데 값 한 개짜리 튜플은 왜 필요할까요? 함수(클래스)를 사용하다 보면 값이 아닌 튜플을 넣어야 할 경우가 생깁니다. 이때 값은 한 개지만 튜플을 넣어야 할 때 (값, )과 같은 형식을 사용해야 합니다. 실무에서는 가끔 이 문법을 사용하게 되는데, 그냥 튜플 형태를 유지하기 위한 문법이라고 생각하면 됩니다.

 

 

다음과 같이 tuple 안에 range를 넣으면 튜플이 생성됨.

>>> c = tuple(range(-4, 10, 2))
>>> c
(-4, -2, 0, 2, 4, 6, 8)

 

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

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

 

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

>>> b = (4, 5, 6)
>>> list(b)
[4, 5, 6]

 

 

Unit 11 시퀀스 자료형 활용

리스트, 튜플, range, 문자열는 모두 값이 연속적(sequence)으로 이어져 있다는 공통점이 있음.

파이썬에서는 리스트, 튜플, range, 문자열처럼 값이 연속적으로 이어진 자료형을 시퀀스 자료형(sequence types)라고 부름.

이 시퀀스 자료형 중에서 list, tuple, range, str을 주로 사용하며 bytes, bytearray라는 자료형도 있음.

 

 

1️⃣ 시퀀스 자료형의 공통 기능 사용하기

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

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

1) 특정 값이 있는지 확인하기

시퀀스 객체에 in 연산자를 사용했을 때 특정 값이 있으면 True, 없으면 False

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

 

반대로 in 앞에 not을 붙이면 특정 값이 없는지 확인

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

 

튜플, range, 문자열도 같은 방법으로 활용 가능

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

 

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)

 

3) 시퀀스 객체 반복하기

* 연산자를 사용해 시퀀스 객체를 특정 횟수만큼 반복하여 새 시퀀스 객체를 만들 수 있음.

(0 또는 음수를 곱하면 빈 객체가 나오며 실수는 곱할 수 없음.)

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

 

앞에서와 마찬가지로 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)

 

2️⃣ 시퀀스 객체의 요소 개수 구하기

 

1) 리스트, 튜플 요소 개수 구하기

시퀀스 객에 있는 요소의 개수(길이)를 구할 때는 len 함수를 사용

 

리스트의 요소 개수 구하기

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

 

튜플의 요소 개수 구하기

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

 

2) range의 숫자 생성 개수 구하기

range에 len 함수를 사용하여 숫자가 생성되는 개수를 구함.

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

range(0, 10, 2)는 0부터 10까지 2씩 증가하므로 0, 2, 4, 6, 8

 

3) 문자열 길이 구하기

문자열도 시퀀스 자료형이므로 len 함수를 사용

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

여기서 문자열의 길이는 공백까지 포함.(문자열을 묶은 따옴표는 제외)

 

3️⃣ 인덱스 사용하기

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

 

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

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

 

여기서 주의할 점은 시퀀스 객체의 인덱스는 항상 0부터 시작한다는 것임.

(대다수의 프로그래밍 언어는 인덱스가 0부터 시작). 따라서 리스트 a의 첫 번째 요소는 a[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'

 

1) 음수 인덱스 지정

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

즉, -1은 뒤에서 첫 번째, -5는 뒤에서 다섯 번째 요소임.

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

 

튜플, range, 문자열도 음수 인덱스를 지정하면 뒤에서부터 요소에 접근

>>> b = (38, 21, 53, 62, 19)
>>> b[-1]        # 튜플의 뒤에서 첫 번째(인덱스 -1) 요소 출력
19

>>> r = range(0, 10, 2)
>>> r[-3]        # range의 뒤에서 세 번째(인덱스 -3) 요소 출력
4

>>> hello = 'Hello, world!'
>>> hello[-4]    # 문자열의 뒤에서 네 번째(인덱스 -4) 요소 출력
'r'

 

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

시퀀스 객체를 만들면 요소의 개수는 정해져 있음.

다음과 같이 리스트를 만든 뒤 범위를 벗어난 인덱스에 접근하면 IndexError가 발생함.

>>> a = [38, 21, 53, 62, 19]
>>> a[5]    # 인덱스 5는 범위를 벗어났으므로 에러
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    a[5]
IndexError: list index out of range 

인덱스는 0부터 시작하므로 마지막 요소의 인덱스는 4이기 때문에 a[5]는 범위를 벗어나게 됨.

 

마찬가지로 튜플, range, 문자열도 범위를 벗어난 인덱스를 지정하면 IndexError가 발생함.

 

2) 마지막 요소에 접근하기

시퀀스 객체에 인덱스를 -1로 지정하면 뒤에서 첫 번째 요소에 접근

-> 시퀀스 객체의 마지막 요소 == len 함수를 이용해 길이를 구한 뒤 이 길이에서 1을 뺀 숫자 

>>> a = [38, 21, 53, 62, 19]
>>> a[len(a) - 1]    # 마지막 요소(인덱스 4) 출력
19

 

3) 요소에 값 할당하기

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

>>> 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]
>>> a[0]
38
>>> a[4]
19

 

단, 이때도 범위를 벗어난 인덱스는 지정할 수는 없음.

 

튜플, range, 문자열은 안에 저장된 요소를 변경할 수 없음.

즉, 시퀀스 자료형 중에서 튜플, range, 문자열은 읽기 전용

# 튜플
>>> 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
>>> r = range(0, 10, 2)
>>> r[0] = 3
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    r[0] = 3
TypeError: 'range' object does not support item assignment 

# 문자열
>>> hello = 'Hello, world!'
>>> hello[0] = 'A'
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    hello[0] = 'A'
TypeError: 'str' object does not support item assignment

 

4) del로 요소 삭제하기

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

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

 

튜플, range, 문자열은 읽기 전용이기 때문에 요소 삭제 불가

# 튜플
>>> 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
>>> r = range(0, 10, 2)
>>> del r[2]
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    del r[2]
TypeError: 'range' object doesn''t support item deletion

# 문자열
>>> hello = 'Hello, world!'
>>> del hello[2]
Traceback (most recent call last):
  File "<pyshell#9>", line 1, in <module>
    del hello[2]
TypeError: 'str' object doesn''t support item deletion

 

4️⃣ 슬라이스 사용하기

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

 

[ ] 안에 시작 인덱스와 끝 인덱스를 지정하면 해당 범위의 리스트를 잘라서 가져올 수 있음.

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

 

여기서 주의할 점이 있는데, 끝 인덱스는 가져오려는 범위에 포함되지 않는 것.

따라서 끝 인덱스는 실제로 가져오려는 인덱스보다 1을 더 크게 지정해야 함.

(끝 인덱스는 범위를 벗어난 인덱스를 지정할 수 있음)

 

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

 

슬라이스는 음수를 인덱스로 지정할 수도 있음.

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

 

끝 인덱스는 가져오려는 인덱스보다 1을 더 크게 지정한다고 했으므로 실제로는 뒤에서 두 번째(인덱스 -2) 요소인 80까지만 가져옴.

(음수는 숫자가 작을 수록 큰 수. 그래서 -1은 -2보다 1이 더 큼)

 

1) 인덱스 증가폭 사용하기

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

여기서 주의할 점은 인덱스의 증가폭이지 요소의 값 증가폭이 아니라는 점임.

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

 

2-1) 인덱스 생략하기

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

주로 시퀀스 객체의 마지막 일부분만 출력할 때 사용

 

시작 인덱스 생략

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

 

끝 인덱스 생략

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

 

시작 인덱스와 끝 인덱스를 둘다 생략 -> 리스트 전체 가져오기

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

 

2-2) 인덱스 생략하면서 증가폭 사용

 

시작 인덱스를 생략하면서 인덱스 증가폭을 2로 지정

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

 

끝 인덱스를 생략하면서 인덱스 증가폭을 2로 지정

>>> a[7::2]    # 인덱스 7부터 2씩 증가시키면서 리스트의 마지막 요소까지 가져옴
[70, 90]

 

시작 인덱스와 끝 인덱스를 둘다 생략하면서 인덱스 증가폭을 2로 지정

>>> a[::2]     # 리스트 전체에서 인덱스 0부터 2씩 증가시키면서 요소를 가져옴
[0, 20, 40, 60, 80]

 

시작 인덱스, 끝 인덱스, 인덱스 증가폭을 모두 생략 -> 리스트 전체 가져오기

즉, a[:]와 a[::]는 결과가 같음.

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

 

💡참고

[슬라이스의 인덱스 증가폭을 음수로 지정]

슬라이스를 사용할 때 인덱스 증가폭을 음수로 지정하면 요소를 뒤에서부터 가져올 수 있음.

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

 

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

 

시작 인덱스와 끝 인덱스를 생략하면서 인덱스 증가폭을 -1로 지정하면 리스트를 반대로 뒤집을 수 있음.

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

 

3) len 응용

len을 응용하여 리스트 전체를 가져오기

>>> 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]

 

마지막 인덱스인 90은 a[9]이고, 끝 인덱스는 가져오려는 인덱스보다 1을 더 크게 지정한다고 했으므로 len(a)에서 1을 빼지 않아야 함.

 

4) 튜플, range, 문자열에 슬라이스 사용

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

 

[튜플]

 지정된 범위만큼 튜플을 잘라서 새 튜플을 생성

>>> b = (0, 10, 20, 30, 40, 50, 60, 70, 80, 90)
>>> b[4:7]     # 인덱스 4부터 6까지 요소 3개를 가져옴
(40, 50, 60)
>>> b[4:]      # 인덱스 4부터 마지막 요소까지 가져옴
(40, 50, 60, 70, 80, 90)
>>> b[:7:2]    # 튜플의 처음부터 인덱스를 2씩 증가시키면서 인덱스 6까지 가져옴
(0, 20, 40, 60)

 

[range]

range는 리스트, 튜플과는 달리 요소가 모두 표시되지 않고 생성 범위만 표시됨.

>>> r = range(10)
>>> r
range(0, 10)
>>> r[4:7]     # 인덱스 4부터 6까지 숫자 3개를 생성하는 range 객체를 만듦
range(4, 7)
>>> r[4:]      # 인덱스 4부터 9까지 숫자 6개를 생성하는 range 객체를 만듦
range(4, 10)
>>> r[:7:2]    # 인덱스 0부터 2씩 증가시키면서 인덱스 6까지 숫자 4개를 생성하는 range 객체를 만듦
range(0, 7, 2)

 

이렇게 잘라낸 range 객체를 리스트로 만들려면 list에 넣음.

>>> list(r[:7:2])
[0, 2, 4, 6]

 

[문자열]

>>> hello = 'Hello, world!'
>>> hello[2:9]    # 인덱스 2부터 인덱스 8까지 잘라서 문자열을 만듦
'llo, wo'
>>> hello[2:]     # 인덱스 2부터 마지막 요소까지 잘라서 문자열을 만듦
'llo, world!'
>>> hello[:9:2]   # 문자열의 처음부터 인덱스를 2씩 증가시키면서 인덱스 8까지 잘라서 문자열을 만듦
'Hlo o'

 

5) 슬라이스에 요소 할당하기

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

>>> 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]

 

특히 이렇게 범위를 지정해서 요소를 할당했을 경우에는 원래 있던 리스트가 변경되며 새 리스트는 생성되지 않음.

 

a[2:5] = ['a', 'b', 'c']는 슬라이스 범위와 할당할 리스트의 요소 개수를 정확히 맞추었지만, 사실 개수를 맞추지 않아도 상관없음.

만약 할당할 요소 개수가 적으면 그만큼 리스트의 요소 개수도 줄어듦.

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[2:5] = ['a']    # 인덱스 2부터 4까지에 값 1개를 할당하여 요소의 개수가 줄어듦
>>> a
[0, 10, 'a', 50, 60, 70, 80, 90]

 

반면 할당할 요소 개수가 많으면 그만큼 리스트의 요소 개수도 늘어남.

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[2:5] = ['a', 'b', 'c', 'd', 'e'] # 인덱스 2부터 4까지 값 5개를 할당하여 요소의 개수가 늘어남
>>> a
[0, 10, 'a', 'b', 'c', 'd', 'e', 50, 60, 70, 80, 90]

 

 인덱스 증가폭을 지정하여 인덱스를 건너뛰면서 할당도 가능.

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[2:8:2] = ['a', 'b', 'c']    # 인덱스 2부터 2씩 증가시키면서 인덱스 7까지 값 할당
>>> a
[0, 10, 'a', 30, 'b', 50, 'c', 70, 80, 90]

 

단, 인덱스 증가폭을 지정했을 때는 슬라이스 범위의 요소 개수와 할당할 요소 개수가 정확히 일치해야 함. (리스트)

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[2:8:2] = ['a', 'b']
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    a[2:8:2] = ['a', 'b']
ValueError: attempt to assign sequence of size 2 to extended slice of size 3 

 

튜플, range, 문자열은 슬라이스 범위를 지정하더라도 요소를 할당할 수 없음.

# 튜플 
>>> b = (0, 10, 20, 30, 40, 50, 60, 70, 80, 90)
>>> b[2:5] = ('a', 'b', 'c')
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    b[2:5] = ('a', 'b', 'c')
TypeError: 'tuple' object does not support item assignment 

# range
>>> r = range(10)
>>> r[2:5] = range(0, 3)
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    r[2:5] = range(0, 3)
TypeError: 'range' object does not support item assignment 

# 문자열
>>> hello = 'Hello, world!'
>>> hello[7:13] = 'Python'
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    hello[7:13] = 'Python'
TypeError: 'str' object does not support item assignment

 

6) 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]

 

인덱스 증가폭을 지정하여 인덱스를 건너뛰면서 삭제

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

 

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

# 튜플
>>> b = (0, 10, 20, 30, 40, 50, 60, 70, 80, 90)
>>> del b[2:5]
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    del b[2:5]
TypeError: 'tuple' object does not support item deletion 

# range
>>> r = range(10)
>>> del r[2:5]
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    del r[2:5]
TypeError: 'range' object does not support item deletion 

# 문자열
>>> hello = 'Hello, world!'
>>> del hello[2:9]
Traceback (most recent call last):
  File "<pyshell#12>", line 1, in <module>
    del hello[2:9]
TypeError: 'str' object does not support item deletion