본문 바로가기
Python 코딩도장

파이썬 코딩도장 Unit 11 정리 : 시퀀스 자료형

by chanfficial 2022. 1. 12.

Unit 11

시퀀스(sequence) 자료형 활용하기

  • 파이썬에서는 리스트, 튜플, range, 문자열처럼 값이 연속적으로 이어진 자료형을 시퀀스 자료형(sequence types)라고 부른다.
  • 시퀀스 자료형 중에서는 list, tuple, range, str을 주로 사용하며 bytes, bytearray라는 자료형도 있다.

 

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

  • 시퀀스 자료형의 가장 큰 특징은 공통된 동작과 기능을 제공한다는 점이다. → 기본적인 사용 방법을 익혀 두면 다른 시퀀스 자료형을 접했을 때 큰 어려움 없이 사용이 가능하다.
  • 시퀀스 자료형으로 만든 객체를 시퀀스 객체라고 하며, 시퀀스 객체에 들어있는 각 값을 요소(element)라고 부른다.

1-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) # range
True
>>> 'P' in 'Hello, Python' # 문자열
True​

1-2. 시퀀스 객체 연결하기

  • 시퀀스 객체는 + 연산자를 사용하여 객체를 서로 연결할 수 있고, 그것으로 새 객체를 만들 수 있다. 
    # 시퀀스객체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, 5)) + list(range(5, 10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> tuple(range(0, 5)) + tuple(range(5, 10))
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
  • 문자열도 + 연산자로 여러 문자열을 연결할 수 있고 파이썬에서 문자열 연결은 여러가지 결과를 묶어서 한 번에 출력할 때 자주 사용한다. 
    >>> 'Hello, ' + 'world!'
'Hello, world!'​
  • 문자열에 숫자를 연결할 때는 '문자열 + 정수'의 형태이기 때문에 에러가 발생하고, 에러를 해결하려면 str을 사용하여 숫자(정수나 실수)를 문자열로 변환하면 된다. 
    >>> 'Hello, ' + str(10)  # str을 사용하여 정수를 문자열로 변환
'Hello, 10'
>>> 'Hello, ' + str(1.5) # str을 사용하여 실수를 문자열로 변환
'Hello, 1.5'​

 

1-3. 시퀀스 객체 반복하기

  • 시퀀스 객체는 * 연산자를 사용하여 요소들이 특정 횟수 만큼 반복하는 새 시퀀스 객체를 만들 수 있다.
  • 0 또는 음수를 곱하면 빈 객체가 나오며 실수는 곱할 수 없다. 
    # 시퀀스 객체 * 정수
>>> [0, 10, 20] * 2
[0, 10, 20, 0, 10, 20]​
  • 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)
  • 문자열은 * 연산자를 사용하여 반복할 수 있다. 
    >>> 'Hello, ' * 3
'Hello, Hello, Hello, '​

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

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

 

2-1. 리스트와 튜플의 요소 개수 구하기

  • 리스트의 요소 개수 
    >>> a = [0, 10, 20, 30, 40]
>>> len(a)
5
  • 튜플의 요소 개수 
    >>> b = (2, 4, 6, 8)
>>> len(b)
4​

 

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

  • range에 len 함수를 사용하면 숫자가 생성되는 개수를 구합니다. 
    >>> len(range(0, 10, 2)) # 0, 2, 4, 6, 8
5​

2-3. 문자열의 길이 구하기

  • 문자열도 시퀀스 자료형이므로 len 함수를 사용하면 된다.
  • 이때 문자열의 길이는 공백을 포함하고, 문자열을 묶은 따옴표는 제외한다.(따옴표는 문자열을 표현하는 문법이기 때문에 문자열 길이에는 포함되지 않고 문자열 안에 포함된 따옴표는 길이에 포함된다.)
    >>> hello = 'Hello, world!'
>>> len(hello)
13​

 

