[데이터 과학을 위한 파이썬 프로그래밍_2판] 3. 화면 입출력과 리스트(1)

- 화면 입출력

1. 표준 입력 함수 : input()  //  표준 출력 함수 : print()

# 예시 1
# 입력
print('이름을 입력하세요 : ')
someone = input()
print("안녕", someone, "오늘 기분이 어때?")

# 출력
이름을 입력하세요 :
Wien
안녕 Wien 오늘 기분이 어때?


# 예시 2
# 입력
a = input("입력하세요! : ")
print(a, type(a))
b = input("입력하세요! : ")
print(b, type(b))
c = input("입력하세요! : ")
print(c, type(c))
d = int(input("입력하세요! : "))
print(c, type(d))
e = float(input("입력하세요! : "))
print(e, type(e))

# 출력
입력하세요! : 1
1 <class 'str'>
입력하세요! : 0.5
0.5 <class 'str'>
입력하세요! : abcd
abcd <class 'str'>
입력하세요! : 2
abcd <class 'int'>
입력하세요! : 3
3.0 <class 'float'>

예시 1번과 같이 input() 함수는 사용자의 입력을 받고, 입력받은 내용을 변수에 할당할 수 있다. 또한 예시 2번과 같이 무엇을 입력받던 다 str형으로 저장되기 때문에 정수나 실수형 자료를 출력하고 싶다면 int()나 float()로 자료형을 변환해 주어야 한다. 또한, 안내문구 등을 지시문으로 띄울 수도 있다.

 

print()는 괄호 안의 내용을 출력한다. 콤마(,)로 괄호 안에 여러 값을 연결해서 출력할 수 있다.

 

 

 

- 리스트

1. 리스트의 개념

 리스트(list)란, 한 변수에 여러 값을 저장하는 자료형이다. 이렇게 리스트처럼 여러 데이터를 하나의 변수에 저장하는 기법을 파이썬에서는 시퀀스 자료형이라 한다.

 아래 예시는 변수에 리스트 자료형 데이터를 할당한 경우다.

# 입력
my_list1 = [1, 2, 3]
print(my_list1, type(my_list1))
my_list2 = ['a', 'b', 'c']
print(my_list2, type(my_list2))

# 출력
[1, 2, 3] <class 'list'>
['a', 'b', 'c'] <class 'list'>

 

2. 인덱싱과 슬라이싱

- 인덱싱indexing

 : 인덱싱이란, 리스트에 저장된 값에 접근하기 위해 이 값의 상대적인 주소를 사용하는 것을 말한다. 이 상대적인 주소는 인덱스 주소, 혹은 간단하게 인덱스 값 / 인덱스(index)라 한다.

 아래 예시를 통해 이해해보자.

# 입력
color = ['R', 'G', 'B']
print(color[0])
print(color[1])
print(color[2])

# 출력
R
G
B

보통 숫자를 셀 때는 1, 2, 3 ... 이지만 프로그래밍에선 0부터 시작한다는 것에 주의하자. 

color라는 list형 데이터의 첫번째 값인 R의 인덱스는 0, 두번째 값인 G의 인덱스는 1, 세번째 값인 B의 인덱스는 2이므로 위와 같은 결과가 나온다.

 

 

- 슬라이싱slicing

  : 슬라이싱이란, 리스트의 인덱스를 이용해서 전체 리스트 중 일부를 잘라내는 기법이다.

    슬라이싱의 기본 문법은 다음과 같다  =>  변수명[시작 인덱스 : 마지막 인덱스]

    예시를 통해 이해해보자.

# 입력
color = ['R', 'G', 'B', 'Y', 'W']
print(color[0:4])	# 0의 인덱스값부터 3의 인덱스값까지
print(color[0:3])	# 0의 인덱스값부터 2의 인덱스값까지
print(color[1:4])	# 1의 인덱스값부터 3의 인덱스값까지
print(color[2:3])	# 2의 인덱스값부터 2의 인덱스값까지
print(color[1:])	# 1의 인덱스값부터 끝까지
print(color[:4])	# 처음부터 3의 인덱스값까지
print(color[:])		# 처음부터 끝까지

# 출력
['R', 'G', 'B', 'Y']
['R', 'G', 'B']
['G', 'B', 'Y']
['B']
['G', 'B', 'Y', 'W']
['R', 'G', 'B', 'Y']
['R', 'G', 'B', 'Y', 'W']

 

1) 시작 인덱스의 값은 제대로 출력되지만 마지막 인덱스 부분에선 마지막 인덱스-1에 해당하는 값이 출력됨을 볼 수 있고,

