정보처리기사 실기를 위한 파이썬 정리(약간의 접수 후기를 곁드린)

정보처리기사 실기를 위한 파이썬 정리한 글

Tmi

이번에 떨어지면 다시... 필기부터 다시 봐야 한다.. 절대 안돼 ㅠㅠㅠㅠㅠㅠㅠㅠ

와.. 접수부터 너무 힘들었다.

평일 10시라서 회사에서 접수해야 하는데 ㅎ... 심지어 서버 터져가지고 점심시간에도 붙잡고 있었던 거 ㄹㅈㄷ

트위터에 사람들 다 욕하고 ㅋㅋㅋㅋ 무슨 단계별로 끊겨서 열받았었다 진짜로

이번에 근처 접수 못해서 멀리 가는 사람들도 많던데..ㅋㅋㅋ 이번에가 더 터진 이유가

이라고.. ㅋㅋㅋ...

티켓팅 같은 정처기 실기를 다시 안보기 위해서 이번에 끝낸다

파이썬 정리

01. 데이터 타입

1) 변수

• 변수는 데이터를 담는 그릇

변수의 이름 규칙(Rule)

• 소문자(a-z)

• 대문자(A-Z)

• 숫자(0-9)

• 한글도 가능

• 특수기호는 언더바(_)만 허용

---

다음의 규칙을 가짐

• 대소 문자를 구분한다.

• 숫자는 맨 처음에 올 수 없다.

• 예약어는 사용할 수 없다.

2) 기본 데이터 타입

주요 데이터 타입

1. int

2. float

3. str

4. bool

type()

• type 함수를 활용하여 데이터의 타입을 알아 볼 수 있음

None 타입

• 말 그대로 아무 것도 아닌 흔히 null 값을 넣는다고 함

• Null : Nullify (무효화하다)

3) 타입 변환

• int를 float로 변환한 경우

a = 1
type(a)
float(a) # 정수 a를 float로 바꿈 1.0

• float를 int로 변환한 경우 : 반올림이 아닌 값이 버림되어 진다.

b = 3.99
int(b) # 3

• bool을 int로 변환한 경우

c = True
int(c) # 1

02. 리스트(List), 튜플(Tuple)

분류	타입	특징	예시
시퀸스(sequence)	리스트(list)	순서가 있고, 가변(mutable)	[1, 2, 3]
시퀸스(sequence)	투플(tuple)	순서가 있고, 불변(immutable)	(1, 2, 3)
세트(set)	세트(set)	순서가 없고, 중복을 허용하지 않음	{1, 2, 3}
맵(map)	딕셔너리(dictionary)	순서가 없고, key/value 쌍으로 이루어짐	{‘a’ : 1, ‘b’ : 2, ‘c’ : 3}

출처 : https://wikidocs.net/137565

1) 리스트

• 리스트는 데이터의 요소를 순차적으로 파악하는데 용이한 자료형

• 리스트는 다양한 메서드 혹은 함수를 지원하며, 메서드를 활용하여 요소를 추가, 삭제, 변경 할 수 있다.

생성과 출력

• 형태로 표현

• 빈 리스트 생성

mylist = []
mylist # []

규칙

• list는 다양한 type의 데이터를 집합으로 가진다

• list안에 list도 허용

• list는 순서의 개념이 존재

• 리스트를 출력하면 []까지 포함

관련 함수

• .점 연산자로 함수 실행 가능

• 함수는 어떤 작업을 수행하는 코드를 모아 이름을 붙인 것

1. append : 값 추가

• 값을 리스트의 맨 뒤에 추가

mylist = []
mylist.append(1)
mylist # [1]

• 중복된 값을 추가할 수 있으며, 순서가 유지

mylist.append(7)
mylist.append(7)
mylist.append(7)
mylist.append(3)
mylist.append(5)
mylist.append(2)
mylist

[출력]

[1, 7, 7, 6, 3, 5, 2]

2. sort() : 정렬

• 요소를 순서대로 정렬(오름차순)

• sort()는 내부적으로 정렬

mylist = [1, 6, 3, 2, 7, 5, 4]
mylist.sort()
mylist

[출력]

[1, 2, 3, 4, 5, 6, 7]

