[3일차] Python 기초 문법(2)

[Python 데이터 전처리 기초]

-기초 문법부터 데이터 결합 및 파생 변수 생성까지

 

<목차>

#01. 데이터 분석의 이해

#02. Python 기초 문법

#03. 데이터 처리 기초

#04. 간단한 데이터 집계 및 시각화

#05. 데이터 처리 심화

#06. 프로젝트 실습

 

<지난 시간 간단 복습>

type 종류

: int, float, str, bool 등이 있습니다.

• "", '' 안에 들어가 있으면 문자열 취급이 됩니다. ex) "3"+'4' -> 34
• bool타입은 True/False로 나눠집니다.

변수란?

: 어떤 공간을 나타내는 이름을 뜻합니다. 값을 가져오거나 넣을 수 있습니다.

선언이 가능하며 있으며, 대입연산자를 통해 할당합니다.

ex) a = 0 (선언, 할당 둘 다 가능)

• 변수 이름은 예약어 사용이 금지되어 있으며, 되도록이면 영어소문자로 시작하는 것이 좋습니다.
• 띄어쓰기 대신 문자를 _로 이을 수 있습니다.

list란?

: 대괄호[] 형태로 이어져 있는 형태를 말합니다.

 

'변수는 값이고 함수는 기능이다.'

 

저번 시간에 배웠던 것들을 다시 한번 상기시켜 보시고,

자! 이제부터 3일차 수업 내용에 대해 들어가 보겠습니다.

 

2. 여러 값을 묶은 리스트(list)

리스트란?

: 연달아 있는 값을 의미합니다.

여기서 순서의 값은 0부터 시작합니다.

 

지난 시간에서 리스트의 주요 메서드를 배웠는데요.

바로. append()/. extend()입니다.

.append( )는 리스트에 값을 추가하고, .extend( )는 리스트에 또 다른 리스트를 이어 붙이는 메서드입니다.

. 을 ~에 속한 것이라고 생각하면 이해하기 더 쉽습니다!

 

변수[] : 대괄호 사이의 여러 수를 선택하겠다로 생각하면 됨.

 

2.3. index의 활용

2.3.1 단일 리스트

리스트를 만들 때 사용한 대괄호와 별개로, 

만들어진 리스트에 대괄호 []를 붙여 특정 요소나 구간을 꺼내올 수 있습니다.

<종류>                             <문법>                                     <설명>

 

단일 인덱싱	lst[i]	0부터 시작하는 i번째 요소
음수 인덱싱	lst[-i]	뒤에서부터 i번째 요소
슬라이싱	lst[start:end]	start ≤ 인덱스 < end 구간 요소들
스텝 슬라이싱	lst[start:end:step]	start부터 end 전까지 step 간격으로 요소들

여기서 슬라이싱이란?

: 시퀀스 객체(리스트, 튜플, 문자열 등)의 특정 범위를 지정하여 부분 객체를 추출하는 기능을 뜻합니다.

 

<예시>

fruits = ["🍎", "🍌", "🍇", "🍑", "🍒"]

# 1) 단일 인덱싱
print(fruits[0])    # -> 🍎  (첫 번째)
print(fruits[2])    # -> 🍇  (세 번째)

# 2) 음수 인덱싱
print(fruits[-1])   # -> 🍒  (마지막)
print(fruits[-3])   # -> 🍇  (뒤에서 세 번째)

# 3) 슬라이싱
print(fruits[1:4])  # -> ['🍌', '🍇', '🍑']  (인덱스 1,2,3)
print(fruits[:3])   # -> ['🍎', '🍌', '🍇']  (처음~2)
print(fruits[2:])   # -> ['🍇', '🍑', '🍒']  (2~끝)

# 4) 스텝 슬라이싱
print(fruits[0:5:2])  # -> ['🍎', '🍇', '🍒']  (0,2,4번)
print(fruits[1::2])   # -> ['🍌', '🍑']       (1~끝, 2간격)

