Skip to content

4. 시퀀스 자료형(Sequence Types)

1. 키워드

  • 시퀀스 자료형(Sequence Types)
  • 인덱스(Index)
  • 슬라이스(Slice)


2. 시퀀스 자료형 활용하기

  • list, tuple, range, str을 잘 보면, 이들 모두 값이 연속적으로 이어져 있다는 공통점이 있다.
  • 파이썬에서는 이와 같이 값이 연속적으로 이어진 자료형을 시퀀스 자료형이라고 부른다.


001


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


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

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


002


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

  • 다음과 같이 시퀀스 객체 안에 특정 값이 있는지 확인할 수 있다.


값 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 시퀀스객체

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

>>> 100 not in a
True
>>> 30 not in a
False


  • 이렇게 not in은 특정 값이 없으면 True, 있으면 False가 나온다.


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


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


2) 시퀀스 객체 연결하기

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


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

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

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


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


003


  • 단, 시퀀스 자료형 중에서 range는 + 연산자로 객체를 연결할 수 없다.


>>> range(0, 10) + range(10, 20) # TypeError: unsupported operand type(s) for +: 'range' and '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)


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


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


  • 문자열 "Hello, "와 "world!"를 연결하여 "Hello, world!"가 나왔다.
  • 파이썬에서 문자열 연결은 여러 가지 결과를 묶어서 한 번에 출력할 때 자주 사용한다.


문자열에 숫자 연결하기

  • 다음과 같이 "Hello, "에 10을 연결해 보자.


>>> "Hello, " + 10 # TypeError: Can't convert 'int' object to str implicitly


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


>>> "Hello, " + str(10)
'Hello, 10'
>>> "Hello, " + str(1.5)
'Hello, 1.5'


  • 문자열에 +를 사용할 때는 어떤 형태의 값이든 str을 사용해서 문자열로 맞춰주면 된다.


3) 시퀀스 객체 반복하기

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


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

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


  • 요소 0, 10, 20, 30이 들어있는 리스트를 3번 반복해서 새 리스트를 만들었다.


004


  • 앞에서 range는 + 연산자로 객체를 연결할 수 없었다.
  • 마찬가지로 range는 * 연산자를 사용하여 반복할 수 없다.


>>> range(0, 5, 2) * 3 # TypeError: unsupported operand type(s) for *: 'range' and 'int'


  • 이때는 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)


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


>>> "Hello, " * 3
'Hello, Hello, Hello, '


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

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


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

  • 다음과 같이 리스트 a의 요소 개수를 구할 수 있다.
  • 리스트 a에는 요소가 10개 들어있으므로 len(a)는 10이 나온다.


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

>>> len(a)
10


005


  • 다음 튜플 b에는 요소가 5개 들어있으므로 len(b)는 5가 나온다.


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

>>> len(b)
5


006


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

  • range에 len 함수를 사용하면 숫자가 생성되는 개수를 구한다.


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


  • range(0, 10, 2)는 0부터 10까지 2씩 증가하므로 0, 2, 4, 6, 8이다.
  • 따라서 5가 나온다.


007


3) 문자열의 길이 구하기

  • 문자열도 시퀀스 자료형이므로 len 함수를 사용하면 된다.


>>> hello = "Hello, world!"

>>> len(hello)
13


  • len으로 "Hello, world!" 문자열이 들어있는 hello의 길이를 구해 보면 13이 나온다.


008


  • 여기서 문자열의 길이는 공백까지 포함한다.


  • 한글 문자열의 길이도 다음과 같이 len으로 구하면 된다.


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

>>> len(hello)
5


  • "안녕하세요"는 5글자이므로 길이는 5가 나온다.


UTF-8 문자열의 바이트 수 구하기

  • 한글, 한자, 일본어 등은 UTF-8 인코딩으로 저장하는데, 문자열이 차지하는 실제 바이트 수를 구하는 방법은 다음과 같다.


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

>>> len(hello.encode("utf-8"))
15


  • UTF-8에서 한글 글자 하나는 3바이트로 표현하므로 "안녕하세요"가 차지하는 실제 바이트 수는 15바이트이다.


5. 인덱스 사용하기

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


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


시퀀스객체[인덱스]

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

>>> a[0]
38
>>> a[2]
53
>>> a[4]
19


  • 시퀀스 객체의 인덱스는 항상 0부터 시작한다.


009


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


  • 다음은 튜플 b의 첫 번째 요소를 출력한다.


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

>>> b[0]
38


  • 다음은 range의 세 번째 요소를 출력한다.


>>> r = range(0, 10, 2)