3. 인덱스 사용하기

  • 시퀀스 객체의 각 요소는 순서가 정해져 있으며 이 순서를 인덱스라고 부르는데, 시퀀스 객체에 [ ](대괄호)를 붙이고 [ ] 안에 각 요소의 인덱스를 지정하면 해당 요소에 접근할 수 있다. 
    >>> a = [1, 2, 3, 4, 5]
>>> a[0] # 리스트의 첫 번째(인덱스 0) 요소 출력
1
>>> a[2] # 리스트의 세 번째(인덱스 2) 요소 출력
3
>>> a[4] # 리스트의 다섯 번째(인덱스 4) 요소 출력
5​
  • 인덱스(index, 색인)는 위치 값을 뜻하는데 시퀀스 객체의 인덱스는 항상 0부터 시작한다는 점을 주의해야 한다.
  • 튜플, range, 문자열도 [ ] 에 인덱스를 지정하면 해당 요소를 가져올 수 있다. 
    # 튜플 b의 첫 번째(인덱스 0) 요소 출력
>>> b = (1, 2, 3, 4, 5)
>>> b[0] 
1

# range의 세 번째(인덱스 2) 요소 출력
>>> r = range(0, 10, 2) # 0, 2, 4, 6, 8
>>> r[2]       
4

# 문자열의 여덟 번째(인덱스 7) 요소 출력
>>> hello = 'Hello, world!' # ,(콤마)와 공백 포함 
>>> hello[7] 
'w'

 

※ 시퀀스 객체에 인덱스를 지정하지 않으면 해당 객체 전체를 뜻하고, 리스트 전체가 출력된다.

>>> a = [1, 2, 3, 4, 5]
>>> a    # 시퀀스 객체에 인덱스를 지정하지 않으면 시퀀스 객체 전체를 뜻함
[1, 2, 3, 4, 5]

 

※ 시퀀스 객체에서 [ ] 를 사용하면 실제로는 __getitem__ 메서드를 호출하여 요소를 가져온다.

# __getitem__ 메서드를 직접 호출하여 요소를 가져오는 방법
# 시퀀스객체.__getitem__(인덱스)
>>> a = [1, 2, 3, 4, 5]
>>> a.__getitem__(1)
2

 

3-1. 음수 인덱스 지정하기

  • 시퀀스 객체에 인덱스를 음수로 지정하면 뒤에서부터 요소에 접근한다. 
    >>> a = [1, 2, 3, 4, 5]
>>> a[-1] # 리스트의 뒤에서 첫 번째(인덱스 -1) 요소 출력
5
>>> a[-5] # 리스트의 뒤에서 다섯 번째(인덱스 -5) 요소 출력
1
  • 튜플, range, 문자열도 음수 인덱스를 지정하면 뒤에서부터 요소에 접근한다. 
    >>> b = (1, 2, 3, 4, 5)
>>> b[-1] # 튜플의 뒤에서 첫 번째(인덱스 -1) 요소 출력
5

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

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

 

3-3. 마지막 요소에 접근하기

  • len 함수로 리스트의 길이를 구한 뒤 이 길이를 인덱스로 지정하면 에러가 발생한다. 
    >>> a = [1, 2, 3, 4, 5]
>>> len(a) # 리스트의 길이를 구함
5
>>> a[5] # 리스트의 길이를 인덱스로 지정
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    a[5]
IndexError: list index out of range
>>> a[4] # 맞는 방법
5​
    - 리스트 a의 인덱스는 0~4까지 인데 인덱스에 a의 길이를 5로 지정하면 인덱스의 범위를 벗어나게 된다.
  • 마지막 요소를 출력하는 방법 : len(a) - 1 
    >>> a = [1, 2, 3, 4, 5]
>>> a[len(a) - 1] # 마지막 요소(인덱스 4) 출력
5

 

3-4. 요소에 값 할당하기

  • 시퀀스 객체는 [ ] 요소로 접근한 뒤 =로 값을 할당한다.
  • 범위를 벗어난 인덱스는 지정할 수 없다. 
    # 리스트의 요소에 값을 할당
