[Python] 기본 문법 정리 (2)

불과 비교 연산자 사용하기

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

파이썬에서는 비교 연산자와 논리 연산자의 판단 결과로 True, False를 사용한다. 즉, 비교 결과가 맞으면 True, 아니면 False이다.

 

숫자가 같은지 비교하기

두 숫자가 같은지 비교할 때는 ==(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

 

논리 연산자 사용하기

• a and b

and는 두 값이 모두 True여야 True이다.

• a or b

or는 두 값 중 하나라도 True이면 True이다.

• not x

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

여기서 and, or, not 논리 연산자가 식 하나에 들어있으면 not, and, or 순으로 판단한다.

비교 연산자와 논리 연산자가 함께 있을 경우, 비교 연산자(is, is not, ==, !=, <, >, <=, >=)를 먼저 판단하고 논리 연산자(not, and, or)를 판단하게 된다.

 

문자열 사용하기

' '(작은따옴표), " "(큰따옴표), ' ' '(작은따옴표 3개), " " "(큰따옴표 3개)로 묶을 수 있다.

 

리스트 만들기

• 리스트 = [값, 값, 값]

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

 

리스트에 여러 가지 자료형 저장하기

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

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

 

리스트에 여러 가지 자료형을 사용하면 관련 정보를 하나로 묶기 좋다.

 

빈 리스트 만들기

• 리스트 = []
• 리스트 = list()

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

보통 빈 리스트를 만들어 놓은 뒤에 새 값을 추가하는 방식으로 사용된다.

 

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

range는 연속된 숫자를 생성하는데 range에 10을 지정하면 0부터 9까지 숫자를 생성한다. 지정한 횟수 숫자는 생성되는 숫자에 포함되지 않는다.

• range(횟수)
• 리스트 = list(range(횟수))

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

• 리스트 = list(range(시작, 끝))
• 리스트 = list(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)

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

보통 튜플은 요소가 절대 변경되지 않고 유지되어야 할 때 사용한다. 튜플을 만든 상태에서 요소를 변경하게 되면 에러가 발생하게 다. 따라서 요소를 실수로 변경하는 상황을 방지할 수 있다.

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

 

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

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

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

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

 

range를 사용하여 튜플 만들기

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

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

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

 

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

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

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

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

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

 

시퀀스 자료형 활용하기

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

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

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

 

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

시퀀스 자료형의 가장 큰 특징은 공통된 동작과 기능을 제공한다는 점이다. 따라서 시퀀스 자료형의 기본적인 사용 방법을 익혀 두면 나중에 어떠한 시퀀스 자료형을 접하게 되더라도 큰 어려움 없이 바로 사용할 수 있다.

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

 

특정 값이 있는지 확인하기

• 값 in 시퀀스객체

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

시퀀스 객체에 in 연산자를 사용했을 때 특정 값이 있으면 True, 없으면 False가 나온다. 따라서 리스트 a에 30이 있으므로 True, 100이 없으므로 False가 나온다.

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

• 값 not in 시퀀스객체

not in은 특정 값이 없으면 True, 있으면 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]

리스트 a와 b를 더하니 두 리스트가 연결된다. 물론 변수를 만들지 않고 리스트 여러 개를 직접 연결해도 상관없다.

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

문자열은 + 연산자로 여러 문자열을 연결할 수 있다.

>>> 'Hello, ' + 'world!'
'Hello, world!'

 파이썬에서 문자열 연결은 여러 가지 결과를 묶어서 한 번에 출력할 때 자주 사용한다.

 

문자열에 숫자 연결하기

문자열에 정수를 연결하려고 하면 에러가 발생한다.(정수를 문자열로 변환할 수 없어서 TypeError가 발생한한다) 이 문제를 해결하려면 str을 사용하여 숫자(정수, 실수)를 문자열로 변환하면 된된다.

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

>>> 'Hello, ' + str(10)      # str을 사용하여 정수를 문자열로 변환
'Hello, 10'
>>> 'Hello, ' + str(1.5)     # str을 사용하여 실수를 문자열로 변환
'Hello, 1.5'

 

시퀀스 객체 반복하기

* 연산자는 시퀀스 객체를 특정 횟수만큼 반복하여 새 시퀀스 객체를 만든다.(0 또는 음수를 곱하면 빈 객체가 나오며 실수는 곱할 수 없다)

• 시퀀스객체 * 정수
• 정수 * 시퀀스객체

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

range는 * 연산자를 사용하여 반복할 수 없다. 이때는 range를 리스트 또는 튜플로 만들어서 반복하면 된다.

문자열은 * 연산자를 사용하여 반복할 수 있다.

 

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

시퀀스 객체에는 요소가 여러 개 들어있는데, 이 요소의 개수(길이)를 구할 때는 len 함수를 사용한다.

• len(시퀀스객체)

 

인덱스 사용하기

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

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

• 시퀀스객체[인덱스]

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

시퀀스 객체의 인덱스는 항상 0부터 시작한다.(대다수의 프로그래밍 언어는 인덱스가 0부터 시작한다) 따라서 리스트 a의 첫 번째 요소는 a[0]이 된다.

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

 

음수 인덱스 지정하기

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

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

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

 

마지막 요소에 접근하기

시퀀스 객체에 인덱스를 -1로 지정하면 뒤에서 첫 번째 요소에 접근한다. 이게 바로 시퀀스 객체의 마지막 요소다.