• 역정렬도 가능 (reverse = True)

mylist = [1, 6, 3, 2, 7, 5, 4]
mylist.sort(reverse=True)
mylist

[출력]

[7, 6, 5, 4, 3, 2, 1]

3. sorted() 정렬

• 요소를 순서대로 정렬

• 내부적으로 정렬하지 않고 정렬된 복사본 반환

• 즉, 원본 데이터는 정렬 x

mylist = [1, 6, 3, 2, 7, 5, 4]
sorted(mylist) # [1, 2, 3, 4, 5, 6, 7]
mylist # [1, 6, 3, 2, 7, 5, 4]

• reverse=True를 지정하여 역정렬할 수 있음

mylist = [1, 6, 3, 2, 7, 5, 4]
sorted(mylist, reverse=True) # [7, 6, 5, 4, 3, 2, 1]

4. reverse() : 역정렬

• 정렬 후 역정렬이 아닌 바로 역정렬

mylist.reverse()
mylist # [4, 5, 7, 2, 3, 6, 1]

5. len() : 전체 항목의 개수 세기

mylist = [1, 6, 3, 2, 7, 5, 4]
len(mylist) # 7

6. insert() : 값 추가

• insert는 지정된 index에 값 추가

mylist.insert(1, 100)
mylist # [1, 100, 6, 3, 2, 7, 5, 4]

7. remove() : 값 제거

• 리스트에서 첫 번째 나오는 해당 값 제거

mylist.remove(7)
mylist # [1, 100, 6, 3, 2, 5, 4]

8. pop() : 요소 꺼내기

• 해당 번째의 요소를 돌려주고 삭제

mylist.pop(1) # 100
mylist # [1, 6, 3, 2, 5, 4]

9. count() : 갯수 세기

• 해당 숫자의 개수 세기

a = [1, 1, 1, 1, 1, 2, 2, 3]
a.count(1) # 5

10. extend() : 리스트 확장

a = [1, 2, 3]
a.extend([4, 5])
a # [1, 2, 3, 4, 5]

• • 연산자는 extemd()와

리스트 검색

list = [1, 2, 3, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4]
print(list.index(2)) # 1(첫 2의 인덱스 번호)
print(list.count(2)) # 3

2) 인덱싱, 슬라이싱

인덱싱 : 색인

mylist = ['P', 'Y', 'T', 'H', 'O', 'N']

인덱스는 0번 부터 시작

• 리스트의 문자열은 ‘'까지 출력

mylist[0] #'P'

역순 인덱싱

• 파이썬은 음수 인덱싱 지원

mylist[-1] #'N'

인덱스로 접근하여 값 바꾸기

mylist = [10, 20, 30, 40, 50]
mylist[0] = 999
mylist # [999, 20, 30, 40, 50]

중첩된 리스트 인덱싱

• 중첩된 리스트에 대한 리스트는 중첩 인덱싱으로 접근하며, 값을 변경하는 것도 가능

mylist = [['가', '나', '다'], [4, 5, 6], 7, 8, 9]
mylist[1] # [4, 5, 6]
mylist[1][1] # 5

슬라이싱(Slicing): 범위 추출

• 슬라이싱의 활용: [start:stop:step] 을 명시하여 부분을 추출할 수 있습니다.

• [start:]는 시작 index 부터 끝까지 추출합니다. end가 명시 안되어 있다면 끝

mylist = [100, 200, 300, 400, 500]
mylist[2:] # [300, 400, 500]

• [:end]는 처음부터 end 전까지 추출합니다. end가 명시되어 있다면 end-1까지 출력

mylist[:3] # [100, 200, 300]

indexing 에 step 활용하기

mylist = [100, 200, 300, 400, 500]
mylist[::2] # [100, 300, 500]
mylist[::-2] # [500, 300, 100]

list 덧셈: list 확장

a = [1, 2, 3, 4]
b = [5, 6, 7, 8]
a + b # [1, 2, 3, 4, 5, 6, 7, 8]

list 곱셈: list 반복

a = ['a', 'b', 'c']
b = [1, 2, 3, 4]
a * 2 # ['a', 'b', 'c', 'a', 'b', 'c']

