blue_cherry.log

미드프로젝트 관련 : 회귀분석, One-Hot Encoding 이용한 상관분석

Thu, 29 May 2025 18:52:45 GMT

휘발되기 전에 두서없이 적어보는 개념, 이해한 바 정리

회귀분석이란?

한 개 이상의 독립변수(X)가 종속변수(Y)에 어떤 영향을 미치는지를 분석하는 통계 기법
두 변수 사이의 관계를 함수로 해석하는 것
원인과 결과 간의 관계를 수학적 모델로 설명하려는 것

회귀분석 종류

종류	설명
단순 선형 회귀	독립변수 1개, 종속변수 1개
다중 선형 회귀	독립변수 여러 개, 종속변수 1개
로지스틱 회귀	종속변수가 범주형일 때 사용 (0 또는 1 같은 분류 문제)
릿지, 라쏘 회귀	다중공선성 해결을 위한 정규화 회귀

내가 분석하고 싶은 건 boolean 데이터들
부가서비스 사용 True / False
이탈여부 True / False
의 분석
-> 연속형이 아니었고, 이진데이터라서 로지스틱 회귀로 분석

개념은 어려울지 몰라도 코드로는 쉽게 할 수 있는 느낌 boolean을 int로 바꿔서 1, 0으로 변경하고

독립변수, 종속변수 할당해서 모델 생성

해석은 마찬가지로 p-value 값이 0.05보다 작으면 유의미한 것으로 간주

의문점 내가 아는 방식 중에서는 카이스퀘어 독립성 검정이 연관성이 있는지 확인하는 검정인데 어떤 경웨 로지스틱 회귀를, 어떤 때에 카이제곱 검정을 쓰는가? 위의 미드프로젝트 사례에서는 어떤 것을 쓰는 게 맞는가?

항목	로지스틱 회귀	카이제곱 검정 (χ²)
목적	원인 변수(X)가 결과(Y)에 영향을 미치는지 분석 (인과 관계 추정)	두 범주형 변수 간에 연관성(상관성)이 있는지 확인 (관련성 유무 판단)
입력 변수	독립변수: 범주형 또는 수치형 / 종속변수: 이진형(True/False)	두 변수 모두 범주형 (2×2 교차표 또는 더 큰 표)
출력	회귀계수(coef), p값, 예측 확률 등 → 예측모델 생성 가능	p값 하나 → 연관성 있음/없음만 판단
해석	계수가 양수/음수인지로 영향 방향 판단 (예: 가입하면 이탈률이 줄어든다)	오직 연관이 있는지만 알려줌 (방향·영향력은 알 수 없음)
예측 가능 여부	O (새로운 데이터 예측 가능)	X (단지 관계만 평가함)
사용 예	"기기보호서비스가 이탈을 줄이는 데 영향을 주는가?"	"기기보호서비스와 이탈 여부는 관련이 있는가?"

gpt피셜

예측모델 생성을 통한 예측이 가능한지, p값 하나로 연관성만 평가하는지 가 메인인 느낌이고 아무래도 머신러닝과 통계적 기법이라는 방식의 차이 카이제곱 검정으로 관련성 확인 후, 로지스틱 회귀로 영향성과 방향 파악하는 등 함께 쓰이기도 한다고 함 우리는 분석 정도의 과제이기 때문에 통계로 연관성만 봐도 될 것이라 추측

보조강사님의 조언

머신러닝을 이용한 분석은 프로젝트 이후, 제대로 배우고 나서 하는 것이 좋아 보임. 아직은 시기상조
통계의 경우 ~~검정은 안 나가긴 했지만~~ 정규 시간에 배운 범위에 있으므로 카이제곱검정까지만 접근하는 게 맞는 듯 → 상관계수 높은 값 먼저, 배경지식상 왜 관련이 없지? 싶은 것들
get_dummies 이용해서 이탈 안 하는 변수의 조건, 하는 조건, 상관없어 보이는 조건
(캐글의 다른 이들의 분석 참조하기 : 다른 시선으로 볼 수 있음)
(GitHub 사용해 보기)

카이제곱 독립성 검정

(출처: ㅇㅅㅈ 멘토님 특강)

정의 : 두 범주형 변수 사이에 연관성(독립성 여부)이 있는지 확인하는 검정
조건 : 범주형 X 범주형 데이터 (교차표 형태)
예시
→ 성별과 과목 선호가 관계가 있는가?
→ 흡연 여부와 질병 발병이 관련 있는가?
해석
- p-value < 0.05 → 두 변수는 관련 있음 → H₀ 기각
- p-value ≥ 0.05 → 두 변수는 독립임 → H₀ 유지

분석 절차

1. One-Hot Encoding

범주형 데이터를 숫자 벡터로 변환하는 인코딩 기법
각 범주를 이진 변수인 1, 0으로 나타냄
고유값에 해당하는 컬럼에만 1, 나머지는 0
pd.get_dummies()
- pandas에서 범주형 데이터를 이진(0/1) 변수들로 바꾸는 함수
주의점 : 다중공선성 문제 다중공선성 : 통계학의 회귀분석에서 독립변수들 간에 강한 상관관가 나타나는 문제 성별이라는 변수에 "남자", "여자"가 있다면

성별_남자	성별_여자
1	0

두 열은 완전히 종속적 따라서 열 하나를 제거해서

성별_여자
1
만 남기면 불필요한 중복 제거

drop_first=True로 열 한 개 제거

현재 하나의 범주가 아닌 여러 범주를 한 번에 상관계수를 구하려고 변환하였음.
회귀 분석이 아닌 탐색적 분석만을 위한 One-Hot-Encoding이었고,
추후 카이제곱 독립성 검정을 시행할 것이므로 범주마다 열 하나씩 제외하는 것보다는 그대로 두는 것 선택

주의점 : 차원의 저주
- 데이터의 차원이 증가할수록, 데이터가 희소해지고 모델의 성능이 저하되는 현상

boolean 이외 범주형 데이터는 최대 4개의 unique 값을 가짐. → 해당 없음

2. 상관계수 행렬

2차원 행렬로, 각 변수(열) 간의 상관계수를 보여줌
.corr()
- pandas의 DF 메서드로, column간의 상관계수(피어슨 상관계수)를 계산해주는 함수
주의점
- 피어슨 상관계수는 '선형 상관성'을 측정 (선형 관계 가정)
- Boolean 값의 경우 1, 0뿐이므로 패턴이 우연히 겹칠 수 있음

카이제곱 독립성 검정을 통해 두 변수의 연관성 검정

3. 히트맵

행렬 형태의 데이터를 색상으로 시각화한 그래프
상관계수 행렬을 히트맵으로 표현

4. 카이제곱 검정

|상관계수| > 3 인 쌍들 대상으로 카이제곱 검정
```
from scipy.stats import chi2_contingency
```

상관계수 절댓값 기준 필터링

threshold = 0.3 corr_filtered = corr_matrix[(corr_matrix.abs() > threshold) & (corr_matrix.abs() < 1)]

중복 제거

import numpy as np checked_pairs = set()

for col in corr_filtered.columns: for row in corr_filtered.index: if not np.isnan(corr_filtered.loc[row, col]): pair = tuple(sorted([row, col])) if row != col and pair not in checked_pairs: checked_pairs.add(pair)

            # 카이제곱 검정
            contingency = pd.crosstab(df_encoded[row], df_encoded[col])
            chi2, p, dof, expected = chi2_contingency(contingency)

            print(f"[{row} vs {col}]")
            print(f"카이제곱 통계량: {chi2:.2f}, p-value: {p:.4f}")
            if p < 0.05:
                print("→ 유의미한 연관성 있음 (독립 아님)\n")
            else:
                print("→ 통계적으로 독립 (연관성 없음)\n")

``` 한 번에도 할 수 있는데 하나씩 할 생각했네 역시 머리가 나쁘면 고생...

느낀 점 우리 조가 중하는 가고 있다고 생각했는데, 다른 조들은 엄청나게 앞서 가고 있었음...어리석음에 반성 문서화, 구조화하는 능력이 확실히 부족한 듯. 확실히 이 부분은 개선 필요 O ~~느낀 점 2~~ ~~아이고 내 시간~~

[멋쟁이사자처럼 데이터분석] 파이썬 실습

Wed, 09 Apr 2025 09:16:44 GMT

Notion에서 정리한 내용을 공유용으로 옮긴 내용입니다. 양식과 구성의 어색함이 있을 수 있습니다.

04/09(수) 학습내용을 바탕으로 업로드하였음

코드라이언 LMS에 따라 실습한 내용입니다.

메뉴 자판기 만들기

이론

메뉴 랜덤 출력

import random

print(random.choice(["된장찌개", "피자", "제육볶음"]))

random.choice : 리스트, 튜플, 문자열(”abcde”면 random으로 “d” 나옴)에서 랜덤으로 값을 하나 추출

반복 : for 문

import random

# list
menu = ["된장찌개", "피자", "치킨","떡볶이", "라면"]
# 30번 반복
for _ in range(30) :
    print(random.choice(menu))
    # print("이 문장도 반복되는가?")

반복 : while 문

import random
import time

menu = ["된장찌개", "피자", "치킨","떡볶이", "라면"]
# 30번 반복
while True:
    print(random.choice(menu))
    # break   # break 위치 학습
    print("이 문장도 반복되는가?")
    time.sleep(1)
    break

무한히 반복되지 않게 주의
while True: 형태라면 break 필요

변수

이해
- 정리 상자에서 티셔츠를 가져다 줘, 라고 친구에게 부탁한다면? → 티셔츠 상자 안에 있는 티셔츠를 하나 꺼내서 줌 → ‘티셔츠’ 이름표를 가져다 주는 게 아님

import random

lunch = random.choice(["된장찌개", "피자", "제육볶음"])
lunch = "냉장고"
# 변수 덮어씌워짐. lunch 는 그저 문자열 "냉장고"
# 이제 위의 list 불러올 수 없음

dinner = random.choice(["김밥", "쫄면", "돈까스"])

print(lunch)

lunch를 프린트하면 lunch가 나오는 게 아닌 그 안에 있는 “피자”가 나옴

이름표 = lunch = 변수

Dictionary

도입
- 조립식 약통

그림출처 : 멋쟁이사자처럼 / CODELION

약이 많다면 이런 식으로 각각 요일로 구분된 약통에 약을 미리 담아 놓고 먹기도 함
```
  - 월요일 : 주황색 알약 한 개
  - 화요일 : 초록색 알약 한 개
  - 수요일 :  작은 알약 각각 한 개
```
- '월요일' 또는 '초록색 알약 한 개' 만으로는 의미가 없음. 두 개가 같이 있어야 의미 완성
딕셔너리 만들기
- 고향은 수원이다.
- 취미는 영화보기이다.
- 좋아하는 음식은 국수이다.

딕셔너리 형태로

  Info1 = {"고향" : "수원", "취미" : "영화보기", "좋아하는 음식" : "국수"}
  print(Info1)

취미가 무엇인지 알고 싶다면?
```
  print(Info1.get("취미"))
```
get( )
- 딕셔너리에서 값을 꺼내되, 에러 없이 None이나 대체값을 줄 수 있는 안전한 메서드
  - dict["키"] 는 키가 없으면 오류 발생(KeyError)
```
info = {"이름": "지민", "나이": 25}