#4) 슬라이싱 후 단일 인덱싱
print(fruits[0:3][2])  # -> 🍇  (0,1,2,3,번 중 2번)

리스트 인덱스 값 변경

: 이미 만들어진 리스트에서 특정 위치의 값을 재할당하려면 lst [index] = 새 값 형태를 사용합니다.

<예시>

# 예시 리스트
nums = [10, 20, 30, 40, 50]
print("변경 전:", nums)
# -> 변경 전: [10, 20, 30, 40, 50]

# 인덱스 2번(세 번째 요소)을 99로 변경
nums[2] = 99
print("변경 후:", nums)
# -> 변경 후: [10, 20, 99, 40, 50]

# 음수 인덱스도 가능
nums[-1] = 0
print("마지막 요소 0으로 변경:", nums)
# -> 마지막 요소 0으로 변경: [10, 20, 99, 40, 0]

 

2.4.2 이중(2차원) 리스트

• 정의: 1차원 리스트 안에 다시 리스트가 요소로 들어 있는 구조를 말합니다.
• 용도: 표 형태의 데이터(행·열), 행렬, 격자(grid) 등 2차원 구조를 표현할 때 사용합니다.
• 특징
  1. 중첩 리스트: matrix = [[a11, a12], [a21, a22]]
  2. 인덱싱: matrix[i][j]로 i행 j열 요소 접근
  3. 슬라이싱:
     • 행 슬라이싱: matrix[i:j] → i ≤ 행 < j 범위 추출
     • 열 슬라이싱: [row[k:l] for row in matrix] → 각 행에서 k ≤ 열 < l 범위 추출
  4. 가변성: 1차원 리스트와 마찬가지로, matrix[i][j] = 값으로 직접 수정 가능합니다.

<예시>

# 1) 2차원 리스트 생성
matrix = [
    [1,  2,  3],
    [4,  5,  6],
    [7,  8,  9]
]
print("matrix =", matrix)
# -> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# 2) 단일 인덱싱
print(matrix[0][1])   # -> 2   (1행, 2열)
print(matrix[2][2])   # -> 9   (3행, 3열)

# 3) 음수 인덱싱
print(matrix[-1][-1]) # -> 9   (마지막 행·열)
print(matrix[-2][-3]) # -> 4   (뒤에서 두 번째 행, 첫 열)

# 4) 행 슬라이싱
print(matrix[1])      # -> [4, 5, 6]       (2행 전체)
print(matrix[:2])     # -> [[1,2,3],[4,5,6]] (처음 두 행)

# 5) 열 슬라이싱 (리스트 컴프리헨션 활용)
first_col = [row[0] for row in matrix]
print(first_col)      # -> [1, 4, 7]       (1열만 추출)

# 6) 스텝 슬라이싱 (행·열 모두)
sub = [row[::2] for row in matrix[::2]]
print(sub)            
# -> [[1, 3], [7, 9]]  (0,2번째 행의 0,2번째 열 요소)

# 7) 슬라이싱 후 인덱싱
print(matrix[0:2][1][2])
# -> 6

# 8) 값 변경
print("변경 전:", matrix)
# -> 변경 전: [[1,2,3], [4,5,6], [7,8,9]]

matrix[1][1] = 99     # 2행 2열을 99로 업데이트
print("변경 후:", matrix)
# -> 변경 후: [[1,2,3], [4,99,6], [7,8,9]]

matrix[-1][-3] = 0    # 마지막 행 첫 열을 0으로
print("최종:", matrix)
# -> 최종: [[1,2,3], [4,99,6], [0,8,9]]

 

2.4. 다양한 리스트 생성 방법

2.4.1. list( )의 활용

: list( )로 빈 리스트를 만들거나 다른 타입의 값들을 리스트 형식으로 변환이 가능합니다.

 

<빈 리스트 생성>

a = list()      # []와 동일하게 빈 리스트를 만듭니다.

 

< iterable → 리스트 변환>

nums = list((1, 2, 3))     # 튜플을 리스트로 변환 → [1, 2, 3]
chars = list("ABC")        # 문자열을 문자 리스트로 변환 → ['A','B','C']

 

