혼공파 3주차

JIN·2023년 7월 18일
3주차파이썬혼공단혼공파혼자 공부하는 파이썬
0

혼공단 10기

목록 보기
3/7
post-thumbnail

🔎 리스트와 반복문


리스트(list)

  • 여러가지 자료를 저장할 수 있는 자료
  • 대괄호[ ]에 자료를 쉼표로 구분해서 입력하면 리스트가 생성됨
  • 대괄호 내부에 넣는 자료를 요소(element)라 함
  • 리스트는 한 가지 자료형만으로 구성 가능하고, 여러 종류의 자료형으로 구성 가능함
  • 리스트 사용시 리스트 이름 뒤에 대괄호 안에 자료의 위치를 숫자로 입력하여 사용함(0부터 시작)
  • 대괄호 들어가는 숫자는 인덱스(index)라 부름
# 리스트 사용방법
[요소, 요소, 요소...]

#리스트 생성 모양
>>> [1, 2, 3, 4]                           # 숫자만으로 구성된 리스트
[1, 2, 3, 4]
>>>["안", "녕", "하", "세", "요"]            # 문자열만으로 구성된 리스트
['안', '녕', '하', '세', '요']
>>> [273, 32, 103, "문자열", True, False]    # 여러 자료형으로 구성된 리스트
[273, 32, 103, '문자열', True, False]

#리스트 생성 / 선언
>>> list_a = [273, 32, 103, "문자열", True, False]  # 리스트 생성
>>> list_a[0]                                      # 인덱스 입력
>>> 273                                            #값 출력

#요소 변경
>>> list_a[0] = "변경"
>>> list_a
['변경', 32, 103, "문자열", True, False]

리스트 사용방법

  • 대괄호 안에 음수를 넣어 뒤에서부터 요소 선택 및 변경
>>> list_a = [273, 32, 103, "문자열", True, False]
>>> list_a[-1]        # 맨 뒤의 1번째 값 출력
False
>>> list_a[-2]        # 맨 뒤의 2번째 값 출력
True
>>> list_-3]          # 맨 뒤의 3번째 값 출력
'문자열'
  • 리스트 접근 연산자를 이중으로 사용할 경우
>>> list_a = [273, 32, 103, "문자열", True, False]
>>> list_a[3]
'문자열'
>>> list_a[3][0]
'문'
  • 리스트안에 리스트를 사용할 수 있음
>>> list_a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> list_a[1]
[4,5,6]
>>> list_a[1][1]
5

리스트 Index Error 예외

  • 리스트의 길이를 넘는 인데스로 요소에 접근하려고 할 때 발생함
  • 요소가 존재하지 않는 위치에서 요소를 꺼내려고 할 때 발생
>>> list_a = [273, 32, 103]
>>> list_a[3]

IndexError: list index out of range

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

  • 연결(+) : 리스트를 서로 연결해 줌
  • 반복(*) : 리스트의 자료를 반복함
  • len() : 괄호 내부에 문자열을 넣으면 문자열의 글자 수(=길이)를 세어주며 변수 입력시 요소의 개수를 세어 줌
# 리스트 선언
list_a = [1, 2, 3]
list_b = [4, 5, 6]

# 출력
print("#리스트")
print("list_a =", list_a)
print("list_b =", list_b)
print()

# 기본 연산자
print("#리스트 기본 연산자")
print("list_a + list_b =", list_a + list_b)
print("list_a * 3", list a * 3)
print()

# 함수
print("#길이 구하기")
print("len(list_a) = ", len(list_a))

#실행 결과
----------
# 리스트
list_a = [1, 2, 3]
list_b = [4, 5, 6]

# 리스트 기본 연산자
list_a + list_b = [1, 2, 3, 4, 5, 6]
list_a * 3 = [1, 2, 3, 1, 2, 3, 1, 2, 3]

# 길이 구하기
len(list_a) = 3

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

  • append() : 리스트 뒤에 요소를 추가함
  • insert() : 리스트의 중간에 요소를 추가함
  • extend() : 한 번에 여러 요소를 추가할 경우에 사용함

append() 사용법 : 리스트명.append(요소)
insert() 사용법 : 리스트명.insert(위치, 요소)
extend() 사용법 : 리스트명.extend(요소, 요소, 요소...)

# 리스트 선언
list_a = [1, 2, 3]

# 리스트 뒤에 요소 추가히기
print("# 리스트 뒤에 요소 추가하기")
list_a.append(4)
list_a.append(5)
print(list_a)
print()

# 리스트 뒤에 요소 여러개 추가하기
print("# 리스트 뒤에 요소 여러개 추가하기")
list_a.extend([6, 7, 8, 9])
print(list_a)
print()

# 리스트 중간에 요소 추가하기
print("# 리스트 중간에 요소 추가하기")
list_a.insert(0, 10)
print(list_a)

# 실행 결과
----------
#리스트 뒤에 요소 추가하기
[1, 2, 3, 4, 5]

# 리스트 뒤에 요소 여러개 추가하기
[1, 2, 3, 4, 5, 6, 7, 8, 9]

# 리스트 중간에 요소 추가하기
[10, 1, 2, 3, 4, 5]

리스트 연결 연산자와 요소 추가의 차이

  • 리스트 연결 연산자(+) : 원본에 어떠한 영향도 미치지 않는 비파괴적 함수
  • 요소 추가 : append(), insert(), extend()함수와 같이 리스트에 영향을 주는 파괴적 함수