print(info.get("취미"))           # 출력: None (취미가 없으니까!)
print(info.get("취미", "없음"))   # 출력: 없음 (기본값을 설정했으니까!)
```
- “없음”이 기본값 → 원하는 값이 없을 때 대신 사용하는 값
- dict.get(”키”,”기본값”)의 형태로 쓰는 게 좋음
key, value

그림출처 : 멋쟁이사자처럼 / CODELION

List와 Dictionary에 자료 추가/삭제

자료를 저장하는 방법에는 리스트, 딕셔너리가 가장 중요

DIctionary

딕셔너리에 값 추가하기
- dict[”키”] = “값”

info = {"나이": 25}
info["이름"] = "지민"

print(info)
# 출력: {'나이': 25, '이름': '지민'}

수정하는 형식도 마찬가지

딕셔너리에 값 삭제하기

del dict[”키”]

  info = {"이름": "지민", "나이": 25}
  del info["이름"]

  print(info)
  # 출력: {'나이': 25}

없는 키 del 하면 KeyError

dict.clear : 딕셔너리 전체를 싹 비움

  info = {"이름": "지민", "나이": 25}
  info.clear()

  print(info)
  # 출력: {}

information = {"고향":"수원", "취미":"영화관람","좋아하는 음식":"국수"}
foods = ["된장찌개", "피자", "제육볶음"]
print(information.get("취미"))

# 딕셔너리에 값 추가하기
information["특기"] = "피아노"
information["사는곳"] = "서울"

# 딕셔너리에 값 삭제하기
del information["좋아하는 음식"]

# 딕셔너리에 정보 묶음이 몇 개인지
print(information)
print(len(information)) # 3개 + 2개 추가 - 1개 삭제 = 4

# clear
information.clear()
print(information)

영화관람 {'고향': '수원', '취미': '영화관람', '특기': '피아노', '사는곳': '서울'} 4 {}

List

순서 값 (인덱싱)

foods = ["된장찌개", "피자", "제육볶음"]
print(foods[2]) # 출력 : 제육볶음
print(foods[3]) # 에러
print(foods[-2]) # 출력 : 피자

그림출처 : 멋쟁이사자처럼 / CODELION

위와 같은 방법으로 0부터 배정
없는 경우 에러

음수 순서값 : 뒤에서부터 -1, -2, …순으로
리스트에 값 추가 : list.append(”값”)

foods.append("김밥")
print(foods)

# ['된장찌개', '피자', '제육볶음', '김밥']

리스트에 값 삭제 : del list[ 순서값 ]

del foods[-1]
print(foods)

# ['된장찌개', '피자', '제육볶음']

list 뒤 순서 값에는 int, slices만 들어갈 수 있음

반복

단순 range

for x in range(30):
    print(x)
# 0부터 29까지 x 안에 넣어져서 출력

list 반복 1)

foods = ["된장찌개", "피자", "제육볶음"]
for x in range(3):
    print(foods[x])

→ 리스트에 “라면”을 추가하고 싶으면, range값 바꿔 줘야 함 → 리스트 수정될 때마다 range 변경 필요 → 개선 필요

list 반복 2)

for i in foods:
    print(i)

된장찌개 피자 제육볶음

→ 이렇게 하면 list 가 몇 개든 알아서 반복

Dictionary도 유사

information = {"고향":"수원", "취미":"영화관람", "좋아하는 음식":"국수"}
for x, y in information.items():
    print(x)
    print(y)

고향 수원 취미 영화관람 좋아하는 음식 국수

→ DIctionary의 요소 개수가 몇 개든 알아서 반복

집합

순서 없음
중복 없음

menu1 = set(["된장찌개", "피자", "제육볶음"])
menu2 = set(["된장찌개", "떡국", "김밥"])

합집합
- 두 집합의 겹치는 부분 알아서 1번으로 처리

menu3 = menu1 | menu2
print(menu3)

{'떡국', '김밥', '피자', '제육볶음', '된장찌개'}

교집합
- 겹치는 부분만 집합

menu4 = menu1 & menu2
print(menu4)

{'된장찌개'}

차집합

menu5 = menu1 - menu2
print(menu5)

{'피자', '제육볶음'}

if 문

if 문 사용시 들여쓰기 주의
만약 뽑힌 게 제육볶음이면, “곱빼기 주세요”를 출력하자. → if - print

import random

food = random.choice(["된장찌개","피자","제육볶음"])

if(food == "제육볶음"):
    print("곱배기 주세요")
print("종료")

만약 뽑힌 게 제육볶음이면, “곱빼기 주세요”를 출력하자. → if - print

그렇지 않다면 “그냥 주세요”를 출력하자. → else - print

food2 = random.choice(["된장찌개","피자","제육볶음"])

if(food2 == "제육볶음"):
    print("곱배기 주세요")
else:
    print("그냥 주세요")
print("종료")

실습

추가/삭제 기능을 탑재한 메뉴 리스트를 만들어서 그 중에 하나를 뽑아라.
메뉴 리스트를 input받아서 추가 + 반복

# 메뉴 리스트
lunch = ["된장찌개", "피자", "제육볶음", "짜장면"]

# 음식 추가
while True : # 반복해서 추가
    item = input("음식을 추가해 주세요 : ")
    lunch.append(item)
    print(lunch)
    #무한으로 추가됨

특정 조건에서 종료할 수 있도록 변경

# 메뉴 리스트
lunch = ["된장찌개", "피자", "제육볶음", "짜장면"]

# 음식 추가
while True : # 반복해서 추가
    print(lunch)
    item = input("음식을 추가해 주세요 : ")
    if (item == "q"): # q면 중단되고
        break
    else:
        lunch.append(item) # 아니면 계속 반복
print(lunch) # 최종 결과 출력 후 종료

데이터 삭제

차집합 사용해 보기

set_lunch = set(["된장찌개", "피자", "제육볶음", "짜장면"])
item = "짜장면"
print(set_lunch - set([item]))
# 차집합을 하기 위해 item 리스트로 만들어서 set으로 묶어줌 : 3개만 출력
print(set_lunch) # 원래의 set_lunch이므로 4개 출력

차집합은 원래의 set_lunch 에 변화를 주지 않음

본인을 참조? 하여 바꿔 주어야 함

set_lunch = set(["된장찌개", "피자", "제육볶음", "짜장면"])
item = "짜장면"
set_lunch = set_lunch - set([item])
print(set_lunch) # 3개 출력

set_lunch = set_lunch - set([item]) 부분 추가하면 3개로 출력

최종

import random
import time

# 메뉴 리스트
lunch = ["된장찌개", "피자", "제육볶음", "짜장면"]

# 음식 추가
while True : # 반복해서 추가
    print(lunch)
    item = input("음식을 추가해 주세요 : ")
    if (item == "q"): # q면 중단되고
        break
    else:
        lunch.append(item) # 아니면 계속 반복
print(lunch) # 최종 결과 출력 후 종료

set_lunch = set(lunch) # lunch가 집합으로 바뀌어 저장

# food12에서 이어서

# 음식 삭제
while True:
    print(set_lunch)
    item = input("음식을 삭제해 주세요 : ")
    if (item == "q"):
        break
    else:
        set_lunch = set_lunch - set([item]) # 괄호 중요

print(set_lunch, "중에서 선택합니다.")
# print를 ,로 연결하면 한 줄로 쭉 출력할 수 있음
print("5")
time.sleep(1)
print("4")
time.sleep(1)
print("3")
time.sleep(1)
print("2")
time.sleep(1)
print("1")
time.sleep(1)

print(random.choice(list(set_lunch))) # random은 set에서 쓸 수 없음 -> list로

이상형이 뭐예요

함수

이해
- 카페에 가서 돌체 라떼를 시킨다면

그림출처 : 멋쟁이사자처럼 / CODELION

이러한 준비물, 레시피, 주의사항 등이 필요
사람이 하면 실수가 있을 수 있음

but 돌체라떼 기계
- 버튼을 누르면 항상 똑같은 돌체라떼가 나옴 = 함수!

함수의 구조
- def 함수이름(): 함수가 해야 할 내용 1 함수가 해야 할 내용 2 …

그림출처 : 멋쟁이사자처럼 / CODELION

익명 게시판에 질문/답변 형식 만들기
구현 idea1)

그림출처 : 멋쟁이사자처럼 / CODELION

→ 딕셔너리로 구현하자!

{”질문” : “취미는 무엇입니까”, “답변” : “영화 보기입니다”}

{”질문” : “특기는 무엇입니까”, “답변” : “댄스입니다”}

구현 idea2 )

→ 리스트로 하나의 딕셔너리씩 나누기

[

{”질문” : “취미는 무엇입니까”, “답변” : “영화 보기입니다”}

{”질문” : “특기는 무엇입니까”, “답변” : “댄스입니다”}

]

위와 같이 리스트 - 딕셔너리 중첩해서 쓰는 경우 많음

작성 방식

그림출처 : 멋쟁이사자처럼 / CODELION

1번
- list, dictionary 둘 다 사용
- 어느 것이 질문, 어느 것이 답변인지 확실히 알 수 있음
- 코드가 복잡함
2번
- dictionary만 사용
- 작성한 사람만 알 수 있음
- 다른 사람과 협업 어려움
- 코드 간결해짐

서로 데이터 어떻게 저장하는지 방식 비교하며 보기

dictionary만 사용

# 딕셔너리만 사용

total_dictionary = {}

# 질문 q로 중단할 때까지 차례로 입력받음
while True:
    question = input("질문을 입력해주세요 : ")
    if question == "q":
        break
    else:
        total_dictionary[question] = ""
        # question이 total_dictionary에 들어가고 답변은 ""

# 질문 전부 하나씩 출력하면서 답변 적을 것임
for i in total_dictionary:
    print(i)
    answer = input("답변을 입력해 주세요 : ")
    total_dictionary[i] = answer # answer로 받은 답변 딕셔너리에 넣기

print(total_dictionary)

질문을 입력해주세요 : 취미는? 질문을 입력해주세요 : 특기는? 질문을 입력해주세요 : q 취미는? 답변을 입력해 주세요 : 피아노 특기는? 답변을 입력해 주세요 : 줄넘기 {'취미는?': '피아노', '특기는?': '줄넘기'}

key 먼저 넣고, key 하나씩 띄우면서 answer 다시 넣었음

list, dictionary 사용

그림출처 : 멋쟁이사자처럼 / CODELION

질문 부분 구성
- total_list 안에 담음
- else 부분 : 딕셔너리 형태로 리스트에 append

# 리스트 사용
total_lsit = []

# 질문하는 부분
while True:
    question = input("질문을 입력해주세요 : ")
    if question == "q":
        break
    else:
        total_list.append({"질문" : question, "답변" : ""})

답변 부분 구성
- 흰 네모 각각이 딕셔너리
- 답변하는 부분에서 딕셔너리가 통째로 i에 들어감
- 취미는 무엇입니까? 만 출력하려면 i[”질문”] 해야 출력됨

# 리스트 사용
total_list = []

# 질문하는 부분
while True:
    question = input("질문을 입력해주세요 : ")
    if question == "q":
        break
    else:
        total_list.append({"질문" : question, "답변" : ""})

# 답변하는 부분
for i in total_list:
    print(i["질문"])
    answer = input("답변을 입력해주세요 : ")
    i["답변"] = answer
print(total_list)

(전체 코드. #답변하는 부분 추가됨)

질문을 입력해주세요 : 취미는? 질문을 입력해주세요 : 특기는? 질문을 입력해주세요 : q 취미는? 답변을 입력해주세요 : 라면 끓이기 특기는? 답변을 입력해주세요 : 라면 먹기 [{'질문': '취미는?', '답변': '라면 끓이기'}, {'질문': '특기는?', '답변': '라면 먹기'}]

실습하는 내용이 굉장히 기초적인 내용이라 쉽기도 하고 해서 재밌게는 한 듯 일단 객체지향 가지고 뭔가 Class와 함수 만들어서 출력하는 것보다 훨씬 이해하기 편함

하지만 시간 체크가 너무 귀찮게 해...분명 정리하면서 천천히 듣고 점심도 한 20분은 켜놨던 거 같은데 어째서 시간이 이렇게 적게 측정됐냔 말임... 내일은 점심 풀로 켜놔야지ㅠㅠㅠㅠ

객체지향 예제를 일부러 정리 안했는데 오늘 이해해서 정리해보려 했더니😵 챗GPT와 떠든 길이가 장난이 아님 이해는 어찌어찌 된 거 같은데 이걸 말로 풀 자신이 없다...

[멋쟁이사자처럼 데이터분석] 객체지향, 상속, 예외처리, 모듈

Tue, 08 Apr 2025 20:00:15 GMT

Notion에서 정리한 내용을 공유용으로 옮긴 내용입니다. 양식과 구성의 어색함이 있을 수 있습니다.

04/07(월) ~ 04/08(화) 학습내용을 바탕으로 업로드하였음

하루 밀려서 오늘 싹 정리...

객체 지향 프로그래밍

~~이 부분 너무 어려워...나 울어...~~ ~~기존에 문제 풀 때도 헤맸던...영상을 따로 찾아보고 했었는데 또 배워도 모르네~~

객체 지향 프로그래밍이란?
- 객체를 지향하는 프로그래밍 방식
객체의 배경 (방식의 발전?)
변수에서 시작 (v1, v2, v3...)
- 이름만 정해주면 값 저장해 두었다가 이름으로 접근해서 가져오기
- 학생 500명 → 변수가 너무 많아… → 배열 등장
배열/리스트/튜플 (묶어서 [v1, v2, v3...] 한번에 관리)
- 국어, 수학, 등등 점수 배열이 많아짐
- 마찬가지로 관리 귀찮음
딕셔너리
- 학생 한 명을 딕셔너리에 담음
- 그것들을 모아서 리스트로
  
  → 이름을 가지고 관리 이거 괜찮네.
딕셔너리에서 객체로
- 자동차의 이름, 연식 : 자동차의 데이터
- 출력하기 위해 외부에 함수 만듦 자동차의 데이터 전달 → 이 정보를 가지고 외부의 함수에서 출력됨
- 즉, 자동차의 데이터 : 딕셔너리가 가지고 있음 자동차의 데이터 처리 : 다른 함수에 할당되어 있음 *이걸 한 번에 묶어버리자! * → ‘객체’
객체란?
- 자동차
  - 자동차의 요소 : 엔진, 타이어, 등등 + 전진/후진/ 등등 처리하는 기능들
  - 누군가 자동차를 외부에서 밀지 않음 → 전부 자동차 객체에 담겨 있는 것
- 비행기
  - 누군가 날리는 게 아님
  - 스스로 나는 것 ← 스스로 날 수 있는 기능 내장
- 학생
  - 학생 객체 = 데이터 + 데이터에 할당된 기능
  - but 반드시 학생과 관련된 것만 담아야 함
  - 이렇게 만들면 학생 객체만 가져오면 그 안에 있는 데이터와 기능을 다 가져올 수 있음

객체

어떤 개체들을 구성하는 데이터 → 변수
데이터에 있는 값들을 처리하는 기능 → 함수(메서드)
객체는 객체와 관련 있는 데이터(데이터를 담는 변수)

+거기에 담겨있는 변수를 처리하는 기능, 함수(메서드)로 구성
객체를 생성하기 위한 설계도 존재 → Class

클래스

개발자는 class 설계

이거 가지고 객체 만들어줘 요청하면 class 개수만큼의 객체 생성

학생 100개 만들어줘 100번 요청한다면 → 객체 100개

변수 : 각 객체마다 만들어짐
메서드 : 하나만
class : 메모리에 올라감

객체를 아무리 많이 만들어도 변수만 만들어지기 때문에 메모리를 많이 먹지 않음

학생 객체는 각각 독립적 학생 A의 ‘이름’에 김이 들어갔다고 모든 학생의 이름이 김인 건 아님

사람들이 객체 지향에서 가장 어려워하는 것
- 뭘 작성해 줘야 하지 → 설계 어려워함
프로그램 상에서 필요한 기능들 정리하기
각 처리를 위해 필요한 기능 정리
관련 있는 것들 묶기 → 이게 바로 객체 지향
다른 곳에서 쓴다면 밖으로 빼기

클래스

~~시작이다~~

객체를 생성하기 위한 설계도

class TestClass1 :
    pass

객체 생성

# 객체를 생성한다.
t1 = TestClass1()
t2 = TestClass1()
print(t1)
print(t2)

<main.TestClass1 object at 0x0000016871104EC0> <main.TestClass1 object at 0x0000016871104680>

TestClass1 object : TestClass1의 객체이다.
뒤 주소값이 다름 → t1, t2는 다른 객체

# 비교
t3 = t2
print(t2)
print(t3)

<main.TestClass1 object at 0x0000016871104680> <main.TestClass1 object at 0x0000016871104680>

→ t2, t3는 같은 객체

객체에 변수 추가

# 파이썬은 생성한 객체에 변수를 추가하는 것이 가능하다.
t1.a1 = 100
print(t1.a1)

100

객체의 독립성

# 객체에 변수를 추가한다고 하더라도 같은 클래스를 가지고 만든 다른 객체에는 추가되지 않는다.
# 객체는 독립적이기 때문이다.
print(t2.a1)

# 에러!

객체의 멤버

멤버 : 클래스나 객체 안에 들어 있는 것들
멤버 변수 : 객체가 가지고 있는 데이터
멤버 메서드 : 객체가 할 수 있는 동작(함수)

~~# 파이썬은 클래스를 통해 생성되는 객체의 멤버 변수를 정의할 수 없다. 헷갈려서 수정~~
# 파이썬은 클래스 정의 부분에 멤버 변수를 미리 선언하지 않는다.
# 클래스를 통해 객체를 생성하면 아무것도 가지고 있지 않는 텅 비어있는 객체가 생성된다.

# 이 객체에 변수를 추가해 줘야 한다.

class TestClass2 :
    # 생성자
    # self : 생성된 객체의 정보가 담기고 이를 통해 객체에 접근할 수 있다.
    def __init__(self) :
        print('init')
        print(f'self : {self}')
        # 객체가 가지고 있어야 할 변수를 여기에서 추가해준다.
        self.a1 = 100
        self.a2 = 200

생성자

클래스를 통해 객체를 생성할 때 자동으로 호출되는 함수(메서드)
파이썬에서는 클래스를 통해 객체를 생성할 경우 텅 비어있는 객체를 생성하고 생성자를 호출한다.
여기에서 객체에 변수를 추가하는 작업을 하면 클래스를 통해 만들어지는 모든 객체는 동일한 이름의 변수들을 가진 상태에서 사용할 수 있다.
t1과 self의 주소값 같음

t1 = TestClass2() # 객체 생성 : 텅 빈 객체 생성 # -> 무조건 자동으로 __init__ 호출
# 객체의 주소값이 매개변수인 self 로 들어옴
print(f't1 : {t1}')

init
self : <__main__.TestClass2 object at 0x00000168713D40B0> 
t1 : <__main__.TestClass2 object at 0x00000168713D40B0>

주소값, 객체에서 변수 호출해보기

t1 = TestClass2()
print(f't1 : {t1}')
# 객체가 가지고 있는 변수에 접근한다.
print(f't1.a1 : {t1.a1}')
print(f't1.a2 : {t1.a2}')

init
self : <__main__.TestClass2 object at 0x00000168711048C0>
t1 : <__main__.TestClass2 object at 0x00000168711048C0>
t1.a1 : 100
t1.a2 : 200

t2 = TestClass2()
print(f't2 : {t2}')
print(f't2.a1 : {t2.a1}')
print(f't2.a2 : {t2.a2}')

init
self : <__main__.TestClass2 object at 0x00000168713D4AD0>
t2 : <__main__.TestClass2 object at 0x00000168713D4AD0>
t2.a1 : 100
t2.a2 : 200

t1 실행시 self와 t1의 주소값, t2 실행시 self와 t2의 주소값 각각 같음

그러나 t1과 t2의 self의 주소값은 서로 다름 (독립적)

나름대로 이해를 위한 몸부림

파이썬은 클래스 정의시 멤버 변수를 필수로 선언하지 않기 때문에,

__init__이 없는 경우 클래스를 통해 객체를 생성하면 아무 멤버도 없는 텅 빈 객체가 생성됨

# (학습) 텅 빈 객체 만들어짐
class TestClass5:
    pass

t = TestClass5()
print(t.__dict__)  #객체 t가 가진 멤버 변수들을 딕셔너리 형태로 보여줘.

{} 따라서 생성자를 이용해 객체가 생성될 때 객체 내부에 변수를 추가하는 작업을 함

class TestClass2 :
    def __init__(self) :
        print('init')
        print(f'self : {self}')
        self.a1 = 100
        self.a2 = 200

이러한 class가 있으면 객체 생성시 a1, a2라는 멤버 변수를 가진 상태로 생성됨

(’a1’ : 100, ‘a2’ : 200)

t1 = TestClass2()
print(f't1 : {t1}')

실행하면 파이썬이 TestClass2()를 호출하면서 init(self) 함수도 자동으로 호출

생성된 객체의 주소값을 self 자리에 넣음 (init(t1)이 실행되는 것. 일종의 t1 = self 가 됨)

만약 새 객체 t2를 생성한다면, t2의 주소값과 그때 print(f'self : {self}')되는 self의 주소값도 같을 것

~~색깔 넣었다!!! 어휴 내가 파이썬하니 HTML하니~~

- 객체는 서로 독립적

# 같은 클래스로 생성한 객체라고 하더라도 서로 독립적이므로
# 변수의 값이 항상 같지는 않다.
t1.a1 = 1000
print(f't1.a1 : {t1.a1}')
print(f't2.a1 : {t2.a1}')

→ t1.a1 : 1000 t2.a1 : 100

매개변수를 가진 생성자

# 생성자도 함수의 일종이므로 매개변수를 가질 수 있다.
# 단, 첫 번째 매개변수에는 생성된 객체의 주소 값으로 결정되기 때문에
# 두 번째 매개변수부터 값을 결정해 주면 된다. (기본값도 설정할 수 있다.)
class TestClass3 :
    # 생성자
    def __init__(self, v1, v2, v3 = 3) :
        self.a1 = v1
        self.a2 = v2
        self.a3 = v3

첫 번째 매개변수 → 무조건 객체의 주소값(self)이 들어옴

t1 = TestClass3(10, 20, 30)
print(t1.a1, t1.a2, t1.a3)

t2 = TestClass3(10, 20)
print(t2.a1, t2.a2, t2.a3)

→ 10 20 30 10 20 3

메서드

객체를 통해 호출하는 함수들

# 객체를 통해 호출하기 때문에 첫 번째 매개변수에는 객체의 주소값이 들어온다.
# 이를 통해 객체에 접근하여 객체가 가지고 있는 변수를 사용할 수 있다.
class TestClass4 :
    # 생성자
    def __init__(self, a1, a2) :
        self.v1 = a1
        self.v2 = a2

    # 메서드
    # 객체를 통해서 메서드를 호출하면 첫 번째 매개변수에 메서드를 호출하기 위해
    # 사용한 객체의 주소값이 들어온다.
    # 이를 통해 객체에 접근하여 객체의 변수를 사용할 수 있다.
    def test_method(self) :
        print(self.v1)
        print(self.v2)

t1 = TestClass4(10, 20)
t1.test_method()

t2 = TestClass4(100, 200)
t2.test_method()

→ 10 20 100 200

헷갈려서 또 정리
```
  class TestClass4 :
      def __init__(self, a1, a2) :
          self.v1 = a1
          self.v2 = a2
```
위와 같은 클래스 호출할 때
```
  t1 = TestClass4(10, 20)
```
클래스 호출 → __init__이라는 생성자를 호출

self : 이 객체 자신 ( t1 )
```
  TestClass4.__init__(t1, 10, 20)