>>> r[2]
4


  • 다음은 문자열 hello의 여덟 번째 요소를 출력한다.


>>> hello = "Hello, world!"

>>> hello[7]
'w'


시퀀스 객체에 인덱스를 지정하지 않으면?

  • 시퀀스 객체에 인덱스를 지정하지 않은 상태는 해당 객체 전체를 뜻한다.
  • 따라서 다음과 같이 리스트 a를 출력하면 []를 포함하여 리스트 전체가 출력된다.


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

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


__getitem__ 메서드

  • 시퀀스 객체에서 [](대괄호)를 사용하면 실제로는 __getitem__ 메서드를 호출하여 요소를 가져온다.
  • 따라서 다음과 같이 __getitem__ 메서드를 직접 호출하여 요소를 가져올 수도 있다.


시퀀스객체.__getitem__(인덱스)

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

>>> a.__getitem__(1)
21


1) 음수 인덱스 지정하기

  • 다음과 같이 인덱스를 음수로 지정할 수 있다.


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

>>> a[-1]
19
>>> a[-5]
38


  • 시퀀스 객체에 인덱스를 음수로 지정하면 뒤에서부터 요소에 접근하게 된다.
  • 즉, -1은 뒤에서 첫 번째, -5는 뒤에서 다섯 번째 요소이다.


  • 리스트 a의 양수 인덱스와 음수 인덱스를 그림으로 표현하면 다음과 같은 모양이 된다.


010


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


  • 다음은 튜플 b의 뒤에서 첫 번째 요소를 출력한다.


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

>>> b[-1]
19


  • 다음은 range의 뒤에서 세 번째 요소를 출력한다.


>>> r = range(0, 10, 2)

>>> r[-3]
4


  • 다음은 문자열 hello의 뒤에서 네 번째 요소를 출력한다.


>>> hello = "Hello, world!"

>>> hello[-4]
'r'


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

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


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

>>> a[5] # IndexError: list index out of range


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


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

  • 시퀀스 객체에 인덱스를 -1로 지정하면 뒤에서 첫 번째 즉, 마지막 요소에 접근할 수 있다.


  • 또한 다음과 같이 len 함수를 이용하여 마지막 요소에 접근할 수도 있다.


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

>>> a[-1]
19
>>> a[len(a) - 1]
19


4) 요소에 값 할당하기

  • 시퀀스 객체의 요소에 값을 할당하는 방법은 다음과 같다.


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


  • 먼저 리스트부터 요소에 값을 할당해 보자.


>>> a = [0, 0, 0, 0, 0]

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


  • a[0] = 38처럼 []에 인덱스를 지정한 뒤 값을 할당하면 된다.


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


>>> a[5] = 90 # IndexError: list assignment index out of range


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


>>> b = (0, 0, 0, 0, 0)

>>> b[0] = 38 # TypeError: 'tuple' object does not support item assignment


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


>>> r = range(0, 10, 2)
>>> r[0] = 3 # TypeError: 'range' object does not support item assignment

>>> hello = "Hello, world!"
>>> hello[0] = "A" # TypeError: 'str' object does not support item assignment


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


5) del로 요소 삭제하기

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


del 시퀀스객체[인덱스]


  • 먼저 리스트부터 저장된 요소를 삭제해 보자.


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

>>> del a[2]

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


  • 마찬가지로 리스트와는 달리 튜플, range, 문자열은 요소를 삭제할 수 없다.


>>> b = (38, 21, 53, 62, 19)
>>> del b[2] # TypeError: 'tuple' object doesn't support item deletion

>>> r = range(0, 10, 2)
>>> del r[2] # TypeError: 'range' object doesn't support item deletion

>>> hello = "Hello, world!"
>>> del hello[2] # TypeError: 'str' object doesn't support item deletion


6. 슬라이스 사용하기

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


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


  • 다음은 리스트의 일부를 잘라서 새 리스트를 만드는 것이다.


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

>>> a[0:4]
[0, 10, 20, 30]


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


011


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


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


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

  • 다음과 같이 리스트의 중간 부분을 가져올 수 있다.


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

>>> a[4:7]
[40, 50, 60]


012


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


>>> a[4:-1]
[40, 50, 60, 70, 80]


013


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

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


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


  • 다음과 같이 인덱스를 3씩 증가시키면서 요소를 가져올 수 있다.


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

>>> a[2:8:3]
[20, 50]


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


014


  • 인덱스 증가폭을 지정하더라도 가져오려는 인덱스를 넘어설 수 없다는 점을 기억해야 한다.


  • 하지만 만약 다음과 같이 끝 인덱스 - 1과 증가한 인덱스가 일치한다면, 해당 요소까지 가져올 수 있다.


