Ch04-1 반복문 / 리스트와 반복문

시작하기 전에

파이썬에는 리스트라는 데이터 형이 있다.

데이터 형(type)를 몇 가지로 분류할 수 있는데 먼저 숫자 형(태의) 데이터와 문자열 형(태의) 데이터 그리고 부울 형(태의) 데이터 등으로 나눌 수 있다. 또 숫자 형(태의) 데이터는 소수점이 있는 형태와 없는 형태로 나눌 수 있다

• 숫자 형(태의) 데이터
  • 소수점이 있는 숫자형 데이터
  • 소주점이 없는 숫자형 데이터
• 문자열 형(태의) 데이터
• 부울 형(태의) 데이터

등의 데이터 형(태)가 있습니다.

리스트는 숫자형 또는 문자열 형 등 다양한 요소를 여러 개 저장할 수 있는 데이터 형이다.

list_a = [1, 2, 3]   # 숫자 요소들로만 구성된 리스트(list)
list_b = [1, 2. 3.14]

list_c = ['a', 'b', 'c']   #문자열 요소들만으로 구성된 리스트(list)
list_d = ['a', 'abc, 'c']

list_e = [ 1, 2, 3.14, 'a', 'abc', 'c'] # 숫자와 문자열 데이터가 썩인 리스트
list_f = [1, 3.14, 'a', 'boy', True]

리스트 선언하고 요소에 접근하기

리스트 형 데이터의 생성은 아래와 같이 각 요소를 쉼표(,)로 구분하고 모든 요소를 대괄호([ ])로 감싸면 된다.

a_list = [ 'b', 'o', 'y' ]

리스트의 요소가 없는 리스트를 빈 리스트라고 부르는데 다음과 같이 만들 수 있다.

a_list = ['b', 'o', 'y']
print(a_list)           # 리스트 형 데이터, a_list가 가지고 있는 데이터을 출력
print( type(a_list) )   # a_list가 어떤 형태의 데이터를 보관하는 녀석인지 확인, "a_list 너 어떤 데이터를 다루냐?"

['b', 'o', 'y'] <class 'list'>

위 코드 셀에서 a_list는 3개의 요소를 가지고 있다. 첫 번째 요소의 값은 문자열 'b'이다. 두 번째 요소의 값은 문자열 'o'이고 세 번째 요소의 값은 문자열 'y'임을 알 수 있다.

a_list에서 첫 번째 요소의 값을 읽어서 출력(print)하고 싶다. 아래 코드 실행 결과를 확인.

print( a_list[0] )

b

a_list[0]의 형태로 첫 번째 요소의 값을 읽어 왔다. 각각의 요소의 값을 읽어 오기 위해서는 리스트_이름뒤에 대괄호([])를 붙이고 대괄호 사이에 숫자를 써넣는다. 이 숫자를 인덱스라고 부르는데 인덱스는 데이터의 순번을 0부터 나타낸다.

print( a_list[0] )
print( a_list[1] )
print( a_list[2] )

b o y

아래 보인 리스트 형 데이터 name_list에서 '이재영'을 출력하는 코드를 만들어 보겠다.

name_list = ['왕조현', '구숙정', '이재영', '오천련', '매염방']

name_list = ['왕조현', '구숙정', '이재영', '오천련', '매염방']

the_name = name_list[2]
print(the_name)

이재영

# 참고
name_list = ['왕조현', '구숙정', '이재영', '오천련', '매염방']

what = name_list[2][0]
print(what)

the_name = name_list[2]   # 'the_name'은 문자열 데이터
what = the_name[0]
print(what)

이 이

지금 우리는 리스트 형 데이터에서 '인덱스'의 의미와 '인덱스' 활용법을 배우고 있다. 그래서 인덱스의 의미와 활용법을 이해해야 한다.

year_list = [1967, 1968, 1973, 1968, 1963]

print( year_list[0] )   # 1967
print( year_list[1] )   # 1968
print( year_list[2] )   # 1973
print( year_list[3] )   # 1963

1967 1968 1973 1968

name_list = ['왕조현', '구숙정', '이재영', '오천련', '매염방']
year_list = [1967, 1968, 2000, 1968, 1963]

print( name_list[0] + '님은 {}'.format(year_list[0]) + '년도 생입니다')
print( name_list[1] + '님은 {}'.format(year_list[1]) + '년도 생입니다')

왕조현님은 1967년도 생입니다 구숙정님은 1968년도 생입니다

인덱스 값을 이용해서 리스트의 특정 위치에 있는 요소를 추출할 수 있었다. 자 그럼 아래 코드는 어떻게 동작할까?

name_list = ['왕조현', '구숙정', '이재영', '오천련', '매염방', '한예슬']
year_list = [1967, 1968, 1973, 1968, 1963, 1981]

idx = 1
print( name_list[idx] + '님은 {}'.format(year_list[idx]) + '년도 생입니다')

구숙정님은 1968년도 생입니다

아래 코드에서는 name_list[0:3]라는 표현이 보인다. 아래 코드 셀을 실행시켜 name_list[0:3]이 어떤 의미를 갖는지 파악해 보자

print( name_list[0:3] )

['왕조현', '구숙정', '이재영']

name_list = ['왕조현', '구숙정', '이재영', '오천련', '매염방', '한예슬']
year_list = [1967, 1968, 1973, 1968, 1963, 1981]

print( name_list[0:3] )

print( name_list[0] )     # 인덱스 0
print( name_list[1] )     # 인덱스 1
print( name_list[2] )     # 인덱스 2

['왕조현', '구숙정', '이재영'] 왕조현 구숙정 이재영

인덱스 표현을 0:N라고 했을 때 인덱스 0부터 N-1까지를 의미한다. 따라서 name_list[0:3]의 의미는 `name_list'의 인덱스 0, 인덱스 1, 인덱스 2에 해당하는 요소를 추출하겠다는 의미가 된다.

---

인덱스

인덱스를 부여할 때 첫 번째 요소에 0부터 두 번째 요소에 1을 부여하는 방식이 일반적으로 많이 쓰인다. 그런데 파이썬에서는 인덱스를 부여하는 방법을 또 하나 더 지원한다. 맨 마지막 요소에 인덱스 -1을 부여하고 맨 마지막 이전 요소에 -2를 부여하는 방식도 지원한다.

list_a = ['b', 'o', 'y', '&', 'g', 'i', 'r', 'l']

위와 같이 리스트 형 데이터 list_a가 있다고 가정하고 각 요소의 인덱스를 아래 표와 같이 두 가지 방법으로 쓸 수 있다. 이는 특정 요소를 꺼내기 위해 두 가지 방법으로 인덱싱할 수 있다는 말이다.

인덱스 부여 방식

요소 'b' 'o' 'y' '&' 'g' 'i' 'r' 'l'

인덱스	0	1	2	3	4	5	6	7
인덱스	-8	-7	-6	-5	-4	-3	-2	-1

리스트의 맨 마지막 요소부터 -1, -2, -3 순으로 인덱싱하는 것에 대해 설명을 추가하겠다. `list_a'을 위에서 보인 것처럼 종이에 쓰고 가위로 오려 낸다면 띠 또는 데이프 형태의 직사각형이 될 것이다. 이 직사각형의 넓은 쪽 좌우를 풀로 붙여 말아보자. 말았다고 상상해 보자. 인덱스 0 위치에는 값 'b'가 있고 오른쪽으로 인덱스 1 위치 값 'o'가 있다. 인덱스 0 위치의 왼쪽에는 값 'l'이 있습니다. 값이 'l'인 이 위치를 -1로 부르면 어떨까?

첫째, 대괄호 안에 음수를 넣어 뒤에서부터 요소를 선택할 수 있다.

list_a = ['b', 'o', 'y', '&', 'g', 'i', 'r', 'l']

print(list_a[-1])
print(list_a[-2])
print(list_a[-3])
print(list_a[-4])

l r i g

둘째, 리스트 접근 연산자를 다음과 같이 이중으로 사용할 수 있다.

lst = ['a', ['b', 'c'], 'd', 'e']
second_element = lst[1]

print( second_element[0] )
print( type(second_element) )

b <class 'list'>

lst = ['a', ['b', 'c'], 'd', 'e']
second_element = lst[1]

print( lst[1][0] )
print( lst[1][1] )

b c

lst = [1,0,[3.14, 'a', 'k'], True, ['b','o','y']]
print(lst[4][2])
print(lst[-1][-1])

y y

위와 같은 개념을 문자열 형 데이터를 요소로 갖는 리스트에 적용할 수 있다.

lst = [1, 'boy', 'girl', 3.1415]
second_element = lst[1]

print( second_element )
print( type(second_element) )

boy <class 'str'>

print( second_element[0] )
print( second_element[1] )
print( second_element[2] )

b o y

print( lst[1][0] )
print( lst[1][1] )
print( lst[1][2] )

b o y

셋째, 리스트 안에 리스트를 사용할 수 있다.

lst = [1, 3.1415, 'boy', [25.4, 11.5]]

위에 보인 리스트, 'lst'의 요소는 몇 개인가?

• 첫 번째 요소 : 1
• 두 번째 요소 : 3.1415
• 세 번째 요소 : 'boy'
• 네 번째 요소 : [25.4, 11.5]

이렇게 총 4개의 요소로 구성되어 있다. 'lst' 리스트는 네 번째 요소로 [25.4, 11.5]의 리스트형 데이터 한 개를 가지고 있는 것이다.

lst = [1, 3.1415, 'boy', [25.4, 11.5]]

fourth_element = lst[3]     # 네 번째 요소에 대한 인덱스는 3
print( fourth_element )
print( type(fourth_element) )

[25.4, 11.5] <class 'list'>

리스트 연결하기:연결(+), 반복(*), len()

숫자형 데이터와 숫자형 데이터는 덧셈 연산이 당연히 가능하고 덧셈 기호로 '+'를 사용한다.

x = 1
y = 2
z = x + y
print(x)

숫자형 데이터 끼리 덧셈, 뺄셈, 곱셈, 나눗셈이 가능하며 덧셈과 뺄셈에 대한 연산자 기호는 우리에게 매우 친숙한 +, -를 사용하고 프로그램에서 곱셈과 나눗셈 기호는 *, /를 사용한다.

그런데 리스트 형 데이터에서도 +, * 연산자가 있는데 리스트 형 데이터에서 이 두 연산자의 의미는 사칙연산에서 덧셈과 곱셈과 다르다.

list_x = [1, 3.1415, 'abc']
list_y = ['girl', 'boy']

list_z = list_x + list_y

print(list_z)

[1, 3.1415, 'abc', 'girl', 'boy']

리스트 + 리스트는 하나의 리스트를 생성하는데 두 리스트를 연결(결합)한 리스트가 된다.

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

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

리스트 * 2도 하나의 리스트를 생성한다.

[1, 2, 3] * 2

[1, 2, 3, 1, 2, 3]

[1, 2, 3] * 3

[1, 2, 3, 1, 2, 3, 1, 2, 3]

'리스트에 * n', 여기서 n은 정수일 때 리스트의 요소들을 동일하게 n번 반복해서 새로운 리스트를 생성한다.

---

꽤나 빈번하게 쓰이는 len()함수가 있습니다. 이 함수는 "요소의 개수"(리스트의 길이)를 반환한다

len( [1, 2, 3] )

3

len( [1, 2, 3] * 2 )

6

len( [1, 2, 3] + [4, 5])

5

lst = [1, 3.1415, 'boy', [25.4, 11.5]]

lst = [1, 3.1415, 'boy', [25.4, 11.5]]
print( len(lst) )

4

print( lst[0] )
print( lst[1] )
print( lst[2] )
print( lst[3] )   # lst[-1]

1 3.1415 boy [25.4, 11.5]

리스트에 요소 추가하기:append(), insert()

리스트_형_데이터.append(추가할_요소)

형식으로 append()함수는 매우 자주 사용하게 된다. append()함수가 하는 기능은 해당 리스트 형 데이터의 맨 마지막에 추가할_요소를 추가한다. 한마디로 리스트의 맨 마지막에 요소를 추가한다.

리스트_형_데이터 = [1, 2, 3]
리스트_형_데이터.append('추가할_요소')
print(리스트_형_데이터)

[1, 2, 3, '추가할_요소']

lst = [1, 2, 3]
lst.append('boy')
print( lst )

[1, 2, 3, 'boy']

append()함수는 리스트의 맨 마지막에 요소를 append(덧붙이다, 첨부하다)한다.

[append]

그런데 insert(인덱스, 추가할_요소)함수는 리스트의 원하는 인덱스 위치에 추가할 요소를 insert(끼워 넣다)한다.

[insert]

lst = [1, 2, 3]
lst.insert(0, 0)    # lst의 인덱스 0 위치에 숫자 데이터 0을 끼워넣어라라
print( lst )

[0, 1, 2, 3]

lst = [1, 2, 4]
lst.insert(2, 3)    # lst의 인덱스 2 위치에 숫자 데이터 3을 끼워넣어라라
print( lst )

[1, 2, 3, 4]

lst = [1, 2, 3]
lst.insert(3, 4)    # lst의 인덱스 3 위치에 숫자 데이터 4을 끼워넣어라라
print( lst )

[1, 2, 3, 4]

◃참고▹ extend() 함수

append()나 insert()는 결국 요소 하나를 리스트에 집어 넣는다. 한번에 여러 요소를 추가하고 싶을 때는 'extend()'함수를 이용한다.

lst = [1, 2, 3]
lst.extend([4, 5, 6])
print(lst)

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

extend()함수는 원 리스트에 (추가할 리스트의) 요소들로 extend(더 길게 만들다)한다.

원_리스트 = [1, 2, 3]
추가할_리스트 = ['a', 'b']

원_리스트.extend(추가할_리스트)
print(원_리스트)

lst = [1, 2, 3]
lst_extend = ['a', 'b']
lst.extend( lst_extend )

print(lst)

[1, 2, 3, 'a', 'b']

• 리스트 연결 연산자 +와 extend()함수의 차이

list_a = [1, 2, 3]
list_b = [4, 5, 6]
list_c = list_a + list_b

print( list_a + list_b)   # 비파괴적 처리
print( list_c )

print( list_a )

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

list_a = [1, 2, 3]
list_b = [4, 5, 6]

list_a.extend(list_b)  # 파괴적 처리

print( list_a )

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

list_a = [1, 2, 3]
list_b = [4, 5, 6]
list_a += list_b     #list_a = list_a + list_b
print( list_a )

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

• Quiz1

아래와 같이 3명에 대한 정보가 담긴 메시지를 받았다.

'김성필, 남, 50, 경기도 화성시 동탄, 010-9105-0000\\n구숙정, 여, 35, 경기도 용인시, 010-9105-1111\\n주성치, 남, 32, 경기도 수원시, 010-1111-2222'

주성치의 주소를 출력하는 코드를 작성하세요.

msg = '김성필, 남, 50, 경기도 화성시 동탄, 010-9105-0000\\n구숙정, 여, 35, 경기도 용인시, 010-9105-1111\\n주성치, 남, 32, 경기도 수원시, 010-1111-2222'

persions = msg.split('\\n')
print(persions)

target = persions[2]
print(target)

attributes = target.split(',')
print(attributes)

['김성필, 남, 50, 경기도 화성시 동탄, 010-9105-0000', '구숙정, 여, 35, 경기도 용인시, 010-9105- 1111', '주성치, 남, 32, 경기도 수원시, 010-1111-2222']

주성치, 남, 32, 경기도 수원시, 010-1111-2222

['주성치', ' 남', ' 32', ' 경기도 수원시', ' 010-1111-2222']

print(attributes[3])

경기도 수원시

구숙정의 전화 번호를 출력하는 코드를 작성하시오.

persions = msg.split('\\n')
target = persions[1]
attributes = target.split(',')
print(attributes[-1])

010-9105-1111

• Quiz2

다음 리스트의 각 요소를 모두 합쳐서 하나의 문자열 데이터로 변환하는 코드를 작성하시오.

lst = ['김성필', '남', 50, '경기도 화성시']

lst = ['김성필', '남', 50, '경기도 화성시']
msg =''

for element in lst:
  msg += element if type(element) == str else str(element)
  msg +=', '
msg = msg[:-2]

print(msg)

김성필, 남, 50, 경기도 화성시

• 리스트의 요소 제거하기
  • 인덱스를 이용하여 제거
  • 요소의 값을 이용하여 제거
• 리스트에서 특정 요소를 제거하는 방법이 다양하다. 리스트의 특정 요소를 제거 하는 방법을 크게 두가지로 나눌 수 있다.

인덱스로 제거하기: del 키워드, pop()

del 리스트_이름[인덱스]

리스트_이름.pop(인덱스)

또 리스트에서 인덱스의 범위를 지정하여 해당 요소들을 삭제할 수 있다. 리스트의 요소를 지정하는 방법은 아래와 같다.

리스트_이름[시작_인덱스:끝_인덱스:증감_폭]

lst = [1, 2, 3, 4, 5]

del lst[0]
print( lst )

[2, 3, 4, 5]

lst = [1, 2, 3, 4, 5]

lst.pop(2)
print( lst )

[1, 2, 4, 5]

pop()함수가 하는 기능에 대해 이해하셨다면 그리고 좀 전에 학습한 'append()'함수가 하는 기능을 이해하셨다면 아래 코드 셀에 있는 코드의 동작을 짐작하실 수 있다.

lst = [1, 2, 3, 4, 5]
pop_data = lst.pop(0)
lst.append(pop_data)

print( lst )

[4, 5, 1, 2, 3]

lst = [1, 2, 3, 4, 5]

pop_data = lst.pop(0)   # 리스트의 맨 앞 요소를 빼서
lst.append(pop_data)    # 리스트의 맨 뒤에 붙이기기

pop_data = lst.pop(0)
lst.append(pop_data)

print( lst )

[3, 4, 5, 1, 2]

리스트 형 데이터를 리스트라고 부르겠다. 아래 코드에서 리스트, lst의 요소를 한 개가 아니라 인덱스 범위를 지정하여 여러 개의 요소를 삭제하려고 한다.

lst = [1, 2, 3, 4, 5]

삭제할 범위는 인덱스 0번부터 인덱스 2까지 3개의 요소를 삭제 하고 싶다. 코딩을 해보겠다.

lst = [1, 2, 3, 4, 5]
del lst[0:3]
print( lst )

[4, 5]

lst[:N]형태로 lst[:N:]과 같은 의미다. '증감_값'이 생략되면 기본 `증감_값'은 1이다.

lst = [1, 2, 3, 4, 5]
del lst[:3]           #'증감_값'이 생략되어 기본 설정 값 1로 인식하는 상황에서 인덱스 시작 위치를 지정하지 않으면 시작 위치는 0으로 인식합니다.
print( lst )

lst = [1, 2, 3, 4, 5]
del lst[:3:]           #'증감_값'이 생략되어 기본 설정 값 1로 인식하는 상황에서 인덱스 시작 위치를 지정하지 않으면 시작 위치는 0으로 인식합니다.
print( lst )

[4, 5] [4, 5]

lst[n:]형태로 lst[n::]과 같은 의미이며 lst[n::]에서 증감_값이 생략되었기 때문에 기본 설정된 증감_값으로 1이 적용된다.

lst = [1, 2, 3, 4, 5]
del lst[2:]
print( lst )

lst = [1, 2, 3, 4, 5]
del lst[2::]
print( lst )

[1, 2] [1, 2]

리스트 lst가 가지고 있는 데이터가 [1, 2, 3, 4, 5]라서 lst 요소의 개수를 직접 셀수 있었다. 요소의 개수 딸랑 5개. 그래서 마지막 요소의 인덱스가 4라는 것을 쉽게 알수 있다만 만약 다루려는 리스트의 요수 개수가 몇인지 모를 경우에 'del lst[2:]`와 같은 코딩 기능은 유용하다.

아래 코드 셀에 있는 코드의 실행 결과를 예측해 본 후 예측과 동일한 결과를 발생시키는 확인

lst = [1, 2, 3, 4, 5]
del lst[2:5]
print( lst )

lst = [1, 2, 3, 4, 5]
del lst[2:5:1]
print( lst )

◃참고▹ 리스트 슬라이싱(slicing)

리스트에 [:] 연산자를 적용하여 일부 요소들만 선택하는 기법을 슬라이싱이라고 한다. 선택한 요소에 대한 인덱스를 지정해서 해당 요소만 분리 추출한다.

list_name[start:end:step]

위 코드는 list_name 리스트 형 데이터에서 [start:end:step]에서 지정한 인덱스 범위에 해당하는 요소만 추출한다는 의미이다. 인덱스 범위 지정을 위해 시작 인덱스 값은 start에 지정하고 인덱스 범위의 끝 인덱스 값 보다 하나 더 큰 값을 end에 지정한다. 그리고 시작 인덱스부터 인덱스 즘감 폭을 step에 지정한다. 자 그렇다면 아래 코드는 어떤 결과를 출력할까?

lst = ['a', 'b', 'c', 'd', 'e']
print( lst[0:5:2] )

위 코드 블록에서 start는 0이고 end는 5이며 step은 2이다. 그러므로 인덱스 범위는 0부터 4까지로 인덱스 즘감 폭이 2이니까 각 인덱스 값은 0, 2, 4가 됩니다. 따라서 이 인덱스 범위에 해당하는 요소의 값은 'a', 'c', 'e'이다.

lst = ['a', 'b', 'c', 'd', 'e']
print( lst[0:5] )
print( lst[0:5:2] )

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

위 코드 셀에서 lst[0:N] 형태의 코드가 있다. [0:N]은 인덱스 0부터 인덱스 (N-1)까지 선택하라는 의미이다. 예를 들어 [0:5]의 의미는 인덱스 0인 요소, 인덱스 1인 요소 , 인덱스 2인 요소, 인덱스 3인 요소 그리고 인덱스 4인 요소가 선택된다는 뜻이다. step에 대한 값이 명확히 지정되지 않은 경우 step의 값은 1로 설정된다.

---

아래 코드 셀에서는 lst[::]형태의 코드가 보입니다. start 값도 end 값도 명확히 표현하지 않으면 뭐다? 인덱스 처음부터 인덱스 끝까지로 다시 말해 인덱스 범위가 전체라는 뜻으로 해석하시면 되고 lst[::2]의 경우는 인덱스 범위는 천체인데 step에 해당하는 값이 2이므로 선택된 인덱스 값은 '0, 2, 4, ... 마지막 인데스' 이다.

lst = [1, 2, 3, 4, 5]
print( lst[::2] )           # 인덱스 범위의 시작은 인덱스 0부터 인덱스 2, 인덱스 4까지입니다.
                            # 끝 인덱스가 4입니다.

[1, 3, 5]

lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']

print( 'lst[0:11] =>', lst[0:11] )      # [0:11]은 인덱스 0부터 인덱스 10까지, step의 값이 생략되었음으로 step 값은 1
                                        # 따라서 선택된 인덱스는 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10이 됩니다.

lst[0:11] => ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']

lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']

print( 'lst[0:] =>', lst[0:] )          # [0:]은 start는 0이고 end는 지정되지 않았고 step도 지정되지 않았음.
                                        # end가 지정되지 않으면 end는 인덱스 끝까지라는 의미로 지정됩니다.
                                        # 다루고 있는 리스트 형 데이터 lst의 끝 인덱스는 10이므로 end는 11로 지정된다고 생각하시면 됩니다.
                                        # step도 생략되었는데 이 경우 step의 값은 1로 지정됩니다.

lst[0:] => ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']

lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']

print( 'lst[0::2] =>', lst[0::2] )      # [0::2]은 start는 0이고 end는 지정되지 않았고 step은 2로 지정되었음
                                        # end가 지정되지 않으면 end는 인덱스 끝까지라는 의미의 값이 지정됩니다.
                                        # 따라서 끝 인덱스는 10이므로 end는 11로 지정됩니다.
                                        # step이 2이므로 선택된 인덱스는 0, 2, 4, 6, 8, 10

lst[0::2] => ['a', 'c', 'e', 'g', 'i', 'k']

print( lst[0::2] )
print( lst[0:11:2] )

위 코드 실행시키면 어떤 결과가 나올까? 일단 [0:11:2]의 의미를 생각해 보겠다. start는 0이고 end는 11이다. 그렇다면 인덱스는 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10에서 step이 2이니까 인덱스 범위는 0, 2, 4, 6, 8이 되겠네. 출력 결과는 위 코드 셀에서 확인.

그렇다면 아래 명령이 실행되면 출력 결과는 무엇이 나올까? 출력 결과를 예상하기 앞서서 [0:11:-2]에서 선택한 인덱스 범위는 어떻게 될까? [0:11:-2]의 의미부터 알아야겠다.

print( lst[0:11:-2] )

start는 0이고 end는 11이니 고려하는 범위 내의 인덱스는 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10이다. 그런데 step이 -2이다. 0부터 -2씩 증가해서 10에 도달할 수 없다. 살짝 다른 표현으로 0부터 시작해서 왼쪽으로 2씩 움직여서 10에 도달 할 수 없다. 없다. 없다. 없으니까 비었다. 리스트에서 요소를 추출하기 위해 인덱스 범위를 결정해야 하는데 인덱스 범위가 빈 리스트다. 그래서 요소를 선택할 수 없다. 요소가 없다. 확인하기 위해 위 명령 print( list[0:11:-2] )를 실행시켜 보겠다.

lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k']
print(lst[0:11:-2])

[]

print( lst[-1:-12:-1] )

위 코드는 그냥 '뭐야~'하는 첫인상을 준다. 저에게 친하게 지내고 싶은 생각이 별로 안드는 코드다. 그래도 어떤 내용인지 알아보도록 하겠다.

start는 -1입니다. 일단 인덱스가 음수다. 인덱스를 양수로 부여하는 방법이 있고 음수로 부여하는 방법이 있음을 이전에 살펴 봤었다.

다시, start는 -1이고 step도 -1이고 end는 -12이네. 그렇다면 -1부터 1씩 빼가며서 -12 직전의 수(-11)까지가 인덱스 범위가 되는거다. 인덱스는 -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11까지.

"step1이 -1이니 인덱스를 1씩 뺀다"를 인덱스를 1씩 왼쪽으로 이동한다고 생각.

값으로 제거하기: remove()

두 번째 방법은 값을 지정하여 해당 요소를 삭제하는 것이다.

lst = [1, 2, 3]
lst.remove(2)
print( lst )

[1, 3]

lst = [1, 2, 2, 3]
lst.remove(2)
print( lst )

[1, 2, 3]

동일한 값을 갖는 요소가 여러 개일 때 remove()함수는 앞 쪽에 있는 요소 하나를 삭제 한다. 위 코드 셀에서 삭제된 요소는 원래 lst의 1번 인덱스에 해당하는 요소가 삭제가 된 것이다.

리스트 정렬하기: sort()

리스트의 요소를 정렬하려고 할 때 sort()함수를 사용한다. 기본 정렬 방식은 오름차순으로 설정되어 있다. '오름차순`이란 작은 수부터 큰 수 순으로 표현하는 것을 말한다.

lst = ['a', 'e', 'b', 'd', 'c']
lst.sort()
print( lst )

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

리스트 내부에 있는지 확인하기: in/not in 연산자

파이썬에서는 특정 값이 리스트 안에 있는지 쉽게 확인할 수 있다. in연산자와 not in연산자를 사용하여 리스트 안에 특정 요소가 있는지 없는지를 파악할 수 있다.

lst = ['아반데', '소나타','그랜저' ]
print( 'K5' in lst )
print( '그랜저' in lst )

False True

hyundai_motor_list = ['아반데', '소나타','그랜저' ]
name_car = 'K5'
if name_car in hyundai_motor_list:
  print('{}는 현대자동차사의 차량입니다'.format(name_car))
else:
  print('{}는 현재자동차사의 차량이 아닙니다'.format(name_car))

K5는 현재자동차사의 차량이 아닙니다

hyundai_motor_list = ['아반데', '소나타','그랜저' ]
name_car = 'K5'
if name_car not in hyundai_motor_list:
  print('{}는 현재자동차사의 차량이 아닙니다'.format(name_car))
else:
  print('{}는 현대자동차사의 차량입니다'.format(name_car))

K5는 현재자동차사의 차량이 아닙니다

lst = [ 10, 20, 30, 40, 50]
x = 20
print( x in lst )

True

for 반복문

컴퓨터 프로그래밍에 있어 기본 중에 기본, 그러니까 핵심 중에 핵심은 반복문과 조건문이다. 컴퓨터 프로그램은 결국 조건에 따라 무수히 많은 반복 실행을 통해 결과를 얻는 구조를 가지고 있다고 하겠다.

• for 반복문: 리스트와 함께 사용하기

for each_element in [0, 1, 2]:
  print(each_element)

0 1 2

for index in [0, 1, 2]:
  print( '사랑해' )

사랑해 사랑해 사랑해

for index in [0, 1, 2]:
  print( '사랑해'[index] )

사 랑 해

for index in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]:
  print(index)