<list( )의 활용 예시>

# 1) 빈 리스트 생성
a = list()
print(a)        # -> []

# 2) 요소 추가
a.append('2023-12-25')
print(a)        # -> ['2023-12-25']

# 3) 또 요소 추가
a.append('2023-12-31')
print(a)        # -> ['2023-12-25', '2023-12-31']

# 4) 다른 iterable 변환 예시
t = (10, 20, 30)
lst = list(t)
print(lst)     # -> [10, 20, 30]

 

2.4.2. range( )를 활용한 수열 만들기

range() 함수

• 역할: 연속적인 수열을 만들 때는 range( )를 활용합니다.
• 형태
  • range(stop) → 0부터 stop-1까지
  • range(start, stop) → start부터 stop-1까지
  • range(start, stop, step) → start부터 step 간격으로 stop-1까지

<예제>

list(range(5))          # -> [0, 1, 2, 3, 4]         # 0부터 4까지

list(range(1, 6))       # -> [1, 2, 3, 4, 5]         # 1부터 5까지

list(range(2, 11, 3))   # -> [2, 5, 8]               # 2부터 10까지 3씩 증가

 

<응용 예제>

# 1) 0부터 9까지의 range 객체 생성
print(range(10))           # -> range(0, 10)
print(list(range(10)))     # -> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 2) 10부터 99까지 2씩 증가하는 숫자 만들기
c = range(10, 100, 2)
print(list(c))             # -> [10, 12, 14, ..., 96, 98]

# 3) 1부터 19까지
print(list(range(1, 20)))  # -> [1, 2, 3, ..., 18, 19]

# 4) 1부터 19까지 3간격
print(list(range(1, 20, 3)))  # -> [1, 4, 7, 10, 13, 16, 19]

 

3. 여러 값을 묶은 튜플(tuple)과 딕셔너리(Dictionary)

3.1. 튜플

튜플(Tuple)이란?

• 정의: 순서가 있는(ordered) 불변(immutable) 시퀀스
• 표현: 소괄호 () 또는 쉼표로 요소를 나열
• 특징:
  • 인덱싱·슬라이싱 가능
  • 수정·추가·삭제 불가 (immutable)
  • 리스트보다 메모리 효율이 좋고, 고정된 데이터 집합에 적합

튜플은 리스트와 달리 수정이 불가능하다는 점!

 

왜 튜플을 사용하나요?

: 리스트와 비슷하게 여러 개의 값을 묶지만, 값 변경이 불가능해서 데이터 분석에서 활용도는 떨어집니다.
다만, 전체 분석과정에서 절대 바뀌지 않는 값 묶음이 있다면, 튜플 형식을 활용할 수 있습니다.

<예제>

# 1) 튜플 생성
aa = (1, 2, 3)
bb = '아침', '점심', '저녁'

print(aa)   # -> (1, 2, 3)
print(bb)   # -> ('아침', '점심', '저녁')

# 2) 인덱싱·슬라이싱
print(aa[0])    # -> 1
print(bb[1:])   # -> ('점심', '저녁')

# 3) 불변성 확인: 요소 변경 시도하면 오류 발생
aa[0] = 4
# TypeError: 'tuple' object does not support item assignment

여기서 잠깐! 3번에 오류가 발생하는 이유는?

: 3번의 오류는 파이썬에서 튜플이 불변(immutable) 하기 때문에 발생합니다.

즉, 튜플이 생성된 후에는 요소를 변경할 수 없습니다.

 

그럼 튜플은 생성된 후에 요소를 변경하는 방법이 없나요?

: 이 문제를 해결하려면 튜플을 가변(mutable)인 리스트로 변환하고, 리스트를 수정한 다음 필요한 경우 다시 튜플로 변환할 수 있습니다. 수정된 코드는 다음과 같습니다!

<예제>

# 3) 튜플 요소를 “업데이트”하려면, 새로운 튜플을 생성해야 합니다.