🔎 리스트 요소 제거하기


인덱스로 제거하기

  • 요소의 위치를 기반으로 요소를 제거하는 del키워드, pop함수
  • del 키워드 : 범위를 지정해 리스트의 요소를 한꺼번에 제거 가능함
  • pop()함수 : 제거할 위치에 있는 요소를 제거하는데 매개변수를 입력하지 않으면 -1이 들어가는 것으로 취급하여 마지막 요소를 제거함

del 리스트명[인덱스]
리스트명.pop(인덱스)


값으로 제거하기

  • remove()함수를 사용하여 값을 지정해서 제거함

값으로 제거하기 : 리스트.remov(값)


모두 지우기

  • clear()함수를 사용하여 리스트 내부의 요소를 모두 제거함

리스트.clear()

# 요소 제거하기

list_a = [0, 1, 2, 3, 4, 5]
print("현재 리스트 :", list_a)
print()

print("#리스트의 요소 하나 제거하기_del 키워드")
# 제거 방법 : del 키워드
del list_a[1]
print("del list_a[1]:", list_a)
print()

del list_a[2:3]
print("del list_a[2:3]", list_a)
print()

print("#리스트의 요소 하나 제거하기_pop()")
# 제거 방법 : pop()
list_a.pop(2)
print("pop(2):", list_a)
print()

list_a.pop()
print("pop():", list_a)
print()

print("#리스트의 요소 값으로 제거하기")
# 제거 방법 : remove()
list_a.remove(2)
print("remove(2):", list_a)
print()

print("#리스트의 모두 제거하기")
# 제거 방법 : clear()
list_a.clear()
print("clear():", list_a)

# 실행 결과
----------
현재 리스트 : [0, 1, 2, 3, 4, 5]

#리스트의 요소 하나 제거하기_del 키워드
del list_a[1]: [0, 2, 3, 4, 5]

del list_a[2:3] [0, 2, 4, 5]

#리스트의 요소 하나 제거하기_pop()
pop(2): [0, 2, 5]

pop(): [0, 2]

#리스트의 요소 값으로 제거하기
remove(2): [0]

#리스트의 모두 제거하기
clear(): []

리스트 슬라이싱

  • 리스트에 [:]연산자로 리스트 범위를 지정하여 여러 요소를 선택하는 것을 슬라이싱이라 함
  • 단계는 기본값이 1이므로 요소를 건너뛰며 가져와야 하는 특별한 경우 아니면 생략 가능함
  • -1을 입력하면 반대로 출력함

리스트[시작인덱스:끝인덱스:단계]

>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8]
>>> numbers[0:5:2]
[1, 3, 5]
>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8]
numbers[::-1]  # 시작 인덱스와 끝 인덱스는 자동으로 "전부"가 저장됨
>>> [8, 7, 6, 5, 4, 3, 2, 1]   # 단계가 -1이므로 반대로 출력함

리스트 정렬하기: sort()

  • 리스트 요소를 정렬하고 싶으면 sort()함수를 사용함
  • 오름차순으로 정렬함

리스트.sort()

>>> list_e = [52, 273, 103, 32, 275, 1, 7]
>>> list_e.sort()  # 오름차순 정렬
>>> list_e
[1, 7, 32, 52, 103, 273, 275

>>> list_e.sort(reverse=True)   # 내림차순 정렬
>>> list_e
[275, 273, 103, 52, 32, 7, 1]

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

  • in 연산자 : 특정 값이 리스트 내부에 있는지 확인함
  • not in 연산자 : 라스트 내부에 해당 값이 없는지 확인하는 연산자로 in연산자와 정확하게 반대로 동작함

값 in 리스트
값 not in 리스트

>>> list_a = [273, 32, 103, 57, 52]
>>> 273 in list_a
True

>>> 273 not in list_a
False

>>> 99 in list_a
False

>>> 99 not in list_a
True

for 반복문

  • 특정 코드를 반복해서 실행할 때 사용하는 기본적인 구문
  • 반복 횟수가 정해졌거나(이 경우는 range()함수를 사용) 변수가 이터러블한 경우에 주로 사용함

for 반복자 in 반복할 수 있는 것:
. . . . 코드

# 리스트 선언
array = [273, 32, 103, 57, 52]

#리스트에 반복문 적용
for element in array:
	#출력
    print(element)

#문자열 반복문
character in "안녕하세요":
	print("-", character)
    
# 실행결과
----------
273
32
103
57
52

- 안
- 녕
- 하
- 세
- 요

이터러블(inerable)

  • 반복을 적용할 수 있는 성질
  • 내부에 있는 요소들을 차례차례 꺼낼 수 있는 객체
  • 문자열, 리스트, 딕셔너리, 범위(range()) 함수)

🔎 중첩 리스트와 중첩 반복문


중첩 반복문

  • 반복문을 여러 겹 중첩해 사용하는 것
  • n-차원 처리를 할 때 사용함

중첩 리스트

  • 리스트 안에 리스트가 있는 경우
  • 1차원 리스트는 [1, 2, 3]처럼 리스트가 1개 있는 것
  • 2차원 리스트는 [[1, 2, 3], [4, 5, 6]]처럼 리스트가 2개 있는 것
  • n-차원 리스트를 모두 확인하려면 반복문은 n번 중첩 해야 함