```
그래서 마치 이렇게 t1이라는 객체가 자동으로 self 자리에 들어가고 10, 20이 a1, a2로 들어가는 것처럼 동작

상속

각각의 특성을 알아보면

강아지
- 다리가 4개
- 꼬리 1개
- 멍멍 짖는다
- 사고친다
- 먹은 사료 개수
구미호
- 다리가 4개
- 꼬리 9개
- 변신한다
- 사고친다
- 먹은 간 개수
class 마다 동일한 기능 있음

→ 동물 class 새로 생성

동물
- 다리 개수
- 꼬리 개수
- 사고친다
그 후 강아지, 구미호 → 동물 상속

상속

클래스가 다른 클래스가 가진 것들을 물려받는 개념
상속 시켜 주는 클래스 : 부모 클래스
상속 받는 클래스 : 자식 클래스
자식 클래스는 부모가 가진 것들을 마치 자기 자신한테 있는 것 처럼 사용할 수 있다.
부모 클래스

class Animal :
    def __init__(self, _type) :
        self.animal_type = _type

    def eat(self) :
        print(f'{self.animal_type}가 사료를 먹습니다')

자식 클래스

class Dog(Animal) :
    def speaking(self) :
        print('멍멍')

class Cat(Animal) :
    def speaking(self) :
        print('냐옹 냐옹')

Animal이 변수 자리에

t1 = Dog('강아지')
print(t1.animal_type)
t1.eat()
t1.speaking()

t2 = Cat('고양이')
t2.eat()
t2.speaking()

강아지
강아지가 사료를 먹습니다
멍멍
고양이가 사료를 먹습니다
냐옹 냐옹

울음소리는 다르지만 먹는 것은 같으므로 애니멀 클래스(부모 클래스)에서 상속

부모 init이 먼저 호출, 그 다음 자식 init이 호출

예외처리

오류 발생 대비하려면
- 발생할 가능성이 높은 것들 목록화
- 실제로 그 작업이 일어나기 전에 먼저 확인하고 그 작업이 일어나지 않도록 중단시킴 → 예외
오류(error) ≠ 예외 (exception)
예외 : 사전에 미리 확인이 가능한 오류
오류 : 실행을 해 봐야 아는 것들
PVM : 오류가 발생할 가능성이 동작할 경우 수행 중단
- 튕기는 이유 : 주로 그 코드가 오류를 발생시킬 가능성이 있어서 virtual machine이 강제 중단 시키는 것
- 개발자는 미리 대처해 놓아서 강제 종료되지 않고 잘 작동되게 함

ex) 키보드 입력받는 것 → 문자열로 받음

문자열 → 숫자로 바꾸는 과정이 있다면
- 100 → 정상으로 바뀜
- 안녕하세요 → 오류 → 강제 종료(튕김)

대응방법

사용자가 정상적으로 입력할 때까지 계속 받기

오류가 발생했거나 오류가 발생될 가능성을 만났을 때 프로그램이 강제 종료되는 것을 막고 돌아가도록 하는 것
다시 정상화하거나 오류 기록 후 종료할 수 있도록 (가장 중요한 건 오류가 나지 않도록 코드를 잘 만드는 것)

발생되는 데이터에 대해서 문제가 있는 데이터를 동작시키기 전에 if 문으로 미리 검사 → 문제가 있으면 return 등을 통해서 돌아가지 않도록 만들기

오류 발생시
- 정상화
- 오류 기록 후 종료
  - 만약 어디까지 했는지 기록하지 않으면 처음부터 해야 함
이런저런 오류들
test 1)

ZeroDivisionError : 파이썬에서 만들어 목록화해놓은 일종의 “Class”

- test 2)

a1 = 10 / 0
print(a1)

print('이 부분이 수행될까요?')

→ 10 / 0 에서 중단 아래 수행은 되지 않음

test 3)

try:
    a1 = 10 / 0
    print(a1)
except :
    print('오류가 발생하였습니다')

print('이 부분이 수행될까요?')

오류가 발생하였습니다
이 부분이 수행될까요?

잘 수행됨

용어

try : 개발자가 작업하고자 하는 코드를 작성하는 부분
except : try 부분에서 예외가 발생하면 try 부분의 수행을 중단하고 except 부분을 수행해 준다.

여기에 정상화를 위한 코드나 오류메시지 기록 등에 관련된 작업을 해준다.
else : try 부분에서 예외가 발생하지 않고 모두 수행되었을 경우 동작하는 부분
finally : try 부분에서 예외 발생 여부와 관계없이 무조건 동작하는 부분이다. (but finally 안 써도 코딩 가능)

진행 구조

예외가 발생하지 않았을 경우 : try 부분을 모두 수행
- else가 있다면 else 부분 수행
- finally가 있다면 finally 부분을 수행
예외가 발생했다면 : try 부분의 수행을 중단
- except 부분을 수행
- finally 부분이 있다면 finally 부분을 수행

- **구조 요약** try, except 는 필수

try
- try에서 아무것도 문제 없으면 else
- try에서 오류 있으면 except
- 둘 중 한 쪽은 무조건 실행
finally (없어도 됨)
구조 1)

try :
    a1 = 10 + 20
    print(a1)
except :
    print('예외가 발생하였습니다')
else :
    print('예외가 발생하지 않았습니다')
finally :
    print('무조건 동작하는 부분입니다')

30
예외가 발생하지 않았습니다
무조건 동작하는 부분입니다

try → else → finally 동작

구조 2)

try :
    a1 = 10 / 0
    print(a1)
except :
    print('예외가 발생하였습니다')
else :
    print('예외가 발생하지 않았습니다')
finally :
    print('무조건 동작하는 부분입니다')

예외가 발생하였습니다
무조건 동작하는 부분입니다

try → except → finally 동작

오류는 하나만 발생한다.
- 오류가 여러 개여도 첫 번째 오류 발생하면 중단
- 따라서 여러 except를 만들어서 구분
- 구분 기준 : 오류 클래스
- 오류가 발생하면 그 클래스에 대한 객체 생성됨
  - except Exception as e: 통해서 객체 받을 수 있음
오류 클래스
- Exception
  - 모든 오류 클래스들은 Exception 상속받음
- ZeroDivisionError
  - 0으로 나누는 에러
- IndexError
  - 순서값 잘못 넣은 에러 (list len이 10인데 a1[20])

모듈

# 모듈
- 파이썬 코드를 작성하는 파일의 확장자는 py이다.
- 이 py 파일이 하나의 모듈이 된다.
- 파이썬 코드를 작성할 때 다른 py 파일에 작성되어 있는 것을
사용할 수 있다.

모듈 생성/작동

모듈 새로 생성 (test_module1)

# test_module1.py

print('test_module.py')
print('안녕하세요')

모듈 작동시켜보기

# test_module1.py 파일의 코드를 "실행"시킨다.
# (다른 언어와 다른 부분)
import test_module1

test_module.py
안녕하세요

이미 import한 모듈을 또 import 하면 아무런 일도 하지 않는다.

import test_module1

→ 출력 아무것도 안 됨

모듈의 변수, 함수, 클래스 사용하기

변수, 함수, 클래스를 가진 모듈 생성 (test_modul2)

# 

test2 = 100

def test2_function() :
    print('test2_function')

class TestClass2 :
    pass

다른 모듈에 있는 변수, 함수, 클래스 사용해 보기
- 기본적으로는 모듈명과 같이 사용해야 함
- 어느 모듈의 것인지 명시
- 다른 모듈에 같은 이름일 경우 구분

import test_module2

print(test_module2.test2)
test_module2.test2_function()
t2 = test_module2.TestClass2()
print(t2)

100
test2_function

모듈명 쉽게 쓰기

쉽게 쓰는 방법
1. (그냥) 생략하기
  - but 동일이름이 다른 모듈에 있을 수 있으니 주의
  - 두 모듈에서의 이름이 같은 경우
    
    modul1의 것은 그냥 쓰고
    
    modul2의 것은 module2.TestClass2( ) 처럼 붙여 쓰기
2. 별칭 사용하기

별칭 사용하기

test_module3 생성

# 

test3 = 300

def test3_function() :
    print('test3_function')

class TestClass3 :
    pass

별칭은 import module as m1 의 형식으로 사용

# 별칭
# 모듈명이 너무 길다고 생각되면 별칭을 사용할 수 있다.
import test_module3 as m3
print(m3.test3)
m3.test3_function()
t3 = m3.TestClass3()
print(t3)

300
test3_function

별칭을 부여해서 import 한 모듈은 모듈명으로는 사용할 수 없고 별칭으로만 사용해야 한다.

print(test_module3.test3)

→ NameError

모듈명 생략 : 부분 생략

test_module4 생성

# 

test4 = 400

def test4_function() :
    print('test4_function')

class TestClass4 :
    pass

모듈명 생략 : 사용하고 싶은 것에 대해서만 지정하기
from 모듈명 import 함수명,변수명,클래스명 등

# 모듈명 생략 - 사용하고 싶은 것에 대해서만 지정하기
# from 모듈명 import 함수명,변수명,클래스명등
from test_module4 import test4
from test_module4 import test4_function, TestClass4

print(test4)
test4_function()
t4 = TestClass4()
print(t4)

400
test4_function

모듈명 생략 : 전체 생략

test_module5 생성

# 

test5 = 500

def test5_function() :
    print('test5_function')

class TestClass5 :
    pass

모듈명 생략 : 전체 모듈명 생략

# 모듈에 있는 모든 요소들을 모듈명 생략하겠다라고 한다.

from test_module5 import *

print(test5)
test5_function()
t5 = TestClass5()
print(t5)

500
test5_function

패키지

py 파일을 가지고 있는 디렉토리(폴더)
패키지 안에 있는 모듈을 사용할 때도 import 필요

패키지 내 모듈 import

test_module6 생성

# 

test6 = 600

def test6_function() :
    print('test6_function')

class TestClass6 :
    pass

패키지 내 모듈 사용시 package1.module1.xxx

# 패키지 내의 모듈을 import 한다.
import package1.test_module6

# 패키지 내의 모듈이 가지고 있는 요소를 사용할 때는 패키지명.모듈명을 해야 한다.
print(package1.test_module6.test6)
package1.test_module6.test6_function()
t6 = package1.test_module6.TestClass6()
print(t6)

600
test6_function

패키지명 생략, 모듈명 명시

test_module7 생성

# 

test7 = 700

def test7_function() :
    print('test7_function')

class TestClass7 :
    pass

패키지명 생략 → 모듈명 명시

# 패키지명을 생략하고 싶다면
# 모듈명은 명시해야 한다.
from package2 import test_module7
print(test_module7.test7)
test_module7.test7_function()
t7 = test_module7.TestClass7()
print(t7)

700
test7_function

패키지명.모듈명 생략

test_module8 생성

# 

test8 = 800

def test8_function() :
    print('test8_function')

class TestClass8 :
    pass

package.module로 패키지명+모듈명 생략

# 패키지명과 모듈명을 생략한다.
from package3.test_module8 import test8, test8_function, TestClass8

print(test8)
test8_function()
t8 = TestClass8()
print(t8)

800
test8_function

모든 모듈의 패키지 생략 (from package import *)

주의
- 패키지 내의 모든 모듈들을 패키지명을 생략하고 사용할 수 있도록 하기 위해 *를 사용하면 __init__ .py 파일에 있는 __all__ 변수에 담긴 리스트를 확인
- 이 리스트에 명시되어 있는 모듈들에 한해서만 패키지명을 생략하고 사용할 수 있음
  - 원래 과거의 파이썬에서는 __init__ .py 파일이 있는 폴더만 패키지로 인식을 하였으나버전이 업데이트 되면서 py만 있으면 패키지로 인식
  - but * 를 통해 패키지명을 생락하고 싶은 모듈을 지정할 때는 __init__ .py 파일을 만들고 __all__ 변수에 모듈명이나 하위 패키지명을 문자열로 넣어 줘야 함

__init__ .py 없을 때

from package4 import *

print(test_module9.test9)
print(test_module10.test10)

→ NameError

package 내에

__init__ .py 파일 생성

  # * 를 통해 패키지명을 생략하고 사용할 수 있도록 허용해주고 싶은 모듈이나 하위 패키지명을
  # 리스트에 문자열로 작성해준다.
  __all__ = ['test_module9', 'test_module10']

test_module9 생성

  

  test9 = 900

  def test9_function() :
      print('test9_function')

  class TestClass9 :
      pass

test_module10 생성

  

  test10 = 1000

  def test10_function() :
      print('test10_function')

  class TestClass10 :
      pass

실행시키면 잘 작동한다.

from package4 import *

print(test_module9.test9)
print(test_module10.test10)

900
1000

진짜 끝

노션에서는 토글로 접어서 내보냈는데 다 들어갔네... 오래 전부터 필기에서 초록색으로 내 생각, 모르겠는 부분, 사족 적는 데 쓰는데 객체지향 부분 노션 페이지는 진짜 한 20~30%가 초록색ㅋㅋㅋ 이제 이해될 거 같긴 한데 또 실전 만나면 모르겠네

일단은 GPT가 많이 발전해서 다행이라는 생각만 드는 중

와 5시! 디코에 아무도 없음 ~~당연하지~~ 노는 시간이 길어서 늦어졌지만 어쨌든 마무리

[멋쟁이사자처럼 데이터분석] 시간, 함수

Mon, 07 Apr 2025 16:06:30 GMT

Notion에서 정리한 내용을 공유용으로 옮긴 내용입니다. 양식과 구성의 어색함이 있을 수 있습니다.

04/07(월) 학습내용을 바탕으로 업로드하였음

오늘 진짜 거의 마지막이라고 미친 듯이 어려운 거 몰아친 느낌 따라가기도 벅차서 거의 기권함 변명을 해보자면 어제 공부하다가 4시 반에 자서 6시 반에 일어났다...

시간

유닉스 타임

C 언어 : OS 개발을 위해 → 유닉스 → 리눅스(라이트 유닉스)
UTC : 1970-01-01-00:00:00:0ms
당시 메모리 용량 비쌈
- 어떻게 하면 최소의 용량으로 데이터를 관리할 수 있을까?
  - 7개의 데이터를 저장하려면 4(정수) * 7 = 28byte 필요
유닉스 타임 개발 : UTC 기준 1970년 1월 1일 자정(0시 0분 0초)에서부터 현재까지 몇 초가 지났는지를 정수 형태로 표시
- 8 byte 기준 서기 42만 년의 데이터 관리 가능
- 현재는 ms 보다 더 작은 단위 필요 : ns 단위나 더 적은 단위 지원
time.time
- 유닉스 타임
- 1970년 1월 1일 0시 0분 0초 0ms(세계 표준시 기준, 대한민국은 9시간을 더한다)을 0으로 정하고 1ms 마다 증가시키거나 감소시킨 값
- 컴퓨터 입장에서의 시간 값
- a1 = time.time()
- 서로 중복되지 않는 유일한 값이 필요 → 현재 시간 사용
time.localtime
- 사람 입장에서의 시간 값
- 현재 컴퓨터에 설정되어 있는 지역 기준

a2 = time.localtime()

print(f'타임 존 : {a2.tm_zone}')
print(f'년 : {a2.tm_year}')
print(f'월 : {a2.tm_mon}')
print(f'현재 월에서 몇 번째 일인지 : {a2.tm_mday}')
print(f'시 : {a2.tm_hour}')
print(f'분 : {a2.tm_min}')
print(f'초 : {a2.tm_sec}')
print(f'이번 주에서 몇 번째 일인지 : {a2.tm_wday}')
print(f'올해에서 몇 번째 일인지 : {a2.tm_yday}')

타임 존 : 대한민국 표준시
년 : 2025
월 : 4
현재 월에서 몇 번째 일인지 : 7
시 : 9
분 : 41
초 : 27
이번 주에서 몇 번째 일인지 : 0   # 월요일
올해에서 몇 번째 일인지 : 97

~~시간 진짜 오지게 빠르다~~

sleep
- 주어진 시간동안 쉰다. 단위는 초 단위
- 0.1초를 쉬고 싶다면 sleep(0.1)
시간 문자열로 만들기
- https://docs.python.org/ko/3.13/library/time.html#time.strftime
- 파이썬은 1월부터 시작 (보통 0월부터 시작)

a1 = time.localtime() a2 = time.strftime("%Y년 %m월 %d일 %H시 %M분 %S초", a1) → 2025년 04월 07일 10시 13분 02초

수행 시간 측정 방법

# 코드 실행 시작 시간
start_time = time.perf_counter()

for v1 in range(5) :
    time.sleep(1)

# 코드 실행 종료 시간
end_time = time.perf_counter()

print(f'시작 시간 : {start_time}')
print(f'종료 시간 : {end_time}')
print(f'총 수행 시간 : {end_time - start_time}')

시작 시간 : 5228.2431957
종료 시간 : 5233.2443848
총 수행 시간 : 5.001189100000374

함수

코드를 미리 만들어 놓고 필요할 때마다 수행할 수 있도록 만든 코드 블럭
재사용이 쉬움

return

~~되돌아간다~~ → 파이썬은 끝까지 수행되거나 값이 없으면 ‘None’ 전달
되돌아가면서 값을 전달한다
함수 수행 원리
- 함수를 쓸 거야 = ‘호출한다(Call)’
- 끝까지 수행되면 알아서 되돌아감
- but 유효성 검사시 문제가 있다면 return 이용해 호출
- return 만나면 호출한 쪽으로 되돌아감
개발에서 함수 사용 방법
- 중복된 코드는 없는 게 좋음
- 따라서 필요한 기능 미리 함수로 만들어 놓음
- 코드 한 줄이거나 한 번만 사용하더라도 함수로 만들어 놓음
- 그 후 함수 호출해서 사용 : 수정시 찾기 쉬움

함수

코드를 관리하는 요소
개발자가 만든 코드를 수행하다가 함수 내부의 코드가 필요할 경우 코드의 흐름을 함수 쪽으로 이동하여 수행하고 끝나면 다시 돌아오는 개념
중복된 코드를 작성하지 않을 수 있어서 코드의 재사용이 좋아지고 생산성이 좋아지며 유지·보수가 용이해진다.
함수 내부의 코드를 동작시키기 위해 "함수를 사용하겠습니다"라고 하는 것을 "함수를 호출한다"라고 부른다.
함수를 호출하기 전에 반드시 함수를 작성한 부분이 실행되어야만 한다. test1() → 오류

함수 정의

# 코드가 수행되다가 함수를 만나게 되면 함수의 존재만 파악하고
# 함수 내부의 코드는 수행되지 않는다.

def test1() : print('test1 함수') print('안녕하세요')


- 함수 호출
    `test1()`
    → *test1 함수
        안녕하세요*

- 파이썬에서 함수의 이름 = 함수를 가지고 있는 변수
    `print(test1)`
    → **

    - 함수 뒤에 괄호가 들어가면 호출 : test1( )
    - 그냥 함수만 쓰여 있으면 ‘test1’이라는 변수

- **다른 변수에 담아 함수를 호출할 수 있다.**
    `test2 = test1
    test2()`
    → *test1 함수
        안녕하세요*

    - 굉장히 좋은 기능
    - but 조심해서 사용해야 함
- **주의**

```python
# 함수의 이름은 변수이므로 다른 것을 넣을 수 있다.
# 단, 다시는 그 이름으로 함수를 호출할 수 없다.
test1 = 100
test1()

→ TypeError: 'int' object is not callable

(그냥 ‘100’이 되어 버려서 함수가 아니게 됨)

실수로 어느 함수에 새로운 값을 집어넣어 버리면 그 함수는 동작하지 않음
list 같은 내장 함수도 마찬가지
변수 이름 조심히 정하기!!!
- 애매하다 싶으면 숫자 붙이기

매개변수 (parameter, 파라미터)

함수를 호출할 때 함수에게 값들을 전달할 수 있다.

def test3(a1, a2, a3) :
    print(a1)
    print(a2)
    print(a3)

파이썬은 함수를 호출할 때 함수에 정의되어 있는 모든 매개변수에 들어갈 값을 결정해 줘야 한다 → 개수 맞춰야 함
함수를 호출할 때 전달하는 값은 매개변수에 담겨져 매개변수에 저장할 값으로 결정된다.
작성해 준 값은 함수의 매개변수에 1:1 대응하여 하나씩 담기게 된다.

test3(10, 20, 30)
test3(100, 200, 300)

함수에 정의되어 있는 매개변수의 개수보다 부족하게 값을 전달하면 값이 결정되지 않는 매개변수가 있기 때문에 오류가 발생한다. test3(10, 20)
```
  → 오류 발생
```

매개변수보다 더 많이 전달하면 오류가 발생한다. test3(10, 20, 30, 40) → 오류 발생

※ 오류 메시지가 발생