2) 마지막 인덱스를 생략하면 리스트의 마지막 원소까지 출력됨을 볼 수 있고,

3) 첫번째 인덱스를 생략하면 리스트의 첫번째 원소부터 출력됨을 볼 수 있다.

 

 

 

- 리버스 인덱싱reverse indexing

  : 기존 인덱싱과는 달리 마지막 값부터 역순으로 올라오는 방식도 있으니, 이를 리버스 인덱싱이라 한다.

    리버스 인덱싱의 경우, 마지막 값의 인덱스는 0이 아닌 -1이고, 첫번째 값까지 차례로 올라온다.

    예시를 통해 이해해보자. 기본 문법은 슬라이싱과 동일하다.

# 입력
color = ['R', 'G', 'B', 'Y', 'W', 'C', 'S']
print(color[-6:-2])	# -6번째 인덱스의 값부터 -3번째 인덱스 값 까지
print(color[:-4])	# 첫번째 인덱스의 값부터 -5번째 인덱스 값 까지
print(color[-4:])	# -4번째 인덱스의 값부터 마지막 인덱스 값 까지

# 출력
['G', 'B', 'Y', 'W']
['R', 'G', 'B']
['Y', 'W', 'C', 'S']

 

 

 

- 증가값step

  : 슬라이싱에서 시작, 마지막 인덱스 외에 증가값을 넣을 수도 있다. 증가값을 넣으면 그 값 만큼의 간격을 두고 출력된다.

    변수명[시작 인덱스 : 마지막 인덱스 : 증가값]

    예시를 통해 이해해보자.

# 입력
color = ['R', 'G', 'B', 'Y', 'W', 'C', 'S']
print(color[::2])	# 2칸 간격으로 출력.
print(color[::3])	# 3칸 간격으로 출력.
print(color[::-1])	# 거꾸로 1칸 간격으로 출력 => reverse slicing과는 다르다.
print(color[::-2])	# 거꾸로 2칸 간격으로 출력


# 출력
['R', 'B', 'W', 'S']
['R', 'Y', 'S']
['S', 'C', 'W', 'Y', 'B', 'G', 'R']
['S', 'W', 'B', 'R']

 

 

 

3. 리스트의 연산

- 덧셈 / 곱셈 연산

리스트끼리 덧셈과 곱셈의 연산이 가능하다.

우선 덧셈 연산의 예시를 보자.

# 입력
color = ['R', 'G', 'B', 'Y', 'W', 'C', 'S']
number = [1, 2, 3, 4, 5, 6]
sum_of_list = color+number

print(color)
print(number)
print(color+number)
print(sum_of_list)

# 출력
['R', 'G', 'B', 'Y', 'W', 'C', 'S']
[1, 2, 3, 4, 5, 6]
['R', 'G', 'B', 'Y', 'W', 'C', 'S', 1, 2, 3, 4, 5, 6]
['R', 'G', 'B', 'Y', 'W', 'C', 'S', 1, 2, 3, 4, 5, 6]

위와 같은 방식으로, 덧셈 연산을 하는 경우는 리스트들이 하나로 합쳐진다. 단, 그렇게 합친 리스트는 기존 리스트와는 무관하다.

 

다음은 곱셈 연산의 예시를 보자.

# 입력
color = ['R', 'G', 'B', 'Y', 'W', 'C', 'S']
color_2 = color*2

print(color)
print(color*2)
print(color_2)

# 출력
['R', 'G', 'B', 'Y', 'W', 'C', 'S']
['R', 'G', 'B', 'Y', 'W', 'C', 'S', 'R', 'G', 'B', 'Y', 'W', 'C', 'S']
['R', 'G', 'B', 'Y', 'W', 'C', 'S', 'R', 'G', 'B', 'Y', 'W', 'C', 'S']

예시에서 보이듯, 리스트에 n을 곱하게 되면 해당 리스트를 n배만큼 늘려준다. 이 역시 늘어난 리스트는 기존 리스트와 무관하다.

 

 

- in 연산

in 연산은 특정 값이 해당 리스트에 들어있는지 아닌지를 판단해서 True / False로 반환하는 연산이다.

# 입력
color = ['R', 'G', 'B', 'Y', 'W', 'C', 'S']
print('R' in color)
print('Red' in color)

# 출력
True
False

 

 

 

4. 리스트 추가, 삭제

- 추가

# 입력
color = ['R', 'G', 'B', 'Y', 'W', 'C', 'S']
color.append('O')		# color리스트 맨 뒤에 'O' 추가
print(color)