0 1 2 3 4 5 6 7 8 9 10 11

for index in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]:
  print( '질풍가도(쾌걸 근육맨)'[index] )

질 풍 가 도 ( 쾌 걸

근 육 맨 )

for each_element in [0, 1, 2]:
  print(each_element)
  print( '{}번째 작업이 완료 되었습니다'.format(each_element + 1) )
  print('---'*30)
  print()

print('모든 작업이 끝났습니다.')

0 1번째 작업이 완료 되었습니다

1 2번째 작업이 완료 되었습니다

2 3번째 작업이 완료 되었습니다

모든 작업이 끝났습니다.

range() 함수

**range**([start,]end[,step])

r = range(0,10)
print(type(r))

<class 'range'>

print(r)

range(0, 10)

rr = list(r)
print(rr)

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

range(N) 함수는 0부터 N-1까지의 정수를 생성

r = range(0, 10, 2)
rr = list(r)
print(rr)

[0, 2, 4, 6, 8]

for index in range(11):
  print(index)

0 1 2 3 4 5 6 7 8 9 10

name_list = ['구숙정', '장만옥', '매염방', '관지림']

for name in name_list:
  print(name)

print('---'*2)

for index in range(4):
  print(name_list[index])

구숙정 장만옥 매염방 관지림

구숙정 장만옥 매염방 관지림