의미 파악해서 해결하려 노력!
모르면 GPT
함수를 호출할 때 값만 작성하면 순서대로 1:1 매칭하여 값을 저장한다.
어떠한 매개변수에 값을 담을지 정해줄 수도 있다. (순서 무관)
```
test3(a2 = 30, a3 = 30, a1 = 10)
```
만약 어느 변수에 담길 것임을 지정하지 않은 값이 있다면 변수의 이름을 지정하지 않은 값은 무조건 앞쪽에 몰려 있어야 한다.

test3(10, a3=30, a2=20) # 오류 발생 X
test3(a3=30, 20, a1=10) # 오류 발생 O

저장될 값은 한 변수당 하나씩만 가능하다.

# a2에 저장될 값을 두 개를 지정하였으므로 오류 발생한다.
test3(10, a2=20, a2=30, a3=30)

기본값을 가지고 있는 매개변수

기본값을 가지고 있는 매개변수에 저장될 값을 결정해주지 않으면 기본값으로 결정된다.

def test4(a1, a2 = 2, a3 = 3) :
    print(a1)
    print(a2)
    print(a3)

# a1은 기본값이 설정되어 있지 않기 때문에
# 함수를 호출할 때 반드시 값을 전달해야 하고
# a2와 a3은 기본값이 설정되어 있기 때문에
# 함수를 호출할 때 값을 전달하지 않으면 기본값으로 결정된다.

함수를 호출할 때 값을 전달하면 기본값이 아닌 전달한 값으로 결정되고 기본값이 있는 매개변수에 값을 전달하지 않으면 기본값으로 결정된다.

test4(10, 20, 30)
test4(10, 20)
test4(10)
test4(10, a3=30)

10
20
30

10
20
3
# 앞에서 2개는 순서대로 전달, 전달되지 않은 a3은 기본값인 3

10
2
3
# a1은 전달, 전달되지 않은 a2, a3는 기본값인 a2 =2, a3 = 3

10
2
30
# 순서대로 a1에 10 전달, a3 = 30으로 지정되었으니 a2는 기본값인 2

반환 값

파이썬은 반환 값을 명시하지 않을 경우 None을 반환한다.

def test5() :
    print('test5 함수 호출')

a1 = test5()
# print('test5 함수 호출')까지 작동하고 None이 a1에 들어감
# 따라서 반환 값 따로 출력 안 됨
print(a1) # None 출력

→ test5 함수 호출 None

return 다음에 값을 적어주면 값 하나를 반환할 수 있다.

def test6(a1, a2) :
    r1 = a1 + a2
    return r1 # r1 : 반환 값

함수를 호출하여 함수가 반환하는 값을 받는다.

t1 = test6(10, 20) 
print(t1)

t2 = test6(100, 200)
print(t2)

# test6 함수 위치로 올라가서 진행
# r1 = 100 + 200 = 300
# return 만나 r1 반환되어 t2 = r1 = 300
# print(t2) 하면 300 출력

→ 30 300

return 키워드는 함수의 수행을 중단하고 함수를 호출하는 쪽으로 돌아간다라는 의미
함수의 수행을 더 이상 하고 싶지 않을 때 많이 사용
유효성 검사 : 정상적으로 동작해야 하는 조건이 있다면 그 조건에 위배될 시 중단

def test7(a1) :
    if a1 % 2 == 0 :
        # 함수 수행 중단
        return

    print(f'test7 : {a1}')

test7(3)
test7(4)

→ test7 : 3

(3 인 경우 if 가 거짓이기 때문에 if 아래는 출력되지 않고, 바로 print(a1) 으로 → a1 = 3 출력

4인 경우 if가 참이기 때문에 return → return 뒤 반환 값이 없으므로 a1 = none. 뒤 print 건너뛰고 함수 끝남 → 출력 X)

함수는 무조건 값 하나만 반환됨
- 여러 값이 반환되는 것이 아닌 ‘튜플 하나’를 반환하는 것

def test8(a1, a2) :
    r1 = a1 + a2
    r2 = a1 - a2
    r3 = a1 * a2
    r4 = a1 // a2
    # 아래의 반환은 동시에 여러개의 값을 반환하는 것이 아닌
    # 튜플로 생성하여 튜플 하나를 반환하는 것이다.
    return r1, r2, r3, r4

확인해 보면

t1 = test8(10, 3)
print(t1)
print(type(t1))

→* (13, 7, 30, 3) *

원리는 이러하고 할 때는 그냥 값 여러 개를 반환하는 것처럼 사용하면 됨
주로 아래처럼 많이 사용

t1, t2, t3, t4 = test8(10, 3)
print(t1, t2, t3, t4)

→* 13 7 30 3*

가변형 매개변수

def test1 = (a1, a2) :
    t1 = a1 + a2
    print(t1)

def test2 = (a1, a2, a3) :
    t2 = a1 + a2 + a3
    print(t2)

def test3 = (a1, a2, a3, a4) :
    t2 = a1 + a2 + a3 + a4
    print(t2)

# 무한히 반복할 수 없으므로 편한 방법을 찾음

가변형 매개변수
- 매개변수 하나로 다수의 값을 받을 수 있다라는 개념

*args → tuple

함수를 호출할 때 전달해주는 값들을 모아 튜플로 만들어 변수에 담아 준다.

def test9(*a1) :
    return sum(a1)

t1 = test9(10, 20, 30)
t2 = test9(10, 20, 30, 40, 50)
t3 = test9(10, 20, 30, 40, 50, 60, 70, 80)

print(t1)
print(t2)
print(t3)

→ 60 150 360

**kargs

전달되는 값들을 모아 딕셔너리로 만들어서 변수에 담아준다.
이때 함수를 호출하는 쪽에서 사용한 이름이 딕셔너리의 이름이 된다.

def test10(**a1) :
    print(a1)

test10(k1=10, k2=20, k3=30)
test10(t1=100, t2=200, t3=300)

→ *{'k1': 10, 'k2': 20, 'k3': 30}

{'t1': 100, 't2': 200, 't3': 300}*

섞여 있는 경우

*와 일반 매개변수

# *변수와 다른 일반적인 매개변수와 섞여 있을 경우
# 앞의 두 개는 a1, a2, 뒤의 두개는 a4, a5에 담기고 나머지는 튜플로 만들어져서
# a3에 담긴다.

def test11(a1, a2, *a3, a4, a5) :
    print(a1)
    print(a2)
    print(a3)
    print(a4)
    print(a5)

예시)

# *변수 다음에 있는 매개변수로 들어갈 값은 이름을 지정해줘야 한다.
# (키워드 인자로 써야 한다.)
test11(10, 20, 30, 40, 50, 60, 70, 80, a4=90, a5=100)

# 또는 a4, a5에 기본값 정해줘도 됨

10
20
(30, 40, 50, 60, 70, 80)
90
100

a1 → 10 / a2 → 20에 담김
- 뒤의 매개변수들은 이름 지정해야 함 → a4 = 90 / a5 = 100
  - 키워드 인자 : 함수를 호출할 때 인자의 이름을 직접 지정해서 전달하는 것 (a4 = 90, a5 = 100)
    
    ↔ 위치 인자 : 순서대로 값을 넣는 방식
  - 키워드 인자 뒤에는 위치 인자를 쓰면 X

가운데는 전부 튜플로 a3에 전달됨

  test11(10, 20, 30, 40, 50, 60, a4 = 70, a5 = 80, 90, 100)
  # 에러

- **와 일반 매개변수

# **변수 다음에는 다른 변수를 두면 안 된다.
def test12(a1, a2, **a3, a4, a5) :
    print(a1, a2, a3)

# 에러

- * 와 ** 섞여 있는 경우

# (학습)
def test12(a1, a2, *args, a4, a5, **a3):  # OK!
    print(a1, a2, args, a4, a5, a3)

test12(10, 20, 30, 40, 50, a4=60, a5=70, x=100, y=200)

→ 10 20 (30, 40, 50) 60 70 {'x': 100, 'y': 200}

함수 연습

저번 자동차 딕셔너리 문제

문제1)

자동차의 정보가 다음과 같이 구성되어 있다.

자동차 하나의 정보는 다음과 같다.

모델명, 연식, 배기량, 색상, 주행거리

첫 번째 자동차 : 붕붕이, 2000, 500, 노란색, 100000

두 번째 자동차 : 방구차, 1950, 200, 빨간색, 200000

세 번째 자동차 : 아스라다, 1980, 5000000, 흰색, 300000

출력은 다음과 같다.

각 자동차의 정보를 모두 출력한다.

총 배기량과 배기량 평균을 출력한다.

총 주행거리와 총 주행거리 평균을 출력한다.

설계 과정

설계 (출력)

  1. 자동차의 정보를 담는다.

  2. 총 배기량과 배기량 평균을 구한다.

  3. 총 주행거리와 주행거리 평균을 구한다.

  4. 자동차의 정보를 출력한다.

  5. 총 배기량, 배기량 평균, 총 주행거리, 주행거리 평균을 출력한다.

항상 출력은 한 번에 모아서

입력

 # 자동차의 정보를 담는 함수
 def setCarInfo(name, year, cc, color, length) :
     car_dict = {
         '이름' : name,
         '연식' : year,
         '배기량' : cc,
         '색상' : color,
         '주행거리' : length
     }
     return car_dict

※ 가급적이면 함수는 매개변수만 가지고 뭔가 처리되는 형태로 만들기

여러 개를 수정할 일 없이 독립성 보장받도록

 # 자동차의 정보를 담는다.
 car1 = setCarInfo('붕붕이', 2000, 500, '노란색', 100000)
 car2 = setCarInfo('방구차', 1950, 200, '빨간색', 200000)
 car3 = setCarInfo('아스라다', 1980, 5000000, '흰색', 300000)

 # 총 배기량과 배기량 평균을 구해 반환한다.
 def get_cc_info(*cars) :
     # 배기량 총합을 담을 변수
     total_cc = 0
     # 자동의 수 만큼 반복한다.
     for car in cars :
         # 배기량을 누적한다
         total_cc = total_cc + car['배기량']

     # 배기량 평균을 구한다.
     avg_cc = total_cc // len(cars)

     return total_cc, avg_cc

 # 총 배기량과 배기량 평균을 구한다.
 total_cc, avg_cc = get_cc_info(car1, car2, car3)
 # print(total_cc, avg_cc) 중간출력 확인 후 지우거나 주석 처리

 # 총 주행거리와 주행거리 평균을 구하는 함수
 def get_length_info(*cars) :
     # 총 주행거리를 담을 변수
     total_length = 0
     # 자동차의 수만큼 반복하면서 주행거리를 누적한다.
     for car in cars :
         total_length = total_length + car['주행거리']

     # 주행거리 평균을 구한다.
     avg_length = total_length // len(cars)

     return total_length, avg_length

 # 총 주행거리와 주행거리 평균을 구한다.
 total_length, avg_length = get_length_info(car1, car2, car3)
 # print(total_length, avg_length) 마찬가지로 중간 확인

 # 자동차의 정보를 출력한다.
 def show_car_info(*cars) :
     for car in cars :
         print(f'이름 : {car["이름"]}')
         print(f'연식 : {car["연식"]}')
         print(f'배기량 : {car["배기량"]}')
         print(f'색상 : {car["색상"]}')
         print(f'주행거리 : {car["주행거리"]}')
         print()

 # 자동차의 정보를 출력한다.
 show_car_info(car1, car2, car3)

 # 총 배기량, 배기량 평균, 총 주행거리, 주행거리 평균을 출력한다.
 def show_cc_length_info(total_cc, avg_cc, total_length, avg_length) :
     print(f'총 배기량 : {total_cc}')
     print(f'평균 배기량 : {avg_cc}')
     print(f'총 주행거리 : {total_length}')
     print(f'평균 주행거리 : {avg_length}')

 # 총 배기량, 배기량 평균, 총 주행거리, 주행거리 평균을 출력한다.
 show_cc_length_info(total_cc, avg_cc, total_length, avg_length)

답안

이름 : 붕붕이
연식 : 2000
배기량 : 500
색상 : 노란색
주행거리 : 100000

이름 : 방구차
연식 : 1950
배기량 : 200
색상 : 빨간색
주행거리 : 200000

이름 : 아스라다
연식 : 1980
배기량 : 5000000
색상 : 흰색
주행거리 : 300000

총 배기량 : 5000700
평균 배기량 : 1666900
총 주행거리 : 600000

print
- sep=’ ‘
- end=’/n’
처음 보는 함수가 나온다 → shift + tab
- 매개변수 구조 확인

※ 구글링 팁

python ㅇㅇㅇ not working 으로 검색
Stack overvflow : 개발자 커뮤니티

객체 지향 정리 안 끝난 겸 한 번 잘라버리자

진짜 함수 파트랑 클래스 파트는...어떻게 할 수가 없다. 일단 이해에 최선을 다했고, 내일 일찍 일어나서 숙제 마저 해봐야겠음 일단 오늘은 2시간 잤더니 너무 피곤해...

~~물론 1시에 할 소리는 아니지만~~

아 그리고 이유는 모르겠지만 오늘 클래스 질문 많이 했더니 GPT가 착해짐 갑자기 이모티콘을 쓰고 칭찬도 세 줄씩 하기 시작 뭐지 나 어려워서 열받은 거 들켰나? 서로 사무적이던 사이였는데 갑자기 응원하는 거 웃겼지만 오늘 큰 도움 되었으니 귀엽게 넘어가준다

[멋쟁이사자처럼 데이터분석] Dictionary, Set

Sun, 06 Apr 2025 12:01:09 GMT

Notion에서 정리한 내용을 공유용으로 옮긴 내용입니다. 양식과 구성의 어색함이 있을 수 있습니다.

04/04(금) 학습내용을 바탕으로, 당일이 아닌 추후 업로드하였음

딕셔너리

자료 관리에서 리스트/튜플

하나의 리스트/튜플 안에는 다른 타입도 넣을 수 있음

[10, 11.11, True, ‘안녕하세요’] 가능
학생리스트 = [’홍길동’, 15, 100, ‘김길동’, 20, 90, ‘박길동’, 30, 80]
- 이름, 나이, 국어 점수
- 홍길동의 값을 가져오려면 3씩 끊어서 가져온다.
- 이름 : 0부터 3씩 증가하는 순서값을 통해 가져온다.
- 나이 : 1부터 3씩 증가하는 순서값을 통해 가져온다.
- but 수학 점수를 추가
  - 한 사람의 값 3개씩 → 4개씩으로 변경
  - 이름, 나이, 등등의 코드도 전부 3씩 → 4씩 으로 전부 수정되어야 함
- 하나가 빠지면
  - 한 사람 2개씩으로 바뀌고 전부 3씩 → 2씩
한 리스트/튜플에는 의미가 같은 데이터만 담을 것
- 0부터 1씩 증가하는 순서값 전부 마찬가지
- 데이터 관리에 용이해야 하며 유지, 보수 중요
- [21, 39, 40, 143, 2, 40, 32, 60, 140, 5, 28, …]
  
  이면 어떤 게 키이고 어떤 게 수학 점수인지 찾기 쉽지 않음

자료 관리에서 딕셔너리

이름을 통해 데이터를 관리
어느 한 개체에 포함되어 있는 데이터를 하나의 딕셔너리에 담는다.
- 학생 1명의 데이터 → 딕셔너리
- 전체 딕셔너리 = 학생, 을 의미하는 딕셔너리 여러 개 (의미 같음)
  
  → 이걸 리스트에 담음
- 첫 번째 학생의 3번째 정보를 줘, 가 아닌
  
  ‘홍길동’의 ‘수학 점수’를 줘, 라고 관리해야 편리
리스트는 종류별로 각각 있어야 함
- 중국집 데이터, 병원 데이터가 섞여서
  1. 짜장면, 2. 복통, 3. 탕수육, 4. 감기 → X
- 여러 리스트에서 첫 번째 것들 가져옴 → 첫 번째 사람의 딕셔너리
- 여러 리스트에서 두 번째 것들 → 두 번째 사람의 딕셔너리
  
  → 개발자는 리스트만 관리하면 됨

딕셔너리는 삽입 X (중간삽입)
- 선입선출(적인) 순서가 중요한 아이라 중간에 삽입 X
- 딕셔너리는 순서가 없다고 생각하는 게 편함. 부를 때도 이름으로 호출, 관리

※ 파이썬은 뒤에 뭔가 없을 때 , 을 찍어도 오류 X

생성

# 딕셔너리 생성
# 비어 있는 딕셔너리가 생성된다.
# 딕셔너리는 나중에 추가할 수 있다.
d1 = dict()
print(type(d1))
print(d1)

# 괄호를 통한 딕셔너리 생성
# 비어 있는 딕셔너리가 생성된다.
d2 = {}
print(type(d2))
print(d2)

{}

# 관리하는 값을 지정하여 생성한다.
d3 = {
    'v1' : 100,
    'v2' : 11.11,
    'v3' : '안녕하세요',
    'v4' : [10, 20, 30],
    'v5' : (10, 20, 30),
    'v6' : {
        'a1' : 100,
        'a2' : 200
    }
}
print(d3)

{'v1': 100, 'v2': 11.11, 'v3': '안녕하세요', 'v4': [10, 20, 30], 'v5': (10, 20, 30), 'v6': {'a1': 100, 'a2': 200}}

생설할 때, 이름은 꼭 문자열이 아니어도 된다.

d10 = {
    'a1' : 100,
    10 : 200,
    11.11 : 300,
    True : 400
}
print(d10['a1'])
print(d10[10])
print(d10[11.11])
print(d10[True])

불러오기 (가져오기)

# [이름] 형태로 데이터를 가져온다.
print(d3['v1'])
print(d3['v2'])
print(d3['v3'])
print(d3['v4'][0]) # 'v4' 리스트의 순서값 0번째
print(d3['v4'][1])
print(d3['v5'][0])
print(d3['v5'][1])
print(d3['v6']['a1']) # 'v6' 딕셔너리의 이름이 'a1'인 값
print(d3['v6']['a2'])

수정/추가

# 수정
# 이름을 통해 값을 새롭게 넣어 주면 값이 수정된다.
d3['v1'] = 200

# 추가
# 없는 이름으로 값을 넣어주면 추가된다.
d3['v7'] = 5000

{'v1': 200, 'v2': 11.11, 'v3': '안녕하세요', 'v4': [10, 20, 30], 'v5': (10, 20, 30), 'v6': {'a1': 100, 'a2': 200}, 'v7': 5000}
5000

삭제

# pop : 이름을 지정하여 이름에 해당하는 것을 전달하고 딕셔너리에서 삭제한다.
v1 = d3.pop('v1')
print(v1)
print(d3)

200
{'v2': 11.11, 'v3': '안녕하세요', 'v4': [10, 20, 30], 'v5': (10, 20, 30), 'v6': {'a1': 100, 'a2': 200}, 'v7': 5000}