>>> a = [0, 0, 0]
>>> a[0] = 10
>>> a[1] = 20
>>> a[2] = 30
>>> a
[10, 20, 30]​
     
  •  튜플은 안에 저장된 요소를 변경할 수 없기 때문에 튜플의 [ ]에 인덱스를 지정한 뒤 값을 할당하면 에러가 발생한다. 
  • range와 문자열도 안에 저장된 요소를 변경할 수 없다.
  • 즉, 시퀀스 자료형에서 튜플, range, 문자열은 읽기 전용이다.

 

3-5. del로 요소 삭제하기

  • 요소를 삭제할 때는 del 뒤에 삭제할 요소를 지정해주면 된다. 
    # 리스트의 요소 삭제
>>> a = [1, 3, 5, 7]
>>> del a[2]
>>> a
[1, 3, 7]​
     
  •  
  •  리스트와 달리 튜플, range, 문자열은 저장된 요소를 삭제할 수 없다.(읽기 전용) 

 

4. 슬라이스(slice) 사용하기 

  • 슬라이스는 말 그대로 시퀀스 객체의 일부를 잘라내는 것이다.
  • 리스트의 일부를 잘라서 새 리스트를 만들 수 있다.
  • [ ] 안에 시작 인덱스와 끝 인덱스를 지정하면 해당 범위의 리스트를 잘라서 가져올 수 있다.
  • 끝 인덱스는 가져오려는 범위에 포함되지 않기 때문에 실제로 가져오려는 인덱스보다 1만큼 크게 지정해야 한다. 
    >>> a = [0, 10, 20, 30, 40, 50, 60]
>>> a[0:4] # 인덱스의 0부터 3까지 잘라서 새 리스트를 만듦
[0, 10, 20, 30]​
  • 시작 인덱스와 끝 인덱스를 같은 숫자로 지정하면 아무것도 가져오지 않기 때문에 최소 1의 차이가 나야 한다. 
    >>> a = [0, 10, 20, 30]
>>> a[1:1] # 인덱스 1부터 0까지 잘라서 새 리스트를 만듦
[]
>>> a[1:2] # 인덱스 1부터 1까지 잘라서 새 리스트를 만듦
[10]​

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

 

 

4-1. 리스트의 중간 부분 가져오기

  • a[4:7]은 리스트 a의 중간에 있는 인덱스 4부터 6까지 요소 3개를 가져온다.
  • 슬라이스는 a[2:-1]과 같이 음수를 인덱스로 지정할 수 있다. 
    >>> a = [0, 10, 20, 30, 40]
>>> a[1:4] # 인덱스 1부터 3까지 요소 3개를 가져옴
[10, 20, 30]

>>> a[2:-1] # 인덱스 2부터 -2까지 요소 2개를 가져옴
[20, 30]​
  • 끝 인덱스는 가져오려는 인덱스보다 1을 더 크게 지정하기 때문에 실제로는 뒤에서 두 번째(인덱스 -2)인 요소까지만 가져온다.

 

4-2. 인덱스 증가폭 사용하기

  • 슬라이스는 인덱스의 증가폭을 지정하여 범위 내에서 인덱스를 건너뛰며 요소를 가져올 수 있다.
  • 이때 주의할 점은 인덱스의 증가폭이지 요소의 값 증가폭이 아니라는 점이다.
  • 인덱스 증가폭을 지정할 때 가져오려는 인덱스(끝 인덱스 - 1)를 넘어설 수 없다.
  • 만약 '끝 인덱스 - 1'과 증가한 인덱스가 일치한다면 해당 요소까지 가져올 수 있다. 
    # 시퀀스객체[시작인덱스:끝인덱스:인덱스증가폭]