# 방법 1: 리스트로 변환 후 수정 → 다시 튜플로 변환
aa = (1, 2, 3)
temp = list(aa)     # [1, 2, 3]
temp[0] = 4         # [4, 2, 3]
aa = tuple(temp)    # (4, 2, 3)
print(aa)           # -> (4, 2, 3)

# 방법 2: 슬라이싱과 덧셈으로 새 튜플 생성
bb = ('아침', '점심', '저녁')
# '아침'을 '새벽'으로 바꾸려면:
bb = ('새벽',) + bb[1:]
print(bb)           # -> ('새벽', '점심', '저녁')

 

3.2. 딕셔너리

딕셔너리(Dictionary)란?

• 정의: 키(key)와 값(value)의 쌍(pair)을 모아 저장하는 매핑(mapping) 자료형
• 특징
  • 중괄호 {}와 콜론 : 으로 표현
  • ex) person = { 'name': '홍길동', 'age': 30, 'city': '서울' }
  • 키는 중복 불가, 값은 중복 허용
  • 순서 없음 (파이썬 3.7+부터는 삽입 순서 유지)
  • 빠른 조회: 해시 테이블 기반으로, O(1) 평균 시간에 값 검색/삽입/삭제 가능
  • 가변(mutable): 기존 키에 대한 값 변경, 새로운 키·값 쌍 추가, 키 삭제 모두 가능

딕셔너리는 키(key)와 값(value)을 연결한 쌍을 활용해서 여러 값을 구분해서 저장합니다.

딕셔너리는 중괄호 { }를 활용하고 아래와 같은 방법으로 생성합니다.

{'key1':'value1', 'key2':'value2', 'key3':'value3', ...}

 

<예제>

# 강의 정보 저장
this_lecture = {'회사':'삼성전자', '분석도구':'Python', '기간':'3일'}
print(this_lecture)  
# -> {'회사': '삼성전자', '분석도구': 'Python', '기간': '3일'}

# 값 조회
print(this_lecture['회사'])        
# -> 삼성전자
print(this_lecture.get('회사'))    
# -> 삼성전자

 

여기서 왜 값 조회 방법이 두 가지로 나뉠까요?

• this_lecture['회사']는 해당 키가 없으면 KeyError를 발생시킵니다.
• this_lecture.get('회사')는 키가 없으면 None(또는 get에 지정한 기본값)을 반환하므로 오류를 피할 수 있습니다.

# 항목 추가
this_lecture['수강인원'] = 20
print(this_lecture)  
# -> {'회사': '삼성전자', '분석도구': 'Python', '기간': '3일', '수강인원': 20}

# 항목 삭제
del this_lecture['기간']
print(this_lecture)  
# -> {'회사': '삼성전자', '분석도구': 'Python', '수강인원': 20}

# 키와 값 확인
print(this_lecture.keys())         
# -> dict_keys(['회사', '분석도구', '수강인원'])
print(list(this_lecture.keys()))   
# -> ['회사', '분석도구', '수강인원']
print(list(this_lecture.values())) 
# -> ['삼성전자', 'Python', 20]

딕셔너리는 항목 추가 시 이미 기존의 값이 있을 때는 덮어씌워진 값으로 저장됩니다.

또한 딕셔너리는 시퀀스(sequence)가 아니기 때문에 리스트처럼 d[1:3] 같은 슬라이싱을 지원하지 않습니다.

대신, 키나 아이템을 리스트로 바꾼 뒤에 슬라이싱 한 후 다시 딕셔너리로 돌려야 합니다.

예제를 보여드리자면 아래와 같습니다.

<예제>

# 예제 딕셔너리
d = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}

# 1) 키 리스트로 변환 후 슬라이싱
keys = list(d.keys())   # ['a','b','c','d','e']
sub_keys = keys[1:4]    # ['b','c','d']

# 2) 슬라이스한 키로 새 딕셔너리 만들기
d_slice = {k: d[k] for k in sub_keys}
print(d_slice)
# -> {'b': 2, 'c': 3, 'd': 4}

 