참고로 **print(fruit[7:])**를 해줘야 출력 되는거임

연습문제

sample = [1, 2, 3, 4, 5, 6, 7, 8]
sample[::-1] # [8, 7, 6, 5, 4, 3, 2, 1]
sample[-1:] #[8]

3) 튜플

• 리스트(list)는 가변(mutable)하는 객체(object)이지만, 튜플(tuple)은 불변(immutable)한 객체

• 가변 객체는 요소에 대한 수정, 삭제, 변경 등이 가능하지만, 불편 객체는 요소에 대한 수정, 삭제, 변경이 불가

생성

• tuple(), () 로 생성

• 혹은 , 로 생성할 수 있다.

mytuple = (1, 2, 3)
mytuple # (1, 2, 3)
mytuple2 = 1, 2, 3
mytuple2 # (1, 2, 3)

단일 요소를 생성할 때는 반드시 ,를 붙여 줍니다.

• (1,)과 (1)은 다른 자료구조임을 꼭 알고 있어야 합니다.

mytuple = 1,
print(type(mytuple))
mytuple # (1,)

class 'tuple'

mytuple = 1
print(type(mytuple))
mytuple # 1

class 'int'

튜플 자료형은 요소의 추가, 삭제, 변경등을 허용하지 않습니다.

• 그렇기 때문에 리스트로 바꾸고 요소 추가 삭제 변경 후 다시 튜플로 바꿔줘야 함

a = (1, 2, 3, 4)
a = list(a)
a.insert(1, 100)
tuple(a)

03. 세트(Set), 딕셔너리(Dictionary)

1) 세트(Set)

• 세트는 순서가 보장 되지 않는다.

• 세트는 요소의 중복을 허용하지 않는다.

• 세트는 **{}**를 활용하여 생성할 수 있다.

생성

참고로 원래 myset만 하면 출력 nono print(myset)해줘야 함

myset = set([1, 1, 1, 2, 2, 2, 3, 3, 3])
myset # {1, 2, 3} 

add() : 값 추가

• set에 요소를 추가

myset = set()
myset.add(1)
myset.add(2)
myset.add(3)

myset.add(1)
myset.add(2)
myset.add(3)

myset.add(1)
myset.add(2)
myset.add(3)
myset # {1, 2, 3}

update() : 여러개 값 추가

• list의 요소들을 한꺼번에 update

myset = {1, 2, 3}
myset.update([4, 5, 6])
myset # {1, 2, 3, 4, 5, 6}

• tuple의 요소들을 한꺼번에 update

myset.update((7, 8, 9))
myset # {1, 2, 3, 4, 5, 6, 7, 8, 9}

• set의 요소들을 한꺼번에 update

myset.update({10, 11, 12})
myset # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}

remove() : 값 제거

myset = {1, 2, 3, 4, 5}
myset.remove(2)
myset # {1, 3, 4, 5}

교집합 (intersection)

a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7}
a & b 
a.intersection(b)

[출력]

{3, 4, 5}

합집합 (union)

• 합집합은 집합 A와 B가 주어졌을 때 집합 A, B 요소 모두를 포함하는 것을 말한다.

• |기호나 union() 메서드를 활용하여 합집합을 구할 수 있다.

a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7}
a | b
a.union(b) 

[출력]

{1, 2, 3, 4, 5, 6, 7}

차집합 (difference)

a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7}
a - b
a.difference(b)

[출력]

{1, 2}

discard : set에서 해당 값 제거 오류 발생 x

my_set = {3, 5, 7, 9}
my_set.add(5)
my_set.add(2)
my_set.add(8)
my_set.discard(7)

2) 딕셔너리(Dictionary)

• 순서를 가지지 않는다.

• 키(key)와 값(value)의 쌍으로 이루어져 있다.

• type은 dict로 표시 된다.

• key를 사용하여 값을 조회할 수 있다.

• 딕셔너리는 수정, 삭제, 추가가 가능하다.

• 딕셔너리는 여러 타입의 key를 가질 수 있다.

mydict = {'a': 1, '가':2, 100: 3, 3.14: 4, True: 5}
mydict # {'a': 1, '가': 2, 100: 3, 3.14: 4, True: 5}