없는 이름 지정시 오류 발생
popitem
- 순서 개념이 들어가는 요소이므로 안 쓰길 권장. 무조건 마지막 것을 알고 있다는 게 확실할 때만 사용 권장

# 딕셔너리는 순서가 없지만 제일 마지막에 추가된 요소를 
# 이름, 값의 쌍으로된 튜플로 반환하고 딕셔너리에서는 제거한다.
v2 = d3.popitem()
print(v2)
print(d3)

('v7', 5000)
{'v2': 11.11, 'v3': '안녕하세요', 'v4': [10, 20, 30], 'v5': (10, 20, 30), 'v6': {'a1': 100, 'a2': 200}}

# del 연산을 통해 삭제할 수 있다.
del d3['v2']
print(d3)

{'v3': '안녕하세요', 'v4': [10, 20, 30], 'v5': (10, 20, 30), 'v6': {'a1': 100, 'a2': 200}}

없는 이름 지정시 오류 발생
있는지 없는지 애매할 때 “get”으로 가져오기
get

# get을 통해 가져올 때 이름이 없을 경우 None 이 나온다.
v3 = d3.get('v3')
print(v3)
print(d3)

v100 = d3.get('v100')
print(v100)

안녕하세요
{'v3': '안녕하세요', 'v4': [10, 20, 30], 'v5': (10, 20, 30), 'v6': {'a1': 100, 'a2': 200}}
None

pop처럼 제거되는 게 아니라 그대로 남아 있음

in

튜플, 리스트, 딕셔너리에서 모두 사용
- 튜플, 리스트인 경우 주어진 값이 포함되어 있는가
- 딕셔너리인인 경우 주어진 이름으로 저장되어 있는 값이 있는가

list1 = [10, 20, 30, 40, 50]
tuple1 = 10, 20, 30, 40, 50
dict1 = {
    'a1' : 100,
    'a2' : 200,
    'a3' : 300
}

print(10 in list1)
print(100 in list1)
print(10 in tuple1)
print(100 in tuple1)
print('a1' in dict1)
print('a100' in dict1)

True
False
True
False
True
False

결과는 T/F로

딕셔너리가 가지고 있는 함수

# 이름들을 가져온다.
name1 = dict1.keys()
# 값들을 가져온다.
value1 = dict1.values()
# (이름, 값) 형태로 되어 있는 튜플들을 가지고 있는 요소를 가져온다.
items1 = dict1.items()

print(name1)
print(value1)
print(items1)

dict_keys(['a1', 'a2', 'a3'])
dict_values([100, 200, 300])
dict_items([('a1', 100), ('a2', 200), ('a3', 300)])

# for 문 사용하기
# 리스트는 값을 추출하여 변수에 담아준다
for v1 in list1 :
    print(v1)

# 튜플은 값을 추출하여 변수에 담아준다.
for v2 in tuple1 :
    print(v2)

# 딕셔너리는 이름을 추출하여 변수에 담아준다.
for v3 in dict1 :
    print(dict1[v3]) # print(v3) 하면 키 이름인 a1, a2, a3가 나옴

set

데이터를 집합으로 사용할 때 사용하는 요소
중복 허용 X
순서, 이름 X → 특정 데이터 지칭해서 추출하는 것 불가능
사용 용도
- 집합 연산이 필요할 때
- 중복된 데이터를 제거할 때.
  
  단,
  - 순서가 바뀌어도 상관없을 때
  - 오름차순, 내림차순이나 새로운 기준으로 어차피 다시 정렬할 때
s1 = {} → 딕셔너리로 만들어짐

→ {10, 20, 30} 처럼 넣을 값 쉼표로 나열

# set은 중복을 허용하지 않는다.
s3 = {30, 20, 30, 10, 20, 30, 30, 20, 10, 5}
print(s3)

{10, 20, 5, 30}

# set은 데이터를 가져다 사용할 수 있는 방법은 다른 형태로 만들어주거나 for 문을 사용하는 것밖에는 없다.
# 이때, 순서가 어떻게 될지는 알 수 없다.
for v1 in s3 :
    print(v1)

# list, tuple -> set
list1 = [10, 20, 30, 10, 20, 30, 20, 10]
tuple1 = 10, 20, 30, 10, 20, 30, 20, 10

s1 = set(list1)
s2 = set(tuple1)
print(s1)
print(s2)

{10, 20, 30}

# set -> list, tuple
# 순서는 어떻게 될지 알 수 없다.
list2 = list(s1)
tuple2 = tuple(s1)
print(list2)
print(tuple2)

[10, 20, 30]

(10, 20, 30)

EX

개발할 때는 입력, 처리, 출력 부분을 나눠서 구조 잡기

# 문제

학생 정보를 출력하는 프로그램을 만든다.

학생 정보는 다음과 같이 구성된다.

학생 한 명은 이름, 나이, 국어점수, 영어점수, 수학점수로 구성된다.

첫 번째 학생 : 홍길동, 15, 90, 91, 92
두 번째 학생 : 김길동, 18, 80, 81, 82
세 번째 학생 : 최길동, 20, 70, 71, 72

출력은 다음과 같이 한다.

모든 학생들의 정보를 모두 출력한다.

각 점수별 총점과 평균을 출력한다.
전체 총점과 평균을 출력한다.

구조 잡기 (입력 / 처리 / 출력)

===입력===

# 각 학생의 정보를 가지고 있는 딕셔너리를 만들어준다.

# 딕셔너리를 리스트에 담는다

===처리===

# 각 점수별 총점과 평균을 구한다

# 전체 총점과 평균을 구한다.

===출력===

# 모든 학생들의 정보를 출력한다.

# 각 점수별 총점과 평균을 출력한다.

# 전체 총점과 평균을 출력한다.

개인적으로 거꾸로 작업

출력
- 필요한 출력들
처리
- 어떻게 구현해야 할지 전략
입력
- 데이터 미리 준비되어 있다면 쓰기
- 준비된 것이 없다면 사용자에게 입력 받기

# 풀이

# 각 학생의 정보를 가지고 있는 딕셔너리를 만들어준다.
studentDict1 = {
    'name' : '홍길동',
    'age' : 15,
    'korean' : 90,
    'math' : 91,
    'english' : 92
}

studentDict2 = {
    'name' : '김길동',
    'age' : 18,
    'korean' : 80,
    'math' : 81,
    'english' : 82
}

studentDict3 = {
    'name' : '최길동',
    'age' : 20,
    'korean' : 70,
    'math' : 71,
    'english' : 72
}

# 딕셔너리를 리스트에 담는다.
studentList = [studentDict1, studentDict2, studentDict3]

# 각 점수별 총점과 평균을 구한다.
koreanTotal = 0
mathTotal = 0
englishTotal = 0

for d1 in studentList :
    koreanTotal = koreanTotal + d1['korean']
    mathTotal = mathTotal + d1['math']
    englishTotal = englishTotal + d1['english']

koreanAvg = koreanTotal // len(studentList)
mathAvg = mathTotal // len(studentList)
englishAvg = englishTotal // len(studentList)

# 전체 총점과 평균을 구한다.
allTotal = koreanTotal + englishTotal + mathTotal
allAvg = allTotal // len(studentList) // 3

# 모든 학생들의 정보를 출력한다.
for s1 in studentList :
    print(f'이름 : {s1['name']}')
    print(f'나이 : {s1['age']}')
    print(f'국어점수 : {s1['korean']}')
    print(f'수학점수 : {s1['math']}')
    print(f'영어점수 : {s1['english']}')
    print()

# 각 점수별 총점과 평균을 출력한다.
print(f'국어 총점 : {koreanTotal}')
print(f'수학 총점 : {mathTotal}')
print(f'영어 총점 : {englishTotal}')
print()
print(f'국어 평균 : {koreanAvg}')
print(f'수학 평균 : {mathAvg}')
print(f'영어 평균 : {englishAvg}')
print()

# 전체 총점과 평균을 출력한다.
print(f'전체 총점 : {allTotal}')
print(f'전체 평균 : {allAvg}')
print()

이름 : 홍길동
나이 : 15
국어점수 : 90
수학점수 : 91
영어점수 : 92

이름 : 김길동
나이 : 18
국어점수 : 80
수학점수 : 81
영어점수 : 82

이름 : 최길동
나이 : 20
국어점수 : 70
수학점수 : 71
영어점수 : 72

국어 총점 : 240
수학 총점 : 243
영어 총점 : 246

국어 평균 : 80
수학 평균 : 81
영어 평균 : 82

전체 총점 : 729
전체 평균 : 81

처음 파이썬 배울 때 진짜 딕셔너리 익히느라 헷갈려했던 기억이 남 지금 가볍게 배우니 별 거 아닌 거 같은데 또 나중에 다른 거랑 합쳐지면 또 어려워서 멘붕 오겠지... 복습을 일단 열심히 해가는 걸 메인으로...

한 주 후기

일단 회고조 하면서 알게 된 게 다른 사람들이 강의중 로비에서 쓴 댓글의 8배 정도를 썼다는 것... 회고조 조원이 정해져서 조원들 검색해 봤는데, 다른 사람들은 각자의 댓글 페이지 검색이 3페이지 안팎인데 나는 26페이지였다 충격받아서 앞으로는 수업에 방해되지 않게 드립이나 댓글을 좀 줄여야겠다는 생각을 함...

그리고 확실히 간만에 8시간 수업을 들어서 그런지 체력이 못 따라오는 게 느껴짐 운동을 하든가 아무튼 체력에 신경을 써야겠다 기존처럼 복습도 하고 다른 일도 하고 하려면.

[멋쟁이사자처럼 데이터분석] string, 자료구조(list, tuple)

Sun, 06 Apr 2025 11:51:36 GMT

Notion에서 정리한 내용을 공유용으로 옮긴 내용입니다. 양식과 구성의 어색함이 있을 수 있습니다.

04/03(목) 학습내용을 바탕으로, 당일이 아닌 추후 업로드하였음

string

문자열, 날짜를 다루는 방법은 스스로 알아 보아야 함. 중요!

파이썬의 언어철학
- 작성하기 쉽고, 읽기 쉬운 언어
에스케이프 문자 \ 와 같이 작성하는 특별한 의미를 가진 문자 \n : 줄바꿈 \t : 탭 ' : 작은 따옴표 " : 큰 따옴표 \ : \
raw string : 에스케이프 문자를 무시한다.

r'동해물과\n백두산이\t마르고\\닳도록'

동해물과\n백두산이\t마르고\\닳도록

''' ''' 나 """ """ 를 사용하면 에스케이프 문자를 사용하지 않아도 된다.
f 문자열

a1 = '홍길동'
a2 = 20
a3 = 185
str4 = f'이름은 {a1}이고 나이는 {a2}살 입니다. {a1}의 키는 {a3}cm 입니다'
print(str4)

문자열 내의 문자 접근

str1 = 'abcdefg'

print(str1[0])

순서값
- 순서값 2 부터 5-1 까지
  
  print(str1[2:5])
- 처음 부터 5-1 까지
  
  print(str1[:5])
- 순서값 2 부터 끝까지
  
  print(str1[2:])

문자열 + 문자열
- 같은 타입끼리만 + 로 합칠 수 있음
- 문자열+문자열, 정수+정수
- 문자열 + 문자열 → 둘을 합친 새로운 문자열이 생성된다.
  
  str1 = '문자열1' + '문자열2' print(str1)
  
  → ‘문자열1문자열2’

문자열 * 숫자

→ 숫자만큼 문자열을 반복한 문자열이 생성된다.
- str1 = '문자열1' * 3 print(str1)

→ ‘문자열1문자열1문자열1’

글자수

str1 = 'abcdefg'
str2 = '가나다라마바사'

a1 = len(str1)
a2 = len(str2)

print(a1)
print(a2)

→ 둘 다 7

어떤 새로운 언어를 배울 때 ‘글자 수’ 개념이 있다면 한글/영어 테스트해보기 (한글은 2byte, 영어는 1byte) 대부분의 언어는 좀 낭비하더라도 한 글자가 동일한 메모리를 사용하도록 프로그래밍되어 있음
첫글자를 대문자로 변경, 뒤는 소문자로 변경한다.

str1 = 'hello world'
str2 = str1.capitalize()
print(str2)

str3 = 'hELLO WORLD'
str4 = str3.capitalize()
print(str4)

대소문자 변경은 꼭 앞 글자만 바꿔주는지, 나머지도 소문자로 바꿔주는지 테스트

Hello world
Hello world

대문자/소문자로 각각 변경

str1 = 'ABcdEF'

# 대문자를 소문자로 변경
str2 = str1.lower()
print(str2)

# 소문자를 대문자로 변경
str3 = str1.upper()
print(str3)

abcdef
ABCDEF

문자열 채우기

str1 = 'python'

# 주어진 문자열을 주어진 크기로 늘려준다.
# 원본 문자열을 가운데 배치하고 나머지는 공백으로 채워준다.
# (만약 홀수면 왼쪽으로 쏠림)
str2 = str1.center(40)
print(f'[{str2}]')

# 원본 문자열을 좌측에 배치하고 나머지는 공백으로 채워준다.
str3 = str1.ljust(40)
print(f'[{str3}]')

# 원본 문자열을 우측에 배치하고 나머지는 공백으로 채워준다.
str4 = str1.rjust(40)
print(f'[{str4}]')

[                 python                 ]
[python                                  ]
[                                  python]

# 원본 문자열을 가운데 배치하고 나머지는 지정된 문자열(글자 1개짜리)로 채워 준다.
str2 = str1.center(40, '_')
print(f'[{str2}]')

# 원본 문자열을 좌측에 배치하고 나머지는 지정된 문자열(글자 1개짜리)로 채워 준다.
str3 = str1.ljust(40, '_')
print(f'[{str3}]')

# 원본 문자열을 우측에 배치하고 나머지는 지정된 문자열(글자 1개짜리)로 채워 준다.
str4 = str1.rjust(40, '_')
print(f'[{str4}]')

[_________________python_________________]
[python__________________________________]
[__________________________________python]

논란 있을까봐 글자 2개 이상은 막았다고 함… 늘어나는 게 맞다 vs 칸 안에 채우는 게 맞다 ㅋㅋㅋ수학 문제 이의 생길 거 같으면 그냥 그 선지 제거해버리기 같네

문자열 찾기

# cde가 어디에 있는가
a1 = str1.find('cde')
a2 = str1.index('cde')

print(a1)
print(a2)

→ 둘 다 2

없는 문자열 찾기

a3 = str1.find('zzz') # -1
print(a3)
a4 = str1.index('zzz') # 오류!
print(a4)

find : 문자열에 없으면 -1 반환
index는 문자열에 없으면 오류
find는 문자열에만 제공. 튜플 (10,20,30) 에서 find 하면 오류.
index는 다른 언어에서도 나는 똑같은 오류. find를 새로 파이썬에서 제공함

# 지정된 문자열의 일부를 다른 문자열로 변경한다
# replace('이걸','이거로',개수만큼)

str1 = 'abcdefg'
# cde 를 zzzzz로 변경한다
str2 = str1.replace('cde', 'zzzzz')
print(str2)

str3 = 'abcdefcdekkk'
str4 = str3.replace('cde', 'zzzzz')
print(str4)

str5 = 'abcdefcdekkk'
# 3번째 숫자를 넣어주면 그 개수만큼 변경한다
str6 = str5.replace('cde', 'zzzzz', 1)
print(str6)

검증/검사

문자열 시작/끝 검사 (startwith, endwith)

str1 = 'abcdefg'

# 문자열이 abc로 시작하는가
a1 = str1.startswith('abc')
print(a1)

# 문자열이 zzz로 시작하는가
a2 = str1.startswith('zzz')
print(a2)

True
False

# 문자열이 efg로 끝나는가
a3 = str1.endswith('efg')
print(a3)

# 문자열이 zzz로 끝나는가
a4 = str1.endswith('zzz')
print(a4)

True
False

사용자 입력할 때 도메인 맞는지 검사할 때 사용하기 좋음

아니면 사용자가 ‘김’으로 시작하는가 등

→ pandas로 할 예정

형식 검사

# 숫자와 문자로 구성되어 있는가
str1 = 'abcd1234'
a1 = str1.isalnum()
print(a1) # T

str2 = 'abcd'
a2 = str2.isalnum()
print(a2) # T

str3 = '1234'
a3 = str3.isalnum()
print(a3) # T

str4 = 'abcd가나다라1234'
a4 = str4.isalnum()
print(a4) # T

str5 = 'abcd_1234'
a5 = str5.isalnum()
print(a5) # F

alnum : 숫자/문자면 True, 특문이면 False

# 숫자로만 구성되어 있는가
str6 = '123456'
a6 = str6.isdigit()
print(a6) # T

# 문자로만 구성되어 있는가
str7 = 'abcdef'
a7 = str7.isalpha()
print(a7) # T

# 소문자로만 구성되어 있는가
str8 = 'abcdefg'
a8 = str8.islower()
print(a8) # T

# 대문자로만 구성되어 있는가
str9 = 'ABCDEFG'
a9 = str9.isupper()
print(a9) # T

자료 구조

자료구조란

정의
- 데이터를 관리하는 기법
- 실제로 겪는 것들을 기반으로 만들어짐
- 보다 실생활의 것들을 쉽고 편하게 할 수 있도록
방식
- 무엇인지, 어떻게 쓰는지
- 구현해 보기 위가 더 중요!
배우는 이유
- 내부적인 동작원리 → 어떻게 쓸지 파악 쉬워짐
- 프로그래밍 능력 키우기에 좋음
쉽게 공부하는 법 : 실생활에서 찾아보기
- 카페 주문 무엇부터 주문받는가
- 이불을 차례차례 쌓고, 무엇을 먼저 꺼내는가 1,2,3번 순서로 넣었으면 3,2,1로 꺼내게 됨 → Stack
변수는 스택 구조로 되어 있음
- 선언을 계속 하다가, 만약 깜빡하고 선언하지 않은 게 있으면 그 근처에서 선언
  - 변수 정의는 많이 사용하는 근처에서 선언. 그래야 빠르게 꺼낼 수 있음
  - why? 변수는 스택이기 때문에 하나씩 하나씩 꺼내고 그 변수를 꺼내야 함.
- 함수
  - 메인에서 함수로 따로 떨어져 나와서 무언가 처리하다가 메인으로 다시 돌아올 수 있는 개념
  - 함수 내에서 사용하는 변수 → 함수 내에서 선언
자료구조 공부방법
- GPT와…

리스트, 튜플

0부터 1씩 증가하는 순서 값을 이용하여 데이터들을 관리하는 요소
List [ ] : 변경 가능(mutable). 수정, 삭제, 삽입, 추가 가능
Tuple ( ) : 변경 불가(immutable). 읽기만 가능