<혹은 아이템(tuple) 전체를 가져온 예제>

items = list(d.items())[::2]   # 2칸씩 건너뛴 (key,value) 튜플 리스트
print(items)
# -> [('a',1), ('c',3), ('e',5)]

 

 

리스트를 값으로 할당도 가능한데요 아래와 같습니다.

# 학생 이름 리스트
students = ["철수", "영희", "민수"]

# 딕셔너리에 리스트를 값으로 저장
course = {
    "과목": "파이썬",
    "수강생": students
}
print(course)
# -> {'과목': '파이썬', '수강생': ['철수', '영희', '민수']}

# 1) 첫 번째 수강생만 추출
print(course["수강생"][0])
# -> 철수

# 2) 두 번째부터 끝까지 추출
print(course["수강생"][1:])
# -> ['영희', '민수']

# 3) 처음 두 명만 추출
print(course["수강생"][:2])
# -> ['철수', '영희']

# 4) 스텝 슬라이싱으로 격자 추출 (여기선 한 칸씩 건너뛰기)
print(course["수강생"][::2])
# -> ['철수', '민수']

 

리스트에 딕셔너리 추가하는 방법도 있습니다.

# 리스트 선언
courses = []
print(courses)  
# -> []

# append()로 딕셔너리 하나 추가
courses.append({'name':'Python', 'duration':3})
print(courses)  
# -> [{'name': 'Python', 'duration': 3}]

# extend()로 딕셔너리 여러 개 이어 붙이기
courses.extend([
    {'name':'Data Analysis', 'duration':2},
    {'name':'Web Dev', 'duration':1}
])
print(courses)  
# -> [
#    {'name': 'Python',         'duration': 3},
#    {'name': 'Data Analysis',  'duration': 2},
#    {'name': 'Web Dev',        'duration': 1}
# ]

# .get()을 사용해 특정 값 조회
print(courses[1].get('name'))    
# -> Data Analysis

# for문과 .get()으로 모든 강좌명 출력
for c in courses:
    print(c.get('name'))
# -> Python
#    Data Analysis
#    Web Dev

 

 

Python 제어문

주요 내용

1. Python 제어문의 이해 및 활용
2. 예제 문제

목표

1. 조건문을 이해하고 활용할 수 있다.
2. 반복문을 이해하고 활용할 수 있다.

 

1. 제어문

1-1. if 조건문

if를 활용하여 특정한 상황에서만 명령어를 실행 가능한데요.
else나 elif를 추가로도 활용이 가능합니다.

 

1.1.1. if 문

: if 문은 Python 조건 처리의 가장 기본적인 형태입니다.

if 문에 지정된 조건이 True 인 경우에만 코드 블록을 실행하게 됩니다. 

stock_price = 250

if stock_price > 200:
    print("Time to sell!")

위 예시에서는 주가가 200보다 큰 지 확인해 True 인 경우 "Time to sell" 을 출력하는 코드입니다.

 

-조건문에서 들여 쓰기의 중요성

Python의 들여 쓰기는 단지 가독성을 위한 것이 아닙니다.

들여 쓰기를 통해 조건문 등 다양한 코드 블록의 범위를 정의할 수 있습니다.

if False:
	print("Fasle")
print("TEST")

위와 같은 코드가 있을 경우 print("False") 의 경우 if 문의 조건이 False 이기 때문에 실행되지 않고 아래 들여 쓰기가 되어있지 않은 print("TEST") 의 경우에만 실행되게 됩니다.

 

-논리 연산자 사용

'and', 'or', 'not'과 같은 논리 연산자를 조건문과 결합하여 보다 복잡한 시나리오를 구현할 수 있습니다.

• and = 그리고
• or = 또는
• not = ~아닌

temperature = 22
weather = "sunny"

if temperature > 20 and weather == "sunny":
	print("Perfect day for a picnic")

 

1.1.2. if - else 문

: if - else 구조는 if 조건이 충족되지 않을 경우 else 블록에 포함된 코드가 실행됩니다.

age = 18