name_list = ['구숙정', '장만옥', '매염방', '관지림']

for index in range(len(name_list)):
  print(name_list[index])

구숙정 장만옥 매염방 관지림

중첩 리스트와 중첩 반복문

중첩 리스트란 아래 코드와 같이 리스트 형 데이터가 리스트 형 데이터를 요소로 갖는 경우를 말한다.

lst = [ [1, 2], [3, 4], [5, 6] ]

위 코드에서 lst 리스트의 인덱스 0 요소는 [1, 2], 인덱스 1 요소는 [3, 4], 인덱스 2 요소는 [4, 5]를 갖는 것과 같이 리스트 형 데이터(lst)가 리스트 형 데이터를 요소로 갖는 경우 중첩 리스트라 부른다. 결국 lst는 리스트이기 때문에 중첩이라는 말을 굳이 붙이지 않고 그냥 리스트라고 불러도 무방.

lst = [ [1, 2], [3, 4], [5, 6] ]
print( len(lst) )

3

for each_element in lst:
  print(each_element)

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

lst = [ [1, 2, '해운대'], ['a', 'b', 'c'], [3, 4, 5, 6], [0, 3.14], ['구숙정', '장만옥', '매염방', '관지림'] ]
print(lst)

lst = [
    [1, 2, '해운대'],
    ['a', 'b', 'c'],
    [3, 4, 5, 6],
    [0, 3.14],
    ['구숙정', '장만옥', '매염방', '관지림']
    ]