※ 사실 파이썬에서 문자열도 순서값을 가지고 데이터를 관리하는 요소이기 때문에 비슷한 점 많음

리스트는 추가가 가능하므로 [ ] 를 만드는 것 의미 O
수정이 없다면 튜플 사용 권장

사용했을 때 나오는 값이 여러 개다 → 튜플
튜플은 추가가 안 되기 때문에 텅 빈 ( )를 만드는 것 의미 X
문자열의 +, *, 슬라이싱, len 지원
max, min 지원
- 통계값을 사용할 일이 있으면 Numpy, Pandas를 사용하는 것이 좋다.
튜플에 있는 값을 모두 추출하여 새로운 리스트를 생성한다.

tuple1 = 10, 20, 30, 40, 50
list1 = list(tuple1)
print(list1)

리스트에 있는 값을 모두 추출하여 새로운 튜플을 생성한다.

tuple2 = tuple(list1)
print(tuple2)

문자열을 리스트나 튜플로 생성 가능

tuple1 = tuple('안녕하세요')
list1 = list('안녕하세요')

print(tuple1)
print(list1)

('안', '녕', '하', '세', '요')
['안', '녕', '하', '세', '요']

join : 문자열로 합치기

str1 = "_"
# join : 지정한 튜플이나 리스트 내의 값들을 모두 추출하여 하나의 문자열로 만들어 준다.
# 이때, join을 사용한 문자열이 구분자가 된다.
str2 = str1.join(tuple1)
str3 = str1.join(list1)

print(str2)
print(str3)

길이가 0인 문자열로 사용하면 그냥 하나의 문자열로 합칠 수 있다. ( str1 = ‘’)
split : 문자열 나누어 리스트 만들기

# 구분자를 기분으로 문자열을 나눈다.
# 결과는 리스트로 나온다.
str1 = 'ab cd_ef gh'

tuple1 = str1.split()
tuple2 = str1.split('_')

print(tuple1)
print(tuple2)

위치 찾기

# 위치 찾기. 없는 것을 넣으면 오류 발생
list1 = [10, 20, 30, 40, 50]
a1 = list1.index(20)
print(a1)

1

enumerate

리스트, 튜플에서만 사용

list1 = [10, 20, 30, 40, 50]
tuple1 = 10, 20, 30, 40, 50

# 관리하고있는 값들과 순서값의 쌍으로 구성된 요소(튜플)를 생성한다.
e1 = enumerate(list1)
e2 = enumerate(tuple1)
print(list(e1))
print(list(e2))

[(0, 10), (1, 20), (2, 30), (3, 40), (4, 50)]
[(0, 10), (1, 20), (2, 30), (3, 40), (4, 50)]

for문에서의 응용
- 파이썬에서 몇 번째 반복인지 알기 어려울 때, enumerate를 사용할 수 있다.
```
for idx, a1 in enumerate(list1) :
  print(f'{idx} : {a1}')
```
```
0 : 10
1 : 20
2 : 30
3 : 40
4 : 50
```

list만 있는 기능 (mutable)

추가/수정/삽입/삭제

tuple은 불가능

list1 = []
print(list1)

추가 : append (한 개만)

# 추가
list1.append(10)
list1.append(20)
list1.append(30)
print(list1)

[10, 20, 30]

추가 : extend (여러 개)

# 다수의 값을 한번에 추가한다
# 다른 리스트나 튜플이 가지고 있는 값을 추출하여 뒤에 추가해준다.
list1.extend([40, 50, 60])
print(list1)

[10, 20, 30, 40, 50, 60]

수정 : 순서값 이용

# 수정
# 순서값을 가지고 접근하여 값을 넣어준다.
list1[1] = 200
print(list1)

[10, 200, 30, 40, 50, 60]

삽입 : insert

# 삽입
# 순서값 1에 해당하는 곳에 지정된 값을 삽입한다.
list1.insert(1, 90)
print(list1)

# 삽입하는 수가 순서값 1이 되도록

[10, 90, 200, 30, 40, 50, 60]

제거 : remove

# 값을 지정하여 제거한다.
list1.remove(90)
print(list1)

# 처음 1개만 제거, 없는 값이면 오류

[10, 200, 30, 40, 50, 60]

제거 : del

# del 연산자 : 지정한 요소를 제거하는 연산자
del list1[1]
print(list1)

→ 순서값 1에 해당하는 값 제거

제거/추출 : pop

# 가장 마지막 것을 가져오고 리스트에서는 제거
a1 = list1.pop()
print(a1)
print(list1)

60
[10, 200, 30, 40, 50]

# 순서값을 지정하여 가져오고 리스트에서는 제거한다.
a2 = list1.pop(2)
print(a2)
print(list1)

30
[10, 200, 40, 50]

순서 변경

정렬 : sort

# 정렬
# 리스트내의 데이터를 직접 정렬 해준다.
# 오름차순 정렬
list1 = [40, 20, 10, 30, 50]
list1.sort()
print(list1)

[10, 20, 30, 40, 50]

반전 : reverse

# 반전
# 순서를 반전시킨다.
list1.reverse()
print(list1)

내림차순을 만들려면 list1.sort(reverse=True)123
문자도 정렬 가능. why? → 유니코드

아스키 코드와 유니코드

정수 → 이진수 정수
실수
- 고정 소수점 : 반 잘라서 소수점 이하 자리, 소수점 왼쪽 자리
- 유동 소수점
논리
- True : 1
- False : 0
문자
- 알파벳, 특문에 8bit를 이용해서 붙임 a = 64 b = 65
전구 1개 → 1bit : 전구의 최소 용량 단위 8bit → 1 byte : 사람 입장에서의 최소 용량 단위

유니코드
- 글자마다 각각 숫자를 붙여 놓은 것
- ASCII + 한글 + 한문 → 한국형 유니코드
  - 2 byte 단위
  - 한국어 100 → 가 였다면 중국어 100 → 人
  - 꿻뚫■쎝 같은 오류가 남
- UTF-8
  - 이것들을 다 모아서 한 번에 표현할 수 있도록 해놓은 것
  - 가장 많이 쓰임
- UTF-16
- 학술형 유니코드 : 잘 안 쓰는 갑골 문자 등도 모아놓음

→ 따라서 숫자로 되어 있기 때문에 문자끼리 대소 비교 가능함

조합형, 완성형
- 윈도우 : 완성형 (가,나,거)
- 맥 : 조합형 (ㄱ,ㄴ,ㅏ,ㅓ)
- 따라서 맥 → 윈도우로 파일 보내면 ㅈㅏㅁㅗㅂㅜㄴㄹㅣ가 일어남

# 컴프리헨션(comprehension)

무조건 익숙해지기!

컴프리헨션 기본

# list1이 가지고 있는 값에 10을 더해 list2에 담아준다.
list1 = [10, 20, 30, 40, 50]
list2 = []

for v1 in list1 :
    list2.append(v1 + 10)

print(list2)

[20, 30, 40, 50, 60]

# list1이 가지고 있는 값의 수만큼 반복한다. (in list1)
# list1이 가지고 있는 값을 v1 변수에 담아 준다.(for v1)
# 새로운 리스트에 v1 + 10을 담아 준다.(v1 + 10)

list2 = [v1 + 10 for v1 in list1]
print(list2)

[20, 30, 40, 50, 60]

list1 에 담기 때문에 5개를 가지고 → [ , , , , ]

list1에서 v1 에 하나씩 담아서 v1 으로 → 10

v1에 담긴 수를 v1 + 10 → 10 + 10 = 20

list2 = [ 20, , , , ]

이런 식으로 list1에서 10, 20, 30, 40, 50 차례대로 가져옴

구하는 값에 if - else

# list3의 있는 값이 2로 나눈 나머지가 0이면
# 10을 곱해서 담고 그렇지 않으면 그대로 담아준다.
list3 = [1, 2, 3, 4, 5]
list4 = []

for v1 in list3 :
    if v1 % 2 == 0 :
        list4.append(v1 * 10)
    else :
        list4.append(v1)
print(list4)

[1, 20, 3, 40, 5]

# list3이 가지고 있는 값의 개수 만큼 반복한다(in list3)
# list3이 가지고 있는 값을 v1 변수에 담아준다(for v1)
# 만약 v1을 2로 나눈 나머지가 0 이라면 (if v1 % 2 == 0) v1 * 10 을 리스트에 담아주고 (v1 * 10)
# 그게 아니면 v1을 그대로 담아준다(else v1)

list3 = [1, 2, 3, 4, 5]
list4 = [v1 * 10 if v1 % 2 == 0 else v1 for v1 in list3]
print(list4)

[1, 20, 3, 40, 5]

list3 에서 v1으로 하나씩

1 → if v1 % 2 == 0 이 False이므로 1

2 → if v1 % 2 == 0 이 True이므로 20

3 → False이므로 3

4 → True이므로 40

5 → False이므로 3

list4 = [1, 20, 3, 40, 5]

담는 조건에 if

list3 = [1, 2, 3, 4, 5]
list4 = []
# list3이 가지고 있는 값을 2로 나눈 나머지가 0이라면
# 10을 곱해 새로운 리스트에 담는다.
for v1 in list3 :
    if v1 % 2 == 0 :
        list4.append(v1 * 10)

print(list4)

# 그 외에는 건너뛰는 것

[20, 40]

list3 = [1, 2, 3, 4, 5]
# list3이 가지고 있는 값의 수만큼 반복한다.(in list3)
# list3이 가지고 있는 값을 v1 변수에 담아 준다.(for v1)
# 이 때, v1을 2로 나눈 나머지가 0일 경우에만(v1 % 2 == 0)
# 새로운 리스트에 v1 * 10을 해서 담아 준다.(v1 * 10)
# 만약 v1 % 2 == 0의 조건에 만족하지 않는 값이라면 리스트에 담지 않는다.
list4 = [v1 * 10 for v1 in list3 if v1 % 2 == 0 ]
print(list4)

[20, 40]

작성/읽기 팁

역순으로!

작성

바꿀 거(list1) → 변수 설정(v1) → 새롭게 담을 거(v1+10)

과제

일반 / comprehension 두 가지 버전

문제1)

리스트에 [1, 2, 3, 4, 5, 6, 7, 8, 9] 까지 담겨져 있다.

이를 이용해 구구단을 출력해 보아라.

# 일반

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 2단부터 9단까지 반복한다.
for dan in list1[1:] : # (2부터 9까지 가져옴)
    # 1부터 9까지 반복한다.
    for number in list1 :
        # 현재 단수에 현재 숫자를 곱한다.
        result = dan * number
        # 출력한다.
        print(f'{dan} X {number} = {result}')
    print() # (단과 단 사이에 줄바꿈? enter? 출력)

# 컴프리헨션

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 결과를 담을 리스트
resultList = []
# 9단까지 반복한다.
for dan in list1[1:] :
    # 현재 단수의 구구단 결과값을 계산하여 담아준다.
    r1 = [dan * number1 for number1 in list1]
    # 결과를 담을 리스트에 담아준다.
    resultList.append(r1)
    # ([[2,4,6,8,10,12,14,16,18],[3,6,...],...,[...,81]] 이런 상태)

# 출력한다.
dan = 2
number1 = 1

# 결과의 수 만큼 반복한다.
for result in resultList :  # ([2,4...],[3,6,...] 이거 한 리스트씩 분리해서 가져오기)
    # 현재 단의 결과로 반복한다.
    for r1 in result : # ([2,4,...,18] 안에서 2, 4, 6, ... 하나씩 가져오기)
        # 출력한다
        print(f'{dan} X {number1} = {r1}')
        number1 = number1 + 1

    dan = dan + 1 # (2, 3, ..., 9까지 반복) 
    number1 = 1 # (number1 은 계속 1, 2, ..., 9여야 함)
    print()

→ 일반 방법으로 하는 게 편함

리스트를 만들기 위해 있는 것이 comprehension인데, 구구단은 출력 위주? 의 문제임

문제2)

1부터 1000까지의 숫자 중 3의 배수이거나 7의 배수에 해당하는 숫자들의 총합을 구하여라.

# 일반

# 숫자를 담을 변수
number1 = 1
# 총합을 담을 변수
total = 0
# 1부터 1000까지 반복한다.
while number1 <= 1000 :
    # 현재 숫자가 3의 배수인지 7의 배수인지 검사한다
    if number1 % 3 == 0 or number1 % 7 == 0 :
        # 3의 배수이거나 7의 배수라면 누적한다.
        total = total + number1

    number1 = number1 + 1

# 총합을 출력한다.
print(f'총합 : {total}')

# (내 답안_수정) 일반
list1 = []
num = 0
while num < 1000 : # 1부터 1000까지
    num = num + 1 # 맨 위로. 대신 num = 0부터로 변경
    if num % 3 == 0 or num % 7 == 0 : # 3의 배수나 7의 배수일 때만
        list1.append(num) # list에 담기

# print(list1) # gpt로 개수 정답과 같은 거 확인 완료
sum(list1)

# comprehension

# 1 ~ 1000까지의 숫자 중 3의 배수 이거나 7의 배수인 숫자를 리스트에 담아준다.
list1 = [v1 + 1 for v1 in range(1000) if (v1 + 1) % 3 == 0 or (v1 + 1) % 7 == 0]
# 리스트에 담긴 숫자들의 총합을 구한다
total = sum(list1)
# 총합을 출력한다.
print(f'총합 : {total}')

# range(a,b) 없이 구현

# (내 답안) comprehension
list1 = [v1 for v1 in range(1,1001) if v1 % 3 == 0 or v1 % 7 == 0 ]
print(sum(list1))

→ 컴프리헨션이 훨씬 간단

문제3)

1부터 1000까지의 숫자 중에 3의 배수만 담아준다. 이때 3의 배수가 짝수라면 '짝수'라고 담고 홀수면 '홀수'라고 담는다.

# 숫자를 담을 리스트
list1 = []
# 1부터 1000까지 반복한다.
for v1 in range(1000) :
    # 3의 배수인지 검사한다.
    if (v1 + 1) % 3 == 0 :
        # 3의 배수가 짝수라면 짝수라는 문자열을 담아준다.
        if (v1 + 1) % 2 == 0 :
            list1.append('짝수')
        # 3의 배수가 홀수라면 홀수라는 문자열을 담아준다.
        else :
            list1.append('홀수')
# 출력한다.
print(list1)

# list1 = [in range(1000)]
# list1 = [for v1 in range(1000)]
# list1 = [for v1 in range(1000) if (v1 + 1) % 3 == 0]
list1 = ['짝수' if (v1 + 1) % 2 == 0 else '홀수' for v1 in range(1000) if (v1 + 1) % 3 == 0]
print(list1)

→ comprehension이 더 간단

뭔가를 더해서 누적시키겠다 → 초기값 0
뭔가를 곱해서 누적시키겠다 → 초기값 1

random

값 하나를 랜덤하게 추출
리스트, 튜플 전부 가능

list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

# 값 하나를 랜덤하게 추출한다.
a1 = random.choice(list1)
a2 = random.choice(list1)
a3 = random.choice(list1)

print(a1, a2, a3)

30 70 30

# 리스트가 가지고 있는 값들을 랜덤하게 섞어 준다. (리스트 자체를 바꾸는 것)
random.shuffle(list1)
print(list1)

[70, 80, 100, 60, 50, 30, 90, 10, 40, 20]

# 0 ~ 99 사이의 정수값 하나를 랜덤하게 추출한다.
a1 = random.randrange(100)
-> 34

# a ~ b 사이의 정수값 하나를 랜덤하게 추출한다.
a2 = random.randrange(-11,-1)
-> -10

# 5 ~ 30 사이이고 2씩 증가된 숫자 중에 하나를 랜덤하게 추출한다.
a3 = random.randrange(5, 31, 2)
-> 15

# 0 ~ 1 보다 작은 실수 중에 랜덤하게 뽑아낸다.
a1 = random.random()
-> 0.14888979525742851

seed

항상 같은 패턴 : 고정값
변화되는 패턴 : 현재 시간
데이터 명세서
- 데이터 분석을 위해서는 데이터분석/통계 + 도메인 지식 필요
- 이 배경 지식을 쌓기 위해 그 산업/분야의 전문가 초빙해서 데이터 명세서 제작

unpack (분해)

a1, a2, a3 = 10, 20, 30

10, 20, 30 → (10, 20, 30) (튜플) 이고

좌우 개수가 같으면

튜플의 각 값을 변수마다 일대일 대응해줌

Range

# 0 ~ 20-1 까지 1씩 증가하는 값을 관리하는 요소
r1 = range(20)

print(f'시작값 : {r1.start}')
print(f'종료값 : {r1.stop}')
print(f'증감값 : {r1.step}')
print(r1)

시작값 : 0
종료값 : 20
증감값 : 1
range(0, 20)