값 조회

• key 값으로 값을 조회할 수 있다.

mydict = {'a': 1, '가':2, 100: 3, 3.14: 4, True: 5}
mydict['a'] # 1

keys() : 모든 key 조회

mydict.keys() 

[출력]

dict_keys(['a', 'b', 'c', 'd', 'e'])

[참고] dict_keys

• dict_keys는 리스트(list)가 아님

• 객체(object)로 생성되는데, 이를 list로 변경하기 위해서는 list()로 타입 변환을 하면 된다.

list(mydict.keys())

[출력]

['a', 'b', 'c', 'd', 'e']

values() : 모든 value 조회

mydict.values() # dict_values([100, 200, 300, 400, 500])

items() : 모든 key, value 조회

• key, value가 튜플로 묶여서 조회

mydict.items()

[출력]

dict_items([('a', 100), ('b', 200), ('c', 300), ('d', 400), ('e', 500)])

key 값의 존재 유무 확인

'a' in mydict # True

값을 추가하기

mydict = dict()
mydict
mydict['apple'] = 123
mydict['apple'] #123

update() : 다중 업데이트

mydict = {'파인애플': 1500, '망고': 3500, '배': 1000}
fruit = {
    '사과': 2000, 
    '딸기': 3000, 
    '수박': 5000, 
}
mydict.update(fruit)
mydict # {'파인애플': 1500, '망고': 3500, '배': 1000, '사과': 2000, '딸기': 3000, '수박': 5000}

값 변경

• key 값에 새로운 값(value)를 대입하여 값을 변경할 수 있다.

mydict = {'a': 100, 'b': 200, 'c': 300, 'd': 400, 'e': 500}
mydict['a'] = 900 
mydict # {'a': 900, 'b': 200, 'c': 300, 'd': 400, 'e': 500}

---

제거하기 / key 제거

pop() 에 key를 지정하여 값을 제거할 수 있다.

제거되는 값의 value를 반환

mydict = {'a': 100, 'b': 200, 'c': 300, 'd': 400, 'e': 500}
mydict
mydict.pop('b') # 200
del mydict['a'] # a의 키 삭

len() : 요소의 개수 파악

len(mydict) # 3

4. 문자열(String)

1) 포맷팅, 길이, 인덱싱, 슬라이싱

%를 사용한 출력

%s -> 문자열

%d -> 정수

%f -> 실수

%c : 문자 1개

"안녕하세요? %s" % ('반갑습니다.') # '안녕하세요? 반갑습니다.'
'안녕하세요? %d' % (12345) # '안녕하세요? 12345'
'안녕하세요? %.4f' % (0.123456) # '안녕하세요? 0.1235'
'안녕하세요? %c' % ('a') # '안녕하세요? a'

{} 와 format를 사용한 출력

'웰컴투? {}'.format('파이썬.') # **'웰컴투? 파이썬.'
'원주율? {:.2f}'.format(3.141592) # '원주율? 3.14'**

문자열 길이

• 공백은 길이에 포함

len('banana pen') # 10

2) 문자열(텍스트)를 다루는 다양한 기능

split() : 분리

• split은 문장을 특정 규칙에 의해 쪼개 주는 기능

• 분리한 결과는 list 형식으로 값을 return 받는다.

a = 'This is a pen'

기본 값으로 공백이 지정되어 있다. 즉, 공백을 기준으로 분리하여 리스트로 반환

a.split() #['This', 'is', 'a', 'pen']

기본 값인 공백에서 특정 문자로 지정할 수 있다.

a = 'This-is-a-pen'
a.split('-') # ['This', 'is', 'a', 'pen']

join() : 합치기

• 결합하고자 하는 문자에 .join() 안에 리스트를 지정하여 결합할 수 있다.

'-'.join(['010',  '1234', '5678']) # '010-1234-5678'

lower(), upper() : 소문자 / 대문자로 만들기

• 내부가 변환이 되는 것은 아님 a =으로 넣어줘야함

a = 'My name is Teddy'
a.lower() # 'my name is teddy'
a.upper() # **'MY NAME IS TEDDY'**

startswith() : 시작하는