print(lst)

[[1, 2, '해운대'], ['a', 'b', 'c'], [3, 4, 5, 6], [0, 3.14], ['구숙정', '장만옥', '매염방', '관지림']] [[1, 2, '해운대'], ['a', 'b', 'c'], [3, 4, 5, 6], [0, 3.14], ['구숙정', '장만옥', '매염방', '관지림']]

요소의 개수가 많은 리스형 테이터를 코딩할 때 한 줄에 모두 타이핑 해서 넣으면 코드 가독성이 떨어진다. 각 줄에 하나의 요소만 타이핑하는 형태로 코딩해 놓으면 코드 가독성이 개선된다.

lists = [
    [1, 2, '해운대'],
    ['a', 'b', 'c'],
    [3, 4, 5, 6],
    [0, 3.14],
    ['구숙정', '장만옥', '매염방', '관지림']
    ]

for each_list in lists:
  for each_element in each_list:
    print(each_element)
  print('---'*10)

print('작업 완료~!')

1 2 해운대

a b c

3 4 5 6

0 3.14

구숙정 장만옥 매염방 관지림

작업 완료

 

• Quiz3

구구단 프로그램

for i in range(1,10):
    print(f'2*{i} = {2*i}')

21 = 2 22 = 4 23 = 6 24 = 8 25 = 10 26 = 12 27 = 14 28 = 16 2*9 = 18