>>> a = [0, 10, 20, 30, 40, 50, 60, 70]
>>> a[2:7:2] # 인덱스 2부터 2씩 증가시키면서 인덱스 6까지 가져옴
[20, 40, 60]​
    - 시작 인덱스가 2이므로 20을 가져오고, 인덱스 증가폭이 2이기 때문에 다음 인덱스는 4, 6이 된다.

 

4-3. 인덱스 생략하기

  • 슬라이스를 사용할 때 시작 인덱스와 끝 인덱스를 생략할 수도 있으며 주로 시퀀스 객체의 마지막 일부분만 출력할 때 사용한다.(이 방법은 시퀀스 객체의 길이를 몰라도 되기 때문에 자주 쓰인다.)
  • 리스트 a에서 a[ :4]과 같이 시작 인덱스를 생략하면 리스트의 처음부터 '끝 인덱스 - 1'(인덱스 3)까지 가져온다. 
    # 시퀀스객체[:끝인덱스]
>>> a = [0, 10, 20, 30, 40, 50]
>>> a[:4] # 리스트 처음부터 인덱스 3까지 가져옴
[0, 10, 20, 30]​
  • a[4: ]와 같이 끝 인덱스를 생략하면 시작 인덱스(인덱스 4)부터 마지막 요소까지 가져온다. 
    # 시퀀스객체[시작인덱스:]
>>> a = [0, 10, 20, 30, 40, 50]
>>> a[4:]    # 인덱스 4부터 마지막 요소까지 가져옴
[40, 50]​
  • a[ : ]와 같이 시작 인덱스와 끝 인덱스를 둘 다 생략하면 리스트 전체를 가져온다. 
    # 시퀀스객체[:]
>>> a = [10, 20, 30, 40, 50]
>>> a[:]     # 리스트 전체를 가져옴
[0, 10, 20, 30, 40, 50]​

 

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

  • 리스트 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[7: :2]와 같이 끝 인덱스를 생략하면서 인덱스 증가폭을 2로 지정하면 시작 인덱스(인덱스 7)부터 인덱스를 2씩 증가시키면서 리스트의 마지막 요소까지 가져온다. 
    # 시퀀스객체[시작인덱스::증가폭]
>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[7::2] # 인덱스 7부터 2씩 증가시키면서 리스트의 마지막 요소까지 가져옴
[70, 90]​
  • 또는 a[ : :2]와 같이 시작 인덱스와 끝 인덱스를 둘 다 생략하면서 인덱스 증가폭을 2로 지정하면 리스트 전체에서 인덱스 0부터 2씩 증가하면서 요소를 가져온다. 
    # 시퀀스객체[::증가폭]
>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[::2] # 리스트 전체에서 인덱스 0부터 2씩 증가시키면서 요소를 가져옴
[0, 20, 40, 60, 80]​
  • 만약 시작 인덱스, 끝 인덱스, 인덱스 증가폭을 모두 생략하면 그냥 리스트 전체를 가져온다. 즉 a[ : ]와 a[ : : ]는 결과가 같다.
  • 슬라이스 인덱스 증가폭을 음수로 지정하면 요소를 뒤에서부터 가져올 수 있다. 
    >>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[5:1:-1] # 인덱스 5부터 2까지 1씩 감소
[50, 40, 30, 20]

>>> a[::-1] # 리스트 전체에서 인덱스를 1씩 감소시키며 요소를 가져옴
[90, 80, 70, 60, 50, 40, 30, 20, 10, 0]
    - 이때 주의할 점은 인덱스가 감소하기 때문에 끝 인덱스보다 시작 인덱스를 더 크게 지정해야 한다는 점이다.

 

4-5. 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]​
    - 리스트 a의 요소는 10개 이므로 len(a)=10 이고, a[0:10]과 같다. 여기서 끝 인덱스는 가져오려는 인덱스보다 1을 더 크게 지정한다고 했으므로 len(a)에서 1을 빼지 않아야 한다. 즉, 길이가 10인 리스트는 [0:10] 이어야 리스트 전체를 가져올 수 있다.

 