if age >= 18:
    print("You are eligible to vote.")
else:
    print("You are not eligible to vote.")

 

1.1.3. if - elif - else 문

: 조건문 작성 시 조건이 여러 개일 경우 Python은 if - elif - else 구문을 사용하여 하나가 참일 때까지 여러 조건을 순차적으로 확인하는 방법을 제공합니다.

day = "Tuesday"

if day == "Monday":
    print("Start of the week!")
elif day == "Friday":
    print("Almost weekend!")
elif day == "Saturday":
    print("Weekend!")
else:
    print("Middle of the week.")

 

---

여기서 잠깐!

변수 입력받는 방법

• 역할: 프로그램 실행 중 사용자로부터 문자열 형태의 입력을 받습니다.

변수명 = input("프롬프트 메시지")

• 특징:
  • 항상 문자열(str)을 반환
  • 숫자 연산에 사용하려면 int()·float() 등으로 형 변환 필요
  • 입력 대기 상태가 되므로, 콘솔이나 Jupyter 셀에서 실행 시 사용자의 응답을 기다림

# 예시: 이름과 나이를 입력받아 인사 및 계산하기

# 1) 이름 입력 (문자열)
name = input("이름을 입력하세요: ")
print("안녕하세요, " + name + "님!")
# 사용자가 '영희'를 입력했다면 출력:
# -> 안녕하세요, 영희님!

# 2) 나이 입력 (문자열 → 정수 변환)
age_str = input("현재 나이를 입력하세요: ")
age = int(age_str)            # '29' → 29
print("내년 나이는", age + 1, "세입니다.")
# 사용자가 '29'를 입력했다면 출력:
# -> 내년 나이는 30 세입니다.

 

 

입력과 형 변환 이론

• input()
  • 역할: 사용자로부터 입력을 받아 **문자열(str)**로 반환
  • 특징: 언제나 str 타입을 반환하므로, 이후 숫자 연산 등에 쓰려면 형 변환이 필요
• int(input())
  • input()으로 받은 문자열을 **정수(int)**로 변환
  • 입력값이 순수한 숫자 문자열이 아닐 경우 ValueError 발생
• float(input())
  • input()으로 받은 문자열을 **실수(float)**로 변환
  • 지수 표기법("1e3") 등도 파싱 가능, 형식이 맞지 않으면 ValueError
• bool(input())
  • input()으로 받은 문자열을 **불리언(bool)**으로 변환
  • 빈 문자열 ""만 False, 그 외(예: "0", "False"도) 모두 True

<예제>

# 1) 기본 input(): 항상 문자열로 반환
s = input("문자열 입력: ")
print(type(s), ":", s)
# 예시 입력) Hello
# -> <class 'str'> : Hello

# 2) int(input()): 정수로 변환
n = int(input("정수 입력: "))
print(type(n), ":", n, "더하기 5 =", n + 5)
# 예시 입력) 10
# -> <class 'int'> : 10 더하기 5 = 15

# 3) float(input()): 실수로 변환
f = float(input("실수 입력: "))
print(type(f), ":", f, "나누기 2 =", f / 2)
# 예시 입력) 3.14
# -> <class 'float'> : 3.14 나누기 2 = 1.57

# 4) bool(input()): 불리언으로 변환
b1 = bool(input("빈 문자열 입력해 보세요: "))
print(type(b1), ":", b1)
# 예시 입력)  (아무것도 입력 후 엔터)
# -> <class 'bool'> : False

b2 = bool(input("아무 문자열 입력해 보세요: "))
print(type(b2), ":", b2)
# 예시 입력) False
# -> <class 'bool'> : True

---

1-2. match

match case 문이란?

: 구조적 패턴 매칭 문법으로, match 뒤에 올 값을 여러 패턴과 비교해 첫 번째로 일치하는 case 블록을 실행합니다.

<예시>

# 입력된 명령어에 따라 분기
cmd = input("명령어를 입력하세요(start/stop): ")

match cmd:
    case "start":
        print("시작합니다.")
    case "stop":
        print("중지합니다.")
    case _:
        print("알 수 없는 명령어입니다.")

 