실제로 관리하는 값을 확인해보고 싶다면 리스트나 튜플로 다시 생성하여 출력
- print(list(r1))
- [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
3 ~ 27-1 까지 1씩 증가하는 값을 가진 range 생성
- range(3, 27)
- [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]
3 ~ 27-1 까지 2씩 증가하는 값을 가진 range 생성
- range(3, 27, 2)
- [3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25]
30 ~ 8 + 1 까지 1씩 감소
- print(list(r4))
- [30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9]

후기

분량 많다... 컴프리헨션은 그 전에 딱히 익힌 적이 없어서 어색 그 자체였다 진짜 자주 쓰나요 질문도 슬쩍 했는데 엄청 많이 쓴다고 강조 강조 강조를 하셔서 울면서 익히려고 함 확실히 슬슬 내용이 어려워짐 따라가기 조금씩 버겁 그래도 아직 평타 이상은 가는 거 같긴 한데 이게 내가 미리 배워놨으니 따라가는 거지 새로 배우는 건 뒤쳐질 수도 있겠단 생각이 들어...

[멋쟁이사자처럼 데이터분석] 제어문

Sun, 06 Apr 2025 11:30:24 GMT

Notion에서 정리한 내용을 공유용으로 옮긴 내용입니다. 양식과 구성의 어색함이 있을 수 있습니다.

04/02(수) 학습내용을 바탕으로, 당일이 아닌 추후 업로드하였음

주피터 사용 방법 ↓

Restart Kernel and Run All Cells

초기화 후 모든 셀 다시 실행
처음 나오는 화면은 실행된 것이 아니라, 그냥 이전 것이 보이는 작업내역

따라서 어제 쓴 a1=100 을 오늘 바로 코드에 사용할 수 없음
그냥 적용하면 not defined로 뜸 → 새로 실행해 주기

제어문

코드의 흐름은 순행적인데 그 흐름을 제어하는 것이 → 제어문
파이썬은 3가지의 제어문만 존재 (switch 없음)

if

결과가 T,F인 식 들어감
결과가 T면 동작
결과가 F면 동작 X

while

결과가 T,F인 식 들어감 → ☆
결과가 T면 아래 내용 수행 후 다시 ☆로 돌아감
결과가 F면 동작 X

for

데이터를 관리하는 요소 반드시 필요

if 문

else

if 문의 False인 경우 수행되는 부분
if는 T든 F든 바로 실행됨

# else
# if 문의 조건식의 결과가 False인 경우 수행되는 부분
if a1 == 100 :
    print("a1은 100입니다") # 실행 O
else :
    print("a1은 100이 아닙니다") # 실행 X

if a1 != 100 :
    print("a1은 100이 아닙니다") # 실행 X
else :
    print("a1은 100입니다") # 실행 O

a1은 100입니다
a1은 100입니다

elif

조건이 여러 개일 때
- 조건이 2개 (ex. 성별) if - else 로 가능
- 조건이 여러 개 (ex. 연령대) elif로 사용
True인 것만 수행되고 아래는 실행되지 않음
- if 문은 위에서 아래로 내려오면서 조건식을 계산함
- True인 것을 만나면 그 부분 수행
- if문 전체 수행 끝
  
  ※ 문법 검사는 코드 수행 전 따로 하기 때문에 문법은 맞아야 함

※ switch case 문

if문은 처음부터 차례차례 실행 100개 중 90번째가 T면 첫 번째부터 90개의 elif를 실행 후 결과 도출
이걸 건너뛰고 그 위치만 바로 찾을 수 있게 해주는 게 switch
but 파이썬에서는 이 부분을 없앰

※ 슈퍼 컴퓨터

1988에 슈퍼 컴퓨터 처음 들여옴
측정 기준
- 1+1을 얼마나 빠르게
- 1+1을 1초에 얼마나 많이
  
  → 전력 공급량을 생각하지 않고 측정하는 방법
- 전력량을 고려하여 측정하는 방법
  - 전력량 스트레스 테스트?
- 요즘은 속도가 거의 차이를 느끼지 못할 정도
  
  (ns 단위의 차이)
  
  → 사용자가 편한 쪽으로
  
  → 파이썬 : 개발자의 공부량을 줄이고 다 빼버림
  
  cf) 코틀린
  - 최근에 만들어진 언어
  - 공부량 오히려 늘어남
  - but 생산성 좋음 → JAVA에서 코틀린으로 바뀌는 추세

반복문

while

True인 경우 구문 실행하고 다시 돌아옴

While (조건식) :
    구문 1
else :
    구문 2

but else는 무의미. 그냥 밖에 쓰면 됨

while (조건식) :
    구문 1
    구문 2
구문 3
구문 4

while은 F가 되지 않으면 영원히 돌아감 → 무조건 False 필요
중단 시키는 방법 : Interrupt Kernel

for in

range(n) : 0부터 n-1까지 반복 (n개 반복)

반복 번째 에 해당하는 데이터가 변수에 들어감

for v1 range(10) 0,1,2,3,4,5,6,7,8,9까지 들어감
- 0이 v1에 들어감 구문 실행
- 1이 v1에 들어감 구문 실행 …
- 마지막인 9가 v1에 들어감 구문 실행
range 대신 (10,20,30)
```
  for i in (10,20,30) :
      print(i)
```
```
  10
  20
  30
```
- 10이 들어감, 반복 20이 들어감, 반복 30이 들어감, 반복
- 관리하는 데이터의 반복 번째에 있는 데이터가 변수에 들어감 → 구문 실행

설계 능력을 늘리는 연습 코딩을 실무에서는 구현할 일이 없음 그냥 갖다 씀

절대 코드 외우지 X 외우면 절대 다른 유형 문제 못 품
단기간에 코딩 테스트 봐야 한다면 암기 어쩔 수 없음 but 무조건 다시 설계하는 연습할 것 ※ 주석 더 중요해짐

while : 이 조건을 가지고 반복할 거야. / 끝나는 범위가 지정
for : 몇 번을 반복해야 하지? / 여기 있는 데이터로 반복해야지

EX

주석 필수로 달기! 한글로 설계 먼저 하고, 그 후 코드 작성하기

Ex 1) 1부터 3씩 증가시킨 숫자를 총 20개 출력

원래는 a = a + 3 과 print(a) 자리가 반대였는데, 4부터 출력되길래 순서 변경

# 학습
a = 1
for _ in range(20) :
    print(a)
    a = a + 3

이렇게 하면 for 밖에 print(a) 했을 때 61 출력됨

but 출력은 정상 작동

~~→ 다른 변수를 사용하면 됨. for 밖에서 a를 안 쓰면 되지~~

# [정답]
a1 = 1
# 1을 출력한다.
print(a1)

# 19번을 반복한다
for _ in range(19) :
    # 3을 증가시킨다
    a1 = a1 + 3
    # 출력한다
    print(a1)

Ex 2) 1부터 100까지의 숫자 중 3의 배수를 모두 출력

# [정답1]
# 1부터 100까지 반복한다.
for v1 in range(100) :
    # 3의 배수인지 확인한다.
    if (v1 + 1) % 3 == 0 :
        # 출력한다.
        print(v1 + 1)

# [정답2]
# 1부터 시작하므로 1을 가지고 있는 변수를 선언한다.
a1 = 1
# 100까지 반복한다.
while a1 <= 100 :
    # 현재 숫자가 3의 배수인지 검사한다.
    if a1 % 3 == 0 :
        # 만약 3의 배수이면 출력한다.
        print(a1)
    # 1을 증가시킨다.
    a1 = a1 + 1

# [정답3]
a1 = 3
while a1 <= 100 : # 내 풀이는 여기서 <= 대신 < 로 작성ㅠ 제대로 보자!
    # 출력한다.
    print(a1)
    # 3을 증가시킨다.
    a1 = a1 + 3

# <실행 중간>
# 숫자를 입력 받는다.
number1 = input('숫자를 입력해 주세요 :')
number2 = int(number1)
# print(number2)
# 1부터 입력 받은 숫자까지의 총합을 구한다.
# 출력한다.

# print(number2) 이 부분 보면 주석 되어 있음.

한 데까지 잘 작동되는지 확인하는 습관 들이기 그리고 주석 처리 습관화되어야 나중에 리버깅?하기도 쉬움

break / continue

단독으로 쓰이지 않고 if - break, if - continue로 씀
break, continue가 쓰이지 않아도 충분히 구현 가능 (break는 필요할 수 있음)
왜 쓰는가? 데이터의 결함이 없게끔 하기 위해 사용 → 데이터 무결성 보장
break
- True라고 하더라도 break 만나면 아래 구문 무시하고 중단
- 외부의 요인에 의해 중단해야 하는 경우 사용
  - 0이 나올 때까지 진행하는데, 언제 0이 들어갈지 모르는 경우
continue
- 끝까지 안 갔더라도, 뒤에 True인 내용이 있더라도 다음 반복 (while 위치로 올라가서) 실행
- 밑이 더 있더라도 특정 조건이면 바로 반복되게

※ 절대 하면 안 되는 행위

선택적 통계의 적용
- 내가 세운 가설이 맞다는 걸 증명하기 위해서 나에게 유리한 것만 봄
다방면 분석, 다양한 시각
내가 세운 가설이 틀렸다, 라는 걸 가설검증 → 내가 세운 가설이 맞다는 걸 주장하는 확실한 방법!

데이터 처리 단계

데이터 수집
데이터 메모리에 저장
데이터 무결성 검사
처리 및 변환
분석 및 해석
출력 및 시각화
저장 및 배포

데이터 무결성 검사를 위해 while - break 문 사용

# (학습) 데이터 결함 검사 예시 1
a1 = 0
while a1 <= 100 :
    a1 = a1 + 1
    if a1 % 3 == 0 :
        print(a1)

# (학습) 데이터 결함 검사 예시 2
a1 = 0
while a1 <= 100 :
    a1 = a1 + 1
    if a1 % 3 != 0 :
        continue
    print(a1)

과제 - 04.02

1부터 1000까지 숫자 중 소수를 모두 출력한다.

# 1부터 1000까지 반복한다.
number1 = 1

while number1 <= 1000 :
    # 2부터 현재 숫자 - 1까지 반복하며 나머지를 구해본다.
    number2 = 2

    # 소수인지의 여부를 판단하기 위한 변수
    isPrimeNumber = True

    while number2 < number1 :
        # 만약 하나라도 나누어 떨어지게 된다면 소수가 아니므로 다음 반복으로 넘어간다
        if number1 % number2 == 0 :
            isPrimeNumber = False
            break

        number2 = number2 + 1
    # 만약 나누어 떨어지는 숫자를 만나지 못했다면 소수이므로 출력한다
    if number1 != 1 and isPrimeNumber == True :
        print(number1)

    number1 = number1 + 1

후기

설명 들으면서 느끼는 수학과의 공통점

처음 헷갈리면 일단 하나씩 다 해보고 반복되는 부분 찾으라고 하심

→ 축차대입법. 하나씩 해보면서 규칙 찾는 방법
외우기만 하면 안 되고 스스로 설계하는 과정 필요

→ 수학도 단순 공식 암기에서 끝나거나 문제를 외우는 것이 아니라 개념에 대한 이해 필요

수시 대비는 어쩔 수 없이 외우더라도 그 후 반복하여 익히기

내가 설계하는 것보다 다른 사람이 만든 코드 이해하는 게 확실히 더 어렵다…

소수 알고 있는 개념이고 알고리즘 방식 알고 있어도 약간 차이가 있을 때 아 이걸 여기서 넣었구나, 이 개념 이렇게 했구나가 확실히 내가 구현하는 것보다 느림

주석이 진짜 필필수…남 보여줄 거면 자세할수록 좋다

[멋쟁이사자처럼 데이터분석] 주피터 사용법, 파이썬 기초

Sun, 06 Apr 2025 11:00:33 GMT

Notion에서 정리한 내용을 공유용으로 옮긴 내용입니다. 양식과 구성의 어색함이 있을 수 있습니다.

04/01(화) 학습내용을 바탕으로, 당일이 아닌 추후 업로드하였음

python 장점

(강사님 개인취향ㅎㅎ)

쉬움
- 3일이면 다 배울 수 있다.
일관성
- 파이썬에서 오류가 난다 → 다른 곳에서도 똑같이 오류 발생
- 오동작한다면 다른 문법에서도 오동작함
개방형 언어
- 다른 사람들이 만들어 놓은 라이브러리가 많다
- 배포가 용이

주피터 노트북 사용 방법

귀여운 경로 트러블
- 처음에 열었을 때 보통 경로가 써 있는 곳에
  
  /
  
  만 있는 거임
  
  오류인가 했는데 알고 보니 처음은 /로 나오고 그 뒤로 경로가 붙는 것.
  
  나는 처음 열리는 폴더에서 바로 작업하게 해 놔서 저게 끝인 거였다 :)
- ** 그 창을 닫지 마... **
  
  그 다음 문제. 주피터는 열렸는데, NEW ipynb 안 열리는 문제 발생.
  
  당황해서 막 workspace 옮겨보고 하다가
  
  프롬프트 창을 닫으면 안 된다는 것을 처음으로 알았다!ㅋㅋㅋ
  
  바로바로 닫는 성격인 나 (안 그럼 자동채점은…뭐가 열렸는지 글씨가 안 보일 정도로 꽉 차는걸…안 쓰는 거 다 닫아놔야 함…)
  
  줌/웨일/zep/카톡/디코/실행하는 폴더 등등 이미 표시줄 꽉 차서 프롬프트 닫았는데 그게 원인이었다
  
  매우 다행 lolol
  
  그 와중에 또 거슬리는 거 싫어서 가상 데스크톱 만들어서 거기에 zep 이랑 프롬프트랑 줌 안 쓰는 창 다 넣어놓음
  
  앞으로도 이렇게 쓰지 않을까 싶다ㅎㅎ

cell : 위 사진의 나누어진 한 칸
버튼 : 위/아래로 이동, 위/아래로 삽입, 삭제
command mode : 밖을 클릭해서 회색으로 된 상태

edit mode : 안을 클릭해서 흰색으로 되어 있고 커서 들어간 상태
code/markdown/raw 모드로 변경 가능
- code mode : 코드 작성 / 왼쪽에 [ ]
- markdown : 주석 / 왼쪽에 [ ] 가 없음

~~아 영문 작성창은 예쁜데 실제 업로드 글씨체가 너무 안 예뻐!!!~~

💡

데이터 분석 / AI 메모리 관리

kernel - Restart Kernel and Run All Cells : 전부 다 초기화하고 다시 실행
주피터 닫고 다시 실행
Running - X 누르기 또는 오른쪽 Shut Down All
이전 프로젝트는 무조건 SHUTDOWN 시키기 보통 데이터 단위가 어마어마하기 때문에 (테라인 경우도 다수) 메모리 부족을 겪는 경우가 많음

주석

실제 주석은 #뿐.
여러 줄 주석으로 쓰는 “”” 나 ‘’’ 는 실제로는 주석이 아니라 사실 문자열
데이터 메모리를 차지한다는 얘기 (주석의 def는 기본적으로 skip 하고 건너뛰어야 주석)
주피터는 맨 밑의 값이 실행됨
```
  100
   200
```
200

따라서 주피터에서

    """
    동해물과 백두산이
    마르고 닳도록
    """

이것만 쓰면 '\n동해물과 백두산이\n마르고 닳도록\n' 출력됨

뒤에 보통 코드와 print() 가 나오니 실행이 안 되는 것

    a1 = 10
    print(10)
    300

10 300

일부 제외하고 정리

식별자

이름/identifier
규칙 ← 지키지 않으면 문제가 발생
- 첫 글자는 영문 대소문자/한글/_ 가능 # 숫자가 안 됨!
- 이후 영문 대소문자/한글/숫자/_ 가능

표기 기법

카멜 표기 기법 : koreanTotalAverage # 맨 앞 소문자
파스칼 표기 기법 : KoreanTotalAverage # 맨 앞 대문자
스네이크 표기 기법 : korean_total_average
변수 : 카멜
함수 : 카멜
클래스 : 파스칼
타입 : 파스칼 (나무위키피셜)
상수 : 모든 글자를 대문자로, 스네이크

복습 방식

예제 가져와서 읽어보기
새로운 파일 만들기
코드를 보고 이해한 순서 한글로 주석 적기
주석 보고 파이썬 코드로 변환하기
주석 지우기
반복하기

→ 작업의 순서를 설계할 수 있는가가 중요 → 많이 읽고 눈으로 익혀 보기 다른 사람 코딩을 볼 때도 주석 작성해 보기 → 절대 코드부터 나가지 말 것! 실무에서는 다이어그램 기획서, 설계 문서를 보고 코딩을 하게 되고, 경력이 쌓이면 내가 설계를 하게 됨 코딩 문법은 AI가 알려 주지만, 순서 설계 능력은 키워야 함!

컴퓨터 장치
- CPU
  - 저장된 코드 가져다 씀
  - 속도 매우 빠름
- HDD, SDD (저장장치)
  - 속도 매우 느림
  - 저장된 데이터를 CPU가 필요할 때부터 옮기기 시작하면 느림/비효율적
- 중간 창고인 RAM에 저장
  - 단위용량당 가격 비쌈
  - 빠를수록 비싸짐
  - 전기 공급 중단되면 데이터 삭제됨
프로그램 동작시
- RAM에 저장
- 저장된 데이터 처리
- 처리된 결과 출력
  
  ※ 저장-처리-출력-저장-처리-출력 X
  
  한 번에 저장, 한 번에 처리, 한 번에 출력

RAM

RAM은 1byte 단위로 나누어져 있고, 필요하다면 벽을 뚫어서 넓게 사용하는 것 가능
메모리의 주소값이 존재 (0,1,2,…) : 1byte마다 0,1,2 이런 식으로 주소값이 있음
하나를 저장하면 그 자리에는 저장 X. 같은 위치에 저장하려 하면 덮어씌워짐
RAM에서 필요한 것
- 위치 : 이름 지정. 그럼 VM이 알아서 판단하여 크기 파악해서 위치 정하고 기억.
- 크기 : 파이썬은 정해져 있음.
- 용도 : 개발자 입장에서는 정해져 있음.
따라서 이름만 정하면 됨. (보통은 이름,타입이지만 파이썬은 타입 필요 X)

리터럴

print('정수 :', 100)
print('실수 :', 11.11)
print('문자열 :', '하하하')
print('참 :', True)
print('거짓 :', False)
print('지수 :', 2e5)
print('복소수 :', 10 + 8j)
print('세자리 마다 표시 :', 123_456_789)
print('없음 :', None)

2e5 : $2×10^5$
세자리마다 _를 써서 구분해도 그냥 정수로 표시.
- 맨 앞, 뒤는 불가능 print(_123) # 오류 발생 print(123_) # 오류 발생 ~~아 역슬래시로 강제 기울임 마크다운 막을 수 있네 위에 _123 표시 때문에 강제로 폰트 기울어짐...ㅋㅋㅋ~~
- 정수 부분에만 가능 print(123_456.789) # 가능 (정수 부분에만 _ 있음) print(123._456) # 오류 발생 (_가 소수점 뒤에 있음)
- 123_456 (\ 연달아 두 개 이상)은 안 됨

# type을 쓰면 값의 타입을 파악할 수 있다
print(type(100))
print(type(11.11))
print(type('하하하'))
print(type(True))
print(type(False))
print(type(2e10))
print(type(10 + 8j))
print(type(123_456_789))
print(type(None))

→ 실수 → 불리안

변수

# 파이썬은 변수의 선언과 동시에 저장할 값을 지정해준다.
# = : 대입연산자. 오른쪽에 있는 값을 왼쪽의 변수에 저장하는 작업을 수행한다.
a1 = 10
a2 = 11.11
a3 = '안녕하세요'

# 여러 변수에 같은 값을 저장하고자 한다면...
a5 = a6 = a7 = 100
print(a5)
print(a6)
print(a7)

# 각 변수에 저장될 값을 각각 다를 경우 다음과 같이 하는 것도 가능하다.
# 여기에는 tuple 이라는 것과 관련된 비밀이 숨어 있다.
a8, a9, a10 = 100, 200, 300
print(a8)
print(a9)
print(a10)

파이썬에서는 쉼표(,)로 구분된 값들이 자동으로 튜플로 간주됨
(a8, a9, a10) = (100, 200, 300) 과 a8, a9, a10 = 100, 200, 300 은 동일
a8, a9, a10 = 100, 200, 300 (a8, a9, a10) = 100, 200, 300 a8, a9, a10 = (100, 200, 300) 전부 다 가능.