4-6. 튜플, 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)

>>> list(r[:7:2]) # 잘라낸 range 객체를 리스트로 만들기
[0, 2, 4, 6]​
    - range는 리스트, 튜플과는 달리 요소가 모두 표시되지 않고 생성 범위만 표시된다.
  • 문자열도 시퀀스 자료형이므로 슬라이스를 사용할 수 있고, 특히 문자열은 문자 하나가 요소이므로 문자 단위로 잘라서 새 문자열을 만든다. 
    >>> hello = 'Hello, world!'
>>> hello[2:9] # 인덱스 2부터 인덱스 8까지 잘라서 문자열을 만듦
'llo, wo'
>>> hello[2:] # 인덱스 2부터 마지막 요소까지 잘라서 문자열을 만듦
'llo, world!'
>>> hello[:9:2] # 문자열의 처음부터 인덱스를 2씩 증가시키면서 인덱스 8까지 잘라서 문자열을 만듦
'Hlo o'​

 

※ 이렇게 모든 시퀀스 자료형은 같은 방식으로 슬라이스를 사용하여 일부를 잘라낼 수 있다.

 

4-7. 슬라이스에 요소 할당하기

  • 리스트와 마찬가지로 시퀀스 객체는 슬라이스로 범위를 지정하여 여러 요소에 값을 할당 할 수 있다. 
    # 시퀀스객체[시작인덱스:끝인덱스] = 시퀀스객체
>>> 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, 문자열은 슬라이스 범위를 지정해도 요소를 할당할 수는 없다.

 

4-8. 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]
  • del로 요소를 삭제하면 원래 있던 리스트가 변경되며 새 리스트는 생성되지 않는다.
  • 인덱스 증가폭을 건너뛰면서 삭제하는 것도 가능하다. 
    >>> 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로 슬라이스를 삭제할 수 없다.

 

Slice 객체 사용하기

  • 파이썬에서는 slice 객체를 사용하여 시퀀스 객체(시퀀스 자료형으로 만든 변수)를 잘라낼 수 있다.
    • 슬라이스 객체 = slice(끝인덱스)
    • 슬라이스 객체 = slice(시작인덱스, 끝인덱스)
    • 슬라이스 객체 = slice(시작인덱스, 끝인덱스, 인덱스증가폭)
    • 시퀀스객체[슬라이스객체]
    • 시퀀스객체.__getitem__(슬라이스 객체)
>>> range(10)[slice(4, 7, 2)]
range(4, 7, 2)
>>> range(10).__getitem__(slice(4, 7, 2))
range(4, 7, 2)

- 시퀀스 객체의 [ ] 또는 __getitem__ 메서드에 slice 객체를 넣어주면 지정된 범위만큼 잘라서 새 객체를 만든다.

  • 물론 slice 객체를 하나만 만든 뒤, 여러 시퀀스 객체에 사용할 수도 있다. 
    >>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> s = slice(4, 7) # 인덱스 4부터 6까지 자르는 slice 객체 생성
>>> a[s]
[40, 50, 60]
>>> r = range(10)
>>> r[s]
range(4, 7)
>>> hello = 'Hello, world!'
>>> hello[s]
'o, '​

 

정리 참조

https://dojang.io/course/view.php?id=7

 

강좌: 파이썬 코딩 도장

모두 펼치기모두 접기

dojang.io

 

'Python 코딩도장' 카테고리의 다른 글

파이썬 코딩도장 Unit 13 정리 : if 조건문  (0) 2022.01.13
파이썬 코딩도장 Unit 12 정리 : 딕셔너리  (0) 2022.01.12
파이썬 코딩도장 Unit 10 정리 : 리스트와 튜플  (0) 2022.01.11
파이썬 코딩도장 Unit09 정리 : 문자열 사용  (0) 2022.01.11
파이썬 코딩도장 Unit 08 정리 : Bool과 비교/논리 연산자  (0) 2022.01.11

관련글

티스토리툴바