for i in range(1,10):
    print(f'{i}단 ------------------')
    for a in range(1,10):       
        print(f'{i}*{a} = {a*i}')

1단 ------------------ 11 = 1 12 = 2 13 = 3 14 = 4 15 = 5 16 = 6 17 = 7 18 = 8 1*9 = 9 . . .

9단 ------------------ 91 = 9 92 = 18 93 = 27 94 = 36 95 = 45 96 = 54 97 = 63 98 = 72 9*9 = 81

<참고>

**전개 연산자: ***

첫째, 리스트 내부에서 사용하는 경우

a 리스트의 요소가 1, 2, 3일 때 b 리스트 내부에 *a라고 입력하면 a 리스트의 요소를 전개해서 입력하는 것과 같은 효과를 가져온다.

a = [1, 2, 3]
b = [*a, *a]
print( b )

[1, 2, 3, 1, 2, 3]

a = [1, 2, 3]
a.append(4)       # 리스트 a의 값이 변경됨 - 파괴적 연산
print(a)

print('--- 구분선 ---')

a = [1, 2, 3]
b = [*a, 3]       # 리스트 a의 값이 변경되지 않음
print(a)
print(b)

[1, 2, 3, 4] --- 구분선 --- [1, 2, 3] [1, 2, 3, 3]

둘째, 함수 매개변수 위치에 사용하는 경우

print()함수, len()함수, append()함수 등 많은 함수(기능)를 사용해왔다.

전개 연산자를 사용해서 함수에 인자를 전달하는 예를 보겠다.

lst = list( range(0, 10, 2) ) # lst = [0, 2, 4, 6, 8]
print(lst)

param = [0, 10, 2]
lst = list( range(*param) )   # lst = list( range(0, 10, 2) )
print(lst)

[0, 2, 4, 6, 8] [0, 2, 4, 6, 8]

<참고>

messages = [ '김성필/경기도 화성시/010-0000-0000', '김민재|경기도 용인시|010-1111-1111']
modified_messages =[]
# 항목을 구분 문자를 ','로 통일
param = [
    ['/', ','],
    ['|', ',']
]
SLASH = 0
VERTICAL_BAR = 1

for message in messages:
  if '/' in message:
    modified_messages.append( message.replace(*param[SLASH]) )        # 원본 유지
  elif '|' in messages[index]:
    modified_messages.append( message.replace(*param[VERTICAL_BAR]) ) # 원본 유지
  else:
    pass

print(modified_messages)

['김성필,경기도 화성시,010-0000-0000', '김민재,경기도 용인시,010-1111-1111']