• 지정한 문자열로 시작하면 True, 그렇지 않다면 False를 반환

a.startswith('01')

[출력]

True

endswith() : 끝나는

• 지정한 문자열로 끝나면 True, 그렇지 않다면 False를 반환

a.endswith('.png')

[출력]

True

4) Replace() : 문자열 바꾸기, 공백 제거

• 문자열에 replace(바꿀 대상, 바꾸려는 문자열) 지정하여 문자열을 변경

• 결과는 복사본이 만들어져 반환

a = '01-sample.png'
a.replace('.png', '.jpg') # '01-sample.jpg'

strip() : 양쪽 공백 제거

a.strip() # '01-sample.png'

lstrip() : 왼쪽 공백 제거

rsreip : 오른쪽 공백 제거

find : 문자열의 첫 시작 위치를 구해줌

str ='hudndhj'
print(str.find('h')) # 0

5. 연산

**1) 기타 연산자 (%, //, )

• //: floor division 연산자입니다. 나눗셈에 대한 몫을 정수형으로 구함

• %: modulus 연산자입니다. 몫을 나눈 나머지를 구함

• *: 제곱 연산

• 연산시 타입(type)이 다르면 Error가 발생합니다.

6. 비교, 논리, 삼항연산자

1) 삼항연산자

(문법) (참인 값) if 조건 else (거짓인경우 값)

age = 35

"30세 이상입니다." if age >= 30 else "30세 이하입니다." # '30세 이상입니다.'

7. 반복문

1) For와 In 구문

[기본 문법]

for 하나씩 꺼내올 때 변수 in [꺼내올 집합]:

(indent)

• list, tuple, set, dictionary, 문자열 형태 모두 가능

• range와 결합하여 사용 가능

리스트(list)

mylist = [1, 2, 3, 4, 5]
for i in mylist:
    print(i) 

[출력]

1
2
3
4
5

tuple + list

• tuple을 전체로 받아주는 경우

person = ('제이콥스', 10)
print(person)
print(person[0])
print(person[1])

[출력]

('제이콥스', 10)
제이콥스
10

• tuple의 요소를 개별로 받아주는 경우

name, age = ('제이콥스', 10)
print(name)
print(age)

[출력]

제이콥스
10

• 반복문에서의 응용

mytuplelist = [('제이콥스', 10), ('피터', 20), ('타이거', 30)]

for mytuplein mytuplelist:
    print(mytuple[0], mytuple[1])

[출력]

제이콥스 10
피터 20
타이거 30

mytuplelist = [('제이콥스', 10), ('피터', 20), ('타이거', 30)]

for name, agein mytuplelist:
    print(name, age)

[출력]

제이콥스 10
피터 20
타이거 30

딕셔너리(dictionary)

mydict = {'헐크': 50, '아이언맨': 60, '펭수': 70}
for keyin mydict.keys():
    print(key)

[출력]

헐크
아이언맨
펭수

for valuein mydict.values():
    print(value)

[출력]

50
60
70

for name, agein mydict.items():
    print(name, age)

[출력]

헐크 50
아이언맨 60
펭수 70

문자열(str)

for cin "Hello":
    print(c)

[출력]

H
e
l
l
o

Range

• range() 함수는 별도의 list, tuple 생성 없이 range() 에서 정의한 범위를 반복하는데 활용할 수 있다.

• range(start, stop, step) 형식을 사용

• stop: 단일 값을 지정하는 경우

for iin range(10):
    print(i)

[출력]

0
1
2
3
4
5
6
7
8
9

---

• start, stop: 두 개의 값을 지정한 경우

• stop - 1 슬라이싱과 같음

for iin range(2, 9):
    print(i)

[출력]

2
3
4
5
6
7
8

---

start, stop, step: 세 개의 값을 지정한 경우

for iin range(1, 10, 2):
    print(i)

[출력]

1
3
5
7
9

• print는 한줄씩 출력

• 한 칸씩 출력하려면

print('안녕', end=' ')

for i in range(5):
    print(i, end=' ')

8. 함수

1) Lambda : 익명 함수(Annonymous Function)

• 이름 없이 정의된 함수 입니다.

• **단일 문장(1줄)**의 코드로 작성되어야 합니다.

