STUDY_Record

[코딩온] 신재생에너지 IoT 개발자 입문_ 데이터분석 2

혈중당부족 — Wed, 11 Feb 2026 18:04:20 +0900

2-1 넘파일 배열 연산

NumPy 배열 연산은 요소 단위로 수행된다.

배열과 배열, 배열과 스칼라 값의 연산이 되고 브로드캐스팅 통해 서로 다른 크기의 배열도 자동 확장 연산한다.

# 배열 간 연산(1차원)

a1 = np.array([1,2,3])

a2 = np.array([4,5,6])

print(a1 + a2)

print(a1 - a2)

[5 7 9]

[-3 -3 -3]

# 배열 간 연산 (2차원)

a1 = np.arange(1,5).reshape(2,2)

a2 = np.arange(11,15).reshape(2,2)

print(a1)

print(a2)

print(a1 + a2)

print(a1 - a2)

3, 4번째가 a1+ a2 / a1- a2 값

+,-,*,/ 와 같은 산술 연산자를 바로 사용할 수 있다.

# 배열과 스칼라 연산(1차원)

a1 = np.array([1,2,3,4])

print(a1 + 10)

print(a1 * 2)

[11 12 13 14]

[2 4 6 8]

# 배열과 스칼라 연산 (2차원)

a1 = np.arange(1,5).reshape(2,2)

a2 = np.arange(11,15).reshape(2,2)

print(a1)

print(a2)

print(a1 + 5)

print(a2 * 3)

print(a2 / 2)

배열과 단일 값(스칼라)의 연산 시 요소별로 단일 값 연산을 한다.

이는 스칼라가 모든 원소에 적용하는 것이라서, a2 원소에서 3씩 곱해져 3번째 결과값이 나오는 거다.

# 배열의 구조가 다를 경우

a1 = np.array([1,2])

a2 = np.array([1,2,3])

#print(a1 + a2) #ValueError

브로드캐스팅 설명

전개 예시

a1 = np.array([[1,2,3],

[4,5,6]]) # (2,3) 배열

a2 = np.array([10,20,30]) #길이가 3인 1차원 배열 (3,)

# 1차원 길이 3

[10,20,30]

# 2차원으로 변형 (1,3)

[[10,20,30]]

#2차원 행이 2 -> 2로 확장

[[10,20,30],

[10,20,30]]

print(a1 + a2)

의 결과물

[[11 22 33]

[14 25 36]]

#브로드캐스팅 예제

a1 = np.array([[1],[2],[3]]) #(3,1)

a2 = np.array([10,20,30]) #(3,)

#a2 = (3,) > (1,3)변형 : 한줄 자리를 3줄로 바꿔야 하니까

[[10,20,30]]

#a1 과 a2 비교 > (3,1), (1,3)

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

[[10,20,30],[10,20,30],[10,20,30]]

print(a1+a2)

[[11 21 31]

[12 22 32]

[13 23 33]]

이하 배열 관련 실습

#실습

#다음 배열을 생성하고, 모든 요소에 3을 더하세요

arr = np.array([1, 2, 3, 4])

print(arr + 3)

#아래 2차원 배열에서 각요소를 -1로 곱한 새로운 배열을 만드세요

arr = np.array([[5, 10],

[15, 20]])

arr_1 = arr * -1

print(arr_1)

#아래 두 배열의 요소별 곱셈과 나눗셈 결과를 각각 출력하세요

arr1 = np.array([2, 4, 6])

arr2 = np.array([1, 2, 3])

print(arr1 / arr2)

print(arr1 * arr2)

[4 5 6 7]

[[ -5 -10]

[-15 -20]]

[2. 2. 2.]

[ 2 8 18]

# 모든 요소 최대값을 100만들기 위해 필요한 값을 더한 결과 배열을 브로드캐스팅

arr = np.array([[95,97],[80,85]])

a1 = 100 - arr

print(a1)

print(arr + a1)

#2차원 배열에서 각 행에 다른 값을 곱하여 새로운 배열 완성(브로드캐스팅)

arr5 = np.array([[1,2,3],[4,5,6]])

# 첫 번째 행 10 곱, 두번째 행 100 곱

a2 = np.array([[10],[100]])

print(arr5 * a2)

[[ 5 3]

[20 15]]

[[100 100]

[100 100]]

[[ 10 20 30]

[400 500 600]]

#아래 배열에서 각 행마다 다른 스칼라 값 더하기

#1차원 배열 만들어 계산 1행 100, 2행 200, 3행 300 더하기

arr6 = np.array([[10,20],

[30,40],

[50,60]])

a3 = np.array([100,200,300]).reshape(3,1)

print(arr6 + a3)

[[110 120]

[230 240]

[350 360]]

2-2 통계 함수 및 집계 연산

np.argmin (): 배열에서 최소값이 있는 인덱스 반환

np.argmax (): 배열에서 최대값이 있는 인덱스 반환.

a = np.array([[1,2,3],[4,5,6]])

print("원소의 합:", np.sum(a))

print("원소의 평균:",np.mean(a))

print("표준편차:",np.std(a))

print("최대값:",np.max(a))

print("최소값:",np.min(a))

print("최대값의 인덱스:",np.argmax(a))

print("최소값의 인덱스:",np.argmin(a))

원소의 합: 21

원소의 평균: 3.5

표준편차: 1.707825127659933

최대값: 6

최소값: 1

최대값의 인덱스: 5

최소값의 인덱스: 0

축(axis) 단위 연산

axis = 0 -> 가장 높은 차원 기준 - >행 기준

행 기준 = 행을 따라 연산 = 행을 증가시키며 연산 : 열(column) 단위로 계산 (세로)

axis = 1 -> 그 다음 차원 기준 - >열 기준

열 기준 = 열을 따라 연산 = 열을 증가시키며 연산 : 행(row) 단위로 계산 (가로)

axis = n -> n번째 차원을 기준으로 연산.

a = np.array([[1,2,3],

[4,5,6],

[7,8,9]])

print("행기준 합", np.sum(a, axis = 0))

print("열기준 합", np.sum(a, axis = 1))

print("행기준 평균", np.mean(a, axis = 0))

print("열기준 평균", np.mean(a, axis = 1))

# 누적 연산

arr = np.array([1,2,3,4])

print(np.cumsum(arr))

print(np.cumprod(arr))

[ 1 3 6 10]

[ 1 2 6 24]

np.cumsum() 누적 합

np.cumprod() 누적 곱

이하 실습 예제들

#아래 배열의 전체 합계와 평균을 각각 구하세요

arr= np.array([5, 10, 15, 20])

print("합", np.sum(arr))

print("평균", np.mean(arr))

#다음 2차원 배열에서 전체 최소값과 최대값을 구하세요

arr1= np.array([[3, 7, 1],

[9, 2, 8]])

print("최소값:",np.min(arr1))

print("최대값:",np.max(arr1))

#아래 배열에서 각 열의 합계와 각 행의 합계를 각각 구하세요

arr2= np.array([[1, 2, 3],

[4, 5, 6],

[7, 8, 9]])

print("행기준 합", np.sum(arr2, axis = 0)) #세로방향

print("열기준 합", np.sum(arr2, axis = 1)) #가로방향

#아래 배열에서 행별 평균과 열별 평균을 각각 구하세요

arr3= np.array([[10, 20],

[30, 40],

[50, 60]])

print("행기준 평균", np.mean(arr3, axis = 0))

print("열기준 평균", np.mean(arr3, axis = 1))

#1차원 배열에서 전체 표준편차를 구하고, 각 요소가 평균으로부터

# 얼마나 떨어져 있는지 편차 배열을 만드세요. (값 -평균)

arr4= np.array([2, 4, 4, 4, 5, 5, 7, 9])

print("표준편차:",np.std(arr4))

print("평균:",np.mean(arr4))

print("오차:", arr4 - np.mean(arr4))

#아래 2차원 배열에서 행 단위 누적 합과 열 단위 누적 곱을 각각 구하세요

arr5= np.array([[1, 2, 3],

[4, 5, 6]])

print("행기준 누적 합", np.cumsum(arr5, axis = 0))

print("열기준 누적 곱", np.cumprod(arr5, axis = 1))

2-3 논리 연산과 조건 연산