split()

: 문자열을 공백(혹은 지정한 구분자) 단위로 나누어 리스트로 반환하는 함수입니다.

ex: "3 + 2".split() → ["3", "+", "2"]

 

match…case 구조적 패턴 매칭

• match 뒤에 올 표현식을 패턴과 비교해, 첫 번째 일치하는 case 블록을 실행합니다.
• case _:는 와일드카드 패턴으로, 어떤 case에도 해당되지 않을 때 실행되는 기본(default) 처리합니다.

이 두 가지를 결합하면, 사용자가 입력한 연산 기호(+, -, *, /)에 따라 알맞은 분기에서 계산을 수행할 수 있습니다.

이제 이를 응용한 문제 하나를 드리겠습니다.

 

<응용문제>

사용자로부터 입력받은 연산을 수행하는 match문을 하고 결과를 출력하시오.

• 입력예시: 3 + 2
• 모든 입력은 공백을 단위로 구분
• 오직 한자리 양수, 사칙연산(+,-,*,/)만 입력가능 (해당 조건 외의 입력 시 잘못된 입력입니다 출력)

expr = input()
expr = expr.split()

a = int(expr[0])
op = expr[1]
c = int(expr[2])

match op:
    case '+':
        print(a + c)
    case '-':
        print(a - c)
    case '*':
        print(a * c)
    case '/':
        print(a / c)
    case _:
        print('잘못된 입력입니다')

 

1-3. 반복문

파이썬 반복문이란?
: 프로그램에서 동일한 코드를 여러 번 실행해야 할 때 사용하는 문법 구조입니다.
반복문을 통해 코드를 효율적으로 작성할 수 있고, 수작업으로 같은 코드를 여러 번 작성하는 실수를 방지합니다.

• for 문
  • 시퀀스(리스트, 튜플, 문자열, range 등)의 각 요소를 한 번씩 순회하며 실행
  • 반복 횟수가 명확할 때 주로 사용
• while 문
  • 조건식이 True인 동안 계속 실행
  • 반복 횟수를 미리 알기 어려운 경우에 사용

1.3.1. for 문

이론

• 목적: 시퀀스(리스트, 튜플, 문자열 등)의 각 요소를 순회(iteration)하며 반복 작업을 수행
• 구조:

for 변수 in 시퀀스:
    실행문

• 특징:
  • 순서가 있는 자료형에만 사용 가능
  • 인덱스를 직접 다루지 않아도 됨

< Range 기반 반복 >

for i in range(start, stop, step):
    # i: start부터 stop-1까지 step 간격 반복

 

< 리스트(또는 시퀀스) 직접 순회 >

nums = [2, 4, 6]
for x in nums:
    # x에 리스트 요소가 차례로 할당

 

< for 문 안에 if>

: 역할: 반복 중 특정 조건에 맞는 경우에만 실행할 코드가 필요할 때 사용

# 예: 1~10까지 중 짝수만 출력
for i in range(1, 11):
    if i % 2 == 0:
        print(i)

#출력:
2
4
6
8
10

 

< 이중 for 문 (Nested Loop) >

: 역할: 2차원 구조 순회, 모든 조합 처리 등에 사용

이중 for 문(중첩 루프)은 바깥쪽 루프가 한 번 실행될 때마다 안쪽 루프가 처음부터 끝까지 모두 실행되는 형태입니다.

즉, 총 반복 횟수는

(바깥쪽 반복 횟수) × (안쪽 반복 횟수)

- 작동 원리

1. 바깥 루프가 1회차를 시작
2. 안쪽 루프가 처음부터 끝까지 전부 실행
3. 안쪽 루프가 끝나면 바깥 루프가 2회차로 넘어감
4. 다시 안쪽 루프가 처음부터 끝까지 전부 실행
5. 바깥 루프가 지정된 횟수만큼 반복될 때까지 2~4 과정을 반복

for i in 바깥범위:
    for j in 안쪽범위:
        수행문

 