마지막 요소의 인덱스는 lan() - 1이다.

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

튜플은 안에 저장된 요소를 변경할 수 없기 때문에 에러가 발생한다.

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

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

 

del로 요소 삭제하기

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

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

리스트와 달리 튜플과 range, 문자열은 안에 저장된 요소를 삭제할 수 없다.

 

슬라이스 사용하기

시퀀스 자료형은 슬라이스라는 기능을 자주 사용한다. 슬라이스(slice)는 무엇인가의 일부를 잘라낸다는 뜻인데, 시퀀스 슬라이스도 말 그대로 시퀀스 객체의 일부를 잘라낸다.

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

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

[ ] 안에 시작 인덱스와 끝 인덱스를 지정하면 해당 범위의 리스트를 잘라서 가져올 수 있다. 여기서 주의할 점이 있는데, 끝 인덱스는 가져오려는 범위에 포함되지 않는다. 따라서 끝 인덱스는 실제로 가져오려는 인덱스보다 1을 더 크게 지정해야 한다. 슬라이스를 했을 때 실제로 가져오는 요소는 시작 인덱스부터 끝 인덱스 - 1까지이다.

 

리스트의 중간 부분 가져오기

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[4:7]     # 인덱스 4부터 6까지 요소 3개를 가져옴
[40, 50, 60]

a[4:7]은 리스트 a 중간에 있는 인덱스 4부터 6까지 요소 3개를 가져온다.

특히 슬라이스는 a[4:-1]과 같이 음수를 인덱스로 지정할 수도 있다.

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

인덱스에서 -1은 뒤에서 첫 번째 요소를 뜻한다. 끝 인덱스는 가져오려는 인덱스보다 1을 더 크게 지정한다고 했으므로 실제로는 뒤에서 두 번째(인덱스 -2) 요소인 80까지만 가져온다.(음수는 숫자가 작을 수록 큰 수입니다. 그래서 -1은 -2보다 1이 더 크다.)

 

인덱스 증가폭 사용하기

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

다음은 인덱스를 3씩 증가시키면서 요소를 가져온다. 여기서 주의할 점은 인덱스의 증가폭이지 요소의 값 증가폭이 아니라는 점이다.

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

먼저 시작 인덱스가 2이므로 20부터 가져온다. 그리고 인덱스 증가폭을 3으로 지정했으므로 인덱스 5의 50, 인덱스 8의 80을 가져올 수 있다. 하지만, 끝 인덱스를 8로 지정했으므로 인덱스 7까지만 가져온다. 따라서 20과 50만 가져와서 [20, 50]이 나온다.

인덱스 증가폭을 지정하더라도 가져오려는 인덱스(끝 인덱스 - 1)를 넘어설 수 없다. 만약 끝 인덱스 - 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]

 

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

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

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

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

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

• 시퀀스객체[ : : 증가폭]

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

• 시퀀스객체[ : : ]

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

 a[:]와 a[::]는 리스트 전체를 가져오므로 결과가 같다.

 

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

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

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

여기서 주의할 점은 인덱스가 감소하므로 끝 인덱스보다 시작 인덱스를 더 크게 지정해야 한다는 점이다. 즉, a[5:1:-1]과 같이 시작 인덱스부터 끝 인덱스까지 감소하도록 지정한다. 그리고 끝 인덱스는 가져오려는 범위에 포함되지 않는다

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

다음과 같이 시작 인덱스와 끝 인덱스를 생략하면서 인덱스 증가폭을 -1로 지정하면 리스트 전체에서 인덱스를 1씩 감소시키면서 요소를 가져오므로 리스트를 반대로 뒤집는다.

 

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]

끝 인덱스는 가져오려는 인덱스보다 1을 더 크게 지정한다고 했으므로 len(a)에서 1을 빼지 않아야 한다. 즉, 길이가 10인 리스트는 [0:10]이라야 리스트 전체를 가져온다.

 

튜플, 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 객체를 새로 만든다.

• 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는 리스트, 튜플과는 달리 요소가 모두 표시되지 않고 생성 범위만 표시된다. 이렇게 잘라낸 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'

 

slice 객체 사용하기

파이썬에서는 slice 객체를 사용하여 시퀀스 객체(시퀀스 자료형으로 만든 변수)를 잘라낼 수도 있습니다.

슬라이스객체 = slice(끝인덱스)

슬라이스객체 = slice(시작인덱스, 끝인덱스)

슬라이스객체 = slice(시작인덱스, 끝인덱스, 인덱스증가폭)

시퀀스객체[슬라이스객체]

시퀀스객체.__getitem__(슬라이스객체)

다음과 같이 시퀀스 객체의 [ ](대괄호) 또는 __getitem__ 메서드에 slice 객체를 넣어주면 지정된 범위만큼 잘라내서 새 객체를 만듭니다.

>>> range(10)[slice(4, 7, 2)]
range(4, 7, 2)
>>> range(10).__getitem__(slice(4, 7, 2))
range(4, 7, 2)

 

슬라이스에 요소 할당하기

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

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

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

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

튜플, 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]

인덱스 증가폭을 지정하면 인덱스를 건너뛰면서 삭제한다. 다음은 인덱스 2부터 2씩 증가시키면서 인덱스 6까지 삭제한다.

>>> 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로 슬라이스를 삭제할 수 없다.

 

 

 

 

 

 

https://dojang.io/mod/page/view.php?id=2191