데이터 분석에서도 NumPy 논리 연산자를 쓰기 때문에 헷갈리지 않도록 한다. (EDA파트에서 다시 보고 있다.

np.where()

조건 기반 선택 함수, Python의 삼항 연산자와 유사한 역할을 한다.

arr = np.array([10,20,30,40,50])

result = np.where(arr > 30, "hing","low")

result 의 결과

array(['low', 'low', 'low', 'hing', 'hing'], dtype='<U4')

arr = np.array([10,20,30,40,50])

조건만 넣을 경우 조건을 만족하는 원소의 인덱스를 반환

result = np.where(arr > 30)

print(result)

print(arr[result])

(array([3, 4]),)

[40 50]

# and 연산(&)

arr = np.array([10,20,30,40,50])

mask = (arr > 10) & (arr < 50)

print(mask)

T/F만 알려줌 [False True True True False]

print("&연산", arr[mask])

요소 알려줌 &연산 [20 30 40]

# or 연산(|) #shift + \

mask_or = (arr > 40) | (arr < 20)

print(mask_or)

[ True False False False True]

print("|연산",arr[mask_or])

|연산 [10 50]

#not연산(~)

mask_not = ~(arr>30)

print(arr[mask_not]) [10 20 30]

[코딩온] 신재생에너지 IoT 개발자 입문_ 데이터분석 1

혈중당부족 — Wed, 4 Feb 2026 18:47:05 +0900

파이썬을 공부하고 나서 배운 건 데이터 분석 분야에 쓰이는 파이썬 기반 라이브러리, 패키지들을 배운다. 데이터를 분석할 때 전처리- 시각화 과정을 밟는데 이 때 들어가는 프로그램들을 배우고 써보기로 했다. (이를 기반으로 팀 프로젝트를 전에 했었고 회고록이 있다.)

0. 가상환경 설정

너무 많은 프로그램을 설치하는 것도 일이고, 충돌이 나니까...

사용 방법으로 주로 두가지가 있다.

VSCode : 가상환경 생성, 연결, 패키지 관리를 한번에 할 수 있다. (코드 편집기)

Anaconda : 패키지, 가상 환경, 개발 도구를 편히 사용하도록 파이썬 환경을 제공하는 소프트웨어

파이썬처럼 설치하는 것이라서, 둘이 충돌날 수도 있고. 파이썬 외에도 배워야 할 게 있다보니 코드 편집기인 VSCode로 진행했다.

VS Code로 가상환경 만들기

만들어지면 이런 상태가 뜬다. 그러면 이제 작업하면 된다.

이번에 쓰는 파일은 .ipynb 을 사용한다.

주피터 노트의 기본 저장 파일 형식이라고 하는데, Markdown, Python 코드 실행, 데이터 결과 출력물 한꺼번에 확인하고 수정, 보수하기 위해 만들어진 대화형 파일이라 데이터 분석할 때 자주 쓰인다.

1. NumPy

- 다차원 배열을 쉽고 효율적으로 사용할 수 있도록 지원하는 파이썬 라이브러리

- 데이터 분석 라이브러리에 많이 사용됨

행렬 설명

주로 어디에 쓰는가? : 대용량 데이터 통계 분석 및 행렬, 벡터/행렬 곱, 난수 생성과 수학 함수 적용 , 이미지 데이터 처리.

NumPy 공식 홈페이지 : https://numpy.org/ 공식 튜토리얼 : https://numpy.org/doc/stable/user/quickstart.htm

1-1. ndarray

- numpy의 핵심 데이터 구조

- 동일한 자료형의 다차원 배열

둘의 자료형 차이점.

구체적인 차이점

List : 원소로 여러가지 자료형이 된다. 내부 배열의 원소 개수가 달라도 됨. / 빼기, 곱하기, 나누기 연산 불가

Ndarray : 한가지 자료형만 허용. 내부 배열 원소 개수가 같아야 함. / 같은 위치의 원소 끼리 산술 계산 가능

> 원소 개수 다르면 에러가 뜬다.

헷갈리기에 용어 이해로 붙여둔다.

먼저 시작하기 앞서 터미널을 통해

pip install numpy 로 설치한다. <이후 라이브러리, 패키지는 이 pip install 명령어를 붙이고 시작한다.

import numpy as np

Numpy를 np라는 별칭으로 임포트 한다.

# ndarray의 생성

a = np.array([[1,2,3],[4,5,6]])

b = np.array([1.0, 3.14, 1,24])

# 배열의 구조

print(f"배열의 구조: {a.shape}")

구조를 튜플로 반환한다.

# 배열의 차원 수

print(f"배열의 차원: {a.ndim}")

# 데이터 타입

print(f"배열의 데이터 타입: {a.dtype}")

print(f"배열의 데이터 타입: {b.dtype}")

# 형변환

new_a = a.astype(np.float64)

print(f"수정한 배열의 데이터 타입: {new_a.dtype}")

자료형 변환하는 ()메서드.

2차원 구조

# 3차원 행렬

a = np.array([[[1,2,3], [4,5,6]],

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

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

print(f"배열의 구조: {a.shape}")

print(f"배열의 차원: {a.ndim}")

# 4차원 행렬

a = np.array([[[[1,2,3],[4,5,6]],

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

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

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

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

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

print(f"배열의 구조: {a.shape}")

print(f"배열의 차원: {a.ndim}")

1-2. 배열 초기화

# 모든 요소가 0인 배열 생성

np.zeros((3,4)) #2차원

np.zeros((2,3,4),dtype=np.int64) #3차원

# 모든 요소가 1인 배열 생성

np.ones((5, 6))

5행, 6열로 모든 요소가 1인 걸 생성한다.

# (원소의 값이) 초기화 되지 않은 배열 생성

np.empty((2,3))

쓰레기 값이라고 지칭하기도 한다.

# 주어진 값으로 채운 배열

np.full((3,3), 7)

full(행, 열, 주어진 값) 구조다.

# 단위 행렬

np.eye(3, 3)

np.eye(3,5,1)

eye (n,n)은 n,n 크기 단위로 생성

eye (n,n,n)은 n,n크기로 생성하고 n 방향으로 대각선 이동한다.

3행 5열 1인덱스부터 1실행

구체적인 설명

1-3. 범위 기반 배열 생성

# arange : range()와 유사한 기능 제공

# 시작 이상 끝 미만의 정수 배열을 지정한 간격으로 생성

np.arange(0, 10)

np.arange(0, 10, 2)

np .arange( 0 , 10 , 2 ) 결과

# linspace : 시작~끝까지 균일 간격으로 지정한 개수만큼 숫자를 생성

# 끝을 포함

np.linspace(10, 100, 10)

np.linspace(0.1, 1, 10)

끝 포함이므로 1도 들어간다.

1-4. 랜덤 배열 생성

# random.rand(m,n) : 0 ~ 1 사이의 난수로 초기화

np.random.rand(2, 3)

# random.randn(m, n) : 표준정규분포를 따르는 난수로 초기화

# 표준정규분포 : 평균 0, 분산 1인 정규분포

np.random.randn(2, 4, 5)

# random.randint(low, high, (size))

np.random.randint(10, 20, (2,4))

low 이상 high 미만의 숫자로 size 형태의 정수 배열을 생성

# random.seed() : 난수 생성시 시작값 제공

np.random.seed(42)

np.random.randn(2,3)

시작값을 동일하게 주면 항상 같은 결과를 얻을 수 있다고 하는데... seed()를 사실 잘 안 써봤다.

seed가 전역 상태(글로벌 스테이터스) 를 사용해서 코드 전반에 예측 어려웠기에

RNG로 독립적인 난수 시퀸스를 생성한다고 한다.

# RNG(Random Numbwer Genenrator) : 최근 Numpy 사용에서 권장되는 방식

from numpy.random import default_rng

rng = default_rng(seed=42)

rng2 = default_rng(seed=10)

print(rng.random((3,2)))

print(rng2.random((3,2)))

이하 이를 기반으로 해본 실습들

# 실습1. 배열 초기화 및 생성(1)

# 1. 0으로 채워진 크기 (3, 4) 배열을 생성한 후, 모든 값을 5로 채우는 새로운 배열을 만드세요.

a1 = np.zeros((3,4))

a1_2 = np.full((3,4), 5)

print("문제1:", a1, a1_2, a1 + a1_2, sep="\n")

# 2. 0부터 20까지 2씩 증가하는 1차원 배열을 생성하세요.

a2 = np.arange(0,21,2)

print("\n문제2:", a2)

# 3. 0~1 사이의 실수 난수를 가지는 (2, 3) 크기의 배열을 생성하세요.

a3 = np.random.rand(2,3)

# print("\n문제3:", a3)

# 4. 평균이 100, 표준편차가 20인 정규분포 난수 6개를 생성하세요.

# (평균, 표준편차, 개수)

a4 = np.random.normal(100, 20, 6)

# print("\n문제4:", a4)

# 5. 1부터 20까지의 정수를 포함하는 1차원 배열을 만들고, 이 배열을 (4, 5) 크기의 2차원 배열로 변환하세요.

a5 = np.arange(1,21).reshape(4,5)

# print("\n문제5:", a5)

# 6. 0부터 1까지 균등 간격으로 나눈 12개의 값을 가지는 배열을 생성하고, 이를 (3, 4) 크기로 변환하세요.

a6 = np.linspace(0, 1, 12).reshape(3,4)

# print("\n문제6:", a6)

# 7. 0~99 사이의 정수 난수로 이루어진 (10, 10) 배열을 생성한 뒤,

# np.eye()로 만든 단위 행렬을 더하여 대각선 요소가 1씩 증가된 배열을 만드세요.

a7 = np.random.randint(0, 100, (10, 10))

a7_eye = np.eye(10)

a7_added = a7 + a7_eye

print("\n문제7:", a7_added)

# 8. 0~9 사이의 정수 난수로 이루어진 (2, 3, 4) 3차원 배열을 생성하세요.

a8 = np.random.randint(0, 10, (2, 3, 4))

print("\n문제8:", a8)

1-5. 인덱싱과 슬라이싱

- 다차원 배열을 다루는 편의 기능 제공

- Python의 시퀀스보다 빠름

- 인덱싱과 슬라이싱의 기본적인 문법은 동일하다.

# 인덱싱

a = np.array([10,20,30,40,50])

print(a[2])

print(a[-1])

결과값은 순서대로

# 다차원 인덱싱

# 파이썬 리스트

matrix = [[1,2,4], [4,5,6]]

print("파이썬 인덱싱:", matrix[1][1])

파이썬은 중첩 리스트로 표현해서 각 차원 따로 접근함.

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

이런 모양으로. 있어서 1은 두번째 리스트 [4,5,6]고 1이면 두 번째 요소 선택이니 5가 된다.

바깥 리스트 → 안쪽 리스트 → 원소 순서로 차례차례 들어가는 방식

# numpy 배열

a2 = np.array([[1,2,4], [4,5,6]])

print("numpy 인덱싱:", a2[1,1])

# 3차원 배열 인덱싱

a3 = np.arange(24).reshape(2,3,4)

print(a3)

print("3차원 인덱싱:", a3[1,1,1])

[행,열] 형식으로 접근하기 때문에

a3[1,1,1]은 두 번째 블록

[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]

에서 그 안에 있는 두 번째 행 선택

[16 17 18 19]

그리고 그 행 안에서 두 번째 열 선택이므로

17이 된다.

3차원이면 차원 하나 더 감싸기 때문에 1이면 3차원을 지칭한다.

a3[0,0,0] 이면 첫 번째 블록, 첫 번째 행, 첫 번째 열이니 0 되듯이.

# 슬라이싱

# arr[행_슬라이스, 열_슬라이스]

# arr[..., 4차원 슬라이스, 3차원 슬라이스, 2차원, 1차원]

a1 = np.array([10,20,30,40,50])

print(a1[1:3])

print(a1[2:])

print(a1[:2])

print(a1[:])

print(a1[::2])

print(a1[::-1])

순서대로

1인덱스~3인덱스 사이로

2인덱스 이후 값으로

2인덱스 이전 값으로

전부 호출

2 배수 인덱스만 호출 0 / 2 / 4

역순 호출

# 파이썬 리스트와의 차이

# 파이썬 리스트

py_list = [10,20,30,40,50]

sliced = py_list[1:4]

sliced[1] = 100

print("py원본:", py_list)

print("py슬라이싱:", sliced)

print()

# numpy 배열

a1 = np.array([10, 20, 30, 40, 50])

a1_sliced = a1[1:4]

a1_sliced[1] = 100

print("numpy원본:", a1)

print("numpy슬라이싱:", a1_sliced)

numpy는 a1_sliced한 게 적용되어 원본이 바뀌었다.

이하 행,열 슬라이싱 예제들

# 2차원 배열 슬라이싱

a2 = np.arange(1,21).reshape(4,5)

print(a2)

# 행 슬라이싱

# print(a2[0])

# print(a2[1])

# print(a2[1:3])

# print(a2[2:])

# print()

# 열 슬라이싱

print(a2[:, 2])

print(a2[:, -1])

print(a2[:, 1:3])

print()

# 행과 열 슬라이싱

print(a2[1:3, 2:4])

print(a2[2: , 3: ])

print(a2[::2, ::2])

# 3차원 슬라이싱

a3 = np.arange(36).reshape(3, 3, 4)

print(a3)

print(a3[1, 1, 1:3])

왜 그렇게 되는지에 대한 설명.

# 얕은 복사 : 복사본이 원본과 메모리를 공유 -> 변경사항이 서로에게 영향을 줌

a1 = np.array([1,2,3])

a1_viewd = a1.view()

a1_viewd[1] = 10

print("원본", a1)

print("복사본", a1_viewd)

print()

# 깊은 복사 : 복사본이 원본과 독립적으로 복사됨 -> 서로 영향을 주지 X

a2 = np.array([1,2,3])

a2_copied = a2.copy()

a2_copied[1] = 10

print("원본2", a2)

print("복사본2", a2_copied)

요소 선택

# Fancy Indexing

# 정수 배열을 사용하여 여러 인덱스로 여러 요소를 한번에 선택

af = np.arange(1,21)

print(af)

print(af[[4, 7, 11]])

af2 = np.arange(1,21).reshape(4,5)

print(af2)

print(af2[[1,3] , [2,4]])

# Boolean Indexing

ab = np.linspace(10, 100, 10)

print(ab)

print(ab[ab > 40])

print()

# Boolean masking

ab2 = np.arange(0, 21)

print(ab2)

mask = ab2 % 2 == 0

print(mask)

print(ab2[mask])

조건식을 사용하여 요소 선택

조건을 변수로 처리하여 인덱싱 가능 ( Boolean Masking)

이하 배운 것들로 하는 실습 예제들

# 실습2

# 1. 다음 배열에서 2, 4, 6번째 요소를 Fancy Indexing으로 선택하세요.

arr = np.arange(10, 30, 2)

print(arr)

answer = arr[[1,3,5]]

print(answer)

[10 12 14 16 18 20 22 24 26 28]

[12 16 20]

# 2. 3x3 배열에서 왼쪽 위 → 오른쪽 아래 대각선의 요소만 인덱싱으로 추출하세요.

arr = np.arange(1, 10).reshape(3, 3)

print(arr)

arr[[0,1,2],[0,1,2]]

[[1 2 3]

[4 5 6]

[7 8 9]]

array([1, 5, 9])

# 3. 3x4 배열에서 마지막 열만 선택해 모두 -1로 변경하세요.

arr = np.arange(1, 13).reshape(3, 4)

print(arr)

arr[:, -1] = -1

arr

[[ 1 2 3 4]

[ 5 6 7 8]

[ 9 10 11 12]]

array([[ 1, 2, 3, -1],

[ 5, 6, 7, -1],

[ 9, 10, 11, -1]])

# 4. 4x4 배열에서 행을 역순, 열을 역순으로 각각 슬라이싱해 출력하세요.

arr = np.arange(1, 17).reshape(4, 4)

print(arr)

print("행 역순:", arr[::-1])

print("열 역순:", arr[:,::-1])

[[ 1 2 3 4]

[ 5 6 7 8]

[ 9 10 11 12]

[13 14 15 16]]

행 역순: [[13 14 15 16]

[ 9 10 11 12]

[ 5 6 7 8]

[ 1 2 3 4]]

열 역순: [[ 4 3 2 1]

[ 8 7 6 5]

[12 11 10 9]

[16 15 14 13]]

# 5. 4x5 배열에서 가운데 2x3 부분을 슬라이싱한 뒤 copy()를 이용해 독립 배열을 만드세요.

arr = np.arange(1, 21).reshape(4, 5)

print(arr)

arr_copied = arr[1:3, 1:4].copy()

print(arr_copied)

[[ 1 2 3 4 5]

[ 6 7 8 9 10]

[11 12 13 14 15]

[16 17 18 19 20]]

[[ 7 8 9]

[12 13 14]]

# 6. 3x4 배열에서 짝수이면서 10 이상인 값만 선택하세요.

arr = np.array([[ 4, 9, 12, 7],

[10, 15, 18, 3],

[ 2, 14, 6, 20]])

print(arr[(arr % 2 == 0) & (arr >= 10)])

[12 10 18 14 20]

# 7. 5x5 배열에서 2, 4번째 행을 선택하고, 선택된 행에서 열 순서를 [4, 0, 2]로 재배치하세요.

arr = np.arange(1, 26).reshape(5, 5)

print(arr)

result = arr[[1,3]]

print(result)

result[:, [4, 0, 2]]

[[ 1 2 3 4 5]

[ 6 7 8 9 10]

[11 12 13 14 15]

[16 17 18 19 20]

[21 22 23 24 25]]

[[ 6 7 8 9 10]

[16 17 18 19 20]]

array([[10, 6, 8],

[20, 16, 18]])

# 8. 5x3 배열에서 각 행의 첫 번째 값이 50 이상인 행만 Boolean Indexing으로 선택하세요.

arr = np.array([[10, 20, 30],

[55, 65, 75],

[40, 45, 50],

[70, 80, 90],

[15, 25, 35]])

arr[arr[: ,0] >= 50 ]

array([[55, 65, 75],

[70, 80, 90]])

# 9. 4x4 배열에서 (0,1), (1,3), (2,0), (3,2) 위치의 요소를 한 번에 선택하세요.

arr = np.arange(1, 17).reshape(4, 4)

arr[[0,1,2,3],[1,3,0,2]]

array([ 2, 8, 9, 15])

# 10. 3차원 배열 (2, 3, 4)에서 모든 블록에서 두 번째 열만 추출해 새로운 2차원 배열 (2, 3)을 만드세요.

arr3d = np.arange(24).reshape(2, 3, 4)

print(arr3d)

arr3d[:, :, 1]

[[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

[[12 13 14 15]

[16 17 18 19]

[20 21 22 23]]]

array([[ 1, 5, 9],

[13, 17, 21]])

[코딩온] 신재생에너지 IoT 개발자 입문_ 파이썬13

혈중당부족 — Tue, 3 Feb 2026 18:55:21 +0900

15 파일 입출력

저장 장치에 저장된 파일을 읽어오거나 저장하는 작업

하드디스크에 저장된 파일 불러오거나 데이터를 파일에 저장하는 경우를 말한다.

여기서 말하는 입출력 뜻은

입력(INPUT) 파일로부터 데이터 읽어온다.

출력 (OUTPUT) 데이터를 파일로 저장(기록)한다.

open() : 파일 열기 함수

open("파일 경로", mode = "r", encoding="원하는 인코딩 - utf8")

open으로 파일을 읽으면 '파일 객체'를 반환

여기서 말하는 인코딩이란?

컴퓨터가 저장하고 처리할 수 있는 이진수로 바꾸는 방식이다. 서로 다르면 한글 깨짐 현상 처럼 깨지기도 하고 Python의 기본 인고딩은 UTF-8 이다.

실습때 r, w, a 위주로 사용했다.

f = open("example.txt", "w", encoding="utf-8")

파일에서 작성하기 위함이므로 'w' 사용

f.write("파이썬 파일 입출력 예제\n")

f.write("파이썬 공부")

close(): 파일 닫기

열린 파일을 닫아 시스템 자원을 해제함.

f.close()

하는 이유: 닫지 않으면 시스템 자원이 해제되지 않아 데이터 누수 발생 가능성 있다.

어떤 경우에는 다른 프로그램에 접근하지 못할 수 있다. (충돌)

계속 켜둔 채로 냅둘 경우 자원 사용이 계속 증가할 수 있다.

파일 읽기

read(): 전체 내용을 한번에 읽기.

f = open("example.txt", "r", encoding="utf-8")

content = f.read()

print(content)

f.close()

readlin() :한줄 씩 순차적으로 읽기

f = open("example.txt", "r", encoding="utf-8")

line1 = f.readline()

line2 = f.readline()

print("첫번 째 줄", line1)

print("두번 째 줄", line2)

f.close() #close로 계속 닫아주는 중.

for문으로 읽기

f = open("example.txt", "r", encoding="utf-8")

for line in f:

print(line.strip())

f.close()

readlines() 모든 줄을 한번에 리스트로 읽기.

f = open("example.txt", "r", encoding="utf-8")

contents = f.readlines()

print(contents)

f.close()

tell () 현재 읽고 있는 위치(바이트)를 반환

f = open("example.txt", "r", encoding="utf-8")

print("처음 위치", f.tell()) << 일반적으로 0

f.read(5)

print("바이트 5 미만 후 읽은 위치", f.tell)

f.close()

한글은 UTF- 8 인코딩시 1글자당 3바이트일 수 있다.

seek() : 파일 포인터 위치로 이동

f = open("example.txt", "r", encoding="utf-8")

print(f.read(10)) #10바이트를 읽기

f.seek(0)#10 바이트 읽기ㅡ 맨 처음으로 가기

print(f.read())

f.close()

텍스트를 반복해서 읽거나, 중간 위치로 갈 때 사용한다.

파일 쓰기

with open("with_example.txt", "w", encoding="utf-8") as f1:

f1.write("with문으로 작성한 파일이에요\n")

f1.write("파일 입출력 완료")

\n은 줄바꿈 처리. 여러 줄을 작성할 때 직접 추가해야 한다.

w 모드 : 덮어 쓰기

파일이 존재하면 기존 내용을 전부 삭제하고 새로 작성한다. 파일이 없으면 새로 생성.

f = open("example.txt", "w", encoding="utf-8")

f.write("이전 내용은 삭제되고 새로 작성됩니다.\n")

f.close()

a 모드 : 추가 쓰기

f = open("example.txt", "a", encoding="utf-8")

f.write("\n추가한 내용입니다.")

f.close()

주로 파일 작성 시 with 문법을 사용한다. 자동으로 파일 닫아주기 때문에 안전한 처리를 할 수 있다.

이를 활용한 예제

파일에서 랜덤 추출

import random

with open("words.txt", "w", encoding="utf-8") as f1:

words = [

"apple", "banana", "orange", "grape", "lemon",

"peach", "melon", "cherry", "plum", "pear",

"school", "friend", "family", "flower", "garden",

"window", "bottle", "pencil", "summer", "winter",

"happy", "future", "travel", "animal", "market",

"doctor", "planet", "energy", "nature", "memory"

]

for i in words:

f1.write(i + "\n")

with open("words.txt", "r", encoding="utf-8") as f1:

data = f1.readlines()

for i in range(5):

word = random.choice(data).strip()

print(word)

입력 받아 파일 쓰기

with open("with_example.txt", "a", encoding="utf-8") as f1:

while True:

text = input("저장할 내용을 입력해주세요(종료 : z)")

if text == "Z" or text == "z":

break

f1.write(text + "\n")

예제를 통해 실습 과제로

명부 작성, 명부 통해 로그인 기능 구현, 로그인 성공시 추가 정보 입력 과정을 작성 하는데

로그인 기능 구현까지 일단 시도 한 코드는 이랬다.

회원에 대한 이름, 비밀번호 입력 받기 위해 사용자로부터 (파일 쓰기모드)로 생성

저장된 회원 명부를 출력(파일 읽기 모드)

user = []

with open("member.txt", "a", encoding="utf-8") as f2:

for m in range(3):

user_name = input(f"{m + 1} 회원명 입력해주세요: ")

user_pass = input(f"{m + 1} 비밀번호 6자 입력해주세요: ")

f2.write(f"회원 {user_name} 번호 {user_pass} \n")

user.append((user_name, user_pass))

with open("member.txt", "r", encoding="utf-8") as f2:

members = f2.readlines()

print(members)

>>회원 명부를 통해 로그인 기능 구현

이름. 비밀번호를 각각 입력 받게 하고 회원 명부에서 한줄 씩 검사해서 성공/ 실패 출력

>> 근데 이거 파일 입출력 어떻게 정보 고정시키냐...

with open("words.txt", "r", encoding="utf-8") as f2:

user_count = 0

for line in f2:

line = line.strip()

user_name, user_pass = line.split(":")

user_name = user_name.strip()

user_pass = user_pass.strip()

while user_count < 3 :

id_input = input("이름을 입력하세요.: ")

pw_input = input("비밀번호를 입력하세요.: ")

if id_input == user_name and pw_input == user_pass:

print("로그인 성공")

user_count += 1

else:

print("로그인 실패")

if user_count == 3:

print("전원 로그인 됐습니다.")

이후 로그인 성공시 사용자에게 전화번호 입력 받기

>받은 번호는 다른 파일에서 이름과 전화번호 기록

>새로운 사람이 로그인 성공시 전화번호 추가 기록

>이미 존재하는 사람이 로그인 시 전화번호 수정

여기까지 구현하지 못하고 종료했다. 그리고 아래는 실습 답안으로 구현한 코드. (참고)

#모범 답안

import os

#os 모듈 갖고 온다. 운영 체제와 상호 작용하는 기능 제공

#파일 및 디렉토리 관리하기 목적으로.

if os.path.exists("member.txt"): #경로의 존재 확인 명령어.

print("member.txt가 이미 존재합니다. 회원 등록을 건너뜁니다.\n")

else: #파일 없을 시 생성해서 추가하기 위한 과정

with open("member.txt", "w", encoding="utf-8") as f:

for i in range(3):

name = input(f"{i+1}번째 회원의 이름: ")

password = input(f"{i+1}번째 회원의 비밀번호: ")

f.write(f"{name},{password}\n")

print("\n[회원 명부 저장 완료]\n")

with open("member.txt", "r", encoding="utf-8") as f:

members = f.readlines()

print(members)

# 로그인 과정

input_name = input("로그인 - 이름을 입력하세요: ")

input_password = input("로그인 - 비밀번호를 입력하세요: ")

#텍스트 파일의 정보를 할당해야 함.

#로그인 성공하면 반복문을 탈출한다.(break 사용)

with open("member.txt", "r", encoding="utf-8") as f:

for line in f: #한줄 씩 갖고와서 비교하고자 for문 사용.

name, password = line.strip().split(",") #,를 기준으로 리스트로 반환해서 출력.

print(line.strip().split(",")) #리스트 형태로 반환되어 나옴. ['QWER','001234']

if input_name == name and input_password == password:

break

#로그인 성공시 전화번호 등록/ 수정

if login:

print("\n로그인 성공!")

#기존 전화번호 데이터 로드

phone_data = {} #딕셔너리 자료형 생성, 빈 걸로 만듬.

if os.path.exists("member_tel.txt"): #파일 존재 유무 확인

with open("member_tel.txt", "r", encoding="utf-8") as f: #존재가 있을 경우에 실행

for line in f:

name, phone = line.strip().split(",")

phone_data[name] = phone #name 키값 폰이 밸류 값 딕셔너리

print(phone_data)

#파일이 있어서 정보를 확인하고, 그걸 딕셔너리에 할당. 그렇기에 phone_data를 출력하면 정보가 나온다.

#전화번호 입력, if 바깥이므로 상관 없이 실행.

new_phone = input(f"{input_name}님의 전화번호를 입력하세요: ")

#전화번호를 딕셔너리로 추가한 것이라 파일 닫으면 사라지므로

#파일 불러와서 작성해야 데이터 저장이 된다. (파일 갱신)

# 추가 또는 수정

if input_name in phone_data: #입력한 값과 기존 정보와 비교.

print("기존 전화번호 수정")

else:

print("전화번호 새로 추가")

phone_data[input_name] = new_phone

#딕셔너리는 해당 키값이 있으면 밸류를 수정. 없으면 추가.

# 전화번호 파일 갱신

with open("member_tel.txt", "w", encoding="utf-8") as f:

for name, phone in phone_data.items():

f.write(f"{name},{phone}\n")

print("전화번호 저장 완료!")

else:

print("\n로그인 실패!")

바이너리 파일 읽고쓰기

import os

#바이너리 파일 열기

with open('./Python/images/ㄱㄴㅍㄱ.jpeg','rb') as f: #현재 디렉토리(.=PYTHON_WORKSPACE)/폴더명(Python)- 라는 뜻

img = f.read()

print(img)

원본 이미지 읽기 코드

#바이너리 파일 쓰기

with open("./Python_workspace/images/ㄱㄴㅍㄱ_copy.jpeg','wb'") as f:

f.writh(img)

복사된 이미지를 새로운 파일로 저장하는 코드

# pickle 모듈

# 객체의 형태를 유지하면서 파일에 저장하고 불러올 수 있음

이때 객체는 리스트나 딕셔너리등의 자료 구조도 포함된다.

import pickle

#리스트, 딕셔너리 파일 저장

with open('pickle.txt','wb') as f:

li = ['dog','cat'] #리스트 형식

dic = {1: 'dog', 2: 'cat'} #딕셔너리 양식 {}

pickle.dump(li, f)

pickle.dump(dic, f)

#읽기

with open('pickle.txt','rb') as f:

li = pickle.load(f)

dic = pickle.load(f)

print(li, dic) #['dog', 'cat'] {1: 'dog', 2: 'cat'} 로 나옴.

16 예외처리

프로그램이 예기치 않게 종료되는 것을 방지하고자 예외 처리 사용한다.

예외 처리 기본 문법

try:

예외가 발생할 수 있는 코드

pass

except:

예외가 발생했을 때 실행할 코드

특정 에러를 지정 가능

pass

예외 종류

1. 인덱스 에러

리스트 인덱스 범위 오류

shop = ['반팔','청바지','이어폰','키보드']

print(shop[2])

print(shop[10]) #IndexError: list index out of range

print("예외 처리")

2.valueError

부적절한 값을 가진 인자를 받았을 때 발생

#number = int("help") #ValueError: invalid literal for int() with base 10: 'help'

#print(shop.index("x")) #ValueError: list.index(x): x not in list < 리스트에 x라는 인자가 없다란 뜻

3.ZeroDivisionError

0으로 나눌 때 발생

#print(5/ 0) ZeroDivisionError: division by zero

4. NameError

존재하지 않는 변수를 호출할 때

#print(x) NameError: name 'x' is not defined < x 정보가 없다.

5. FileNotFountError

존재하지 않는 파일을 호출할 때

#file = open('test.txt') #FileNotFoundError: [Errno 2] No such file or directory: 'test.txt'

1 단일 except

try:

num = int(input("숫자를 입력하세요: "))

print(10 / num)

except:

print("예외 발생")

# 모든 에러를 "예외 발생"으로 띄워버림

2 특정 예외처리

try:

num = int(input("숫자를 입력하세요: "))

print(10 / num)

except ValueError as e:

print("숫자가 아닙니다.",e)

except ZeroDivisionError as e:

print("0으로 나눌 수 없습니다.",e)

# 여러 예외를 각각 처리해서 달리 출력함.

예외 처리 구조

try:

#예외가 발생할 수 있는 코드

pass

except 오류내용1:

#예외가 발생했을 때 실행할 코드

#특정 에러를 지정 가능

except 오류내용2:

다중 except라고 한다.

else:

#예외 없는 경우에 실행

finally:

#예외 발생 여부와 상관 없이 실행

이하 예외처리 관련 실습 1

#실습1

try:

num = int(input("숫자를 입력하세요: "))

except ValueError as e:

num = -1

finally:

if num > 0 :

print(f"{num}이 0보다 큽니다.")

else:

print("숫자가 아닙니다.")

#모범 답안

# 실습 1

answer = input('Enter a number: ')

try:

num = int(answer)

except:

num = -1

if num > 0:

print('0보다 큽니다!')

else:

print('숫자가 아닙니다!')

이하 예외처리 관련 실습 2

def calc(a,b,x):

if x == '+':

return a + b

elif x == '-':

return a-b

elif x == '*':

return a*b

elif x == '/':

if b == 0:

print("0으로 나눌 수 없습니다")

else:

return a/b

while True:

try:

a = int(input("숫자를 입력하세요: "))

b = int(input("숫자를 입력하세요: "))

except ValueError as e:

print("잘못 입력 했습니다.")

x = input("계산 방법을 입력하세요: ")

if x not in ['+','-','*','/']:

print("잘못된 연산입니다.")

continue

break

r = calc(a,b,x)

print(f"{a}{x}{b} = {r}")

#모범 답안

# 실습 2

def print_result(n1, op, n2, result):

print(f"{n1} {op} {n2} = {result}")

while True:

try:

num1 = float(input("첫 번째 숫자: "))

op = input("연산자(+ - * /): ")

num2 = float(input("두 번째 숫자: "))

if op not in ['+', '-', '*', '/']:

raise ValueError("잘못된 연산자입니다.")

if op == '/' and num2 == 0:

raise ZeroDivisionError("0으로 나눌 수 없습니다.")

# 계산

if op == '+':

result = num1 + num2

elif op == '-':

result = num1 - num2

elif op == '*':

result = num1 * num2

else:

result = num1 / num2

print_result(num1, op, num2, result)

break

except ValueError:

print("입력이 잘못되었습니다. 다시 입력하세요.\n")

except ZeroDivisionError as e:

print(e)

print("다시 입력하세요.\n")

except Exception:

print("알 수 없는 오류가 발생했습니다.\n")

이렇게 파이썬 배웠던 부분을 전부 올렸다. 띄엄띄엄 해서, 남은 것들을 어디서까지 할 수 있을지 모르나 일단 달려봐야 아는 법이니까. 파이썬 기본 구조, 양식을 알았으니 다른 프로그램 사용할 때도 골자가 이해 안 가거나, 모른다. 하지 않고 접근할 수 있게 된 기분이었다. 특히 조건문, 반복문은... 질리도록 보지 않을까 싶다.

[코딩온] 신재생에너지 IoT 개발자 입문_ 파이썬12

혈중당부족 — Thu, 22 Jan 2026 16:51:18 +0900

14 모듈 Module

여러 기능들이 뭉쳐진 하나의 py.파일

함수, 변수, 클래스 등을 담아 코드 재사용성과 관리 효율을 높인다.

클래스 만큼이나 분량이 많았고 여러 모듈을 하나하나 익힐 수도 없다. 정말 많고, 정신 없었던 챕터로 기억한다. 그래도 많이 왔고 해두면 두고두고 쓰이며, 데이터 분석에서도 쓸 수 있으니 열심히 기록하고자 한다.

모듈의 종류는 표준 모듈/ 외부 모듈 정도로 나눠지며

표준 모듈:

파이썬에 기본적으로 내장되어 있는 모듈

설치 과정 없이 바로 사용할 수 있음

공식 문서에서 모듈 보기: docs.python.org/ko/3/library/index.html

외부 모듈:

다른 사람이 만든 모듈

모듈을 사용하려면 설치 과정이 필요함

모듈 불러오기(1) import 모듈명

import calc_module

print("**** 두 수 입력 ****")

x = int(input('x 값 입력 > '))

y = int(input('y 값 입력 > '))

print("\n**** 결과 출력 ****")

# 모듈의 함수 사용하기: 모듈명.함수명

print(x, "+", y, "=", calc_module.add(x, y))

print(x, "-", y, "=", calc_module.sub(x, y))

print(x, "*", y, "=", calc_module.multiply(x, y))

print(x, "/", y, "=", calc_module.divide(x, y))

from 모듈명 import 이름 형태.

매번 [모듈이름.]을 입력하지 않고 바로 사용 가능 / 모듈에서 필요한 것만 골라서 가져올 수 있다.

모듈 불러오기(2)

from calc_module import add, multiply

print("**** 두 수 입력 ****")

x = int(input('x 값 입력 > '))

y = int(input('y 값 입력 > '))

print("\n**** 결과 출력 ****")

print(x, "+", y, "=", add(x, y))

print(x, "*", y, "=", multiply(x, y))

모듈의 특정 함수만 불러와 쓴 것이기에 명렁어에 써두지 않은 함수를 쓰면 NameError 뜬다

모듈 불러오기(3)

from 모듈명 import 모두 = 전체 기능 다 불러온다.

from calc_module import *

print("**** 두 수 입력 ****")

x = int(input('x 값 입력 > '))

y = int(input('y 값 입력 > '))

print("\n**** 결과 출력 ****")

print(x, "+", y, "=", add(x, y))

print(x, "-", y, "=", sub(x, y))

print(x, "*", y, "=", multiply(x, y))

print(x, "/", y, "=", divide(x, y))

[모듈이름.]을 작성하지 않아 코드가 짧아지나

식변자 간의 이름 충돌의 가능성이 있고, 모듈에서 불러온 것임을 구별하기 어렵다.

그런 점에서 import문으로 작성 권장하기도 한다.

모듈 불러오기(4)

import hello as h #h로 모듈 약칭하겠다.

h.greeting("kim")

h.introduce("U",10)

패키지

모듈의 묶음

모듈을 폴더 단위로 묶어놓은 곳

: 대규모 프로젝트, 라이브러리 제작 시 사용한다.

패키지 폴더 만들어서 py 파일 넣고 모듈 불러와서 쓰면 __pycahe__라는 게 생성된다.

mypackage/ - 패키지
├─ __init__.py
├─ calc.py
└─ string_utils.py

py파일 두개는 모듈이다.

__init__.py : 패키지로 인식하게 해준다.

패키지에서 모듈 불러오기(1)

from my_package import calc as c

calc 모듈 전체를 불러오고 이를 c로 지정함.

함수, 변수, 클래스 모두 사용가능하고 이름 충돌이 적다. 호출할 때 as로 지정한 객체를 써야 함.

패키지에서 모듈 불러오기(2)

from my_package.calc import add

c.add(10,5)

calc 모듈 안에 있는 add 함수만 가지고 온다.

코드가 짧고 간결해지나 나중에 같은 명칭을 import하면 덮어 씌워진다. 모듈 수정 확장에 번거로움도 있다.

Python에 기본으로 내장되어 있는 모듈 중 종종 쓰일 수 있는 것들.

random / math

random: 난수(랜덤한 수)를 생성하는 모듈

math : 수학 관련 함수를 갖는 모

random 모듈: 랜덤 값(난수) 생성 시 사용

import random

1 난수 생성

#random() : 0이상 1미만의 float 난수 반환

print(random.random())

uniform(a,b) : a이상 b이하의 실수 난수 반환

print(random.uniform(1,10))

randint(a,b): a이상 b이하의 정수 난수 반환

print(random.randint(5,20))

randint(a, b) 활용 예시

a <= N <= b를 만족하는 정수 N 반환

print('** randint 함수 **')

for i in range(10):

# 1~5 사이의 난수 생성

print(random.randint(1, 5), end=' ')

randrange(start, stop ,step): 범위 안의 정수 난수 반환, 간격 지정시

print(random.randrange(0, 100, 5))

range(start, stop, step) 에서 임의로 선택된 요소 반환, stop값은 포함하지 않는다.

>range(start, stop, step) 에서 임의로 선택된 요소 반환

>매개변수는 range(start, stop, step) 함수와 동일한 의미

print('\n\n*** randrange 함수1 ***')

for i in range(10):

# 1~6 사이의 난수 생성

print(random.randrange(1, 7), end=' ')

print('\n\n*** randrange 함수2 ***')

for i in range(10):

# 1, 3, 5 중에서 난수 생성

print(random.randrange(1, 7, 2), end=' ')

2 랜덤 선택

fruits = ["apple","banana","watermelon","grape","orange"]

choice(list): 리스트에서 랜덤으로 요소 반환

print('\n\n*** choice 함수 ***')

mylist = ["apple", "banana", "cherry"]

for i in range(5):

print(random.choice(mylist), end=' ')

choice(seq) : 시퀀스에서 임의의 요소 1개 반환

print(random.choice(fruits))

choices(seq,k): 시퀀스에서 "중복 허용" k개 요소 리스트를 반환

print(random.choices(fruits, k = 2))

섞기

sample(seq,k): 시퀀스에서 "중복 없이" k개 요소 리스트를 반환

print(random.sample(fruits, k = 2))

shuffle(seq): 시퀀스의 요소를 무작위로 섞음 <- 원본 시퀀스를 변경

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

random.shuffle(number)

print(number)

실습 : 로또 번호 뽑기

1-45 사이의 수 중 6개, 중복 없이 뽑고 오름차순으로 정렬

작성했던 코드

import random

lotto = []

num = random.randint(1,45)

for n in range(6):

while num in lotto:

num = random.randint(1,45)

lotto.append(num)

print(sorted(lotto))

모범 답안

result = sorted(random.sample(range(1,46), k= 6))

print(result)

lotto = []

while len(lotto) < 6:

num = random.randint(1,45)

실습: 가위바위보

random 모듈 함수 사용, input으로 입력 받기, 승패 로직은 if조건문으로

직접 쓴 코드

import random as r

com = ['가위','바위','보']

user = input("가위,바위,보: ")

def game(user):

com_c =r.choice(com)

if user == com_c:

return "무승부"

elif user == "가위" and com_c == "보":

return "승"

elif user == "바위" and com_c == "가위":

return "승"

elif user == "보" and com_c == "바위":

return "승"

else:

return "패"

print(game(user))

#모범 답안

RPS = ["가위", "바위", "보"]

win_count = 0

while win_count < 3:

com_choice = random.choice(RPS)

user_choice = input("가위, 바위, 보 : ")

print(f"유저의 선택: {user_choice}")

print(f"컴퓨터의 선택: {com_choice}")

if user_choice == com_choice:

print("무승부")

elif ((user_choice == "가위" and com_choice == "보") or

(user_choice == "바위" and com_choice == "가위") or

(user_choice == "보" and com_choice == "바위")):

print("이겼습니다")

win_count += 1

elif user_choice in RPS:

print("졌습니다")

else:

print("잘못된 입력이에요")

math 모듈: 수학적 연산에 사용되는 모듈

import math as m

1.올림/내림

ceil: 올림, 소수점 지정x

m.ceil(3.14)

floor: 내림, 소수점 저정x

m.floor(3.14)

round :반올림 - 내장 함수 (math 모듈 아님)

round(3.141492, 2)

2. 제곱, 제곱근

pow(x, y) : 제곱 - x^y

m.pow(2,3)

sqrt(x): 제곱근 반환

m.sqrt(16)

3. 상수

pi : 원주율

print(m.pi)

4. 수학 계산 편의 기능

print(m.factorial(3))

최대 공약수

print(m.gcd(12,80))

최소 공배수

print(m.lcm(12,20))

실습 math모듈 사용

import math as m

x1, y1 = 10, 52

x2, y2 = 4, 30

#모범 답안

x1,y1 = map(int, input("x1, y1을 입력해주세요.: ").split(","))

#int(x1), int(y1)

x2,y2 = map(int, input("x2, y2을 입력해주세요.: ").split(","))

#int(x2), int(y2)

'''

dis = m.sqrt(m.pow(x2 -x1, 2) +m.pow(y2 - x1, 2))

print(f" 거리 값 {round(dis, 2)}")

#최소 공배수, 최대 공약수

s,t= 18,24

print(m.gcd(s,t))

print(m.lcm(s,t))

datetime 모듈

날짜와 시간의 생성, 조작, 현실 변환과 같은 시간 관련 기능을 제공

import datetime

1 현재 날짜와 시간 구하기

print(datetime.datetime.now())

오늘 날짜만 구하기

today = datetime.date.today()

print(today)

2. 날짜/ 시간 형식 변환

formatted = now.strftime("%Y/%m/%d %H:%M:%S")

print(formatted)

parsed = datetime.datetime.strptime(formatted, "%Y/%m/%d %H:%M:%S")

print(parsed)

3. 날짜/ 시간 연산

dt = datetime.date(2025, 7, 7)

passed_time = today - dt

print(f"{passed_time.days}일이 지났습니다.")

4. 요일반환: weekday

0: 월요일 ~ 7: 일요일

days = ["월","화","수","목","금","토","일"]

day_num = today.weekday()

print(days[day_num])

datetime 또는 date 갹체에는 년/월/일 시간 등의 속성으로 들어있음.

print(datetime.datetime.now().year)

실습

사용자로부터 생일 입력 받고, 오늘 날짜를 기준으로 올해 또는 내년 생일까지 남은 날짜(일 수) 계산 출력

import datetime

사용자로부터 생일 입력 받음

birth_month, birth_day = map(int,input("생일을 입력하세요.(예 03-14): ").split("-"))

올해 생일은 date 객체로 변환

birthday_this_year = datetime.date(today.year, birth_month, birth_day)

오늘 날짜와 올해의 생일을 비교

if today > birthday_this_year:

#올해 생일이 지났으면 내년으로 설정

birthday_naxt = datetime.date(today.year + 1, birth_month, birth_day)

else:

#올해로 설정

birthday_naxt = birthday_this_year

남은 일수 계산

day_left = (birthday_naxt - today).days

print(f"다음 생일까지 {day_left}일이 남았어요.")

calender 모듈

날짜와 달력 관련 기능을 제공

import calendar

1. 달력 조회

print(calendar.prmonth(2025,9))

print(calendar.prcal(2025))

텍스트로 값을 반환

print(calendar.month(2025, 11))

요일 반환

print(calendar.weekday(2025,11,26))

time 모듈

시간의 측정, 지연, 변환가 같은 시간 관련 기능 제공

import time

1. 시간 반환

time()

Unix 타임 스탬프로 반환 (1920.1.1부터 경과 초)

print(time.time())

ctime(): 현재 시간을 문자열로 반환

print(time.ctime())

print(time.ctime(0)) #기준 시로 반환 Thu Jan 1 09:00:00 1970 나옴.

하단은 ctime 0 결과값

strptime(): 원하는 포켓의 문자열로 시간 객체 변환

lt = time.localtime()

formatted = time.strftime("%Y-%m-%d %H:%M:%S", lt)

print(formatted) #2025-11-26 12:37:35 형식으로 나옴.

strptime(): 문자열을 struct_time 객체로 변환

parsed = time.strptime(formatted,"%Y-%m-%d %H:%M:%S")

print(parsed)

2. 시간 지연

# sleep(seconds): 지정한 초만큼 프로그램이 일시 정지

time.sleep(1)

print("time sleep") #지연 후에 다음 코드 실행

시간 측정하기

start = time.time()

for i in range(5):

print(i)

time.sleep(1)

end = time.time()

print(f"수행시간 : {end - start: .2f}초")

실습 : 타자 연습 게임 만들기

import random

import time

words = ["apple", "banana", "orange", "grape", "lemon",

"peach", "melon", "cherry", "plum", "pear",

"school", "friend", "family", "flower", "garden",

"window", "bottle", "pencil", "summer", "winter",

"happy", "future", "travel", "animal", "market",

"doctor", "planet", "energy", "nature", "memory"

]

input("[타자 게임] 준비되면 엔터 ")

start = time.time()

n = 1

while n <= 10:

q = random.choice(words)

print(f"문제 {n} : {q}")

x = input()

if x == q:

print("통과!")

n += 1

else:

print("다시 입력!")

continue

end = time.time()

#et = end - start

#et = format(et, ".2f")

#print(f"총 걸린 시간{et}초")

print(f"총 걸린 시간{end - start:.2f}")

#모범 답안

input("[타자 게임] 준비되면 엔터 ")

start = time.time()

while n < 11:

print(f"{n}번 문제")

q = random.choice(words)

print(q)

while True: #문제가 계속 바뀌지 않고 고정하기 위한 방법

answer = input()

if answer == q:

print("통과!")

n += 1

break

else:

print("다시 도전!")

end = time.time()

play_time = end - start

print(f"총 소요시간: {play_time:.2f}초")

sys 모듈

파이썬 인터프리터와 관련된 다양한 기능 제공

import sys

파이썬 버전 정보

print(sys.version) #3.14.0

운영 체제 정보

print(sys.platform) #win32

프로그램 종료

#sys.exit() #강제 종료

print("실행되지 않는 코드") #위 코드로 인해 그 아래 코드들이 출력되지 않는다.

os 모듈

운영체제와 상호작용 할 수 있도록 도와주는 기능 제공

import os

# getcwd(): 현재 작업 디렉토리 반환

print(os.getcwd())

#lisrdir(): 현재 폴더 내 파일, 디렉토리 목록 반환

print(os.listdir())

#폴더 생성

folder_name = "sample_folder"

if not os.path.exists(folder_name): #서치했을 때 이 명칭이 존재하지 않다면- 양식

os.mkdir(folder_name)

else:

print(f"{folder_name} 폴더가 이미 있습니다.")

print(os.listdir())

모듈은 제공하는 기능이 다양하고 전부 다 알아도... 써먹는 게 중요하니까 자주 쓰일 법한 모듈 위주로만 옮겨 적었다. 파이썬 오랜만에 백업하는 기분인데 이제는 다른 걸 배우다보니 시간 날 때마다 다시 짬짬히 쓰러 다녀야 겠다...

[코딩온] 신재생에너지 IoT 개발자 - 팀 프로젝트 회고1

혈중당부족 — Tue, 13 Jan 2026 19:44:42 +0900

서론

git, 파이썬, 데이터 분석, 시각화 데이터 교육 과정을 거치고 이를 종합적으로 활용하고자 팀 프로젝트를 하게 됐다. 팀원은 나를 포함해 둘이서 하게 됐고 이에 대한 회고를 작성하기 위해. 이전에 작성했던 회고록보다 먼저 쓰게 됐다. 강의 회고는 기록, 코드를 다시 읽어가며 이해하는 복습이라면 프로젝트는 방금 마무리 했을 때 바로 기억해야 피드백을 포함해 비교적 온전히 남기 때문이다.

팀 프로젝트 같이 진행한 팀원에 대한 감사를 간결히 남기고 본론에 들어가기로 한다.

프로젝트 개요

프로젝트 명은 강원도신재생에너지 데이터 분석

부제 강원도RE100 및 그린뉴딜 정책기반 신재생에너지 산업 분석

기간: 25년 12월 15일(월) - 26년 1월 12일(월)

추진 배경 및 목적

배경: 기후 재난 위기로 인한 사회문제를 대응하고자 기후 협약과 함께 글로벌 RE100의 확산, 국가의 그린뉴딜 정책 등이 부상

목적

- 국제 정세 흐름에 따라 한국의 RE100 실행 지표와 한국판 그린뉴딜 정책 시행 성과 분석

- 그린뉴딜과 RE100의 무대로 선정된 신재생에너지 발전 지역인 ‘강원도’는 얼마나 변화했는지.

- 산업의 현황과 미래발전 가능성을 데이터 토대로 시사점을 알리고, 제언함으로써 추후 정책 의사결정에 도움

- 프로젝트 과정에서 에너지 측정, 분석 역량 강화와 함께 값을 토대로 근거 제시, 주장까지 실무 프로젝트 경험을 쌓고자 했다.

프로젝트 담당 역할 (notion 참고)

C (me) - 정책 자료 정리, 분석 설계, 결과 해석, 최종 발표

K - 데이터 수집 자동화, 시각화(히트맵, 막대그래프,선 그래프, 지도) , PPT 작업

공통 - 데이터 전처리(기상과 신재생에너지 구분), 데이터 통합 상관관계 분석 시도

프로젝트 협업 과정

분석 과정

정책 시행이 유의미한지 분석, 정책 제언의 목적을 가지고 있기 때문에 정책(Policy)/ 에너지(Energy) 두 방향성을 잡고 조사

정책 : 국내외의 그린뉴딜, RE100... 등

에너지 : 강원도 지형 환경과 기상 데이터, 에너지 발전량, 에너지 자립도... 등

참고 자료

데이터 출처: 기상청, 한국에너지공단, K - RE100, 강원특별자치도 , 그 외 논문

분석 도구

Python / IDE(통합 개발 환경) VScode / Pandas, NumPy, Selenium , BeautifulSoup, Matplotlib, Seaborn, Foilium

통계 기법 : Pearson 상관분석, 유의성 검정

정책, 실제 사례 조사를 위해 플랫폼에서 제공하는 정보를 selenium 활용한 동적 데이터 크롤링

ppt에 첨부된 과정 1 - K씨의 작업

공공기관에서 얻은 기상데이터 전처리

- 원본 자료의 시트 명, 셀 정리 (서론을 포함한 문자열 필터)

사용한 확장 프로그램

- 필요 없는 행,열을 df.iloc, df.reset_index로 제거

- 결측값 처리하기 위한 함수를 만들어 def 함수로 여러 종류의 기상 데이터를 목적에 맞게 처리

- 통합 DF > 시트 통합하여 테이블화 시도: 컬럼 정리, 구역 통일화.

pip install pyarrow 설치하여 parquet로 통합 D.F를 저장했다. (과정은 더보기란)

과정 1

과정 2

과정3

과정4

상관관계에 사용할 분석 데이터 과정

- parquet 파일 활용해 수집한 에너지 분야별 데이터와 대응, 상관 관계를 분석

- 해당 파일을 사용한 건 경로를 지정해 불러올 시, 추후 경로 변동 마다 수정하는 작업을 최대한 줄이기 위함.

- 기상데이터는 관측 지점, 에너지 발전량은 행정 구역을 기준으로 하고 있으며 대응되도록 명시적 테이블화

기상 데이터와 에너지 발전량의 데이터 기준을 맞추기 위한 단위 변환.

분석 결과

- Policy

RE100

시각화 자료로 가공한 결과 일부

- 국내 RE100의 특징은 20년도 이후로 기업의 가입은 매년 상승세

- 낮은 이행률은 타 국가보다 비교적 늦은 참여, 대기업 제조업 중심 확산으로 인해 에너지 집약적 산업 구조 (느린 전환), 기존 PPA 가 아닌 REC와 녹색 요금제 등의 제한된 수단 의존.

시각화 자료로 가공한 결과 일부

- 한국의 그린뉴딜은 디지털 뉴딜과 결합하여 중장기 기후대응 전략에 초점을 두고, 정책 아이디어 플랫폼 성격으로 바뀜.

- 각국의 경제 상황과 사회적 요구에 따라 차별화된 전략을 추진

- 경제 불황 대응 수단으로 시작한 미국과 한국은 높은 경기 부양 효율

- 사회적 형평성과 같은 공정한 전환에 있어 동아시아권은 중앙정부 중심으로 하향식 의사결정으로 이뤄진 태생적인 한계에 의해 비교적 낮은 것으로 보여짐.

- Energy

시각화 자료로 가공한 자료 일부

- 분석 방법으로 pearson 상관 분석( 유의 수준 = 0.05)

- 기후요인에 영향받는 에너지로 태양광, 수력, 풍력, 바이오를 기준으로 지역별 발전 효율성 분석

- 비교적 균형된 분포 발전, 수력, 바이오 중심의 기존 발전에 태양광, 풍력이 추가되면서 다변화

지도화 QR코드

- 바이오, 태양광은 강한 상관관계를 보였으며, 풍력은 약한 양의 상관관계, 수력은 상관 관계가 없었음.

- 바이오와 태양광의 발전 원리를 토대로 나타났고, 풍력은 이론적 관계가 존재하나 설비 부족으로 인한 관계성 악화.

- 수력은 기후 요인보다 그 외의 요인이 복합적으로 나타났고, 수력 발전이 있는 지역은 수력 발전소가 공통적으로 존재함.

- 결론

정책 시행 기준 변화

- 강원도의 풍력과 수력은 복합 변수가 필요하나 나머지 에너지원에서 예측 가능한 분석 (지역 특화 발전 가능성)

- 국가가 시행한 그린뉴딜 정책은 통계적으로 유의미

- 이를 토대로 이후 신재생에너지 정책에 강원도를 어떻게 발전시킬 수 있을 지 구상할 수 있다.

분석 한계점

- 일부 지역은 특정 에너지원만 있는 등 시설 부재가 존재

- 기후 요인과 발전량은 시설 유무와 같은 인위적인 요인을 제외했기에 신뢰성 떨어지는 부분이 존재

- 에너지 발전량은 연간 집계 데이터, 기상 정보는 월별 집계 데이터 등 계절성 분석에 용이하지 못함

1월 12일에 프로젝트 최종 발표 - PPT 목차

회고

기간 내에 프로젝트를 완성하고 최종 발표까지 끝낸 후, 조별 각자 다른 팀을 평가했고, 리더님이 이를 계산해 결과 발표한 후 피드백과 프로젝트 관련 예상 질문을 건네주셨다. 이에 관해 주관적인 내용을 적고자 한다.

프로젝트 평가 (한계점, 개선제안, 예상 질문 포함)

강점

- 정책 맥락 정리 능력이 우수하다고 평가함.

RE100, 그린뉴딜, 해외 비교까지 구조적으로 정리

- 기술 스택 활용 범위가 넓다.

Selenium, Folium, 시각화 등 교육 과정에서 배웠던 기술을 많이 활용하고자 함.

- 데이터를 통해 정책 해석 연결 시도.이는 현재 교육 과정 취지에 정확하게 부합된다 함.

단점
- 데이터 분석 비중이 정책 설명에 비해 약함
그래프는 많으나 정략적 인사이트가 한 문장으로 정리되지 못함.

- 상관 관계 분석 결과와 매끄럽게 이어지지 못함.
- RE100 기업 데이터는 현황 나열에 가까웠다.

받았던 개선 제안

- 분석 질문을 하나로 압축한다. (ex 강원도는 어떤 에너지 조합이 RE100 대응에 가장 현실적인가?

- 최소 1개는 **정책 제안이 아니라 ‘지표 기반 선택’을 보여줄 것 (ex 태양광 vs 풍력 vs 수력 중 단위면적·변동성 기준 최적은?

예상 질문 일부 말한다면

- RE100 기업 데이터가 ‘분석’에 기여한 지점은 정확히 어디인가?

- 상관관계 히트맵에서 가장 의미 없는 지표 하나만 고른다면? 이유는?

- 강원도에 한정했을 때, 태양광·풍력·수력 중 데이터 기준으로 가장 비효율적인 건 무엇인가?

나의 결론 : 데이터 분석가의 정체성이 부족하다.

진행 과정 중 주제에 맞는 데이터가 실제로 적었다...! 공공기관에 없거나, 제공하는 사이트는 유료 자료인 등 접근성이 높지 않았기에 우회하는 일이 있었고, 데이터 검증을 하기에 신뢰도가 떨어진다고 판단해 새로 찾기도 했다. 시각 데이터 여럿을 만들었으나 선별 과정이 길어진 탓에 후반에 밀도가 부족한 게 보여서 아쉬웠다. 시간 부족이라고 보는 게 맞다.

본인의 기술 부족을 실감했다. 배웠던 지식대로 하는 과정에서 어떻게 접근할 지 찾고, 적용하고, 피드백 받아서 진행할 때 내가 배운 것보다 더 많은 것이 필요했고 고민이 더해져 투자대비 결과가 많지 않음을 인지 했다. 자료를 모으고, 이를 연결 지어서 결론을 내기까지는 어렵지 않았으나 필요한 기술 활용에서 막막함을 느끼고, 코딩 숙련에 많이 기여 못한 게 컸다.

프로젝트 진행하면서 얻었던 긍정적인 부분과 향후 개선 방향

긍정 (이어갔으면 하는 부분)

- 팀원이 노션과 슬랙을 통한 협업 환경을 만들어줬고 이용하면서 남은 기록들 덕분에 프로젝트 계획서, 과정, 피드백이 고스란히 남아 추후 포트폴리오와 실무에 직간접적으로 도움이 됐다. 그리고 작업에 몰입하면 컨디션이 나빠질 수도 있는데 이에 대한 브레이크를 걸어줘 일정한 컨디션으로 작업 할 수 있었다.

- 주제 선정, 목적이 확실했기에 데이터 수집을 최대한 모을 수 있었다.

- ai 도구 활용. IT 분야에서 ai는 뗄 수 없는 영역이고, 다들 활용한다고 하는데 보조 도구를 활용해 작업 효율을 높이는 목적으로 사용한다고 생각하면 그것은 괜찮은 도구라고 생각했다. 코드에 관한 설명도 친절해서 이해에 도움이 됐다.

개선 방향

- 데이터 분석에 있어 원본 자료를 가지고 어떤 의도로 가공할지를 판단, 계획 필요.

- 인사이트에 대한 이해, 어떤 해석과 인사이트를 내리는 지에 따라 달라진다.

- 그러기 위해서는 분석 방법, 방향성을 검토하고 때에 따라 바꾸는 등 유도리 있게 접근

마지막

교육도, 분야도 모든 게 처음인 나로서 광범위한 구역에 돌아다닌 기분이 들었다. 기술을 익혀도 분야, 직업에 대한 이해도가 있어야 활용할 수 있다는 걸 인지했다. 어떤 바탕 없이 뛰어들어 막막함이 컸지만 다음은 나아지지 않을까. 그런 기대도 생겼다. 값진 경험과 함께 흥미가 꽤 생겼다고 봐야겠다.

[코딩온] 신재생에너지 IoT 개발자 입문_ 파이썬11

혈중당부족 — Mon, 15 Dec 2025 17:09:19 +0900

13 class

같이 수업 받는 수강생분이 클래스도 분량이 많다고 들었는데... 얼마나 걸릴 지 알 수 없지만 하나로 넣기 위해 노력해보고자 한다.

class 들어가기 전에 기초OOP를 먼저 배웠다. 그래야 조금 더 이해할 수 있다며.

객체 지향 프로그래밍

OOP, Object-Oriented Programming

: C++ 이 대표적인 객체 지향 프로그래밍인데, 객체를 기반으로 프로그램을 설계하는 패러다임 같은 거다.

방법론의 어떤 하나 같은 거라서, OOP라고 하면 상호작용하는 객체들의 집합이라 보는 거다. 함수 지향이면 값이 없는 함수들을 연속으로 나온다 같이...

구체적으로 궁금하면 이 쪽 링크로... Plato and Object Oriented Programming | Richard Farrar

Plato and Object Oriented Programming | Richard Farrar

Some of the fundamental concepts behind today's Object Orientated Programming methods have direct analogies with Plato's metaphysical constructs almost 2,500 years ago. Was Plato the Great Great Grandfather of modern computing?

www.richardfarrar.com

여기서 말하는 객체는 데이터와 데이터를 조작하는 기능(메서드)을 하나로 묶은 독립적인 실행 단위 다. 자동차의 부품같이 여러개 모아서 상호작용을 해 자동차를 움직이게 하는 형식으로. 부품과 유사하다.

속성과 행동을 함께 묶은 객체 여러개를 모델링해 구현한다 느낌이다.

여기의 예시도, Car 안에 여러 함수(행동)이 들어있고 변수(속성)을 기입해 Car는 이렇다고 구현한 거다.

그러면 OOP의 핵심 개념이 무엇인가.

1 캡슐화 (Encapsulation)

객체 내부 데이터를 외부에서 접근하지 못하도록 보호.

데이터 보호를 통해 잘못된 값이 저장되는 걸 방지하고, 코드가 바뀌어도 외부에서 영향 받지 않고 사용한다.(모듈)

2 상속 (Inheritance)

기존 클래스를 확장하여 새로운 기능을 추가

코드 재사용성을 높이고 유지보수를 쉽게 만든다. 기존 클래스를 기반으로 새로운 기능을 추가하는 거다.

3 다형성 (Polymorphism)

같은 함수를 서로 다른 방식으로 실행.

새로운 클래스 추가할 때 기존 코드 변경할 필요가 없고 같은 인터페이스를 사용해 다양한 기능을 쉽게 다룬다.

4 추상화 (Abstraction)

필요한 정보만 보여주고 불필요한 내부 구현을 숨긴다.

핵심 기능만 제공해 코드 관리가 쉬워지고, 공통적인 동작을 정의. 세부 구현은 각 클래스에서 따로 처리 가능하다.

여기까지 OOP의 기초를 적었으니 본격적으로 클래스에 들어가자.

class

클래스는 데이터 ( 속성 “ ) 와 기능 ( 메서드 ) 을 하나로 묶는 구조

새로운 형식을 정의하기에 객체를 만드는 틀이 된다.

객체는 클래스(틀)에서 만들어지는 것으로 '인스턴스'라고 부르기도 함.

클래스는 객체 만드는 붕어빵 틀이고, 객체는 붕어빵이라 틀 통해 여러개 붕어빵이 나오기도 한다.(하나의 클래스에 여러개 객체) 그리고 그 붕어빵들 중 하나 먹어도 나머지가 온전하듯이 객체끼리 상호작용하지 않는다. 그럼 객체는, 속성을 가지는 모든 것인데 그 속성은 여기서 클래스, 또는 객체에 소속된 변수(필드)와 함수(메서드)를 가리킨다.

클래스 기분 문법

클래스의 정의

class ClassName: # PascalCase 형태로 작성

#생성자(comstructor): 인스턴스(객체)가 생성될 때 호출

#인스턴스 변수를 초기화, 기본 상태 설정

#하나의 클래스 에서 하나만 정의 가능

def __init__ (self, name):

# 인스턴스 변수

# self : 인스턴스 자기 자신을 가리킴

self.name = name #매개변수

self.age = 0 #임의로 넣은 값

#(인스턴스) 메서드

def method_name(self): #메서드는 주로 스네이크 케이스 양식 씀

print(f"이 인스턴스 이름은 {self.name} 입니다.")

강의 중 일부 설

물론 호출 시 파이썬은 자동으로 할당하므로. self에 직접 값을 넣지 않아도 된다. 이 self는 매개변수 없는 메소드를 정의할 때도 필수로 들어가는데 이는 '식별자'이기 때문이다.

객체를 인스턴스라고 부르는 건, 클래스의 객체를 관계 중점으로 표현할 때 사용함.

# 클래스 정의
class Person:
    # 메소드 정의
    def say_hello(self):
        print('Hi!! Nice to meet you.')

p = Person() # 객체 p
p.say_hello() # 메소드 호출

>> Hi!! Nice to meet you.로 출력

#인스턴스 생성

my_instance = ClassName("I1") #name 변수 받기로 했으니, 문자열 입력

print(my_instance.name)

my_instance.method_name()

코드 실행 출력 값

생성자 (__ self : init __) : 객체 생성될 때 자동 호출되는 초기화 메서드

self : 생성되는 개체 자신을 가리킴

인스턴스 변수: 객체마다 독립적으로 유지되는 변수 (self. 변수명)

메서드: 클래스 내부에 정의된 함수. 첫 번째 인지로 self 사용

생성자 __ init __() 함수

위에도 썼지만 클래스로부터 객체(인스턴스)를 생성할 때 자동으로 호출되는 초기화 함수

필요한 속성 초기화 및 기본 상태 설정에 쓴다.

하나의 클래스에, 하나의 __ init __() 만 정의 가능하다.

실습

책 클래스 만들기

인스턴스 변수는 title, author, total_pages, current_pages

메서드는 read_page (현재 페이지를 읽음, 총 페이지 수 넘기지 않게 처리) / progress(얼마나 읽었는지 %로 소수점 1까지 출력)

class BookClass:

def __init__(self,title,author,total_pages,current_pages):

self.title = title

self.author = author

self.current_pages = current_pages

self.total_pages = total_pages

def read_page(self,page):

self.current_pages += page #입력한 값(page)을 더해서 할당

if self.current_pages > self.total_pages:

self.current_pages = self.total_pages

#초과할 시 total과 동일하게 해 넘기지 않도록 한다.

def progress(self): #함수 생성

percent = (self.current_pages / self.total_pages) * 100

#읽은 페이지 나누기 총 페이지에 100 곱한다.

print(f"현재 읽은 분량: {percent: .1f}%")

#소수점 한자리 값까지만 보여준다. (.1f)

book1 = BookClass("넥서스","유발 할라리", 500, 1)

book1.read_page(10) #10 추가하겠다.

book1.progress()

BookClass에 타이틀, 작가, 총 페이지(500), 시작 페이지(1)를 넣었다. 그리고

read_page 함수에 변수 10을 넣었고, page(10)은 current_pages에 할당되었다.

조건문으로 현재 페이지 수가 총 페이지 수보다 커지면 똑같다로 정의해둔다.

그리고 progress 함수는 백분율 계산을 하고 출력하는 걸로 코드 작성. 여태 넣은 데이터를 바탕으로 계산해 코드 실행 시키면 2.2%만 출력된다.

Rectangle 클래스 구현

인스턴스 변수 width, heigh

메서드는 area() 사각형의 넓이 반환, 사용자가 직접 입력해 계산 되도록 한다.

class Rectangle_Mathod:

def __init__(self, width, height):

self.width = width

self.height = height

def area(self):

return self.width * self.height

Rectangle = Rectangle_Mathod(int(input("가로 값: ")),int(input("세로 값: ")))

print(f"사각형의 넓이는 {Rectangle.area()}")

class에 변수 지정할 때 입력된 값을 변수로 저장한다.

그리고 print에서 Rectangle(변수).area () 를 실행해 그 값을 반환한다.

클래스 변수 : 클래스가 가지고 있는 변수

모든 인스턴스가 공유할 수 있다.

클래스로부터 생성된 인스턴스(객체)에 속하는 변수

각각의 객체에 속해 서로 공유되지 않고 영향받지 않음

클래스 자체에 속하는 변수

그 클래스로부터 생성된 모든 객체가 공유

객체를 생성하지 않아도 사용 가능

객체의 전체 수를 계하기 위해서면 클래스 변수를 만들어서 모든 객체가 공유해야 함. 객체가 생성될 때마다 변경해야 하므로.

예시 코드

class Person:

count = 0 # 클래스 변수

def __init__(self, name, age):

self.name = name

self.age = age

Person.count = Person.count + 1 # 객체가 생성될 때 마다 증가

def say_hello(self):

print('Hi!! Nice to meet you.')

def about_me(self):

print('I am ' + self.name + ' (' + str(self.age) + ')')

print('******* 총 ' + str(Person.count) + '명 *******')

suzy = Person('Suzy', 20)

suzy.say_hello()

suzy.about_me()

print('******* 총 ' + str(Person.count) + '명 *******')

minho = Person('Minho', 23)

minho.say_hello()

minho.about_me()

print('******* 총 ' + str(Person.count) + '명 *******')

yeji = Person('Yeji', 21)

yeji.say_hello()

yeji.about_me()

print('******* 총 ' + str(Person.count) + '명 *******')

여기서 클래스 변수는 클래스 내부와 외부에서 접근할 때 [클래스명.변수명] 으로 쓴다.

그러니 여기서 클래스 변수를 확인하려면 Person.count 라고 작성한다.

class Dog:

#클래스 변수

kind = "강아지"

def __init__(self, species, name, age):

self.species = species

self.name = name

self.age = age

dog1 = Dog("포메라니안", "리치", 12)

dog2 = Dog("비숑", "비수", 6)

print("인1", dog1.kind)

print("인2", dog2.kind)

print("클래스", Dog.kind)

클래스 메서드

클래스 자체를 대상으로 동작하는 메서드

클래스 데이터를 조작하는데 사용

예제

class Book_1:

book_count = 0 #책_카운트 변수는 0으로 시작한다.

def __init__(self, title, author):

Book_1.book_count += 1

self.title = title

self.author = author

#제목, 작가 입력될 때마다 book_count가 1씩 올라간단 뜻이다.

# 클래스 메서드

@classmethod #데코레이터 (설명해준다 맥락)

def get_count(cls):

print(f"현재 {cls.book_count}권의 책을 가지고 있다.")

book1 = Book_1("a1","abc")

book2 = Book_1("a2","def")

print(Book_1.book_count)

Book_1.get_count()

Book_1에 (인자 2개) 변수가 2개 추가되었기에 count값이 올라갔고, 현재 class를 호출하니 count가 2인 걸 알려준다.

정적 메서드

클래스나 인스턴스의 데이터를 조작하지 않는 클래스 메서드

클래스나 인스턴스의 상태를 의존하지 않는 일반 함수(self나 cls를 사용 안 한다.)

개념적으로는 클래스와 연관이 있으나, 클래스나 인스턴스의 데이터를 조작하지 않음.

class OperationTool:

@staticmethod #데코레이터

def add (a, b):

return a + b

print(OperationTool.add(10, 20)) #곧바로 30이란 결과값이 나온다.

기록하면서 배운 것들을 요약하면 이렇다.

실습 클래스

User 클래스구현

인스턴스 변수 : username, points (초기값은 0)

클래스 변수: total_users

메서드

add_point(amount): 포인트 추가

get_level(): 포인트 기준으로 레벨 반환(설정) 0~99: Bronze, 100~499: Silver, 500 이상 : Gold

클래스 메서드: get_total_users () > 총 유저 수 출력

class User:

total_users = 0

def __init__(self,username,points):

self.username = username

self.points = points

User.total_users += 1

#이름, 점수 입력될 때마다 total 유저 수 1 증가

#모범 답안

#def __init__(self,username,points):

#self.username = username

#self.points = 0

#User.total_users += 1

#이름 입력 될 때마다 유저 수 증가로 설정.

def add_points(self, amount):

self.points += amount

#amount는 self.points 값이 더해지는 값과 같다.

def get_level(self):

if 0 <= self.points < 100:

return "Bronze"

elif 100 <= self.points < 500:

return "Silver"

else:

return "Gold"

@classmethod

def get_total_users(cls):

print(f"총 유저 수는 {cls.total_users} 입니다.")

User1 = User("a", 200)

User2 = User("b", 500)

print(User1.get_level())

print(User2.get_level())

User.get_total_users()

#User1.add.points(100)

#def add_points(self, amount) 메서드 쓰기 위해서 입력하는 숫자값 맥락.

접근 제어와 정보 은닉

데이터 무결성을 보호하기 위함

코드 안정성을 향상 시키기 위함

파이썬에서 일반적으로 정의한 인스턴스 변수는 기본적으로 모두 public

protected

_ 변수명 으로 표현

명시적으로 표현하기 위해 사용

외부에서 직접 접근이 가능하나 캡슐화를 깨트리는 행위므로 권장하지 않는다.

private

__ 변수명 으로 표현 (underscore 두 번)

네임 맹글링 (name mangling )

내부적으로 _{ 클래스명 }__ 변수명으로 이름이 변경되어 접근을 어렵게 한다.

_{ 클래스명 }__ 변수명으로 접근할 수 있지만 권장되지 않는다.

getter: 객체 내부 속성 값을 읽을 수 있도록 외부에서 제공하는 메서드

setter: 객체 내부 속성 값을 변경할 수 있도록 외부에서 제공하는 메서드

외부에서 직접 변수에 접근하지 못하도록 하고 , 메서드를 통해 접근할 때 사용

class Person:

def __init__(self, age):

self._age = age

@property

def age(self):

"""Getter"""

return self._age

@age.setter

def age(self, value):

"""Setter"""

if value < 0:

raise ValueError("나이는 0 이상이어야 합니다.")

self._age = value

p = Person(20)

print(p.age) # Getter 호출 → 20

p.age = 30 # Setter 호출

print(p.age) # 30

p.age를 일반 변수처럼 입력하면 Setter가 호출해서 사용한다. 내부에서는 함수가 호출됨.

변수처럼 쓰이지만 함수와 같이 제어가 가능하다.

class Person2:

def __init__(self, name, age):

#public

self.name = name

#private : self 언더바(__) 두개 변수 앞에 붙여서 정의

self.__age = age

#getter

def get_age(self):

return self.__age

#setter

def set_age(self, value):

if value > 120 or value < 0:

print("유효하지 않습니다.")

else:

self.__age = value

p1 = Person2("lee", 20)

print(p1.name)

#print(p1.__age)

#AttributeError: 'Person2' object has no attribute '__age' 뜸.

print(p1.get_age())

p1.set_age(-10)

@property 데코레이터

메서드를 속성처럼 보이게 만들어주는 데코레이터

보통 데코레이터를 사용해 구현한다.

class Ex:

def __init__(self):

self.__value = 0

#getter

@property

def value(self):

return self.__value #위의 getter양식과 동일

#setter

@value.setter

def value(self, val):

if val < 0:

print("유효하지 않은 값입니다.")

else:

self.__value = val

ex1 = Ex()

print(ex1.value) #ex1.value() 안해도 0으로 출력

ex1.value = 100

print(ex1.value) #setter 작동함.

ex1.value = -100 #유효하지 않은 값입니다.

print(ex1.value)

실습

UserAccount 클래스 비밀번호 보호

class UserAccount:

def __init__(self, username, password):

self.username = username

self.__password = password

def change_password(self, old_pw, new_pw):

if self.__password != old_pw:

return "비밀번호 불일치"

else:

print("비밀번호 변경되었습니다.")

return new_pw

#setter

def set_check(self, value):

if value != self.__password:

return False

else:

return True

user1 = UserAccount("asd", 123456)

print(user1.set_check(1234567)) #false

user1는 클래스 정보에 저장되었고, 들어가있던 변수 123456과 방금 입력한 1234567를 비교함.

print(user1.set_check(123456)) #ture

print(user1.change_password(123, 123789)) #비밀번호 불일치

print(user1.change_password(123456, 1123)) #비밀번호 변경되었습니다. (변경 번호)

print(user1.set_check(1111)) #false

추후에 받은 모범 답안

class UserAccount:

def __init__(self, username, password):

self.username = username

self.__password = password

def change_password(self, old_pw, new_pw):

if old_pw == self.__password:

self.__password = new_pw

print("비밀번호 변경되었습니다.")

else:

print("기존 비밀번호와 일치하지 않습니다.")

#setter

def check_password(self, password):

return self.__password == password

user1 = UserAccount("asd", 123456)

print(user1.username)

#print(user1.__password)

user1.check_password("123456")

Student 클래스: 성적검증(@property 사용)

class Student:

def __init__(self,score):

self.__score = score # private 선언

#getter

@property

def get_score(self):

return self.__score

#setter

@get_score.setter

def set_ver(self, value):

if 0 <= value <= 100:

self.__score = value

else:

raise ValueError("유효하지 않습니다.")

s1 = Student(80)

print(f"이 학생의 점수는 {s1.set_ver}점 입니다.")

s1.set_ver = -120

print(s1.set_ver) # ValueError 작동

상속

부모 클래스의 속성과 메서드를 물려받아 새로운 자녀 클래스를 만드는 것

코드 재사용성 높이고 공통 기능은 부모 클래스에서 정의, 자식 클래스에서 확장 또는 수정한다.

상속 기본 문법

부모 클래스

class Animal:

def __init__(self,name):

self.name = name

def bark(self):

print("동물 소리를 냅니다.")

class Dag(Animal):

pass

# super() 사용

class Animal:

def __init__(self,name,age):

self.name = name

self.age = age

def bark(self):

print("동물 소리를 냅니다.")

class Dog(Animal):

def __init__(self, name, age, species):

super().__init__(name, age)

#__init__ 누르자마자 바로 부모 클래스 메서드 갖고 왔다;

# super는 부모 가리킴

self.species = species

#오버라이딩

def bark(self):

super().bark() #부모 클래스의 메서드도 적용

print("멍멍")

dog = Dog("구름이",5, "포메라니안")

dog.bark()

print(dog.name)

print(dog.species) #부모 클래스에 없는 속성값을 추가해도 적용 된다.

super() 함수 : 부모 생성자 호출

자식 클래스에서 부모 클래스의 요소를 명시적 클래스명 없이 호출할 때 사용.

super().메서드명(인자) 구조: super().__init__() 로 많이 사용

상속 구조가 변경되어도 자동 추적이 된다.

메서드 오버라이딩 (Overriding)

부모 클래스의 메서드를 자식 클래스에서 동일한 이름으로 다시 정의.

기존 기능을 새로운 방식으로 변경하거나 특화된 동작 실행.

=> 자식 클래스에서 부모클래스에 사용한 메서드를 덮어씌워 실행한다.

실습

class Shape:

def __init__(self,sides,bass):

self.sides = sides

self.bass = bass

def printlnfo(self):

return print (f"변의 개수: {self.sides} , 밑변의 길이: {self.bass}")

def area(self):

print("넓이 계산이 정의되지 않았습니다.")

class Rectangle(Shape):

def __init__(self, sides, bass, heigh):

super().__init__(sides, bass)

self.heigh = heigh

def area(self):

area = self.heigh * self.bass

print (f"{self.sides}사각형의 넓이: {area}")

class Triangle(Shape):

def __init__(self, sides, bass, heigh):

super().__init__(sides, bass)

self.heigh = heigh

def area(self):

area = int((self.bass * self.heigh) / 2) #area 값은 이거다의 계산식으로 수정

print(f"{self.sides}의 넓이 {area}")

rect = Rectangle(4,10,5)

rect.printlnfo()

rect.area()

tri = Triangle(3,8,10)

tri.printlnfo()

tri.area()

추상 클래스 (파이썬에만 있는 개념은 아니다)

(Abstract Class)

클래스의 구조를 정의하는 클래스

직접 인스턴스를 만들 수 없고 반드시 자식 클래스에서 구현 완성 해야한다.

공통적인 구조는 정의하되, 구체적인 동작을 상속받은 클래스에서 하도록 강제하기 위함.

from abc import ABC, abstractmethod #abc에서 ABC, abstractmethod 가져온다.

구현하기 위해 모듈을 갖고와야 하고, ABC를 반드시 상속. 직접 인스턴스화 불가능.

class Animal(ABC):

#추상 메서드

@abstractmethod #자식 클래스에서 꼭 구현해라

def bark(self):

pass

#메서드는 여러개 만들어도 됨.

class Dog(Animal):

def bark(self): #부모 메서드에 있는 걸 갖고와 온전히 구현해둬야 한다.

print("멍멍")

#a = Animal() #TypeError: Can't instantiate abstract class Animal 에러남.

a = Dog()

a.bark() #멍멍

실습

Payment 구현

from abc import ABC, abstractmethod

class Payment(ABC):

@abstractmethod

def pay(self,amount):

pass

class CardPayment(Payment):

def pay(self, amount):

self.amount = amount

print(f"카드로 {self.amount}원을 결제합니다")

class CashPayment(Payment):

def pay(self, amount):

self.amount = amount

print(f"현금으로 {self.amount}원 결제합니다.")

amo = CardPayment()

amo.pay(15000)

amo1 = CashPayment()

amo1.pay(20000)

#이후 받은 모범 답안

from abc import ABC, abstractmethod

class Payment(ABC):

@abstractmethod

def pay(self,amount):

pass

class CardPayment(Payment):

def __init__(self):

#pass 가능, 알아서 동작해줌.

super().__init__()

def pay(self, amount):

self.amount = amount

print(f"카드로 {self.amount}원을 결제합니다")

class CashPayment(Payment):

def pay(self, amount):

self.amount = amount

print(f"현금으로 {self.amount}원 결제합니다.")

처음 인터넷 강의 들었을 때는 클래스 정의, 용법 정도로 익혔는데 실제 수업 듣고 실습하면서 여러 메서드, 데코레이터 등 확장되는 영역이 많으니 3일간 조금씩 매달리며 쓰게 됐다. 사실 갈 길이 멀지만 내가 이렇게 써두지 않으면 또 펼쳐볼 게 뻔하니까. 이렇게 클래스 부분 기록 끝!

[코딩온] 신재생에너지 IoT 개발자 입문_ 파이썬10

혈중당부족 — Tue, 9 Dec 2025 17:49:27 +0900

12 function

함수는 특정 작업을 수행하는 코드 블록이다.

수학 함수와 유사한 점이 있어 비유한 이미지

함수를 쓰는 건 코드를 재사용(재활용)하여 동일한 작업 반복의 효율을 올려주고, 미리 작성된 코드를 호출해 쓰는 식이니 코드의 가독성도 올라간다. 기능 단위로 묶어서 코드를 쓸테니 명확하고, 다른 사람도 이게 무슨 코드인지 읽고 이해하기 쉬워지기 때문이다. 거기다 수정이 필요하다면 그 함수만 고쳐도 전체를 수정할 필요 없이 쓸 수 있으니 유지 보수에도 용이해진다.

이런 구조이니 큰 작업에 여러 개의 역할을 나눠서 작업해 합칠 수 있는 구조화(모듈화)가 되고, 작업 분담으로 협업이 가능하고 계층적 설계에도 쓰이니 설명을 듣고 활용할 수 있도록 배우는 게 맞다.

기본적으로 파이썬에는 기본적으로 제공하는 기능(내장함수)가 있어 별도 지정 없이 이미 몇 번 씩 끌어 쓰고 있다.

예시: print(), len (), type(), sum(), max(), sorted()

그리고 이번에 배울 건 사용자 정의 함수다. 사용자가 def 키워드를 사용하여 직접 만든 함수를 그렇게 부른다.

> 사용자 정의 함수 기본 문법

함수의 정의: define의 약자로 def 사용

def 함수이름 (매개변수): #콜론(:), 들여쓰기 중요

#실행할 코드

print(매개변수)

return "반환값"

#함수의 실행 (호출 call)

result = 함수이름("인자") #인자라는 갓이 def의 매개변수로 들어감.

print(result) #"반환값"으로 출력됨 return 결과물을.

> 매개 변수(Parameter): 매개 + 변수

매개 : 둘 사이를 연결해줌.

함수가 실행될 때 인자로부터 입력되는 값을 함수의 코드 블록으로 전달하는 역할.

> return: 결과값 반환(선택적 사용, 없으면 None으로 출력)

return을 만나면 함수는 즉시 종료된다.

> ()는 함수에 전달할 값이 없더라도 반드시 필요하며, 인자는 함수 호출 할 때 전달하는 값이다.

> 매개 변수와 인자는 같은 맥락으로 사용되기도 하고 둘의 수가 일치해야 함수가 작동된다. 아니면 TypeError 뜬다.

> 인자의 순서대로 매개변수에 대응된다 : 가장 일반적이고 기본적인 전달 방식.

#함수의 필요성 예제

a = 10

b = 20

if a > b:

print(a - b)

else:

print(a + b)

c = 30

d = 40

if c > b:

print(c - d)

else:

print(c + d)

#... 비슷한 구조로 길어지게 된다.

def my_func(a,b):

if a > b:

return a - b

else:

return a + b

print(my_func(10,20))

print(my_func(30,40))

그러니 def로 연산하는 코드를 작성하고 그 함수 안에 인자(10,20/ 30,40)을 넣으면 출력된다.

#실습 1 : 사칙연산 계산기 함수 만들기

조건

1 매개 변수는 a,b,operator 3개고 oper-은 문자열이다.

2 나눗셈을 실수(float)로 반환

3 올바르지 않은 연산자 들어올 시 잘못된 연산자라고 반환한다.

def calculate(a,b,operator):

if operator == "+":

return a + b

elif operator == "-":

return a - b

elif operator == "*":

return a * b

elif operator == "/":

return float(a / b)

else:

print("지원하지 않는 연산입니다.")

print(calculate(20,5,"?"))

? 들어가서 바로 출력된다.

함수 정의 시 인자에 대한 여러 종류들.

- 키워드 인자

인자의 이름을 명시하여 전달한다. 순서와 무관하게 매개변수에 대응해 순서가 헷갈릴 때 유용한다.

예시 1

print("안녕하세요", "반갑습니다.", sep="-", end="/") #공백은 -, 마무리는 /

예시 2

def my_func(a, b, c=None, operator=None):

if operator == "+":

return a + b

else:

return c

print(my_func(10,20,operator="+"))

#a,b만 설정하면 none 뜨고 operator = "+"라고 새인자 지정하면 변경해 적용됨

/ 다음에 10+20 값 30이 출력된 거다.

- 기본값 인자

함수 정의 시 매개변수에 기본값을 지정한다. 호출할 때 인자를 생략하면 기본 값으로 나온다.

단, 기본값 매개변수는 뒤쪽에 위치해야 함.

def greet(name, message="안녕하세요."):

print(f"{name}님, {message}")

#호출 시 인자 생략 -> 기본값 사용.

greet("luna")

greet("ff","반갑습니다!")

- 위치 가변 인자

여러개의 값을 유동적으로 받을 수 있음

값이 튜플 형태로 받아짐. 함수 정의 시 *args 로 표기한다.

def add_all(*args):

return sum(args)

print(add_all(1,2,3,4,5)) #15 출력

- 키워드 가변 인자

여러 키워드 인자를 유동적으로 받을 수 있다.

딕셔너리 형태로 값이 입력됨. 함수 정의시 **kwargs로 표기한다.

def print_info(**kwargs):

for key, value in kwargs.items():

print(f"{key} : {value}")

print_info(name="luna", age = 15 , city="souel")

인자 지정해서 줄 때, 순서에 유의해야 한다.

매개변수 전달 방식은, 파이썬에서 값 전달( Call by Value)이 아닌 객체 참조에 의한 전달 (Call by Object Reference)이다.

변경 가능한 객체(mutable)을 함수 내에서 변경하면 외부에도 영향을 주고 [ 리스트(list), 딕셔너리(dict), 집합(set) ]

변경 불가능한 객체 (immutable)을 쓰면 외부에 영향이 없는 형식이다. [ 정수(int), 실수(float), 문자열(str), 튜플(tuple) ]

실습

1. 숫자 여러 개의 평균 구하기.

def avg(*args):

return sum(args)/len(args) #sum(iterable) = 모든 요소의 합을 계산

print(avg(1,4,5,2,6))

2. 가장 긴 문자열 찾기 (max함수 사용)

def max_log(*args):

return max(args, key= len)

print(max_log("as", "asdf"))

문제보고 이렇게 작성했었는데. 두가지 방법을 알려주셨다.

#모범 답안

def max_log(*args):

answer = ""

for s in args:

if len(s) > len(answer):

answer = s

return answer

print(max_log("asg","qwtsah","01asfssg"))

작동 잘 된다.

여러가지 값을 받는 *args만 쓴다면, 그 값의 요소 s 하나씩 answer이 되고 비교해서

s가 크면 그걸로 바꾸는 식으로 바꿔 반환되는 구조다.

#모범 답안 2

def max_log(*args):

#예외처리

if len(args) == 0:

return "입력값이 없습니다"

return max(args, key=len)

max_log()

3. 사용자 정보 출력 함수

사용자의 이름 나이 이메일 등의 정보를 받아 출력하는 함수. 몇 개가 들어오든 모두 출력해야 한다.

def print_info(**kwargs):

for key, value in kwargs.items():

print(f"{key} : {value}")

print_info(name="luna", age = 15 , email="coodingon@gmail.com")

헷갈리는 거: name="luna" 입력 시 key = name 이고 value = "luna"로 알아서 적용되는 거다.

age 정보 넣어도 알아서 반환 되는 걸 보면

키워드 인자는 딕셔너리처럼 받는 형식이니, key = value 인자를 입력한 대로 나오는 거다.

4. 할인 계산기

def print_info(**kwargs):

for key, value in kwargs.items():

print(f"{key} 할인가: {value * 0.9} 정가: {value}")

print_info(item = 12000, item1 = 10000, item2 = 15000)

이것도 딕셔너리 구조처럼 입력하니 잘 나온다. 10% 할인은 0.9를 곱하면 된다.

지역변수와 전역변수

들어가기 전에 파이썬의 메모리 구조부터 쓰자면

스택 영역: 지역 변수( local variable ), 매개 변수( parameter )가 저장되는 곳

힙 영역: 파이썬에서 생성되는 모든 객체 ( 숫자 (parameter) , 문자열 , 등이 리스트 , 저장되는 공간 딕셔너리 , 클래스 인스턴스 등 ) 가 저장되는 공간

이렇게만 봐서는 잘 와닿지 않아 아쉽다.

전역 변수

x = 200

예제

def my_func():

#지역변수

x = 10

print(x)

my_func() # 10

print("함수 밖", x) # 200

지역 변수

x = 200

예제

def my_func2():

#지역변수

x = 20

x += 5

print("지역변수", x)

my_func2() # 25 x가 20으로 바뀌고, 5가 더해졌단 뜻.

print("전역변수", x) #200

예제2

전역변수를 쓸 때 오류. UnboundLocalError, x(전역 변수)를 지역변수로 인지함.

def my_func2():

x = 20

x += 5

print("지역변수", x)

my_func2()

print("전역변수", x)

전역 변수 사용 주의사항

global 키워드 사용 : 함수 내부에서 전역 변수 수정이 필요할 때.

global 키워드 쓰면 전역 변수라고 지정할 수 있지만.

어디서 선언 했는지 파악하기 어렵고, 의도 따라 달리 익히기 때문에 권장하지 않는다.

nonlocal :내부 함수가 외부 함수를 쓰려고 할 때 씀.

전역 변수 관련

예제3

x = 10 #지역변수

def my_func3():

global x #전역변수 사용 선언

x += 5

print("지역", x) #15 지역이 전역으로 바뀌었다.

my_func3()

print("전역", x) #15

권장되는 패턴

부수효가(side effect)을 발생시키지 않는 함수를 위주로 프로그래밍

x = 10

def my_func4(n): #변수명칭(n)이 함수 내부에서 일치해 사용하면 된다.

n += 5

return n

x = my_func4(x)

print("전역", x )

전역, 지역 변수 헷갈리나 실습은 해야한다. 당시에 받았던 실습 문제.

문제: 로그인/로그아웃 전역 상태 관리

이건 문제를 받고 입력했던 코드.

current_user = ""

#로그인, 로그아웃 함수식 만들기

def login(name): #name = 매게 위치 login(A) 쓰면 name = a다.

global current_user #전역변수로 사용.

if current_user == "":

current_user = name

print(f"{name}님 로그인 성공!")

else:

print("이미 로그인 되어 있습니다.")

def logout():

global current_user

if not current_user:

print("로그인 상태 없습니다.")

else:

current_user = ""

print("로그아웃 되었습니다.")

logout()

print(current_user)

어찌저찌 작동은 됐기 때문에...

보여주던 시범 코드 보고 신기해 했던 기억 있다.

#모범 답안

current_user = ""

login_count = 0

def login(name):

global current_user

global login_count

if current_user == None:

current_user = name

print(f"{name}님 로그인 성공!")

else:

print("이미 로그인 되어있습니다.")

login_count += 1

if login_count > 4:

print("더이상 로그인 할 수 없습니다.")

def logout():

global current_user

global login_count

if current_user == None:

print("로그인 상태가 아닙니다.")

else:

print("로그아웃 되었습니다.")

current_user = None

login_count = 0

재귀함수

1 자기 자신을 호출하는 함수

2 반드시 기본 조건 (종료 조건)이 있어야 함.

- 큰 문제를 작은 문제로 나누었을 때 일정한 패턴이 있어야 함.

주의사항까지 있는 이미지.

재귀함수의 장단점

비슷한 역할을 하는 반복문 중, 쓰는 것이 좋은지 알기 위한 비교.

import time

def recursive_func(n):

#기본조건

if n == 0:

return

recursive_func(n-1)

print("재귀 호출" , n)

time.sleep(1)

recursive_func(5)

재귀 함수 진행 과정 설명을 주변에 물어서 들었는데, 대략적인 이해로

recursive_func(5) 는 변수를 5넣은 것이고. 매개변수가 0인지 조건을 확인한다. 0이 아니기 때문에 recursive_func(n-1)로 가고, 그건 5-1로 부른다. 그래서 print("재귀 호출" , n)에 n의 값은 4.

모든 함수는 그 내용이 끝나기 전까지 다음 줄을 호출하지 않으므로 그렇게 작동된다.

매개변수 = 나는 뭐든 된다.

동작 과정(왼쪽 넘버링은 내부적 실행 순서.

실습4

거듭제곱. a**b = a*(a*b-1) 함수 <사실 여기서 수학적 지식 필요한 사실이 괴로웠다...

def func_c (a,b):

if (b == 0): # a 의 b(0승) = 1이란 뜻

return 1

return a * func_c(a, b-1)

# a가 b개 만큼 곱해야 한다. a * a * a*... 1 (=> b = 1)

print("재귀함수", func_c(2,3))

2의 3승 2*2*2*1 b= 3이면 3,2,1,0이 되는 순간까지 포함 총 4개의 곱

그래서 0 되는 걸 1로 조건 거는 것 if (b == 0): 1

실습, 팩토리얼

팩토리얼 : 1부터 지정된 수 까지 모든 수의 곱 수학 기호로 "!" 숫자 뒤에 붙여 표시

3! = 3의 계승 1 2 3 =6

문제를 받아 팩토리얼 계산식 찾고, 당시에 짰던 코드.

N = int(input("팩토리얼 할 숫자: "))

Result = 1

for n in range(1, N+1):

Result *= n

print(Result)

# 1부터 N+1의 값을 반복 생성한다.

# Result은 1에서 시작하고 지정한 값만큼 곱해진다.

# 1 사이클 1*1 / 2사이클 +1*2/ 3사이클 + 1*3 =6

그런데 재귀함수를 배웠다는 걸 그걸 쓰라는 것이니까.

그걸 활용해 짠다면 이런 코드여야 한다.

모범답안

def fact_f(n):

#예외 처리

if n < 0 :

return "음수의 팩토리얼은 정의되지 않습니다."

if n == 0 or n == 1:

return 1

return n * fact_f(n-1)

def m_func(N):

if (N == 0):

return 1

return N * m_func(N-1)

print(m_func(N))

#1*1 + 1*2 + 1*3 = 6

#리턴을 한다. 3이면 3(N)에 2(n-1)호출, 2에서는 1(n-1)호출, 1은 0이되니 1로.

#사이클 도는 것처럼 역순으로 더해져서 3 * 2* 1* 1로 =6이다.

실습, 피보나치 수열

피보나치 수열은? N의 수가 N-1와 N-2를 더한 값.

프로그램 작성 시, 규칙을 찾아서 공통된 코드로 만든다.

def fibonacci_f(n):

if n <= 0:

return 0

elif n == 1:

return 1

a, b = 0, 1

for _ in range(n-1):

a,b = b , a+b

# 0 1 <= 1 1

# 1 1 <= 1 2

# 1 2 <= 2 3

return b

print("파보나치 수열", fibonacci_f(5))

#모범 답안

def fibonacci_R(n):

if n <= 0:

return 0

elif n == 1:

return 1

return fibonacci_R(n-1) + fibonacci_R(n-2)

print(fibonacci_R(6))

답안을 보니 지정한 값에서 -1, -2를 더하는 것이니, 매개변수가 이 조건일때 이걸 출력할지만 검토하고 아니면 return fibonacci_R(n-1) + fibonacci_R(n-2)로 가서 계산하면 그만이었다.

6 넣으면 0과 1이 아니니 5와 3이 더해지는 거다.

람다(lambda) 함수 : 익명 함수

간단한 함수를 한줄로 표현 할 때 사용

예시 함수 코드

일반 함수

def add(x,y):

return x+y

람다 함수

add_func = lambda x, y: x + y

print(add_func(3, 5))

어디든 똑같이 8로 반환된다.

람다 함수는 한 줄로 간단히 축약하고자 할 때 쓰는 것 같다.

람다로 값을 반환하고 사용을 끝내는 경우

print("람다 값 반환", (lambda x: x**2)(10))

lambda x(변수)는 x 제곱이고 그 다음에 x변수를 10으로 넣은 거다.

람다 함수의 활용

1 map 에서 활용

map(function, iterable): iterable의 각 요소에 함수를 적용한 값을 반환한다.

map(함수 명칭, 변수)구조라는 뜻이다.

my_list = [1,2,3,4]

일반 함수

def square_func(x):

return x ** 2

함수를 인자로 받는 함수

print(list(map(square_func, my_list)))

람다 함수

print(list(map(lambda x: x ** 2,my_list)))

[1, 4, 9, 16]로 매개변수(my_list)에 있는 1,2,3,4를 순차 적용해 나온 값이다.

2 filter 에서 활용

filter(function, iterable): iterable의 요소 중 함수의 조건에 맞는 것만 남긴다.

my_list2 = [1,2,3,4,5,6,7,8,9,10]

일반 함수

def is_even(x):

return x % 2 == 0

print(list(filter(is_even, my_list2)))

람다 함수

print(list(filter(lambda x: x % 2 == 0, my_list2)))

return x % 2 == 0의 계산식 넣음.

[2, 4, 6, 8, 10]로 매개변수(my_list2)에 있는 요소 중 충족되는 것만 나온다.

3 sorted 에서 활용

sorted 함수의 key 에는 각 요소에 대해 정렬 기준이 될 값을 반환하는 함수를 넣을 수 있음

my_list3 = ["apple", "banana", "watermelon", "grape"]

print(sorted(my_list3, key= lambda word: len(word)))

#['apple', 'grape', 'banana', 'watermelon'] 요소의 글자 수를 기준으로, 오름차순으로 출력

디버깅이 뭔가요? 컴퓨터 프로그램이나 시스템에서 오류(버그) 찾아내고 수정하는 과정이다.

실습

특정 조건 만족하는 튜플만 추출

students = [

("Alice", [80, 90]),

("Bob", [60, 65]),

("Charlie", [70, 70])

]

평균 점수 70 넘는 학생만 추출.

x = ()

total = 0

def average_70(x):

global students

global total

for name, score in students:

total = sum(students)/len(students)

if total >= 70:

x.append()

return

일반 함수 코드, 외부에 있는 변수를 내부에서 사용하겠다 선언하고 반복문 실행 조건 맞을 시 리스트 추가해서 출력.

print(list(filter(lambda a: sum(a[1] )/ len(a[1]) >= 70 , students)))

#튜플 키워드 a의 v 값을 더하고(sum), v의 개체 수(len)만큼 나누겠다.

#튜플을 리스트로 변환하고, [1]인덱스 값을 쓰겠다.(튜플의 각 요소 2번째 값)

출력, 튜플이 리스트로 변환되어 나왔다.

키워드 추출 리스트 만들기: 맨 앞단어만 출력하기

여기서 str.split () 활용한다. (문자열을 일정한 규칙으로 잘라 리스트로 만든다.)

sentences = [

"Python is fun",

"Lambda functions are powerful",

"Coding is creative"

]

print(list(map(lambda s: s.split()[0],sentences)))

#공백을 기준으로 나누고 리스트의 첫번째 요소만 나열하겠다.

#마지막 위치는 넣어야 할 리스트,튜플 등의 정보

#리스트 변환, 지정값, 계산식, 넣을 정보 흐름.

튜플 리스트 정렬 (나이를 기준으로 오름차순)

people = [("Alice", 30), ("Bob", 25), ("Charlie", 35)]

print(sorted(people, key= lambda age : age[1]))

#key 사용해 기준 정하고 리스트를 정렬함.

#튜플의 1인덱스를 기준으로 나열하겠다.

print(sorted(my_list3, key= lambda word: len(word)))

이런 저런 사용자 지정 함수, 가변 인자, 전역/지역 변수, 재귀 함수, 람다 함수 통째로 묶어 함수라는 카테고리 안에서 작성했다. 각자 의미가 다르고, 구분해서 적절하게 쓰고자 배우다보니 포괄적인 만큼 분량이 꽤 길어졌다.

이 중에서 가장 어려웠던 건 재귀 함수로 꼽고 싶다. 만든 함수를 다른데서 또 불러다 쓰는 건 알겠지만 실행 원리가 헷갈려서 돌려보고, 읽으면서 파악하느라 더 구체적인 것도 크다. 람다 함수는 간단한 산술식으로 쓰는 것이니 내가 연산자/ 명령어를 잘 안다면 그만큼 써먹기 유용하다고 느꼈다.

후기는 이렇게 마무리 됐다. 작성 끝!

[코딩온] 신재생에너지 IoT 개발자 입문_ 파이썬9

혈중당부족 — Sun, 7 Dec 2025 16:34:53 +0900

11. while문

조건이 true 인 동안 코드 반복하는 반복문

조건이 false가 되면 반복을 멈춤

반복 힛수가 정해지지 않았을 때 사용

while 기본 문법

조건 : 참/거짓으로 구분할 수 있는 문장

while 조건:

반복할 코드

블리언 표현식 사용, :과 들여쓰기 무조건 들어간다.

while문은 언제 유용하게 쓰일까, for, range와 다르게 반복 횟수가 필요하지 않고, 조건 기반 루프가 필요할 때.

또는 무한 루프+ 조건 분기 구조에도 쓰인다.(게임 진행, 서버대기와 같은 게 그런 예시다.)

사용할 때 주의 사항은, True 일 때까지 계속 반복시키기 때문에 조건을 누락하면 무한 루프에 빠진다. 그래서 작성 시, 반드시 종료 조건이 있어야 하며 만일 빠지면 'ctrl + c'로 실행 멈춘다.

예제1

light = "green"

while light == "green":

print("계속 가세요")

light = input("신호등의 신호를 입력하세요.(green/yellow/red): ")

print("중지!")

green 제외한 답 나올 때까지 계속 물어봄.

예제 2. 별도의 반복 변수를 정의

i = 0

while i < 5:

print(i,"반복")

i += 1

print("반복 종료")

반복할 때마다 1씩 추가 할당해서 5가 되면 멈춘다.

실습1 조건

1. 변수를 미리 설정.

2. 입력 받는 코드 작성, 입력한 값이 변수와 다를 경우 다시 입력하게 함.

3. 변수를 맞출 시 다른 문구 출력.

secret_code = "coodingonre3"

code = input("비밀 코드를 입력하세요.: ")

while code != secret_code:

print("비밀 코드가 틀렸습니다.")

code = input("비밀 코드를 입력하세요.: ")

print("입장이 허용되었습니다!")

#축약 버전

while code != secret_code:

code = input("비밀 코드를 입력하세요.: ")

print("입장이 허용되었습니다!")

실습 2 조건

업다운 게임, 맞출 때 까지 답을 계속 입력한다.

1. 크면 크다고 출력, 작으면 작다고 출력

2. 맞출 시 입력 횟수를 기입해 맞췄다고 출력.

이건 답안 듣기 전에 다른 분들 코드와 서치 통해 직접 썼던 코드다.

N = int(input("숫자를 정합니다.(1~100): "))

try_count = 0

while True:

A = int(input("답을 정합니다.(1~100): "))

try_count += 1

if A == N:

print(f"{try_count}만에 정답을 맞췄습니다.")

break

elif A < N:

print("입력한 숫자보다는 작아요.")

elif A > N:

print("입력한 숫자보다 커요.")

작성하면서 궁금했던 걸 생각에 써뒀는데 이 둘 정도가 떠올랐다.

- if 에서 true가 될 때를 상정하고 elif는 조건 벗어났을때(false)를 작성하는게 맞는 모양이다.

- true는 왜 붙이는 거지.

true는 지금 보니 논리가 참일 때 실행해라. 로 써두는 게 긴 조건 코드 작성에 유용해 보였다. 여러 조건을 쓰면 while 시작 코드 명을 못 쓸 게 분명하니 여러 조건이 전부 맞을 때, 의도 하고 쓰는 게 아녔을까.

그 후 받은 강사님의 코드는 이랬다.

N = int(input("숫자를 정합니다.(1~100): "))

#import random 코드 쓸 수 있다. 이건 추후에 배울 예정이다.

# N = random.randint(1,100)

#print(N)

A = 0 #사용자 입력 변수

try_count = 0 #횟수 변수

while A != N:

A = int(input("1-100 사이의 수를 정합니다.: "))

try_count += 1

if A > N:

print("입력한 숫자보다는 커요.")

elif A < N:

print("입력한 숫자보다 작아요.")

print(f"{try_count}만에 정답을 맞췄습니다.")

어차피 다음 코드 실행에서 횟수를 끌어 쓰면 되는 거니 while문 안에 꼭 넣을 필요가 없더라. 멈추면 카운트 된 변수가 나올테니까.

while True:를 언제 쓸까 생각하던 중에 정말로 나와버렸다. 이럴 때 루프를 따로 멈춰줄 코드를 써서 조절해야 한다.

루프 제어문 문법

running = True

while running:

if 조건1:

running = False

if 조건2:

running = False

break문

루프 탈출하는 명령어.

while running:

if 조건1:

break

예제1

i = 0

while True:

print(i, "실행")

my_select = input("메뉴를 골라주세요.: ")

if my_select == "종료":

break

i += 1

print("반복문 종료")

실행 결과

continue

이 조건일 때 실행하지 말고, 반복해라 할 때 쓴다.

홀수만 출력하는 코드 구조.

i = 0

while i < 5:

i += 1

if i % 2 == 0:

continue

print(i)

print("반복 종료")

1씩 더하다 짝수가 될때 넘기고, 진행한다.

if - else 구몬처럼 쓰는데 루프 종료 됐을 때 else를 실행한다.

실습

비밀 코드 입력

정답을 입력할 때까지 무한히 반복되며, 정확한 코드를 입력하면 루프를 탈출.

secret_code = "coodingonre3"

while True:

code = input("비밀 코드를 입력하세요.: ")

if code == secret_code:

print("입장 완료!환영합니다.")

break

else:

print("비밀 코드가 틀렸습니다. 다시 시도하세요.")

print("반복 종료")

#유효한 나이만 평균 내기

총 5명의 나이를 입력 받고, 유효한 나이만 평균 내서 출력.

나이 0 이하거나 120 초과일 시 무시하고 계산.

5명이 될 시 루프 종료하고 총합, 평균 출력.

times = 0

sum_age = 0

while True:

age = int(input("나이를 입력하세요: "))

if age <= 0 or age >= 120:

continue

times += 1

sum_age += age

if times == 5:

break

avg = sum_age / times

print(f"총 나이 합계는 {sum_age}, 평균은 {avg} 입니다.")

- 후에 받은 모범 코드.

while times < 5:

age = int(input("나이를 입력하세요: "))

#나이가 0이하 또는 120 초과면 건너 뜀.

if age <= 0 or age >= 120:

continue

# 정상 입력 시 코드.

times += 1

sum_age += age

print(f"총 나이 합계는 {sum_age}, 평균은 {int(sum_age / times)} 입니다.")

print에 계산식 가능하니 여기서 바로 해도 되는 거였다.

중첩 while 문

while 문 안에 또 while 문 쓸 수 있다. 반복문 안에서 또 다른 반복이 필요할 때 사용.

예제 코드: 구구단

dan = 2

while dan <= 9:

num = 1

print(f"[ {dan}단 ]")

while num <= 9:

num += 1

if num % 2 != 0:

continue #면 짝수 곱하기로 나오고 break 하면 해당 수만 하고 멈춤.

else:

print(f"{dan} X {num} = {dan * num}")

num += 1

print()

dan += 1 #바깥 루프 조건 갱신

실습 예제: 로그인 시스템 구현

- 조건과 구조.

ID, 비밀번호 세팅

잘못 입력시 존재하지 않습니다 출력, 아이디 맞으면 비밀번호 입력.

실패시 비밀번호 틀렸다는 오류 출력 후 재입력.

둘다 맞으면 로그인 성공.

ID = "Re3_1234"

Pass_word = "56789"

while True:

id = input("아이디를 입력하세요: ")

if id == ID:

while True:

password = input("비밀번호를 입력하세요.: ")

if password != Pass_word:

print("비밀번호가 틀렸습니다.")

else:

print("로그인 성공")

break

else:

print("ID가 존재하지 않습니다.")

break

아이디 입력을 성공해야 내부 반복문 비밀번호 구조가 돌아가는 식으로 진행하고자 if 문을 앞서 넣어뒀다. (순차 진행이기 때문에.)

이건 추가 실습 과제로 받았던 문제.

두 화면이 이어지도록 만드는 것이라서 비슷하게 만들고자 짠 코드는 이랬었다.

ID = "abc123"

PW = "7789"

while True:

print ("===로그인 화면===")

In = input("1. 로그인 2. 종료 (1/2) 선택: ")

if In == "1":

id = input("아이디를 입력하세요: ")

pw = input("비밀번호를 입력하세요.: ")

if id != ID or pw != PW:

print("로그인 실패! 다시 시도해주세요.")

continue

else:

print("로그인 성공!")

while True:

print("=== 메뉴 ===")

In_1 = input("1. 정보 보기 2. 설정 3. 로그아웃 (1/2/3): ")

if In_1 == "1":

print("회원 정보 입니다.")

elif In_1 == "2":

print("설정 메뉴 입니다.")

else:

print("로그아웃 합니다.")

break

else:

print("프로그램을 종료합니다.")

break

#후에 받은 코드들

ID = "abc123"

PW = "7789"

#아이디 먼저 검사

while True:

id_input = input("아이디를 입력하세요.: ")

if id_input != ID:

print("ID가 일치하지 않습니다.")

continue

while True:

pw_input = input("비밀번호를 입력하세요.")

if pw_input != PW:

print("비밀번호가 일치하지 않습니다.")

continue

print("로그인 성공")

break

#문제 2

ID = "coodingon"

PW = "abc123"

while True: # 전체 프로그램 반복

print("=== 로그인 화면 ===")

print("1. 로그인")

print("2. 종료")

main_sel = input("선택: ")

if main_sel == "2":

print("프로그램을 종료합니다.")

break

elif main_sel != "1": #만약에 어디에도 해당되지 않는 입력값이 나올 시의 조건문.

print("잘못 선택하셨습니다.\n")

continue

# 로그인

id_input = input("ID : ")

pw_input = input("PW : ")

if id_input != ID or pw_input != PW:

print("로그인 실패! 다시 시도해주세요.\n")

continue

print("로그인 성공!\n")

# 로그인 후 메뉴 화면

while True:

print("=== 메뉴 ===")

print("1. 정보 보기")

print("2. 설정")

print("3. 로그아웃")

print("============")

sel = input("메뉴 선택: ")

if sel == "1":

print("회원 정보입니다.\n")

continue

elif sel == "2":

print("설정 메뉴입니다.\n")

continue

elif sel == "3":

print("로그아웃합니다.\n")

break # 안쪽 while만 끊고 로그인 화면으로

else:

print("잘못 입력하셨습니다.\n") #만약에 어디에도 해당되지 않는 입력값이 나올 시의 조건문.

continue

while문 복습까지 끝냈다. 하고 나니 어떤 구조든 조건이 맞고 실행이 된다면 돌아간다는 걸 새로 알아간 기분이다. 이전에 배운 if문도 섞어서 나오고 비교연산자, 논리연산자 조합으로 식이 진행되는 게 틀이 잡혔으니 자주 써봐야지... 이렇게 while 반복문까지 더해 반복문 구간을 넘어갔다.

이것도 기록 끝.

[코딩온] 신재생에너지 IoT 개발자 입문_ 파이썬8

혈중당부족 — Fri, 5 Dec 2025 17:25:12 +0900

10. for

이터너블(순회 가능한) 요소를 하나씩 꺼내서 실행 블록에 전달하는 반복문

동일한 작업의 반복 실행시켜 가독성과 유지보수를 올리고 자동화, 대량처리에 사용된다.

이렇게 써먹기 위함이다.

리스트로 생성, 반복

fruits = ['apple','banana','cherry']

for fruit in fruits: #fruit = 리스트 안에 있는 개체 명칭 의미

print(f"I like {fruit}")

리스트 요소대로 출력

문자열 반복

my_str = "apple"

for char in my_str:

print(char)

쪼개서 내준다.

문자열은 문자 하나하나가 반복대상인데, 문자열은 순서있는 시퀸스이니 인덱스 접근, 반복문 순회 둘 다 가능하다.

#튜플 반복+ 변수 값 분해

coords = [(1, 2),(10, 15),(-6, 10)]

#언패킹 (X,Y)구조 (구조 분해 가능)

for x,y in coords:

print(f"x 좌표 {x} y 좌표 {y}")

튜플의 경우 구조 분해를 활용해 동시에 여러 값을 unpack 가능

#딕셔너리 반복 -key 순회 : dict 파일에서 한번 복습, 이해하기.

person = {

"name": "kim",

"age": 15,

"address": "seoul"

}

# 기본

for key in person:

print(f"key: {key}, value: {person[key]}")

# value 만 가져오기

for value in person.values():

print(f"value: {value}")

# items 가져오기

for key, value in person.items():

print(f"key: {key}, value: {value}")

딕셔너리 정보를 입력하고, for문으로 나눠서 지정 가능하다. key만 하면 key로 저장된 것만.

딕셔너리{key}는 자료 인덱스 지정처럼 key가 인덱스 좌표로 인지되어 value 값으로 출력되는 거다.

#set 반복

my_set = {1,2,3,4}

for key in my_set:

print(key)

set은 순서 없고, 중복도 없는 자료형이나 반복문이 된다. 단 출력할 때 순서는 예측할 수 없다.

#리스트 값을 두 배로 변환

numbers = [3, 6, 1, 8, 4]

for number in numbers:

print(number * 2)

#모범 답안

이건, 리스트의 2배 결과물을 새 리스트에 저장한다 문제여서 이런 코드를 작성하는 게 모범이라고 써둔 듯 하다.

numbers = [3, 6, 1, 8, 4]

doubled = [] #새 리스트 생성

for number in numbers:

doubled.append(number * 2) #새 리스트에 바뀐 변수값을 넣겠다는 뜻

print(doubled) #[6, 12, 2, 16, 8] 출력

위에 쓴 코드와, 모범답안 코드도 확연히 다르다...

예전에 요소는 하나하나 입력해야 알아듣는다고 했는데 그럴 필요 없다!

#문자열 길이 구해서 새 리스트 만들기

words = ["apple", "banana", "kiwi", "grape"]

for word in words:

length = len(word) #새로운 리스트를 생성해서 저건 word(변수)의 길이값이다 함.

print(length)

문자열의 개수를 각각 세주고 있다.

# 좌표 튜플에서 x, y 좌표나누기

#이 문제 읽고 만들었던 코드는 이랬고.

coordinates = [(1, 2), (3, 4), (5, 6), (7, 8)]

for x_values,y_values in coordinates:

print(f"x 좌표 {x_values} y 좌표 {y_values}")

#모범답안은 달랐는데 해당 리스트 만들어서 추가해 출력으로 봐야 하나보다.

coordinates = [(1, 2), (3, 4), (5, 6), (7, 8)]

x_values = []

y_values = []

for x, y in coordinates:

x_values.append(x)

y_values.append(y)

print(x_values, y_values)

리스트에 저장된 것만 출력하면 되니 요소만 나왔다.

for 문과 range()

range 함수 : 지정된 범위의 정수 시퀀스 생성

기본 문법

range(start,end,step)

start: 생략 가능, 기본 0 / end: end -1까지 생성 / step: 생략 가능 기본 값 1

for i in range(1,5):

print(i)

#동일한 맥락이다.

for i in [1,2,3,4]:

print(i)

둘 다 똑같이 작동한다.

#start 생략

for i in range(11):

print(i)

0-10까지 출력

#간격(step) 지정

for i in range(0,11,2):

print(i)

0 2 4 6 8... 출력

for i in range(11,0,-2):

print(i)

11 9 7 ... 출력. 음수로 지정하면 역순으로 출력한다.

이제 이를 활용한 실습 코드.

실습 1 입력받은 수의 합 구하기

num = int(input("수 입력: ")) #먼저 사용자가 입력할 값 구한다.

num_total = 0

for n in range(num + 1):

num_total += n

print(num_total)

1+2+3+4+5 = 15

for i in range(11): 에서 10까지만 출력되는 것처럼 for n in range(6)으로 계산해야 5까지 반복한다.

#구구단 만들기

이건 전체 구구단 만드는 것 (a와 b 범위 지정 곱하기)

for a in range(0,10):

for b in range (1,10):

print(a, '*' , b, '=', a*b)

반복문 만들 때 연습하기 좋은 건 구구단인 모양이다. 반복문 중첩시켜서 만들었는데.

a = int(input("숫자를 입력하세요: ")) #입력 값 만들기

for b in range (1,10):

print(f"{a}, '*' , {b}, '=', {a*b}")

어차피 b는 1-9까지 반복해야 하니까 a값만 지정해주고 b만 반복문 돌리면 원하는 구구단 숫자가 나온다.

산술식도 금방 적용되니까... 당시에 이 생각 못한 걸 보면 많이 버벅인 모양이다.

3의 배수의 합 구하기

total = 0 #현재 총합

for n in range(1,101,3): #1부터 100까지의 3의 배수를 반복

total += n #n에서 3배수로 할당한 값들을 더했다.

print(f"합 {total}")

#이것도 똑같이 작동된다.

for n in range(1,101):

if n % 3 ==0: #3을 나눴을 때 0이 된 값만,조건문

total += n

#짝수이면서 5의 배수인 수 출력

C = int(input("숫자를 입력하세요: "))

for c in range(0,C+1,5):

print(c)

#실습 후 보여준 답안

for c in range(0,C+1):

if c % 2 == 0 and n % 5 == 0: #짝수이면서 5배수란 조건을 빼먹었다...

print(c)

루프 제어문

특정 조건 하에서 작동하도록 구현

#break : 반복문 즉시 중단

for i in range(10):

if i == 5:

break

print(i)

print("반복 종료1")

stop-1까지 출력이니 4까지만 나온다.

#continue : 현재 반복을 넘어감, 다음 반복으로 실행한다.

for i in range(5):

if i == 2:

print("건너뜀")

continue

print(i)

print("반복 종료2")

if가 2되니 건너뜀을 출력하고, 컨티뉴가 다시 반복시켰다.

#pass

for i in range(10):

pass

일단 할당되지 않았으니 넘어간단 명령어다.

for - else 구문

반복이 정상적으로 모두 수행된 경우 else 블록을 실행한다.

for i in range(5): #5면 4까지만 출력한단 뜻

if i == 2:

break

print(i)

else:

print("반복 종료3")

여기서 이렇게 짜면 2에서 브레이크 걸려 멈춘 거기에 else까지 가지 않는다.

중첩 for 문

하나의 for 문 안에 다른 for 문이 들어있는 구조

#이중 for문

for i in range(5):

for j in range(5):

print("i,j", i , j)

print()

안쪽에서 돌리고, 바깥이 횟수 올라가는 식으로 전개된다.

#실습

구구단만들기 for문 중첩 활용해서.

for a in range(2,10):

print(f"{a}단")

for b in range (1,10):

print(a, 'x' , b, '=', a*b)

#또는 print(f"{a} x {b} = {a*b}")

# 중첩 for 문 별 찍기

a = int(input("몇 줄?: "))

#for n in range(0,a):

# print("*" * (n+1)) #별표를 n+1값 만큼 곱한 걸 출력한다.

for i in range(1,a+1):

for j in range(i):

print("*", end ="")

#중앙 정렬

a = int(input("몇 줄?: "))

for n in range(a):

print(" " * ((a - 1) - n), end = "") #공백의 수를 ((10-1)-1(시작 수)) 만큼 만든다.

print('*' * (2 * n + 1)) #*을 (a의 시작수+1의 2배) 만큼 곱한다

#역삼각형은?

a = int(input("몇 줄?: "))

for n in range(a):

print(" " * (a - (n+1)), end="")

print('*' * (n+1))

#a값을 지정하고, a=10 - (n+1)=a의 시작점+1 만큼의 여백을 만든다.

#공백을 줄바꿈으로 정리

for i in range(1,a+1):

#공백 출력

for j in range(a-i):

print(" ", end="")

for j in range(i):

print("*",end="")

print()

#받은 답안 비교용 원본

# 오른쪽 정렬

n = int(input("몇 줄?:"))

for i in range(1, n+1):

for j in range(n - i):

print(" ", end="")

for j in range(i):

print("*", end="")

print()

리스트 컴프리헨션

for 문을 리스트에 한 줄로 축약하여 새 리스트를 생성하는 문법

[표현식(리스트의 원소) for 변수 in 반복대상 if 조건문] <= if 조건문 없어도 괜찮다.

표현식 : 값을 유도하는 식(표현)

for문 이용

squares = []

for x in range(1,6):

squares.append(x ** 2)

print(squares)

출력 값

리스트컴프리헨션 사용 시

squares2 = [x ** 2 for x in range(1,6)]

print(squares2)

리스트 명 = 컴프리헨션 문법 적용. 구조다.

아직 미숙한 내게 컴프리헨션은 쓰일 일이 적을 듯 하다.

# 실습

1부터1 0까지의숫자에 대해, 각 수의 제곱값을 요소로 갖는 리스트를 리스트 컴프리헨션

cphs = [n ** 2 for n in range (1,11)]

print("답",cphs)

n을 **(제곱)할때 n의 값 1-10까지 반복해서 출력 느낌이다. 산술 기호를 정확히 기억하고 있어야 헷갈리지 않는 문제다.

3의 배수만 출력하는 컴프리헨션은

cphs2 = [x for x in range(0,51) if x % 3 == 0]

#앞의 표현식은 변수값(x)만 두고 없어도 딘다.

# x % 3 == 0 < 3으로 나눴을때 0이 된다 = 3의 배수다.

print(cphs2)

출력 값

문자열 리스트에서 길이가 5이상인 값만 출력하는 컴프리헨션

fruits = ["apple", "fig", "banana", "plum", "cherry", "pear", "orange"]

cphs3 = [f for f in fruits if len(f) >= 5]

#변수 f만 나오게, fruits 중의 f(변수)가 글자수(len) 5보다 같거나 크게란 뜻

print(cphs3)

반복 실행할 때 글자수가 5이상인 (if len(f)>=5) 것을 기준으로 f변수만 나오게 해라. 그런 축약인데 헤맸다.

for문은 함수에서 자주 사용되고 여러 조건문을 반복 처리하기 위해 쓰이기도 하니 꽤 눈에 보이는데, 이때는 for 문을 이해했지만 문제 읽고 어캐 써야 할지 모르겠어의 연속이었다. 그래서 질문하고, 코드가 이리 진행된다고 자판 두드렸던 기억이 났다. 이제 반복문을 백업 했으니 이만 마무리 하겠다.

[코딩온] 신재생에너지 IoT 개발자 입문_ 파이썬7

혈중당부족 — Wed, 3 Dec 2025 17:24:09 +0900

9.if

슬슬 와버렸다... 조건, 함수, 클래스까지 가기 위해 문법 익히는 구간이다. 시작에 앞서 자주 쓰이고 헷갈릴 수 있으니 자료 올려둔다.

조건식 평가 순서는 왼쪽에서 오른쪽으로 순차 계산하되, 단축 평가를 쓴다.

and 앞의 조건이 거짓이면 뒤는 안 보고, or은 앞 조건이 참이면 뒤를 안 본다. 빠른 연산을 위한 구조 같다.

조건문

조건에 따라서 프로그램의 실행 흐름을 분기시키는 제어문

조건: 참/거짓 구분할 수 있는 문장

프로그램의 로직을 분기별로 처리하고 효율성과 논리를 챙기고자 생긴 게 조건문이고 상황따라 여러개 쓰이나 기본은 if부터다.

조건문 기초 문법

if + 조건식: > 조건이 참이면 실행

조건식은 특정한 코드블록을 말한다. 끝에 무조건 : 붙이고, 들여쓰기로 띄워서 코드 작성해야 된다.

콜론(:)은 코드 시작을 알리기도 하고, 파이썬에서 조건문 , 반복문 , 함수 정의 , 클래스 정의 등 블록 구조에서 무조건 : 이 와야 실행된다. 안되면 SyntaxError 뜬다.

들여쓰기는 이 코드가 같은 그룹에 속한다는 걸 구분하기 위해 사용하며 쓰나 안쓰나에 따라 그룹이 묶여서 정렬이 중요하다.

공백 4칸 = Tab 한 번 으로 구분하고, 한 블록 내에서 일관성 있게 써야한다. 보통은 tab 횟수 차이로 구분하는 편.

조건문 썼는데 코드 블록이 없다면? : pass 써둬서 이걸 넘긴다고 명령어 실행시킨다. (일단 아무것도 안 하겠다.)

들여쓰기 오류

if a > 10:

print("a는 10보다 커요") #IndentationError 뜸

if a > 100:

pass

> IndentationError 떠서 pass 붙이면 안 뜸.

#실습1

날씨 = input("오늘의 날씨를 입력하세요.(비/맑음): ")

if 날씨 == "비":

print("우산을 챙기세요!") #명령어에서 언어는 "" 표시를 해야 인식되는 듯 하다.

if 날씨 == "맑음":

print("선크림을 바르세요!")

그 다음 구조로

if + else 문

조건이 참일 때는 if 문, 조건이 거짓일 때는 else문을 실행

else > ~아니라면 의 의미라서 조건 필요 X 대신 if문과 같이 나와야 한다.

a = int(input())

if a > 10:

print("a는 10보다 커요.")

else:

print("a는 10보다 작아요.")

else는 if의 조건식이 False일때 실행된다. (a가 10초과면 if로, 미만이면 else 실행)

#실습2 예제도 이랬다.

정수 = int(input("정수를 입력해주세요.: "))

계산 = 정수 % 2

if 계산 == 0:

print("짝수입니다.")

else:

print("홀수입니다.")

(정수)입력하고 계산은 이를 실행. if는 그 계산의 값을 보고 판단한다. 흐름이다. (위에서 아래로 순차 실행)

주의사항

else는 조건식을 쓸 수 없다. else: 로 끝맺기에 모든 조건이 다 F일때 마무리로 이걸 내라 느낌으로 짜야한다.

이것도 들여쓰기가 잘못되면 인식 못하기에 빼먹으면 안된다.

if - elif - else 구문

elif: else if의 약자

elif 에서 조건을 반드시 기록

if 가 있어야 사용 가능

복수의 조건을 순차적으로 검사하여 True인 조건만 실행할 때 쓴다.

맨 처음 True만 실행하고 그 이후 조건은 검사하지 않고 모든 조건이 거짓일때 else가 출력되는 형식이다.

문법 주의할 점

- elif는 여러 번 쓸 수 있으나 else는 한번 만 가능.

- else는 무조건 마지막에 위치.

- elif 또는 else 없이 if만 사용가능하다는 건 나머지 둘은 if가 있어야 된다는 맥락이다.

문법 활용한 코드 예제.

score = int(input())

if score >= 90:

print("A")

elif score >= 80:

print("B")

elif score >= 70:

print("C")

elif score >= 60:

print("D")

else:

print("F")

여기서 70 코드가 위로 올라갔다면 점수 80 입력시 2번째 줄 70 코드가 실행되어 "C"로 나오고 아래는 무시된다.

이것도 조건을 순차적으로 정렬해 써야 한다는 뜻이다.

그러면 if를 여러번 써도 작동되는데 문법이 있는 건, 어떤 경우에 쓰고 실행되는 식일까... 지금 배우는 과정에서 if를 여러번 쓰지 않고 문법을 활용하는 게 많아서 잘 모르는 데 차이가 있긴 하다. 나중에 능숙해지면 다를지도.

if 활용할 때 만든 실습 예제 중 잘 몰라서 설명 들었던 것 중 하나.

실습4: 초를 입력하면 시, 분, 초로 나누어 알려주는 프로그램

hour, minute, second = 0, 0, 0

time = int(input())

#60s = 1m, 60m =1h

minute = time // 60 # 60으로 나누고 남은 몫

second = time % 60 # 나누고 남은 나머지

hour = minute // 60 # 분에서 60으로 나누고 나온 몫

minute %= 60 # 60나누고 나머지 값

if hour > 0:

print(f"{hour}시간{minute}분 {second}초")

elif minute > 0:

print(f"{minute}분 {second}초")

else:

print(f"{second}초")

실행 값

중첩 조건문 (Nested if)

하나의 if문 안에 또다른 if문을 작성한다.

username = input("관리자 아이디를 입력하세요.: ")

password = input("비밀번호를 입력하세요.: ")

if username == "admin":

if password == "abcd":

print("관리자 로그인 성공")

else:

print("비밀번호가 틀렸습니다.")

else:

print("존재하지 않는 사용자입니다.")

유저 아이디 맞는데 번호에서 틀려 if 내부 else가 출력됐다.

if 안에 if 내용을 넣는. 폴더 안에 폴더 같은 구조가 되는 모양이다.

여러 코드 쓰다보면 들여쓰기를 잘하라는 게 이런 이유일 것이다...

여기서부터 실습 문제가 조건이 생기고 그 형태로 만들라는 게 시작하는데 버벅이기 시작했다. 코드를 보고 이런 답이겠구나 파악할 수 있지만 그런 문제를 만들라고 해서 그런지 헤맨 편이다.

이와 같은 코드도.

받았던 실습 문제다.

직접 풀지 못해 정해진 과정 메모.

상수로 정보 기입할 때 보통 대문자를 쓴다. 값이 변하지 않는 정보라는 의미로.

먼저 금액을 입력 받습니다.

김밥 = "김밥"

삼김 = "삼각김밥"

도시락 = "도시락"

a_price, b_price, c_price = 2500, 1500, 4000

#사용자가 어떤 식의 입력을 할 지 모르니 오류, 중복을 줄이고자 가독성 신경 써서 짠다고 함.

주문 = input("무엇을 주문하겠습니까?(김밥/ 삼각김밥/도시락): ")

금액 = int(input("금액을 입력하세요.: "))

if 주문 == 김밥:

if 금액 >= a_price:

print(f"{김밥}을 구매했습니다.")

else:

print("금액이 부족합니다.")

elif 주문 == 삼김:

if 금액 >= b_price:

print(f"{삼각김밥}을 구매했습니다.")

else:

print("금액이 부족합니다.")

elif 주문 == 도시락:

if 금액 >= c_price:

print(f"{도시락}을 구매했습니다.")

else:

print("금액이 부족합니다.")

else:

print("입력이 잘못됐습니다.")

윗 조건이 결정되면(주문) 아랫 조건도 결정된다.(금액)

그래서 if 안에 if 중첩문을 쓰고, 첫 주문에서 정해진 것에 따라 대조해서 실행하는 건데

메뉴와 가격은 고정된 값이며 딕셔너리가 짝을 이루는 값이니, 저 형태를 딕셔너리 형태로 묶어도 된다.

# 2) 딕셔너리 활용한 코드.

가격 = {

"김밥" : 2500,

"삼각김밥" : 1500,

"도시락": 4000

}

주문 = input("무엇을 주문하겠습니까?(김밥/ 삼각김밥/도시락): ")

금액 = int(input("금액을 입력하세요.: "))

#딕셔너리에 밸류에 접근하는 방법 N.get 또는 [딕셔너리]

if 주문 in 가격:

if 금액 >= 가격[주문]:

print(f"{주문}을 구매했습니다.")

else:

print("금액이 부족합니다.")

else:

print("입력이 잘못됐습니다.")

그러면 이렇게 간결해진다. 이건 N.get 쓰거나 키 입력해서 밸류 불러오는 식으로 하는 모양이다...

if가 간단하고 조건문의 기초라서 쉽다 여기면서도 반복, 함수가 섞이면 튀어나오고, 잊어먹고 하다보니 이해가 되더라도 한번 더 복습 실행했다. 자료형 정리할 때는 이해하고 구분한다고 애먹었는데 문법은 조금 재밌게 와닿아서 조금씩 코드 문제를 풀어봐도 될 거 같다. 일단 여기까지 작성 끝