# 2차원 리스트에 반복문 1번 사용하기
list_of_list = [
	[1, 2, 3],
    [4, 5, 6, 7],
    [8, 9]
]

for items in list_of_lists:
	print(items)
  
# 실행 결과
----------
[1, 2, 3]
[4, 5, 6, 7]
[8, 9]
# 2차원 리스트에 반복문 2번 사용하기
list_of_list = [
	[1, 2, 3],
    [4, 5, 6, 7],
    [8, 9]
]

for items in list_of_lists:
	for item in items:
		print(item)
  
# 실행 결과 --- 요소를 하나하나 출력 가능함
----------
1
2
3
4
5
6
7
8
9

전개 연산자

  • 리스트 내용을 전개해서 입력할 수 있음
  • 리스트 앞에 *기호를 사용하고 리스트 요소를 전개하여 입력한 것과 같은 효과를 냄
  • 리스트 내부, 함수의 매개변수 위치에 사용함

*리스트 ---> 리스트[0], 리스트[1], ....

# 리스트 내부에 사용하는 경우_1
>>> a = [1, 2, 3, 4]
>>> b = [*a, *a]
>>> b
[1, 2, 3, 4, 1, 2, 3, 4]
# 리스트 내부에 사용하는 경우_2
>>> a = [1, 2, 3, 4]
>>> a.append(5)
>>> a
[1, 2, 3, 4, 5] ---> append()함수를 통하여 파괴됨

# 전개 연산자를 사용한 경우
>>> b = [1, 2, 3, 4]
>>> c = [*b, 5] ---> 전개연산자를 통하여 함수를 비파괴함
>>>
[1, 2, 3, 4]
>>> c
[1, 2, 3, 4, 5]
# 함수 매개변수 위치에 사용하는 경우
>>> a = [1, 2 , 3, 4]
>>> print(*a)
1 2 3 4

🔎 딕셔너리와 반복문


딕셔너리(dictionary)

  • 키(key)를 기반으로 값(key)을 저장하는 것
  • 가리키는 위치는 키이며, 선언은 변수 ={} 형식으로 선언함

딕셔너리 선언하기

  • 딕셔너리는 중괄호{}로 선언함
  • 키: 값 형태를 쉼표(,)로 연결해서 만듦
  • 키는 문자열, 숫자, 불 등으로 선언 가능함
  • 일반적으로는 문자열로 사용하는 경우가 많음

변수 ={
키: 값,
키: 값,
...
키:값,
}


딕셔너리의 요소에 접근하기

  • 리스트처럼 딕셔너리 뒤에 대괄호[ ]를 입력하고 내부에 인덱스처럼 키를 입력함
  • 딕셔너리를 선언할 때는 중괄호{}를 사용함
  • 딕셔너리의 요소에 접근할 때는 딕셔너리 뒤에 대괄호[ ]를 입력하고 내부에 인덱스처럼 키를 입력함
>>> dict_a = {
	"name" : "어벤저스 엔드게임",
    "type" : "히어로 무비"
    }