>>> a[2:9:3]
[20, 50, 80]


015


3) 인덱스 생략하기

  • 슬라이스를 사용할 때 시작 인덱스와 끝 인덱스를 생략할 수도 있다.
  • 인덱스를 생략하는 방법은 시퀀스 객체의 길이를 몰라도 되기 때문에 자주 쓰이는 방식이다.
  • 주로 시퀀스 객체의 마지막 일부분만 출력할 때 사용한다.


  • 다음과 같이 시작 인덱스를 생략하면서 슬라이스를 사용할 수 있다.


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

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

>>> a[:7]
[0, 10, 20, 30, 40, 50, 60]


  • 그리고 다음과 같이 끝 인덱스를 생략하면서 슬라이스를 사용할 수 있다.


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

>>> a[7:]
[70, 80, 90]


  • 또는, 다음과 같이 시작 인덱스와 끝 인덱스를 둘 다 생략하면서 슬라이스를 사용할 수 있다.


시퀀스객체[:]

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


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

  • 다음과 같이 시작 인덱스를 생략하면서 인덱스 증가폭을 지정할 수 있다.


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

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

>>> a[:7:2]
[0, 20, 40, 60]


016


  • 그리고 다음과 같이 끝 인덱스를 생략하면서 인덱스 증가폭을 지정할 수 있다.


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

>>> a[7::2]
[70, 90]


017


  • 또는, 다음과 같이 시작 인덱스와 끝 인덱스를 둘 다 생략하면서 인덱스 증가폭을 지정할 수 있다.


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

>>> a[::2]
[0, 20, 40, 60, 80]


018


  • 마지막으로, 시작 인덱스, 끝 인덱스, 인덱스 증가폭을 모두 생략할 수도 있다.


시퀀스객체[::]

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


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


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

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


  • 다음과 같이 리스트 a에서 인덱스 5부터 2까지 1씩 감소시키면서 요소를 가져올 수 있다.


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


  • 이 방법은 리스트뿐만 아니라 모든 시퀀스 객체에 사용할 수 있다.


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)


  • 물론 slice 객체를 하나만 만든 뒤 여러 시퀀스 객체에 사용하는 방법도 가능하다.


>>> s = slice(4, 7)

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

>>> r = range(10)
>>> r[s]
range(4, 7)

>>> hello = "Hello, world!"
>>> hello[s]
'o, '


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

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


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


  • 먼저 리스트를 만든 뒤 특정 범위의 요소에 값을 할당해 보자.


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

>>> a[2:5] = ["a", "b", "c"]

>>> a
[0, 10, 'a', 'b', 'c', 50, 60, 70, 80, 90]


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


019


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


  • 다음과 같이 요소 개수를 맞추지 않아도 알아서 할당되며, 만약 할당할 요소 개수가 적으면 그만큼 리스트의 요소 개수도 줄어든다.


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

>>> a[2:5] = ["a"]

>>> a
[0, 10, 'a', 50, 60, 70, 80, 90]


020


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


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

>>> a[2:5] = ["a", "b", "c", "d", "e"]

>>> a
[0, 10, 'a', 'b', 'c', 'd', 'e', 50, 60, 70, 80, 90]


021


  • 또한 다음과 같이 인덱스 증가폭을 지정하여 인덱스를 건너뛰면서 할당할 수 있다.


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

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

>>> a[2:8:2] = ["a", "b", "c"]

>>> a
[0, 10, 'a', 30, 'b', 50, 'c', 70, 80, 90]


022


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


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

>>> 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") # TypeError: 'tuple' object does not support item assignment

>>> r = range(10)
>>> r[2:5] = range(0, 3) # TypeError: 'range' object does not support item assignment

>>> hello = "Hello, world!"
>>> hello[7:13] = "Python" # TypeError: 'str' object does not support item assignment


6) del로 슬라이스 삭제하기

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


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


  • 다음은 리스트의 인덱스 2부터 4까지 요소를 삭제한다.


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

>>> del a[2:5]

>>> a
[0, 10, 50, 60, 70, 80, 90]


  • del로 요소를 삭제하면 원래 있던 리스트가 변경되며 새 리스트는 생성되지 않는다.


023


  • 다음과 같이 인덱스 증가폭을 지정하여 삭제할 수도 있다.


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

>>> del a[2:8:2]

>>> a
[0, 10, 30, 50, 70, 80, 90]


024


  • 마찬가지로 튜플, range, 문자열은 del로 삭제할 수 없다.

References