• i가 고정된 상태에서 j가 모든 값을 순회
• 안쪽 루프가 전부 끝나야 바깥 루프가 다음 i 값으로 이동

 

# 예: 1~3단 구구단 출력
for i in range(1, 4):
    for j in range(1, 4):
        print(f"{i}×{j}={i*j}", end="  ")
    print()
    
#출력:
1×1=1  1×2=2  1×3=3  
2×1=2  2×2=4  2×3=6  
3×1=3  3×2=6  3×3=9

 

< 리스트 컴프리헨션 -> 간단한 반복 + 리스트 생성 >

: [] 안에서 for·if를 조합해 한 줄에 리스트 생성

a = [i for i in range(5)]                # [0,1,2,3,4]
b = [i*j for i in range(1,10) for j in range(1,10)]  # 구구단
c = [n**2 if n%2==0 else n**3 for n in range(1,11)]

 

1.3.2 while 문

이론

• 목적: 주어진 조건식이 참(True) 인 동안 계속 반복 작업을 수행
• 구조:

while 조건식:
    실행문

• 특징:
  • 반복 횟수를 미리 알기 어려울 때 사용
  • 내부에서 조건을 반드시 변경하지 않으면 무한 루프가 될 수 있음

<예제>

# 5번 “Hello” 출력
count = 0
while count < 5:
    print("Hello")
    count += 1
# 출력:
# Hello
# Hello
# Hello
# Hello
# Hello

 

1.3.3. break와 continue

• break: 반복문을 즉시 종료
• continue: 현재 반복만 건너뛰고 다음 반복으로 계속

<break - for문>

# break 예시: 1~10 중 5에 도달하면 중단
for i in range(1, 11):
    if i == 5:
        break
    print(i)

#출력:
1
2
3
4​

 

<break - while문>

count = 0
while True:
    count += 1
    print(count)
    if count >= 5:
        break   # count가 5 이상이면 루프 전체 즉시 종료

#출력:
1
2
3
4
5

<continue - for문>

# continue 예시: 1~10 중 짝수는 건너뛰고 홀수만 출력
for i in range(1, 11):
    if i % 2 == 0:
        continue
    print(i)

#출력:
1
3
5
7
9

 

 

<continue - while문>

n = 0
while n < 10:
    n += 1
    if n % 2 == 0:
        continue   # 짝수일 땐 print를 건너뛰고 다음 반복
    print(n)

#출력:
1
3
5
7
9

 

1.3.4. for vs while

구분	for	while
용도	횟수가 정해진 반복 (시퀀스 순회)	조건식이 참인 동안 반복
구조	for 변수 in 시퀀스:	while 조건식:
주요 사용 사례	리스트·튜플 등 컬렉션 순회, range() 루프	입력 대기, 외부 조건에 따라 중단 필요 시

 

언제 쓰나?

• for: 요소 수가 고정된 데이터 순회, 명확한 횟수 반복
• while: 반복 횟수를 모를 때(예: 사용자 입력을 기다릴 때, 조건이 외부 요인에 의해 바뀔 때)

<마무리>

3일차에도 마찬가지로 파이썬 기초 문법을 배워보았는데요!

파이썬의 조건문, 반복문, 리스트만 배웠는데도 데이터 전처리의 기본기를 다진 기분이 듭니다!

조건문을 사용해 원하는 데이터만 ‘콕’ 집어낼 수 있다는 점이 특히 흥미로웠는데요. 반복문으로 리스트를 차례차례 훑으면서 필요한 값만 추려내고, 리스트 컴프리헨션으로 한 줄에 깔끔하게 처리할 수 있다는 사실이 “코드를 마법처럼 줄여주는 지팡이” 같았습니다. 그럼 내일도 파이팅 해보겠습니다!

 

+ <데이터 분석 응용>

1. 조건문과 반복문, 리스트 기능을 활용해서 CSV 파일에서 결측치 골라내기.

2. 숫자 칼럼만 쏙쏙 뽑아내는 전처리 스크립트 작성하기.