• 함수 내부에서는 return문이 포함하지 않지만 값을 반환합니다.

단일 인수를 가지는 lambda 함수

a =lambda x: x * 2
a(4) # 8

---

2개의 인수를 가지는 lambda 함수

a =lambda x, y: x * y
a(4, 8) # 32

---

기본 값이 지정된 인수를 가지는 lambda 함수

a =lambda x, y=10: x * y
a(3) # 30

---

키워드 인수를 지정하는 lambda 함수

a(y=5, x=3)

[출력]

15

---

lambda 함수 내부에서 조건문 사용

a =lambda x, y: x * yif x > 0else y
a(4, 8) # 32

9. 내장함수(Built-in Function)

• 파이썬에는 이미 만들어진 내장함수(built-in function)가 존재

• 이미 사용하고 있는 print(), type()이 파이썬의 대표적인 내장함수

map

• 문법: map(function, iterable)

• map은 함수(f)와 순회 가능한(iterable) 자료형을 입력으로 받다.

• map은 입력받은 자료형의 각 요소를 함수(function)가 수행한 결과를 묶어서 돌려

sample_data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

map만 실행시 요소의 내용이 바로 출력되지 않습니다.

map(str, sample_data)

[출력]

---

list()로 타입 변환하여 요소를 출력

list(map(str, sample_data))

[출력]

['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

map에 lambda 함수 적용

result = map(lambda x: x*2, sample_data)
list(result)

[출력]

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

---

map에 다중 인수를 지정

sample_data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
sample_data_2 = [0, 1, 2, 3, 5, 8, 13, 21, 34, 55]
list(map(lambda x, y: x+y, sample_data, sample_data_2))

[출력]

[1, 3, 5, 7, 10, 14, 20, 29, 43, 65]

---

list의 size가 다른 경우, 작은 size에 맞춰 생성

sample_data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
sample_data_2 = [1, 1, 1, 10, 100]

list(map(lambda x, y: x+y, sample_data, sample_data_2))

[출력]

[2, 3, 4, 14, 105]

zip

• 문법: *zip(iterable)

• 동일한 개수로 이루어진 자료형을 묶어 주는 역할을 합니다.

sample_data1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
sample_data2 = [0, 1, 2, 3, 5, 8, 13, 21, 34, 55]
sample_data3 = [5, 6, 7]

sample_data1, sample_data2을 zip으로 묶어준 경우

result = zip(sample_data1, sample_data2)
list(result)

[출력]

[(1, 0),
 (2, 1),
 (3, 2),
 (4, 3),
 (5, 5),
 (6, 8),
 (7, 13),
 (8, 21),
 (9, 34),
 (10, 55)]

---

sample_data1, sample_data2, sample_data3을 zip으로 묶어준 경우

• 작은 size를 가지는 리스트(list)에 맞춰 생성합니다.

list(zip(sample_data1, sample_data2, sample_data3))

[출력]

[(1, 0, 5), (2, 1, 6), (3, 2, 7)]

---

zip의 응용

number = [1, 2, 3, 4]
name = ['홍길동','김철수','John','Paul']

number_name = list(zip(number,name))
number_name

[출력]

[(1, '홍길동'), (2, '김철수'), (3, 'John'), (4, 'Paul')]

---

zip을 활용한 dict 만들기

number = [1, 2, 3, 4]
name = ['홍길동','김철수','John','Paul']
dic = {}

for number, namein zip(number,name):
    dic[number] = name

dic

[출력]

{1: '홍길동', 2: '김철수', 3: 'John', 4: 'Paul'}

enumerate

• [문법]: enumerate(iterable, start=0)

• 순서가 있는 자료형을 입력 받아 index를 포함하는 객체로 return 합니다.

일반 range() 함수를 사용한 경우

for valuein range(1, 10, 2):
    print(value)

[출력]

1
3
5
7
9

---

enumerate() 함수를 사용하여 index를 return 받은 경우

for idx, valuein enumerate(range(1, 10, 2)):
    print(f'index: {idx}, value: {value}')

[출력]

index: 0, value: 1
index: 1, value: 3
index: 2, value: 5
index: 3, value: 7
index: 4, value: 9