파이썬 3.6 부터 변수에 자료형을 명시할 수 있다. (int, bool 같은 데이터의 타입) 변수를 정의할 때 자료형을 명시하면 값을 지정하지 않아도 된다. 단 변수를 사용하기 전에 반드시 값을 저장해야 한다.
변수에 자료형을 붙여 주는 이유

변수를 선언할 때 최초의 값을 지정해주고 싶지 않을 때 -> 그냥 값을 0 같은 값을 넣어주면 된다.
변수의 타입을 명시적으로 표현하고 싶을때 -> 다른 타입의 값을 저장할 수 있기 때문에 별 의미가 없다.


a11:int

a11 = 100
print(a11)

a11 = 11.11
print(a11) # (출력하면 그냥 오류 없이 출력돼서 의미가 없음.)

최초의 값을 지정해주고 싶지 않을 때
1. 함수 중간에 값이 결정될 때 → 초기값 0 등으로 설정
2. 반복문에서 특정 조건이면 출력되는 변수 → 초기값 0, -1 등으로 설정
3. 클래스의 인스턴스 변수 → 생성자 __init__() 사용
4. 여러 경우 중 특정 조건이 만족될 때 값이 정해지는 경우 (근데 미리 선언하고 싶음) → “Invalid” 같은 걸 대신 넣어서 오류시 출력되도록 함

연산자

산술 연산자

- : 더하기
- : 빼기
- : 곱하기
/ : 나누기. 결과가 실수
// : 나누기. 결과가 정수 (몫)
% : 나머지
** : 거듭제곱 → 2^3

비교 연산자

좌측의 값이 우측값과 비교하여 어떻다, 라는 연산을 수행한다.
결과는 True나 False로 나온다.
"==" : 좌측의 값이 우측의 값과 같은가
"!=" : 좌측의 값이 우측의 값과 다른가
">" : 좌측의 값이 우측의 값보다 큰가
"<" : 좌측의 값이 우측의 값보다 작은가
">=" : 좌측의 값이 우측의 값보다 크거나 같은가
"<=" : 좌측의 값이 우측의 값보다 작거나 같은가

증감 연산자(대입 연산자)

++, -- : 변수에 저장되어 있는 값을 1 증가시키거나 1 감소시키는 연산자이다. 파이썬은 지원하지 않는다.
+=, -=, =, /=, //=, %=, *= 연산자를 사용할 수 있다.

취향에 안 맞으면 쓰지 않아도 됨

논리 연산자

연산자 좌측과 우측에는 참, 거짓이 결과인 연산식이 존재해야 한다.
and : 좌측과 우측이 하나라도 False면 최종 결과는 False가 된다.
or : 좌측과 우측이 하나라도 True면 최종 결과는 True가 된다.
not : 우측의 결과가 True면 False로, False면 True로 바꿔준다.

v1 = 10
v2 = 20
print(not v1 < 5)
print(not v1 > 5)

True
False

10<5 가 False이므로 → True

10>5가 True이므로 → False

당연히 vscode로 할 거라 생각했는데 주피터라는 새로운 환경에서 적응하느라 어색한 감이 더 크다.

초반이라 주피터 가지고 놀기에 좀 더 몰입한 듯...

그리고 새로운 걸 배우기 시작하면 왠지 당연하게 단축키부터 외우게 된다.

한글로 문서 편집, 검수할 당시 진짜 온갖 단축키에 매크로 다 달고 살아서 그런가 효율적이고 빠르지 않으면 못 견디게 되어버림.

주피터 노트북 실행 경로 변경

Sun, 06 Apr 2025 08:57:44 GMT

~~시키지 않은 짓을 했다가 나의 난리 여행 시작~~

강의 내용이 아닌 혼자 난리친 내용입니다.

검색으로 들어오신 분들. 큰 도움이 안 될 수 있습니다.

주피터는 설치는 굉장히 쉽다.

정확히는 아나콘다 설치가 쉽다.

다만...그 주피터가 열리는 위치가 맘에 안 드는 사람이 분명...있을 것이다.

쓰지도 않는 사용자 폴더 뭐냐고

강사님께서는 Desktop에 workspace 폴더 위치시키라고 하셨지만…

D 드라이브에 모든 걸 쑤셔넣고 배경화면엔 최소한의 폴더와 귀여운 애옹이만 있어야 하는 나

용서할 수 없었다.

우리 애옹이 지켜

jupyter notebook 실행방법

anaconda navigator → jupyter notebook
anaconda prompt → jupyter notebook
프롬프트에서 ‘인터넷 주소 부분’ 컨트롤+클릭 or 복붙
(윈도우) jupyter notebook 아이콘 클릭

나는 이 중에서 주피터 노트북 바로 클릭하는 방법을 주로 이용했고, 따라서 이 아이콘의 "시작 위치"를 변경해 보기로 함

변경 시작

1. 속성-시작 위치 변경

윈도우 기준 시작 메뉴에 뜨는 Jupyter Notebook 아이콘 눌러 실행하는 방식이 제일 간단했기 때문에 파일 위치 열어서 시작 위치 변경

- _config.py 수정하는 방법도 같이 나왔는데, 그냥 아이콘만 건드리고 싶었음
- ‘부트캠프’ 폴더를 바탕 화면으로 옮겨 놨기 때문에 먼저 D 드라이브 다른 폴더로 시도

- “시작 위치”에 %USERPROFILE% 대신 D:\Study\파이썬 삽입 (아래가 속성창)
    ![](https://velog.velcdn.com/images/blue_cherry/post/bf2b667e-cb2a-4815-9b98-ffaa5a6be8cc/image.png)

    **→ 그대로 유저 창에서 시작 ㅜ**

- “대상”이
C:\Users\Administrator\anaconda3\python.exe C:\Users\Administrator\anaconda3\[cwp.py](http://cwp.py/) C:\Users\Administrator\anaconda3 C:\Users\Administrator\anaconda3\python.exe C:\Users\Administrator\anaconda3\Scripts\[jupyter-notebook-script.py](http://jupyter-notebook-script.py/) %USERPROFILE%
로 되어 있음. 대상 수정
- C:\Users\Administrator\anaconda3\python.exe C:\Users\Administrator\anaconda3\[cwp.py](http://cwp.py/) C:\Users\Administrator\anaconda3 C:\Users\Administrator\anaconda3\python.exe C:\Users\Administrator\anaconda3\Scripts\[jupyter-notebook-script.py](http://jupyter-notebook-script.py/) "D:\Study\파이썬"

    **→ 정상 작동!**

2. 이제 바탕화면의 “부트캠프”폴더 다시 D드라이브에 넣고, 부트캠프로 폴더 변경

“대상” 부분이 분명 원래 수정이 됐는데, *갑자기 회색으로 막힘. *왜…? 프롬프트가 뜨긴 뜨는데, 주피터는 열리지 않음…
관리자 권한으로 실행해 보고, 권한 줬다 뺐다 해보고, 이것저것 바꿔도 안 됨

3. 이것 저것 시도

시작 위치 되돌려 보기
```
  → 실패
```

다른 주피터 실행 방법들은 정상 작동되는지 확인

CMD에서 실행 → jupyter notebook 입력

'jupyter'은(는) 내부 또는 외부 명령, 실행할 수 있는 프로그램, 또는 배치 파일이 아닙니다.
- Anaconda 프롬프트에서 시도

→ 정상적으로 실행됨

프롬프트 시작 위치 변경

→ 정상 작동

어쨌든 이 방법이 되긴 되는 것. 꼬인 것뿐…

프롬프트로 매번 열기에는 ‘jupyter notebook’ 이거 쳐야 해서 너무 귀찮음

- Anaconda Navigator

    → 정상 실행. but USER 파일에서 시작됨

- where jupyter로 경로 찾아서 다시 바로가기 경로를 수정

    → 클릭했는데 마찬가지로 잠깐 열렸다가 바로 닫히는 현상

4. 성공

원본 위치? 에 가서 jupyter-notebook.exe 누르니까 정상 실행
저 exe에 대해서 새 바로가기 생성
"C:\Users\사용자명\Anaconda3\Scripts\jupyter-notebook.exe" --notebook-dir=D:\Study\부트캠프\workspace\01_Python

이렇게 지정해서 새로 만들고, 아이콘 png?도 원래 주피터 아이콘 이미지 찾아서 설정

새로 시작 위치에 고정..

못 쓰게 되어 버려진…이전 아이콘 🤣

어쨌든 바탕화면에서 D 드라이브로 폴더 위치도 옮겼고, 실행도 한 번에 바로 되니 만족하며 쓰기로…
** :) HAPPY ENDING!**

[멋쟁이사자처럼 데이터분석] 파이썬 개요, 개발환경 구축

Sun, 06 Apr 2025 08:33:23 GMT

Notion에서 정리한 내용을 공유용으로 옮긴 내용입니다. 양식과 구성의 어색함이 있을 수 있습니다.

03/31(월) 학습내용을 바탕으로, 당일이 아닌 추후 업로드하였음

OT를 소요시간 착각으로 앞부분만 듣고 다음 일정을 위해 차를 타러 급하게 가느라 첫날 눈치를 좀 봤다... 그리고 하필 강사님이 자리 비우지 말아라 하시면서 출석 어쩌구 얘기를 꽤 하셨음ㅋㅋㅋ아 찔려

그래도 처음 시작하는 과목인 파이썬은 기존에 유튜브로 공부를 좀 했던 파트라 조금 손쉽게 들을 수 있어 다행이었다. ~~(응 백준 브론즈)~~

목표는 진짜 꾸준히 출석하기

Python 개요

프로그래밍 언어의 발전

프로그래밍 언어의 시초
- 포트란 : 수학 계산 최적화
- Algol : 최초의 프로그래밍 언어. 포트란에 대항하여 만들어짐 = A 언어
- B 언어 = Bell 언어
- 그 후 C 언어 → C++ → C# ~~++에 ++이 아래로 더 붙어서 # 모양. 아이디어 미쳤~~
C 언어
- OS를 만들기 위해서 만든 언어
OS 종류
- 유닉스 : 최초의 OS - 슈퍼,워크스테이션 / IOS 등
- 리눅스 : 라이트 유닉스 - 웹서버/안드로이드에서 사용
- Window

플랫폼

플랫폼이란?
- ex) 배민
  
  → 고객과 식당과 배달원을 연결해줌 but 그냥 연결하는 것이 아니라 각각을 위한 어플을 만들어서 그 어플에 맞춰 주문/배달/음식 제공
- 즉, 이미 만들어진 곳에서 들어와서 돌아가는 것
- 규칙, 규격에 맞춰서 작업하면 언제든 사람들이 더 들어오고 확장할 수 있음
  
  ~~이래서 초반에 플랫폼 시장에서 잘 만들어 놓으면 독과점이 쉬워지는…~~
- 기차들을 '플랫폼'에 맞춰서 만들었기 때문에 승객이 KTX를 타든 1호선을 타든 타고 내릴 수 있음

독립성

개념

‘플랫폼 독립적’에서 플랫폼은 'OS'를 말함
독립적 ↔ 종속적
만약 Window에서 만들어서 Window에서만 돌아간다면 → 플랫폼에 종속적

독립성/종속성 비교

플랫폼에 독립적이냐 종속적이냐를 잘 알고 있어야 함

독립적인 소프트웨어
- 느림, 메모리 많음
- 개발자가 만든 코드를 윈도우/맥/리눅스 모두에서 실행 가능
- 결과물이 실행 파일로 나오는 것이 아님.
  
  바이트 코드나 스크립트 형태로 도출되며, 인터프리터나 가상 머신을 통해 실행 (by GPT)
- JAVA, Python : 플랫폼 독립적
종속적인 소프트웨어
- 장점 : 메모리 덜 사용, 처리속도 빠름
  
  OS에서만 되게 만들면, 그냥 그 OS에서 지원하는 기능?을 갖다 쓰면 되기 때문에 실행파일로 결과물 도출

    실행파일 용량이 적고, 속도가 빠름

    그 OS에 최적화되면 메모리, 처리속도에 여유가 있으므로, 그래픽에 더 투자할 수 있음

- 단점 : 각각 OS에 맞춰서 개발자가 여러 개를 만들어야 함
- C 언어 계열 : 플랫폼 종속적
- 게임은 주로 종속적 ← 속도가 매우 중요

독립성의 이해/비유

ex) 라틴어 책을 읽고 싶다면 취할 수 있는 방법

여기서 "출판사 = 개발자"

한국 버전 번역서 읽기 = 플랫폼에 종속적
- 출판사 → 한국 번역서 출간, 중국 번역서 출간, 일본 번역서 출간…
  - 출판사 : 나라별로 여러 개 각각 판매. 한 번역서는 그 나라에서만 가능
  - 어느 나라에서 많이 읽힐지 고려하여 출간

    -    많은 돈, 많은 시간

    - 독자 : 쉽게 읽을 수 있음. 자신에게 편한 언어. 독자 친화적

 → 개발자가 여러 OS로 만들기와 동일

  - 어느 나라(플랫폼)에서 많이 쓰일지 고려하여 개발

  - 많은 비용/시간 소요

  - 개발사의 어려움

번역가가 읽어주기 = 플랫폼에 독립적
- 출판사는 라틴어로 된 책만 출간
- 라틴어를 한국어로 실시간으로 통역하는 사람 고용
  
  라틴어를 일본어로 실시간으로 통역하는 사람 고용
  
  …
  
  → 라틴어로 된 책을 사면 → 그 나라의 통역가 보내서 읽어줌
- 책은 1번만 쓰임
  
  통역가 미리 대기시키면 됨
- 초기 투자/비용만 들이면 됨
- 매번 실시간으로 한 명 한 명 배당하므로 메모리 많이 사용, 처리속도 느림
- but 프로그래밍 개발에 주류로 쓰임. Why?
  - 하드웨어의 발전 → 속도 차이 현저히 감소

파이썬

플랫폼에 독립적
- OS에 맞는 언어 형태로 번역해 줌
- VM(python virtual machine) : 인터프리터 내장 → 파이썬 코드를 win/mac 등등으로 번역해줌
어떤 코드를 만들어도 그 OS에 맞춰서 동작함 (윈도우용 파이썬/맥용 파이썬을 설치한다면)
GPL 라이센스 : 수정/배포에 자유로움
개방형 언어 : 여러 개발자가 다같이 발전시킬 수 있음
수치 연산 빠르게 가능 : Torch - Numpy
- AI/ML에서 학습/추론이 중요
- 추론은 금방 가능
- but 학습에는 많은 시간이 소요
  - 대규모 연산은 시간이 오래 걸림
  - Numpy → 빠른 배열 연산 가능
  - 계산 단축을 위해 GPU 연산 필요 → Torch : GPU 연산 지원
  - 파이썬에 이미 PyTorch 내장, Numpy와 변환도 쉬움

개발도구

방식

일반 코딩 방식 : 실행하면 쭉 실행 컴퓨터에서 동작하는 프로그램 만들 때 용이 웹서버, 데몬, 사용자가 사용하는 컴퓨터용 프로그램 등
노트북 방식 : 원하는 부분 원할 때 실행 실행 결과가 바로바로 코드 아래에 삽입 데이터 분석 등등

→ 수업에서는 노트북 방식 사용 vscode로 해보긴 하고 그 후 아나콘다 이용

종류

VS Code : 마이크로소프트 개발. 다양한 개발 분야 지원. 가벼움
- 단점 플러그인 많음 모르면 쓰기 힘듦 프로젝트 폴더 관리의 호불호 ~~(강사님의 불호ㅎㅎ)~~
PyCharm : Jet Brains 개발. 파이썬용 개발 도구
- 단점 : 무거움. 기능이 많아서 용량이 큼
jupyter : notebook 방식, 웹브라우저 사용. (데이터 분야에서 많이 사용)
- 단점 : ai 어시스턴스 없음

개발환경 구축

1. python 설치

python.org
다운로드
설치시 '반드시' add python x.x to PATH 체크

2. vscode 설치

그냥 설치-쭉 하고

Extention에서 python 설치

3. 아나콘다 설치

anaconda 사이트
Free Download → Skip 후 OS 맞춰 설치
업데이트 하면 느리므로 하지 말자!

jupyter notebook 실행방법

anaconda navigator → jupyter notebook
anaconda prompt → jupyter notebook
프롬프트에서 ‘인터넷 주소 부분’ 컨트롤+클릭 or 복붙

4. 주피터 노트북 사용

PDF 만드는 법
1. Save as 에서 HTML 로 변환
2. HTML 켜서 인쇄-PDF로 저장
만약 ipynb 너무 길어서 안 열리면 txt로 떠서 빼서 저장하기

너무 많이 출력하면 그럴 수 있음
안드로이드 뷰어 : ipynb viewer pro (200원)

기타 : 빅데이터 관련 추천

강사님이 봤으면 좋겠다고 추천해 주신 목록들

Morgan AI로 만든 예고
시사기획 창, 빅데이터 세상을 바꾸다 빅데이터, 비지니스를 바꾸다
스타트업

마녀(드라마)

아 벨로그 어렵네...양식 엉망이다 진짜

공부 후기라기에는 오늘은 개발환경 구축이 메인이었던 느낌이다 역시 제일 어려운 건 설치...

이게 제일 어렵고 제일 귀찮아 그래도 같이 공유해주는 사람이 있으니까 다들 편하게 하실 수 있었던 듯 ~~(부럽)~~

잠깐. Velog 폴더 개념이 없어...?

Wed, 02 Apr 2025 11:22:49 GMT

벌써 좀 당황스러워... 일단 알아가는 글쓰기

보통 공부를 노션에 정리하는 편인데 부트캠프에서 챌린지를 해서 어쩔 수 없이 공유용 블로그? 개설

글씨체는 바꿀 수 없군요. 고딕이라 봐드리겠습니다. 근데 내가 쓸 때는 0 lI| 개발자들 쓰는 폰트인데 (consolas인지 D2coding인지도 모름...난 개발자가 아닌걸) 오른쪽 view? 에는 다른 글씨네. 어떻게 적용되는 거지

제목

####### 제목 오 뭐야 다 지원되네???

괜찮은데...? '실험' "실험" 실험 """오오"""

일단 노션에서 벨로그로 옮겼을 때 최대한 많이 잘 옮겨지길 바라며... 그러고 보니 색도 없군요. 배경으로 떡칠하면 안 되겠네. 미래의 나를 위해 볼드로 최대한 강조해 보는 걸로

일단 중간 중간 알려주는 임시 저장은 맘에 든다. 개발자의 트라우마를 자극하지 않으려 최선을 다하고 있구나 벨로그.