color = ['R', 'G', 'B', 'Y', 'W', 'C', 'S']
number = [1, 2, 3, 4, 5, 6]
color.extend(number)	# color리스트와 number리스트 합치기
print(color)

color = ['R', 'G', 'B', 'Y', 'W', 'C', 'S']
color.extend(['O'])		# color리스트와 ['O']리스트 합치기
print(color)

color = ['R', 'G', 'B', 'Y', 'W', 'C', 'S']
color.insert(1,'O')		# color리스트의 1번 인덱스 자리에 'O' 삽입
print(color)

# 출력
['R', 'G', 'B', 'Y', 'W', 'C', 'S', 'O']
['R', 'G', 'B', 'Y', 'W', 'C', 'S', 1, 2, 3, 4, 5, 6]
['R', 'G', 'B', 'Y', 'W', 'C', 'S', 'O']
['R', 'O', 'G', 'B', 'Y', 'W', 'C', 'S']

1) append() : 추가. 리스트의 맨 뒤에 괄호 안의 원소를 추가한다.

2) extend() : 확장. 덧셈 연산과 기능이 같다. 리스트에 리스트를 합친다. 괄호 안에는 리스트를 담은 변수가 들어가도 되고, 리스트가 직접 들어가도 된다.

3) insert() : 삽입. append()와는 달리 원하는 인덱스 위치에 값을 넣을 수 있다. 기존 값들은 뒤로 한 칸씩 밀리게 된다.

 

 

- 변경 및 제거

# 입력
color = ['R', 'G', 'B', 'Y', 'W', 'C', 'S']
color.remove('R')	# color리스트 내의 'R'값을 제거한다
print(color)

color = ['R', 'G', 'B', 'Y', 'W', 'C', 'S']
del color[3]		# color리스트의 3번 인덱스 값을 제거한다. 
print(color)

color = ['R', 'G', 'B', 'Y', 'W', 'C', 'S']
color[2] = 'O'		# 리스트의 2번 인덱스의 값을 'O'로 바꾼다.
print(color)

# 출력
['G', 'B', 'Y', 'W', 'C', 'S']
['R', 'G', 'B', 'W', 'C', 'S']
['R', 'G', 'O', 'Y', 'W', 'C', 'S']

1) remove() : 제거. 괄호 안의 값을 리스트에서 삭제한다. 제거된 값 뒤의 값들은 한 칸씩 당겨진다.

2) del list[n] : 리스트의 n번 인덱스의 값을 제거한다. 제거된 값 뒤의 값들은 한 칸씩 당겨진다.

3) list[n] = x : 리스트의 n번 인덱스의 값을 x로 바꾼다. 나머지 값들에 영향은 없다.

 

 

 

5. 패킹, 언패킹

- 패킹packing, 언패킹unpacking

  : 비단 list에만 쓰이는 개념이 아니라, 시퀀스 자료형에 일반적으로 다 사용하는 개념이다. 하나의 변수에 여러 데이터를 할당하는 것을 패킹이라 한다. 반대로, 한 변수에 여러 데이터가 있을 때 그 데이터들을 각각의 변수로 반환하는 것을 언패킹이라 한다.

패킹과 언패킹 둘 다 변수와 데이터의 수를 맞추지 않으면 에러가 발생한다.

# 입력
num = [1, 4, 9]		# num이라는 변수에 1, 4, 9를 패킹
a, b, c = num		# a, b, c에 각각 1, 4, 9를 언패킹
print(num)
print(a, b, c)

# 출력
[1, 4, 9]
1 4 9

 

 

 

6. 이차원 리스트

이차원 리스트는 행렬과 같은 개념으로, 쉽게 말하자면 리스트를 원소로 갖는 리스트를 말한다.

# 입력
fruit = ['orange', 'apple', 'pear']
meat = ['pork', 'beef', 'chicken']
food = [fruit, meat]

print(food, type(food))
print(food[1][2])		# 이차원 리스트의 인덱싱. food의 2번째 값의 3번째 값 선택.
print(food[1][0:2])		# 이차원 리스트의 슬라이싱. food의 2번째 값의 1번째~2번째 값 선택.


# 출력
[['orange', 'apple', 'pear'], ['pork', 'beef', 'chicken']] <class 'list'>
chicken
['pork', 'beef']

리스트이기 때문에 당연히 인덱싱, 슬라이싱도 가능하다. 예시와 같은 방법으로 인덱싱과 슬라이싱을 할 수 있다.