>>> dict_a
{'name: '어벤저스 엔드게임', 'type' : '히어로 무비'}
>>> dict_a["name"]
'어벤저스 엔드게임'
>>> dict_a["type"]
'히어로 무비'
  • 딕셔너리 내부의 값에 문자열, 숫자, 불 등의 다양한 자료 넣을 수 있음
  • 리스트와 딕셔너리도 하나의 자료이므로 리스트와 딕셔너리를 값으로 넣을 수 있음
>>> dict_b = {
	"director" : ["안소니 루소", "조 루소"],
    "cast" : ["아이언맨", "타노스", "토르", "딕터스트레인지", "헐크"]
    }
>>> dict_b
{'director' : ['안소니 루소', '조 루소'], 'cast' : ['아이언맨', '타노스', '토르', '닥터스트레인지', '헐크']}
>>> dict_b["director"]
['안소니 루소', '조 루소']
# 딕셔너리의 요소에 접근하기

# 딕셔너리 선언
dictionary = {
	"name" : "7D 건조 망고",
    "type" : "당절임",
    "ingredient" : ["망고", "설탕", "메타중아황산나트륨", "치자황색소"]
    "origin" : "필리핀"
}

# 출력
print("name:", dictionary["name"])
print("type:", dictionary["type"])
print("ingredient:", dictionary["ingredient"])
print("origin:", dictionary["origin"])
print()

# 값 변경
dictionary["name"] = "8D 건조 망고"
print("name:", dictionary["name"]

# 실행 결과
----------
name: 7D 건조 망고
type: 당절임
ingredient: ['망고', '설탕', '메타중아황산나트륨', '치자황색소']
origin: 필리핀

name: 8D 건조 망고

리스트와 딕셔너리

자료형의미카리키는 위치선언 형식사용 예틀린 예
리스트인덱스를 기반으로 값 저장인덱스변수 = [ ]list_a[1]
딕셔너리키를 기반으로 값 저장키변수 = { }dict_a["name"]dict_a{"name"}

딕셔너리의 문자열 키와 관련된 실수 : NameError

  • 딕셔너리의 키에 따옴표 없이 단순하게 식별자를 입력하면 이를 변수로 인식함
  • 키를 문자열로 사용할 경우에는 반드시 따옴표 필수
# 오류
>>> dict_key = {
	name : "7D 건조 망고",
    type : "당절임"     ---> 여기서도 오류가 나타날 수 있지만 나타나지 않는 이유는 type은 type()함수라는 기본 식별자가 있기 때문에 이것이 키로 들어가도 오류가 나타나지 않음
}
>>> NameError : name 'name' is not defind

# 수정
>>> name = "이름"
>>> dict_key = {
	name : "7D 건조 망고",
    type : "당절임"
}
>>> dict_key
{'이름': '7D 건조 망고', <class 'type'>: '당절임'}

딕셔너리에 값 추가하기/제거하기

  • 딕셔너리에 값을 추가할 때는 키를 기반으로 값 입력하면 됨

딕셔너리[새로운 키] = 새로운 값

# 딕셔너리의 요소에 접근하기

>>> dictionary = {
	"name" : "8D 건조 망고",
    "type" : "당절임",
    "ingredient" : ["망고", "설탕", "메타중아황산나트륨", "치자황색소"]
    "origin" : "필리핀"
}
>>> dictionary["price"] = 5000
>>> dictionary
{'name' : '8D 건조 망고', 'type' : '당절임', 'ingredient' : ['망고', '설탕', '메타중아황산 나트륨', '치자황색소'], 'origin' : '필리핀', 'price' : 5000}   ---> price 추가됨
  • 딕셔너리에 이미 존재하고 있는 키를 지정하고 값을 넣으면 기존의 값을 새로운 값으로 대치하기도 함
>>> dictionary = {
	"name" : "8D 건조 망고",
    "type" : "당절임",
    "ingredient" : ["망고", "설탕", "메타중아황산나트륨", "치자황색소"]
    "origin" : "필리핀"
}
>>> dictionary["name"] = "8D 건조 파인패플"
>>> dictionary
{'name' : '8D 건조 망고', 'type' : '당절임', 'ingredient' : ['망고', '설탕', '메타중아황산 나트륨', '치자황색소'], 'origin' : '필리핀', 'price' : 5000}   ---> 새로운 값으로 대치됨
  • 딕셔너리 요소의 제거는 del 키워드를 사용하여 특정키를 지정하면 제거됨
>>> dictionary = {
	"name" : "8D 건조 망고",
    "type" : "당절임",
    "ingredient" : ["망고", "설탕", "메타중아황산나트륨", "치자황색소"]
    "origin" : "필리핀"
}
>>> del dictionary["ingredient"] = "8D 건조 파인패플"
>>> dictionary
{'name' : '8D 건조 망고', 'type' : '당절임', 'origin' : '필리핀', 'price' : 5000}

KeyError 예외

  • 존재하지 않는 키에 접근하면 KeyError가 발생함
  • 존재하지 않는 키를 제거할 경우에도 KeyError가 발생함
>>> dictionary ={}
>>> dictionary["key"]
KeyError: 'Key'

>>> del dictionary["Key"]
KeyError: 'Key'

🔎 딕셔너리 내부에 키가 있는지 확인하기


in 키워드

  • 딕셔너리 내부에 키가 있는지 없는지 확인할 때 in 키워드 사용함
# 딕셔너리 선언

dictionary = {
	"name" : "7D 건조 망고",
    "type" : "당절임",
    "ingredient" : ["망고", "설탕", "메타중아황산나트륨", "치자황색소"]
    "origin" : "필리핀"
}

# 사용자로부터 입력 받음
key = input("> 접근하고자 하는 키: ")

# 출력
if key in dictionary:
	print("dictionary[key])
else:
	print("존재하지 않는 키에 접근하고 있습니다.")
    
# 실행 결과
----------
> 접근하고자 하는 키: name
7D 건조 망고
> 접근하고자 하는 키: ㅇㅂㅇ
존재하지 않는 키에 접근하고 있습니다.

get()함수

  • 딕셔너리의 키로 값을 추출한느 기능
  • 딕셔너리[키]를 입력할 때와 같은 기능을 수행함
  • 존재하지 않는 키에 접근할 경우 KeyError를 발생시키지 않고 None출력함
# 딕셔너리 선언
dictionary = {
	"name" : "7D 건조 망고",
    "type" : "당절임",
    "ingredient" : ["망고", "설탕", "메타중아황산나트륨", "치자황색소"]
    "origin" : "필리핀"
}

# 존재하지 않는 키 접근
value = dictionary.get("존재하지 않는 키")
print("값:", value)

# None 확인 방법
if value == None:
	print("존재하지 않는 키에 접근했었습니다.")
    
# 실행 결과
----------
값 : None
존재하지 않는 키에 접근했었습니다.

for 반복문: 딕셔너리와 함께 사용하기

  • 딕셔너리 내부에 있는 키가 변수에 들어가게 사용함

for 키 변수 in 딕셔너리:
. . . . 코드

# for 반복문과 딕셔너리

# 딕셔너리 선언
dictionary = {
	"name" : "7D 건조 망고",
    "type" : "당절임",
    "ingredient" : ["망고", "설탕", "메타중아황산나트륨", "치자황색소"]
    "origin" : "필리핀"
}

# for 반복문 사용
for key in dictionary:
	#출력
    print(key, ":", dictionary[key])
    
# 실행 결과
----------
name : 7D 건조 망고
type : 당절임
ingredient : ['망고', '설탕', '메타중아황산나트륨', '치자황색소']
origin : 필리핀

🔎 범위 자료형과 while 반복문


범위(range)

  • 정수로 이루어진 범위를 만들 때 range()함수 사용
  • 범위를 지정할 경우에 맨 뒤에 숫자는 들어가지 않음
>>> list(range(0, 5))
[0, 1, 2, 3, 4]

>>> list(range(0, 10, 2))
[0, 2, 4, 6, 8]
  • 범위를 만들 때 수식을 사용하는 경우도 존재함
>>> a = range(0, 10+1)
>>> list(a)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  • 수식에 나누기 연산자를 사용할 경우에는 TypeError가 발생함
  • range()함수의 매개변수는 반드시 '정수'를 입력해야 함
>>> n = 10
>>> a = range(0, n / 2)
TypeError: 'float' object cannot be interpreted as an integer
  • 정수로 바꾸는 방법도 있지만 주로 정수 나누기 연산자를 사용함
>>> n = 10
>>> a range(0, int(n/2))
>>> list(a)
[0, 1, 2, 3, 4)

>>> n = 10
>>> a = range(0, n // 2)
>>> list(a)
[0, 1, 2, 3, 4]

for 반복문: 범위와 함께 사용하기

for 숫자 변수 in 범위:
. . . . 코드

# for 반복문과 범위를 함께 조합해서 사용
for i in range(5):
	print(str(i) + "=반복 변수")
print()

for i in range(5, 10):
	print(str(i) + "=반복 변수")
print()

for i in range(0, 10, 3):
	print(str(i) + "=반복 변수")
print

# 실행 결과
----------
0=반복 변수
1=반복 변수
2=반복 변수
3=반복 변수
4=반복 변수

5=반복 변수
6=반복 변수
7=반복 변수
8=반복 변수
9=반복 변수

0=반복 변수
3=반복 변수
6=반복 변수
9=반복 변수

for 반복문: 리스트와 범위 조합하기

  • 리스트의 반복문을 조합해서 사용할 경우 몇 번째 반복인지를 알아야 할 경우가 있는데 아래와 같이 범위를 조합하면 가장 쉬움
# 리스트 선언
array = [273, 32, 103, 57, 52]

# 리스트에 반복문 적용
for i in range(len(array)):
	# 출력
    print("{}번째 반복: {}".format(i, array[i]))
    # i : 순서번호
    # array[i] : 각 순서에 있는 값
    
# 실행 결과
----------
0번째 반복: 273
1번째 반복: 32
2번째 반복: 103
3번째 반복: 57
4번째 반복: 52

for 반복문: 반대로 반복하기

  • 역반복문 : 큰 숫자에서 작은 숫자로 반복문을 적용해야 하는 경우 사용
  • range() 함수의 매개변수 3개 사용하여 만드는 방법 있음
  • reversed()함수를 사용하여 반복문 반대로 돌리는 방법 있음
# range() 함수 사용
for i in range(4, 0 - 1, -1):  
	#출력
    print("현재 반복 변수: {}".format(i))
    
# 실행 결과
----------
현재 반복 변수: 4
현재 반복 변수: 3
현재 반복 변수: 2
현재 반복 변수: 1
현재 반복 변수: 0

# reversed() 함수 사용
for i in reversed(range(5)):
	# 출력
    print("현재 반복 변수: {}".format(i))
    
# 실행 결과
----------
현재 반복 변수: 4
현재 반복 변수: 3
현재 반복 변수: 2
현재 반복 변수: 1
현재 반복 변수: 0

while 반복문

  • if조건과 비슷한 형식이며 <불 표현식>이 참인 동안 문장을 계속 반복함
  • for문은 무한반복을 할 수 없지만 while은 무한반복이 가능함
  • 조건을 활용하여 반복문을 작성해야 한다면 while문을 이용하는것이 좋음

while 불 표현식:
. . . . 문장

while True:
	# "."을 출력함
    # 기본적으로 END가 "\n"이라 줄바꿈이 일어남
    # 빈 문자열 ""로 바꿔서 줄바꿈이 없음
    print(".", end = "")
    # "."이 무한반복으로 출력됨
    # 강제종료 Ctrl + C를 눌러서 종료 가능함

while 반복문 : for 반복문처럼 사용하기

# 반복 변수 기반으로 반복하기
i = 0
while i < 10:
	print("{}번째 반복입니다.".format(i))
	i += 1

# 실행 결과
----------
0번째 반복입니다.
1번째 반복입니다.
2번째 반복입니다.
3번째 반복입니다.
4번째 반복입니다.
5번째 반복입니다.
6번째 반복입니다.
7번째 반복입니다.
8번째 반복입니다.
9번째 반복입니다.

while 반복문: 상태를 기반으로 반복하기

  • remove()함수는 리스트 내부에서 해당하는 값을 1개만 제거함
  • while반복문을 활용하면 여러 개를 제거 할 수 있음
list_test = [1, 2, 1, 2]
value = 2

while value in list_test:
	list_test.remove(value)
    
#출력
print(list_test)

# 실행 결과
----------
[1, 1]

while 반복문: 시간을 기반으로 반복하기

  • 유닉스 타임(Unix Time)이란 세계 표준시(UTC)로 1970년 1월 1일 0시 0분 0초를 기준으로 몇 초가 지났는지를 정수로 나타냄
  • 파이썬에서 유닉스 타임을 구할 때는 아래의 코드를 이용함

import time ----> 시간과 관련된 기능 가져옴
time.time() ----> 유닉스 타임 구하기

# 5초동안 반복하는 코드
import time

# 변수 선언
number = 0

# 5초동안 반복
target_tick = time.time() + 5
while time.time() < target_tick:
	number += 1
    
# 출력
print("5초동안 {}번 반복했습니다.".format(number)

# 실행 결과
----------
5초동안 31473573번 반복했습니다.

🔎 while 반복문: break 키워드


break 키워드

  • 반복문을 벗어날 때 사용함
  • 무한반복문을 만들고 내부의 반복을 벗어날 때 많이 사용함
# 변수 선언
i = 0

# 무한 반복
while True:
    # 몇 번째인지 출력
    print("{}번째 반복문입니다.".format(i))
    i += 1
    # 반복 종료
    
    input_text = input("> 종료하시겠습니까?(y/n): ")
    if input_text in ["y", "Y"]:
        print("반복을 종료합니다.")
        break
        
# 실행 결과
----------
0번째 반복문입니다.
1번째 반복문입니다.
2번째 반복문입니다.
3번째 반복문입니다.
4번째 반복문입니다.
반복을 종료합니다.

🔎 while 반복문: continue 키워드


continue 키워드

  • 현재 반복을 생략하고 다음 반복으로 넘어갈 때 사용함
  • 이후 처리의 들여쓰기를 하나 줄일 수 있음
# 변수 선언
numbers = [5, 15, 6, 20, 7, 25]

# 반복 돌리기
for number in numbers:
	# number가 10보다 작으면 다음 반복문으로 넘어가기
    if number < 10:
    	continue
    # 출력
    print(number)
    
# 실행 결과
----------
15
20
25

🔎 문자열, 리스트, 딕셔너리와 관련된 함수


리스트에 적용할 수 있는 기본 함수 : min(), max(), sum()

함수설명
min()리스트 내부에서 최솟값을 찾음
max()리스트 내부에서 최댓값 찾음
sum()리스트 내부에서 값을 모두 더함

리스트 순서를 뒤집고 싶을 때 : reversed()

temp = reversed([1, 2, 3, 4, 5, 6])

for i in temp:
	print("첫 번째 반복문 : {}".format(i))
    
for i in temp:
	print(" 두 번째 반복문: {}".format(i))

# 실행 결과
----------
첫 번째 반복문 : 6
첫 번째 반복문 : 5
첫 번째 반복문 : 4
첫 번째 반복문 : 3
첫 번째 반복문 : 2
첫 번째 반복문 : 1
  • 위 코드를 보면 두 번째 반복문이 실행이 안 됨. 이는 함수의 결과가 제너레이터이기 때문임
  • 제너레이터는 reversed()함수와 반복문을 조합할 때는 결과를 여러 번 활용하지 않고 for 구문 내부에 reversed()함수를 곧바로 넣어서 사용함
numbers = [1, 2, 3, 4, 5, 6]

for i in reversed(numbers):
	print("첫 번째 반복문 : {}".format(i))
    
for i i nreversed(numbers):
	print(" 두 번째 반복문: {}".format(i))

# 실행 결과
----------
첫 번째 반복문 : 6
첫 번째 반복문 : 5
첫 번째 반복문 : 4
첫 번째 반복문 : 3
첫 번째 반복문 : 2
첫 번째 반복문 : 1
 두 번째 반복문: 6
 두 번째 반복문: 5
 두 번째 반복문: 4
 두 번째 반복문: 3
 두 번째 반복문: 2
 두 번째 반복문: 1

현재 인덱스가 몇 번째인지 확인 : enumerate()

# 변수 선언
example_list = ["요소A", "요소B", "요소C"]

# 그냥 출력
print("# 단순 출력")
print(example_list)
print()

# enumerate() 함수를 적용하여 출력
print("# enumerate() 함수 적용 출력")
print(enumerate(example_list))
print()

# list() 함수로 강제 변환해 출력
print("# list() 함수로 강제 변환 출력")
print(list(enumerate(example_list)))
print()

# for 반복문과 enumerate() 함수 조합해서 사용
print("# 반복문과 조합하기")
for i, value in enumerate(example_list):
	print("{}번째 요소는 {}입니다.".format(i, value))

# 실행 결과
----------    
# 단순 출력
['요소A', '요소B', '요소C']

# enumerate() 함수 적용 출력
<enumerate object at 0x000001AC38843830>

# list() 함수로 강제 변환 출력
[(0, '요소A'), (1, '요소B'), (2, '요소C')]

# 반복문과 조합하기
0번째 요소는 요소A입니다.
1번째 요소는 요소B입니다.
2번째 요소는 요소C입니다.

딕셔너리로 쉽게 반복문 작성하기 : items()

  • 키와 값을 조합해서 쉽게 반복문을 작성할 수 있음
# 변수 선언
example_dictionary = {
    "키A" : "값A",
    "키B" : "값B",
    "키C" : "값C",
}

# 딕셔너리 items() 함수 결과 출력하기
print("# 딕셔너리의 items() 함수")
print("items():", example_dictionary.items())
print()

# for 반복문과 items() 함수 조합해서 사용하기
print("# 딕셔너리의 items() 함수와 반복문 조합하기")

for key, element in example_dictionary.items():
    print("dictionary[{}] = {}".format(key, element))
    
# 실행 결과
----------  
# 딕셔너리의 items() 함수
items(): dict_items([('키A', '값A'), ('키B', '값B'), ('키C', '값C')])

# 딕셔너리의 items() 함수와 반복문 조합하기
dictionary[키A] = 값A
dictionary[키B] = 값B
dictionary[키C] = 값C

리스트 안에 for문 사용하기 : 리스트 내포(list comprehension)

  • 반복문의 요소를 삽입할 때 한 줄로 작성할 수 있도록 제공하는 문법

리스트 이름 = [표현식 for 반복자 in 반복할 수 있는 것]
리스트 이름 = [표현식 for 반복자 in 반복할 수 있는 것 if 조건문]

# 변수 선언
array = []

# 반복문 적용
for i in range(0, 20, 2):
	array.append(i * i)
    

# 출력
print(array)

# 실행 결과
---------- 
[0, 4, 16, 36, 64, 100, 144, 196, 256, 324]
# 리스트 안에 for문
array = [i * i for i in range(0, 20, 2)]

#출력
print(array)

# 실행 결과
----------  
[0, 4, 16, 36, 64, 100, 144, 196, 256, 324]
# 조건을 활용한 리스트 내포
# 리스트 선언

array = ["사과", "자두", "초콜릿", "바나나", "체리"]
output = [fruit for fruit in array if fruit != "초콜릿"]

#출력
print(output)


🤔 기본 미션 ) 리스트, 딕셔너리, 범위 자료형에 대해 이해한 내용을 바탕으로 포스팅하기

리스트(list)

  • 여러가지 자료 저장할 수 있음
  • 대괄호에 값 쉼표로 구분하여 입력
  • 리스트 인덱스 가능
  • len()함수를 통하여 개수 확인 가능
  • 리스트 관련 함수 존재(append(), insert(), remove(), extend(), clear(), pop(), del, sort()...)

딕셔너리(dict)

  • 키 기반으로 키 저장
  • 가리키는 위치는 키이며 선언은 변수 = {}형식으로 선언
  • 키는 문자열, 숫자, 불등으로 선언가능하지만 일반적으로 문자열로 선언 많이 함
  • 딕셔너리는 요소에 접근할 때 딕셔너리 뒤에 대괄호 사용하며 인덱스처럼 키 입력함

범위 자료형(range)

  • 정수로 이루어진 범위를 만들 때 rnage()함수 사용함
  • 범위 지정할 경우에 맨 뒤 지정한 숫자는 제외하고 들어감


😮 선택 미션 ) p. 213쪽의 1번 문제의 답 쓰고 인증하기

1. list_a = [0, 1, 2, 3, 4, 5, 6, 7]입니다. 다음 표의 함수들을 실행했을 때 list_a의 결과 어떻게 나오는지 적어 보세요.

함수list_a의 값
list_a.extend(list_a)[0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7]
list_a.append(10)[0, 1, 2, 3, 4, 5, 6, 7, 10]
list_a.insert(3, 0)[0, 1, 2, 0, 3, 4, 5, 6, 7]
list_a.remove(3)[0, 1, 2, 4, 5, 6, 7]
list_a.pop(3)[0, 1, 2, 4, 5, 6, 7]
list_a.clear()[]
#extend() : 한 번에 여러 요소 추가
list_a = [0, 1, 2, 3, 4, 5, 6, 7]
list_a.extend(list_a)   # 리스트 a추가
print(list_a)

# 실행 결과
----------  
[0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7]
# append() : 리스트 뒤에 요소 추가
list_a = [0, 1, 2, 3, 4, 5, 6, 7]
list_a.append(10)   # 10 추가
print(list_a)

# 실행 결과
----------  
[0, 1, 2, 3, 4, 5, 6, 7, 10]
# insert() : 리스트 중간에 요소 추가
list_a = [0, 1, 2, 3, 4, 5, 6, 7]
list_a.insert(3, 0)   # 3번째 위치에 0 추가
print(list_a)

# 실행 결과
----------  
[0, 1, 2, 0, 3, 4, 5, 6, 7]
# remove() : 값 제거
list_a = [0, 1, 2, 3, 4, 5, 6, 7]
list_a.remove(3)   # 3 제거
print(list_a)

# 실행 결과
----------  
[0, 1, 2, 4, 5, 6, 7]
# pop : 제거하고 싶은 위치의 요소 제거
list_a = [0, 1, 2, 3, 4, 5, 6, 7]
list_a.pop(3)   # 3번째 위치요소 제거
print(list_a)

# 실행 결과
----------  
[0, 1, 2, 4, 5, 6, 7]
# clear : 리스트 내부 요소 모두 제거
list_a = [0, 1, 2, 3, 4, 5, 6, 7]
list_a.clear()
print(list_a)

# 실행 결과
----------  
[]


👀 도전문제

1. 숫자의 종류

리스트에서 몇 가지 종류의 숫자가 사용되었는지 구하기


# 입력
[1, 2, 3, 4, 1, 2, 3, 1, 4, 1, 2, 3]
# 출력 형식
[1, 2, 3, 4, 1, 2, 3, 1, 4, 1, 2, 3]에서
사용된 숫자의 종류는 4개입니다.
참고: {1: 4, 2: 3, 3: 3, 4: 2}

🖥️ for문 이용

list_a = [1, 2, 3, 4, 1, 2, 3, 1, 4, 1, 2, 3]

count = {}  # 딕셔너리 생성

for i in list_a: # i가 list_a에 있는 동안
    if i not in count:   # 만약에 count에 i가 없으면
        count[i] = 0    # count값은 0
    count[i] += 1    # count에 1씩 추가

'''
for i in list_a: # i가 list_a에 있는 동안
    if i not in count:   # 만야게 count에 i가 없으면
        count[i] = 1    # count 기본 값은 1
    else:               # 아니면
        count[i] += 1   # count에 +1씩 추가
'''


print(f"{list_a}에서")
print(f"사용된 숫자의 종류는 {len(count)}개 입니다.")
print(f"참고: {count}")

🖥️ 모듈과 set 이용

# collections 모듈의 Counter 불러오기
from collections import Counter

list_a = [1, 2, 3, 4, 1, 2, 3, 1, 4, 1, 2, 3]
Set = set(list_a)   # 집합 자료형으로 변경하여 중복 제거
count = dict(Counter(list_a))   # Counter로 개수 세고 딕셔너리로 변환

print(f"{list_a}에서")
print(f"사용된 숫자의 종류는 {len(Set)}개 입니다.")
print(f"참고: {count}")

2. 염기의 개수

염기 서열을 입력했을 때 각각의 염기가 몇 개 포함되어 있는지 새는 프로그램을 구현하기

# 입력
ctacaatgtcagtatacccattgcattagccgg
#출력 형식
염기 서열을 입력해주세요: ctacaatgtcagtatacccattgcattagccgg\
a의 개수: 9
t의 개수: 9
g의 개수: 6
c의 개수: 9

🖥️

rank = input("염기 서열을 입력해주세요: ")
count = {
    "a" : 0,
    "t" : 0,
    "g" : 0,
    "c" : 0
}

for i in rank:   #  염기 개수 세기
    count[i] += 1

for key in count:
    print(f"{key}의 개수: {count[key]}")

🖥️ 모듈 사용

from collections import Counter

rank = input("염기 서열을 입력해주세요: ")

count = Counter(rank)
for key in count:
    print(f"{key}의 개수: {count[key]}")

3. 염기 코돈 개수

# 입력 
ctacaatgtcagtatacccattgcattagccgg

5글자가 되어 있으면 3글자는 세고 2나머지 2글자는 버리기
# 출력 형식
염기 서열을 입력해 주세요: ctacaatgtcagtatacccattgcattagccgg
{'cta' : 1, 'caa' : 1, 'tgt' : 1, 'cag' : 1, 'tat' : 1, 'acc' : 1, 'cat' : 1, 'tgc' : 1, 'att' : 1, 'agc' : 1, 'cgg' : 1}

🖥️

rank = "ctacaatgtcagtatacccattgcattagccgg"

for i in range(0, len(rank), 3):  # 범위 지정(처음부터, 글자개수, 3개씩)
    codon = rank[i:i+3]   # coden은 rank의 i번째부터 i+3글자씩 자르기 --> 3글자씩 출력

    if len(codon) == 3:   # 만약에 codon 개수가 3개면
        print(codon)   # codon 출력 ---> codon의 개수가 3개가 아닐 경우를 대비

🖥️ 딕셔너리 사용하여 개수 세기

nucleos = input("염기 서열을 입력해주세요: ")
counter = {}

for i in range(0, len(nucleos), 3):
    codon = nucleos[i:i+3]   # 3글자씩 추가하기
    if len(codon) == 3:   # 글자가 3글자인지 확인하기
        if codon not in counter:   # 딕셔너리에 키가 없으면 추가
            counter[codon] = 0
        counter[codon] += 1   # 개수 추가
print(counter)

4. 2차원 리스트 평탄화

리스트 평탄화(list flatten) : 리스트가 중첩되어 있을 때 중첩을 제거하는 처리

# 입력
[1, 2, [3, 4], 5, [6, 7], [8, 9]] --> [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 출력 형식
[1, 2, [3, 4], 5, [6, 7], [8, 9]]를 평탄화하면 [1, 2, 3, 4, 5, 6, 7, 8, 9]입니다
# 😊 Hint
리스트 평탄화를 할 때는 '요소가 일반 요소인지 리스트인지 확인'하는 처리가 필요함. 이는 아래와 같이 type()함수를 사용하면 됨

if type(대상) == list:
	print("대상은 리스트입니다!")

🖥️

a = [1, 2, [3, 4], 5, [6, 7], [8, 9]]
output = [ ]

for i in a:     # 리스트 평탄화 하기 위한 코드
    if type(i) == list:   # 만약에 type이 리스트라면
        
        for j in i:   # 반복해서 요소를 추가함
            output.append(j)
    else:    # 아니면 그냥 요소 추가
        output.append(i)

print(f"{a}를 평탄화 하면")
print(f"{output}입니다.")
profile
JIN
개발을 '잘'하고 싶다는 마음은 항상 늘 지니고 있는 사람
이전 포스트

혼공파 2주차

다음 포스트

혼공파 4주차

1개의 댓글

comment-user-thumbnail
happy
2023년 7월 19일

많은 도움이 되었습니다, 감사합니다.

답글 달기