undefined-1.md

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

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

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