j_jume.log

[제로베이스_데이터 취업 스쿨 16기](7/10 ~ 7/16) - EDA_Proj4

Thu, 13 Jul 2023 04:01:35 GMT

네이버 개발자 Document 에서는 네이버 검색 기능에 대해 Open API 서비스를 제공하고 있다. 아래는 Python 에서 활용할 수 있는 코드를 직접적으로 제공해준 것이다.

# 네이버 검색 API 예제 - '블로그 검색'
import os
import sys
import **urllib.request**

**client_id** = "4omsiCD4L2V8zrVCumOq" -- 서비스 API 를 요청하면 아이디와
**client_secret** = "0Toygo8jG_" -- 비밀번호를 제공해준다. 
encText = **urllib.parse.quote**("파이썬")
url = "https://openapi.naver.com/v1/search/**blog**?query=" + encText # JSON 결과
# url = "https://openapi.naver.com/v1/search/**blog.xml**?query=" + encText # XML 결과
request = **urllib.request.Request**(url) # 요청하고
request**.add_header**("X-Naver-Client-Id",client_id)
request**.add_header**("X-Naver-Client-Secret",client_secret)
response = **urllib.request.urlopen**(request) # 요청받은 페이지를 받아오고
rescode = response**.getcode()** #정상적으로 받아왔는지 확인, (=status, code)
if(rescode==200):
    response_body = response**.read()**
    print(response_body**.decode('utf-8')**) 
else:
    print("Error Code:" + rescode)

✅ urllib.parse.quote ✅

▶️ 아스키코드 형식이 아닌 글자를 url 인코딩 시켜준다.

들어갈 수 있는 인자에는 string, bytes 형식이 들어간다.

그래서 Naver API를 사용해서 하고 싶은 웹스크래핑이 뭐냐?

요즘 장마철이고..비도 많이 와서 개인적으로 구매하고픈 ‘헌터 부츠’ 에 대해 쇼핑 검색 데이터를 뽑아보기로 했다.🥹

# 네이버 검색 API 예제 - '헌터 부츠' 검색 (쇼핑)
import os
import sys
import urllib.request
client_id = "4omsiCD4L2V8zrVCumOq"
client_secret = "0Toygo8jG_"
encText = urllib.parse.quote("헌터부츠")
url = "https://openapi.naver.com/v1/search/shop?query=" + encText # JSON 결과
# url = "https://openapi.naver.com/v1/search/blog.xml?query=" + encText # XML 결과
request = urllib.request.Request(url)
request.add_header("X-Naver-Client-Id",client_id)
request.add_header("X-Naver-Client-Secret",client_secret)
response = urllib.request.urlopen(request)
rescode = response.getcode()
if(rescode==200):
    response_body = response.read()
    print(response_body.decode('utf-8'))
else:
    print("Error Code:" + rescode)

물론, 위의 Open API 서비스를 사용해서 가져올 수도 있지만, 수동으로 직접 비슷하게 구현해보기로 한다.

이때, 필요한 함수들을 만들어줘야 하는데 아래와 같다.

검색 search url 뽑아오기
데이터 읽어오기
필요한 데이터만 파싱해서 데이터프레임으로 만들어주기
불필요한 태그 없애주기
각각의 데이터프레임 합쳐주기(concat)

위의 함수들을 만들어주고 실행한 다음, 엑셀에 데이터를 저장하는 방법에 대해서도 실습한다.

pd.ExcelWriter 사용하기

간단한 sns.countplot 시각화

(1) 검색 url 만들어내기 : gen_search_url()

# api_node: 네이버 검색 url 중 '쇼핑','사전','책' 등의 카테고리를 담을 node
# search_text : 내가 검색할 상품 이름
# start_num : 검색 시작 위치(기본값 : 1, 최댓값 : 1000)
# disp_num : 한번에 표시할 검색 결과 개수(기본값 : 10, 최댓값 : 100)
def gen_search_url(api_node, search_text, start_num, disp_num):
    base = "https://openapi.naver.com/v1/search"
    node = "/" + api_node + '**.json**' # json 데이터 형식이므로
    param_query = "?query=" + **urllib.parse.quote**(search_text)
    **param_start** = "**&start=**" + str(start_num)
    **param_disp** = "**&display=**" + str(disp_num)

    return base + node + param_query + param_start + param_disp

gen_search_url('shop', '헌터부츠', 10, 3)

(2) 검색 데이터 읽어오기 : get_result_onepage

import **json**
import datetime

def get_result_onepage(url):
    request = **urllib.request.Request**(url) # 위에서 생성한 url 이 인자로 들어간다.
    request**.add_header**("X-Naver-Client-Id",client_id)
    request**.add_header**("X-Naver-Client-Secret",client_secret)
    response = **urllib.request.urlopen**(request)
    print("[%s] Url Request Success" % datetime.datetime.now())
    return **json.loads**(response**.read().decode('utf-8')**)

url = gen_search_url('shop','헌터부츠',1,5)
one_result = get_result_onepage(url)
one_result

(3) 필요한 데이터만 파싱해 데이터프레임 만들기 : get_fields()

import pandas as pd

def get_fields(json_data): # 위에서 만든 one_result 가 인자로 들어간다.
    title = [each['title'] for each in json_data['items']]
    link = [each['link'] for each in json_data['items']]    
    price = [each['lprice'] for each in json_data['items']]    
    mall_name = [each['mallName'] for each in json_data['items']]    

    result_pd = pd.DataFrame({
        "title": title,
        "link": link,
        "price": price,
        "mall": mall_name,

    }, columns=['title','price','link','mall'])

    return result_pd

🔻 결과 🔻

(4) title 필드의 태그 없애주기 : delete_tag()

def **delete_tag**(input_str):
    input_str = input_str.replace('' ,'')
    input_str = input_str.replace('' ,'')
    return input_str

import pandas as pd

def get_fields(json_data):
    title = [**delete_tag**(each['title']) for each in json_data['items']]
    link = [each['link'] for each in json_data['items']]    
    price = [each['lprice'] for each in json_data['items']]    
    mall_name = [each['mallName'] for each in json_data['items']]    

    result_pd = pd.DataFrame({
        "title": title,
        "link": link,
        "price": price,
        "mall": mall_name,

    }, columns=['title','price','link','mall'])

    return result_pd

🔻 결과 🔻

(5) 위의 함수를 사용해서 간단하게 API 사용, 데이터프레임 형성, concat 까지 수행하기

result_mol = []
**for n in range(1,1000,100): # 총 1 ~ 1000까지의 검색 결과 위치를 스크래핑해오고 싶다면**
    url = gen_search_url('shop','헌터부츠', n, 100)
    json_result = get_result_onepage(url)
    pd_result = get_fields(json_result)

    result_mol**.append**(pd_result)

result_mol = pd**.concat**(result_mol)

result_mol.reset_index(drop=True, inplace=True)
result_mol['price'] = result_mol['price'].astype('float')

(6) 엑셀파일에 저장해주기

pd.ExcelWriter

엑셀의 여러 시트에 데이터를 적용해주고자 할때 일반적으로 활용된다.

또는, 기존의 파일에 새 시트만 추가하여 저장하고자 할때 사용된다.
파이썬에서 엑셀의 형식, 스타일 지정해주기

writer = **pd.ExcelWriter**('../data/06_hunter_boots_in_naver_shop.xlsx', **engine='xlsxwriter'**)
result_mol**.to_excel**(**writer**, **sheet_name='Sheet1'**)

**workbook** = writer**.book**
**worksheet = writer.sheets['Sheet1']**
worksheet.**set_column**("A:A", 4) # 컬럼별 공간 크기 지정
worksheet.set_column("B:B", 60)
worksheet.set_column("C:C", 10)
worksheet.set_column("D:D", 10)
worksheet.set_column("E:E", 50)
worksheet.set_column("F:F", 10)

worksheet.**conditional_format**('C2:C1001', {'type': '3_color_scale'})
writer.save()

간단한 countplot 으로 시각화

import set_matplotlib_hangul
import matplotlib.pyplot as plt
import seaborn as sns

plt.figure(figsize=(15,6))

sns.countplot(
    x = result_mol['mall'], # x = 를 꼭 넣어줘야 한다. 
    data=result_mol,
    palette='RdYlGn',
    order=result_mol['mall'].value_counts().index[:10]
)
plt.xticks(rotation=90)
plt.show()

🔻 결과 🔻

‘헌터 부츠’와 관련된 상품 마켓은 네이버 쇼핑이 압도적인 것을 확인할 수 있다.

[제로베이스_데이터 취업 스쿨 16기](7/3 ~ 7/9) - EDA_Proj3

Tue, 11 Jul 2023 02:23:51 GMT

크롤링을 진행할 때, 동적 페이지의 경우에는 BeautifulSoup으로 접근할 수가 없다. 세번째 프로젝트에서는 동적 페이지를 크롤링하는 방법에 대해 가볍게 다룬다!

프로젝트의 주제는 다음과 같다.

📌 셀프 주유소가 싸다고 알려져있는데, 정말로 그럴까?

동적 페이지 동적 페이지는 대부분의 요즘 페이지 트렌드라고 볼 수 있는데, BeautifulSoup 으로 가져올 수 없다. 그 이유는 웹주소를 알 수 없기 때문이다.

대표적으로 BeautifulSoup을 사용할 수 없는 경우는 다음과 같다.
- 접근할 웹 주소를 알 수 없거나
- 자바스크립트를 사용하는 웹페이지이거나
- 웹브라우저로 접근하지 않으면 안되는 경우

그래서, BeautifulSoup 대신, Selenium 이라는 걸 사용한다!

셀레니움
- 파이썬에서 웹 브라우저를 원격 조작하는 도구다.
- 자동으로 url을 열고 클릭, 스크롤, 문자 입력, 화면 캡쳐 등이 가능하다.

셀레니움 설치

콘다 환경에서 다운로드 할거면 콘다 활성화 후
맥북 m1 유저라면, 아래 코드 실행!
```
  !pip3 install selenium
```

chrome driver 다운로드

크롬 도움말 → 크롬 정보 → 크롬 버전 확인 후

https://chromedriver.chromium.org/downloads

사이트 들어가서, 앞번호 버전과 일치하는 드라이버 다운로드
파일을 ds_study(나의 작업 디렉토리)의 driver 파일에 옮겨두기

🔻 터미널에서 파일을 옮기는 방법은 🔻
```
mv ~Downloads/chromedriver/ ~/Documents/ds_study/driver\
```

chrome driver 불러오기

from selenium import webdriver

# 크롬 브라우저로 webdriver 읽기
driver = webdriver.Chrome()
driver.get('https://www.naver.com')

# driver 꺼주기 - 필수!
driver.quit()

데이터를 확보하기 위한 작업 - selenium 으로 동적페이지의 엑셀 데이터 다운로드 받기

싼 주유소 찾기 오피넷

위의 사이트에서 국내 존재하는 모든 주유소의 정보를 얻어올 수 있다.

목표 데이터
- 주유소 브랜드
- 휘발유 가격
- 셀프 주유 여부
- 위치

# 페이지 접근하는 함수 만들어주기

def main_get():
        url = 'https://www.opinet.co.kr/searRgSelect.do'
        driver = webdriver.Chrome()
        driver.get(url)

main_get()

selenium 으로 시/도 데이터 추출하기

from selenium.webdriver.common.by import By

# 시/도 부분 데이터 가져오기
# 태그가 ID 일 경우
sido_list_raw = driver**.find_element**(**By.ID**, 'SIDO_NMO')

# 다시 위의 태그에서 세부적으로 들어가기
# 태그 이름이 "option" 인 부분 가져오기 - 여러개라서 find_elements 로 가져오기
sido_list = sido_list_raw.find_elements(By.TAG_NAME, 'option')

# 속성 value 안에 있는 지역의 풀네임에 접근하기 - '서울특별시'
sido_list[1].**get_attribute**(**'value'**)

# 모든 시/도의 풀네임 데이터를 리스트에 받기
sido_names = [option.get_attribute('value') for option in sido_list]

# 시/도 데이터 중 서울특별시의 지역 데이터를 원하기 때문에 
# selenium 의 send_keys() 함수를 사용해서 '서울특별시'로 웹드라이버에서 선택하게 해주기
sido_list_raw.send_keys(sido_names[0])

selenium으로 ‘구’ 데이터 추출하기

gu_list_raw = driver.find_element(By.ID, 'SIGUNGU_NM0')

# 태그 이름이 'option'인 부분 가져오기
gu_list = gu_list_raw.find_elements(By.TAG_NAME, 'option')

gu_names = [option.get_attribute('value') for option in gu_list]

위의 과정을 한꺼번에 수행해서, ‘엑셀로 다운로드’ 까지 수행해보기

import time
from tqdm import tqdm_notebook
def data_download():

        # '서울특별시' 데이터를 선택해주기
        sido_list_raw = driver**.find_element**(**By.ID**, 'SIDO_NMO')
        sido_list = sido_list_raw.find_elements(By.TAG_NAME, 'option')
        sido_list[1].**get_attribute**(**'value'**)
        sido_names = [option.get_attribute('value') for option in sido_list]
        sido_names = sido_names[1:]
        sido_list_raw.send_keys(sido_names[0])

        # 구 데이터 다운로드 받기
        gu_list_raw = driver.find_element(By.ID, 'SIGUNGU_NM0')
        gu_list = gu_list_raw.find_elements(By.TAG_NAME, 'option')
        gu_names = [option.get_attribute('value') for option in gu_list]
        gu_names = gu_names[1:]

        for gu in tqdm_notebook(gu_names):
                gu_list_raw.send_keys(gu)
                time.sleep(3)

                # 엑셀 저장 클릭 - xpath 로 읽어오기
                driver.find_element(By.XPATH,'//*[@id="glopopd_excel"]').click()
                time.sleep(3)

data_download()

# 꼭 마지막에는 driver 꺼주기
driver.close() # 또는 driver.quit()

다운로드 받은 데이터 전처리 작업 하기

glob
concat
결측치 데이터 제거
데이터 타입 변환
인덱스 재설정

glob

파일들의 리스트를 뽑을 때 사용하는데, 파일의 경로명을 이용해서 입맛대로 사용할 수 있다.

인자로 받은 패턴과 이름이 일치하는 모든 파일과 디렉터리의 리스트를 반환한다.

▶️ 사용 예제

    from glob import glob

    # 현재 디렉토리에 .exe 로 끝나는 확장자 파일 리스트로 반환하기
    glob('*.exe')
    # 결과 : ['python.exe', 'pythonw.exe']

    # 현재 디렉토리에 .txt 로 끝나는 확장자 파일 리스트로 반환하기
    glob('*.txt') 
    # 결과 : ['LICENSE.txt', 'NEWS.txt']

    # C:\ 디렉토리에서 이름이 U로 시작하는 디렉토리나 파일 찾기
    glob(r'C:\U*')
    # 결과 : ['C:\\Users', 'C:\\usr']

    # glob('*') : 모든 파일과 디렉토리

✅ 서울특별시의 '구'별 파일 목록을 리스트로 가져오기

import pandas as pd
import numpy as np
from glob import glob

# 다운로드 받은 서울특별시의 '구'별 파일 목록을 리스트로 가져오기
station_files = glob('../data/지역_*.xls')

# 맨 첫번째 파일을 읽어보기
tmp = pd.read_excel(station_files[0], header=2)
tmp.tail()

# 각각의 파일에 대해 읽어들인 데이터를 리스트 원소에 저장
tmp_raw = []

for file_name in station_files:
        tmp = pd.read_excel(file_name, header=2)
        tmp_raw.append(tmp)

concat

파일들의 구조가 동일하기 때문에 concat을 이용해서 합쳐주기

station_raw = pd.concat(tmp_raw)

필드명 변경해주기

stations = pd.DataFrame({
        "상호": staton_raw['상호'],
        "주소": staton_raw['주소'],
        "셀프": staton_raw['셀프여부'],
        "상표": staton_raw['상표'],
        "휘발유": staton_raw['휘발유'],

})

stations.tail()

주소 데이터에서 ‘구’ 필드 만들어주기

stations['구'] = [eachAddress.split()[1] for eachAddress in stations['주소']]

가격 데이터 타입 변환 : object → float

stations['가격'] = stations['가격'].astype('float')

#### 오류 발생 ####
#### 이유 : could not convert string to float: '-' 

# 가격 데이터에 있는 '-' 데이터는 모두 삭제해주자
stations = stations[stations['가격'] != '-']

# 다시 변환!
stations['가격'] = stations['가격'].astype('float')

인덱스 재정렬

stations.reset_index(inplace=True, drop=True)

주유 가격 정보 기본 시각화

import matplotlib.pyplot as plt 
import seaborn as sns
import platform
from matplotlib import font_manager, rc

%matplotlib inline

if platform.system() == 'Darwin':
    rc('font', family='Arial Unicode MS')
else:
    print('Unknown System.')

1. boxplot

📌 셀프 주유소인지 아닌지의 여부에 따라 가격의 분포가 다를까?

pyplot

stations.boxplot(column='가격', by='셀프', figsize=(12,8))

▶️ 중앙값의 경우, 확실히 셀프주유소가 가격이 더 저렴한 것을 확인할 수 있다. 또한, 가격의 편차도 셀프 주유소의 경우가 더 작은 것을 확인할 수 있다.

seaborn

plt.figure(figsize=(12,8))

sns.boxplot(x='셀프', y='가격', data=stations, palette='Set3')
plt.grid(True)
plt.show()

📌 브랜드에 따라 가격의 편차는 어떻게 될까?

plt.figure(figsize=(12,8))

sns.boxplot(x='상표', y='가격', hue='셀프', data=stations, palette='Set3')
plt.grid(True)
plt.show()

▶️ 가장 눈에 띄는 점은 gs칼텍스, sk에너지의 경우, 셀프 주유소가 아닌 경우의 가격 편차가 다른 주유 브랜드에 비해 큰 것을 확인할 수 있다.

▶️ 셀프 주유가 가능한 브랜드 중, 알뜰주유소가 가장 낮은 가격으로 제공하는 것을 확인했다.

▶️ 셀프 주유가 아닌 경우, sk에너지의 주유가격 중앙값이 가장 높은 것으로 확인됐다.

2. folium - 지도 시각화

import json # 지도 경계선 데이터가 json 데이터이기 때문에
import folium
import warnings

warnings.filterwarnings('ignore')

gu_data = pd.pivot_table(data=stations, index='구', values='가격', aggfunc=np.mean)

geo_path = '../data/02. skorea_municipalities_geo_simple.json"
geo_str = json.load(open(geo_path, encoding='utf-8'))

my_map = folium.Map(location=[37.5502, 126.982], zoom_start=10.5, tiles='Stamen Toner')
my_map.choropleth(
        geo_data=geo_str,
        data=gu_data,
        columns=[gu_data.index, '가격'],
        key_on='feature.id',
        fill_color='PuRd'

)

my_map

[제로베이스_데이터 취업 스쿨 16기](6/26 ~ 7/2) - EDA_Proj1

Thu, 06 Jul 2023 07:14:49 GMT

제로베이스 첫번째 EDA 로, 서울시 지역별 인구현황과 CCTV 보유 개수의 Line Chart 를 그려볼 것이다. 전반적으로 어떻게 이 경향성이 잘 드러나게 효과적으로 시각화할 것인지 기본기를 다져보는 것이 목표다.

데이터 확보

서울시 열린 광장 사이트에서 open API 를 통해 두가지 데이터를 받아왔다.

01. CCTV_result.csv

01. Seoul_Population.xls

# csv 파일 읽어오기
CCTV_seoul = pd.read_csv('../data/01. Seoul_CCTV.csv', encoding='utf-8')

✅ encoding = ‘utf-8’ ✅

✅ encoding = ‘cp949’ ✅

오류가 발생하거나, 잘 안불러와진다면 위의 encoding 방식을 시도해보자.

# excel 파일 읽어오기
pop_seoul = pd.read_excel(
    '../data/01. Seoul_Population.xls',**header=2**, **usecols=**'B, D, G, J, N'
)

✅ header ✅

몇 번째 행을 header 로 읽어올 것인지 선택할 수 있다.

✅ usecols ✅

어떤 칼럼을 사용할 것인지 선택할 수 있다.

필드 이름 정리해주기

# cctv 데이터의 '기관명' 필드 이름을 '구별' 로 바꿔주자.
CCTV_seoul.rename(
    columns={'기관명':'구별'}, inplace=True
)

# 인구 데이터의 모든 필드 이름을 바꿔주자. 
pop_seoul.rename(columns={
    pop_seoul.columns[0] : "구별",
    pop_seoul.columns[1] : "인구수",
    pop_seoul.columns[2] : "한국인",
    pop_seoul.columns[3] : "외국인",
    pop_seoul.columns[4] : "고령자",
},  inplace = True
)

데이터 정리

CCTV 데이터 정리

최근 3년간(2014 ~ 2016)의 CCTV 대수가 이전 대수에 비해 얼마만큼 증가했는지 증가율 변수 생성

CCTV_seoul['최근증가율'] = (
    (CCTV_seoul['2014년'] + CCTV_seoul['2015년'] + CCTV_seoul['2016년']) / CCTV_seoul['2013년도 이전'] * 100
)

인구 데이터 정리

# 맨 처음 합계 행 데이터를 삭제한다. 
pop_seoul.drop([0], inplace=True)

# 외국인 비율, 고령자 비율 필드를 만든다.
pop_seoul['외국인 비율'] = pop_seoul['외국인'] / pop_seoul['인구수'] * 100
pop_seoul['고령자 비율'] = pop_seoul['고령자'] / pop_seoul['인구수'] * 100

데이터 결합

pd.merge

두 데이터프레임의 칼럼이나 인덱스를 기준으로 병합한다.

기준이 되는 인덱스나 컬럼을 ‘키’ 라고 부른다.

당연히 해당 키는 두 데이터프레임에 모두 있어야 한다. (이름이 동일해야 됨)

default : inner join 이다. → how 인자 값을 ‘left’, ‘right’ ,’outer’ 등으로 설정할 수 있다.

# 두 데이터를 inner join 하자. '구별' 을 공동 칼럼으로 한다. 
data_result = pd.merge(CCTV_seoul, pop_seoul, on='구별')

# 연도 컬럼을 삭제하자.
data_result.drop(['2013년도 이전','2014년','2015년','2016년'], axis=1, inplace=True)

# '구별' 필드를 행 인덱스로 설정하자.
data_result.set_index('구별', inplace=True)

# 인구수 대비 CCTV 비율 필드를 만들자.
data_result['CCTV비율'] = data_result['소계'] / data_result['인구수'] * 100

# CCTV 비율을 기준으로 내림차순 정렬하자.
data_result.sort_values('CCTV비율').head()

시각화

matplotlib 기초

import matplotlib.pyplot as plt
from matplotlib import rc

rc('font', family='AppleGothic') # 한글 폰트 설정
plt.rcParams['axes.unicode_minus'] = False # 마이너스 부호때문에 한글이 깨질 수가 있어 주는 설정

%matplotlib inline

인구수를 구별로 막대 그래프 시각화하기

data_result['인구수']**.plot**(**kind='barh'**, figsize=(10,10))

cctv 보유대수를 구별로 막대 그래프 그리기

data_result['소계'].plot(kind='barh', grid=True, figsize=(10,10));

# CCTV 보유대수 막대 그래프
def drawGraph():
    **plt.style.use('seaborn') # seaborn 스타일 이용하기**
    plt.rcParams['font.family'] = 'AppleGothic' # 한글 폰트 설정
    data_result['소계'].sort_values().plot(
        kind='barh', grid=True, title='가장 CCTV가 많은 구', figsize=(10,10));
drawGraph()

# CCTV 비율 막대 그래프
def drawGraph():
    plt.style.use('seaborn')
    plt.rcParams['font.family'] = 'AppleGothic'
    data_result['CCTV비율'].sort_values().plot(
        kind='barh', grid=True, title='인구 대비 CCTV 비율', figsize=(10,10));
drawGraph()

인구수와 CCTV 보유대수 간의 산점도 그리기

def drawGraph():
    plt.figure(figsize=(14,10))
    plt**.scatter**(data_result['인구수'],data_result['소계'], s=50)
    plt.xlabel('인구수')
    plt.ylabel('CCTV')
    plt.grid(True)
    plt.show()
drawGraph()

경향 파악하기

Numpy 를 이용해서 회귀선 만들어주기

np.polyfit(x, y, d)
- x : 설명변수
- y : 종속변수
- d : 구할 차수

import numpy as np

fp1 = **np.polyfit**(data_result['인구수'],data_result['소계']**,1**)
f1 = **np.poly1d**(fp1)

# 회귀선을 그려주기 위해 임의로 100개의 x데이터를 지정된 범위 내에서 생성
fx = **np.linspace**(100000,700000,100) # 10만 ~ 70만 사이에서 100개의 데이터를 등간격으로 추출

def drawGraph():
    plt.figure(figsize=(14,10))
    plt.scatter(data_result['인구수'],data_result['소계'], s=50)
    # 선형 회귀 직선 추가
    plt**.plot**(**fx**, **f1(fx)**, ls='--', lw=3, color='g')
    plt.xlabel('인구수')
    plt.ylabel('CCTV')
    plt.grid(True)
    plt.show()
drawGraph()

오차 값 생성하기

위의 과정으로 회귀선(경향선)을 그렸다면, 실제값과의 차이(오차)를 구할 수 있다.

경향값은 만든 f1함수에 해당하는 인구수를 넣었을 때의 값이다. → f1(data_result[’인구수’])

data_result['오차'] = data_result['소계'] - f1(data_result['인구수'])

# 오차를 기준으로 내림차순
data_sort_f = data_result.sort_values('오차', ascending=False) # 내림차순

즉, 경향 대비 훨씬 많은 CCTV 를 보유하고 있는 지역을 알아볼 수 있다. (강남구 > 양천구 > 용산구 >…)

# 반대로, 경향 대비 CCTV 보유대수가 훨씬 적은 하위 지역을 살펴보면,
data_sort_t = data_result.sort_values('오차')  # 오름차순

강서구 > 송파구 > 도봉구 > … 순으로 인구수 대비 CCTV 보유대수가 경향보다도 훨씬 적은 것을 파악할 수 있다.

Line Plot 강화하기

좀 더 한눈에 확 파악할 수 있도록 해보자.

from **matplotlib.colors** import **ListedColormap**

# colormap 을 사용자 정의로 세팅
**color_step** = ['#e74c3c','#2ecc71','#95a9a6','#2ecc71','#3498db','#3498db']
my_cmap = **ListedColormap(color_step**)

def drawGraph():
    plt.figure(figsize=(14,10))
        # 오차 필드 값의 크기에 따라 색깔을 위의 지정한 my_cmap 으로 표현하자
    plt**.scatter(**data_result['인구수'],data_result['소계'], s=50, **c = data_result['오차']**, **cmap = my_cmap**)
    # 선형 회귀 직선 추가
    plt**.plot(fx**, **f1(fx)**, ls='--', lw=3, color='g')
    for n in range(5):
        # 상위 5개 **데이터 labeling** 해주기
        **plt.text(**data_sort_f['인구수'][n] * 1.02, data_sort_f['소계'][n] * 0.98 , data_sort_f**.index[n]**, fontsize=15)    
        # 하위 5개 데이터 labeling 해주기
        **plt.text(**data_sort_t['인구수'][n] * 1.02, data_sort_t['소계'][n] * 0.98 , data_sort_t.index[n], fontsize=15)    
    plt.xlabel('인구수')
    plt.ylabel('CCTV')
    plt.grid(True)
    **plt.colorbar()**
    plt.show()
drawGraph()

[제로베이스_데이터 취업 스쿨 16기](6/16 ~ 18) - 기초 수학2

Tue, 20 Jun 2023 07:39:07 GMT

기초수학2

수열

1. 등차수열

🔻연습 문제🔻

# 수열을 보고 n번째 항의 값을 출력하는 프로그램을 만들자.

inputN1 = int(input('a1 입력: '))
inputD = int(input('d 입력: '))
inputN = int(input('n 입력: '))

n = 1
result = 0
while n <= inputN:
    # 항의 값을 구하기
    result = inputN1 + (n - 1) * inputD
    print(f'{n}번째 항의 값: {result}')
    n += 1

# 등차수열의 n번째 항까지의 합을 구하는 프로그램을 만들자.

inputN1 = int(input('a1 입력: '))
inputD = int(input('d 입력: '))
inputN = int(input('n 입력: '))

n = 1
while n <= inputN:
    # 첫째항과 끝항을 이용한 식으로 합을 구하자
    sum = (inputN1 + (inputN1 + inputD * (n - 1))) * n / 2
    print(f'{n}번째 항까지의 합: {int(sum)}')
    n += 1

2. 등비수열

🔻연습 문제🔻

# n번째 항의 값을 출력하는 프로그램. 등비수열

inputN1 = int(input('a1 입력: '))
inputR = int(input('r 입력: '))
inputN = int(input('n 입력: '))

n = 1
result = 1
while n <= inputN:
    result = inputN1 * inputR ** (n-1)
    print(f'{n}번째 항의 값: {result}')
    n += 1

# n번째 항까지의 합을 구하는 프로그램

inputN1 = int(input('a1 입력: '))
inputR = int(input('r 입력: '))
inputN = int(input('n 입력: '))

n = 1
result = 1
sum = 0
while n <= inputN:
    result = inputN1 * inputR ** (n-1) # n번째의 값
    sum += result
    print(f'{n}번째 항까지의 합: {sum}')
    n += 1

# 등비수열의 합을 구하는 공식 활용하는 방법
# n번째 항까지의 합을 구하는 프로그램

result = inputN1 * (1 - (inputR ** inputN)) / (1 - inputR)
print(f'{inputN}번째까지의 등비수열 합: {int(result)}')

3. 계차수열

두 항의 차이로 이루어진 수열이다.

🔻연습 문제🔻

# 계차수열의 n번째 항의 값을 출력하는 프로그램을 만들어보자.

inputAn1 = int(input('a1 입력: '))
inputAn = int(input('an 입력: ')) # n번째 항

inputBn1 = int(input('b1 입력: '))
inputBD = int(input('bn 공차 입력: '))

valueAn = 0
valueBn = 0

n = 1
while n <= inputAn:

    if n == 1: # 1번째 항
        valueAn = inputAn1
        valueBn = inputBn1
        print(f'an의 1번째 항의 값: {valueAn}')
        print(f'bn의 1번째 항의 값: {valueBn}')
        n += 1
        continue

    valueAn = valueAn + valueBn
    valueBn = valueBn + inputBD
    print(f'an의 {n}번째 항의 값: {valueAn}')
    print(f'bn의 {n}번째 항의 값: {valueBn}')
    n += 1

print(f'an의 {inputAn}번째 항의 값: {valueAn}')
print(f'bn의 {inputAn - 1}번째 항의 값: {valueBn}')

# 계차수열 항 구하기
bn = inputBn1 + (inputAn-1) * inputBD

# bn의 n-1 항까지의 합 - a1 을 계산하면 an의 값을 구할 수 있다.

inputAn1 = int(input('a1 입력: '))
inputAn = int(input('an 입력: ')) # n번째 항

inputBn1 = int(input('b1 입력: '))
inputBD = int(input('bn 공차 입력: '))

# inputBn1 + inputBD * (inputAn - 1) # b(n-1) 의 값
sumBn = (inputBn1 + inputBD * (inputAn - 1) + inputBn1) * (inputAn - 1) / 2 # b(n-1)까지의 합
An = sumBn - inputAn1 # an

4. 피보나치 수열

전항과 전전항을 더한 값으로 이루어진 수열

✅ 적어도 두 항은 있어야 하며, 1,2번째 항은 모두 1이어야 한다.✅

5. 군 수열

여러 개의 항을 묶었을 때 규칙성을 보이는 수열

🔻연습 문제🔻

EX1.

intputN = int(input('n항 입력: '))

flag = True
n = 1; nCnt = 1; searchN = 0 # nCnt 는 n항의 숫자를 담는 변수, searchN은 해당 항의 값을 담는 변수
while flag:

        for i in range(1, (n + 1)): # n은 군을 의미한다. 
                if i == n: 
                        print('{} '.format(i), end='')
                else:
                        print'{} ,'.format(i), end='')
                nCnt += 1

                if (nCnt > inputN):
                        searchN = i
                        flag = False
                        break

        print()
        n += 1

print('{}항 : {}'.format(inputN, searchN))

EX2.

# 분모값 따로, 분자값 따로 만들어줘야 한다.

inputN = int(input('n항 입력: '))

flag = True
n = 1; nCnt = 1; searchNC = 0; searchNP = 0
while flag:

    for i in range(1, (n + 1)): # 1 ~ n까지
        if i == n:
            print('{}/{} '.format(i, (n - i + 1)), end='')
        else:
            print('{}/{}, '.format(i, (n - i + 1)), end='')

        nCnt += 1
        if (nCnt > inputN):
            searchNC = i
            searchNP = n - i + 1
            flag = False
            break

    print()
    n += 1

print('{}항: {}/{}'.format(inputN, searchNC, searchNP))

팩토리얼

크게 3가지 방식으로 구현할 수 있는데 아래와 같다.

반복문 사용하기

재귀함수 사용하기

내장 모듈 사용하기

반복문으로 구현

# 팩토리얼
# 1.반복문
inputN = int(input('n 입력: '))

result = 1 for i in range(inputN,0,-1): result *= i

print(f'{inputN} 팩토리얼: {result}')

또는

n = 1 result = 1 while n <= inputN: result *= n n += 1

print(f'{inputN} 팩토리얼: {result}')



- 재귀함수로 구현
```python

inputN = int(input('n 입력: '))

def factorialFun(n):
        if n == 1: return 1

        return n * factorialFun(n-1)

print(f'{inputN} 팩토리얼: {factorialFun(inputN)}')

내장 모듈 - math() 사용 ```python
# math 기능 활용하기* import math

print(math.factorial(inputN))







## 순열 : nPr
> 순서를 지켜서 일렬로 나열하는 경우의 수

🔻연습 문제🔻
```python
# 파이썬을 이용해서 순열을 구하는 프로그램
n = int(input('N 입력: '))
r = int(input('R 입력: '))

result = 1 #결과값 초기화
# nPr = n * (n-1) * ... * (n-r+1)

for i in range(n, (n-r), -1):
    result *= i

print('{}P{} 의 값 : {}'.format(n, r, result))

원순열

시작과 끝의 구분이 없는 순열

🔻연습 문제🔻

# n명의 사람이 원탁 테이블에 앉는 경우의 수를 구하자
# 1. math 모듈 활용
import math
n = int(input('친구 수 입력: '))
result = 1
print('{}명의 사람이 원탁에 앉는 경우의 수: {}'.format(n,math.factorial(n-1)))

# 2. 
n = int(input('친구 수 입력: '))
result = 1
for i in range(n-1, 0, -1): # 또는 range(1,n)
    result *= i
print('{}명의 사람이 원탁에 앉는 경우의 수: {}'.format(n,result))

조합 : nCr

순서에 상관없이 r개를 뽑는 경우의 수

🔻연습 문제🔻

# 조합을 계산하는 프로그램을 만들자.
# 1. math
n = int(input('N 입력: '))
r = int(input('R 입력: '))
import math
result = 1

# nCr = n * ... * (n - r + 1) / r! -> (n - r)! / r!
result = (math.factorial(n) / math.factorial(n-r)) / math.factorial(r)
print('{}C{} 의 값: {}'.format(n,r,int(result)))

확률

모든 사건에서 특정 사건이 일어나는 경우의 수

✅ 일반적으로 조합을 이용해서 확률을 구할 수 있다.✅

🔻연습 문제🔻

import math
# 꽝이 4개, 선물이 3개 중에서 꽝 2개, 선물 1개를 뽑는 확률을 구하자.

while True:
    n = int(input('전체 카드 수 입력: '))
    r = int(input('뽑을 카드 수 입력: '))

    tot_case = math.factorial(n) / math.factorial(n-r) / math.factorial(r)
    print('sample: {}'.format(int(tot_case)))

    fail_n = int(input('fail card count 입력: '))
    fail_r = int(input('fail get count 입력: '))
    fail_case = math.factorial(fail_n) / math.factorial(fail_n - fail_r) / math.factorial(fail_r)
    print('event1: {}'.format(int(fail_case)))

    wow_n = int(input('wow card count 입력: '))
    wow_r = int(input('wow get count 입력: '))
    wow_case = math.factorial(wow_n) / math.factorial(wow_n - wow_r) / math.factorial(wow_r)
    print('event2: {}'.format(int(wow_case)))

    break
result = (fail_case * wow_case / tot_case) * 100
print('probability: {}%'.format(round(result,2)))

🔜 다음 스터디 노트..

다음 스터디 노트에서는 기초수학과 관련된 연습 문제 풀이를 정리해보도록 하겠다.😊

[제로베이스_데이터 취업 스쿨 16기](6/16 ~ 18) - 기초 수학1

Tue, 20 Jun 2023 07:07:02 GMT

기초 수학

본격적으로 파이썬 코드에 잘 활용되는 기초 수학 개념들에 대해 학습하고 정리해보기로 한다.

1. 약수 / 소수

바로 문제 풀이를 통해 어떻게 코드적으로 구현하는지 살펴본다.

Ex 1.약수

# 사용자가 입력한 숫자의 약수를 출력
inputNum = int(input('0보다 큰 정수 입력: '))

for i in range(1, (inputNum + 1)):
    if inputNum % i == 0: # 나눠떨어지면 약수
        print(f'{inputNum}의 약수: {i}')

Ex 2. 소수

# 사용자가 입력한 숫자까지의 소수 찾기
inputNum = int(input('0보다 큰 정수 입력: '))

for num in range(2,(inputNum + 1)):
    flag = True
    for n in range(2,num):
        if num % n == 0:
            flag = False
            break

    if flag:
        print(f'{num}: 소수!')
    else:
        print(f'{num}: 합성수!')

2. 소인수분해

말 그대로, 소인수 : 소수 + 약수라서

약수 중에서 소수인 숫자를 소인수라고 보면 된다.

따라서 소인수 분해는

어떤 수를 소인수로 분해하는 것을 말한다.

✅ 소인수분해를 이용해서 약수를 구할 수도 있다. ✅

🔻연습 문제🔻

# 입력한 수를 소인수분해하자.
inputNum = int(input('1보다 큰 정수 입력: '))

n = 2
while n <= inputNum:
    if inputNum % n == 0:
        print(f'소인수 : {n}')
        inputNum /= n
    else:
        n += 1

# 72에 x를 곱하면 y의 제곱이 된다고 할 때, x에 해당하는 가장 작은 정수를 구하자.

inputNum = int(input('1보다 큰 정수 입력: '))

n = 2
numlist = []
while n <= inputNum:
    if inputNum % n == 0:
        print(f'소인수 : {n}')
        if numlist.count(n) == 0: # numlist 에 없고, 처음 나왔다면
            numlist.append(n)
        elif numlist.count(n) == 1: # 이미 들어있기 때문에, 그냥 신경쓸 필요 없다. -> 제거하자
            numlist.remove(n)

        inputNum /= n
    else:
        n += 1

print(f'searchNumber : {numlist}')

3. 최대공약수

소인수분해를 이용하면 최대공약수 및 공약수를 구할 수 있다.

🔻연습 문제🔻

# 두 개의 수를 입력하면 공약수와 최대공약수를 출력하는 코드를 작성하자.
n1 = int(input('1보다 큰 정수 입력: '))
n2 = int(input('1보다 큰 정수 입력: '))

max_num = 0
for i in range(1, (n1 + 1)):
    if n1 % i == 0 and n2 % i == 0:
        print(f'공약수 : {i}')
        max_num = i

print(f'최대공약수 : {max_num}')

# 세 개의 수를 입력하면 공약수와 최대공약수를 출력하는 코드
n1 = int(input('1보다 큰 정수 입력: '))
n2 = int(input('1보다 큰 정수 입력: '))
n3 = int(input('1보다 큰 정수 입력: '))

maxNum = 0
for i in range(1,(n1 + 1)):
    if n1 % i == 0 and n2 % i == 0 and n3 % i == 0: # 세 값에 모두 나눠떨어지면 공약수
        print(f'공약수 : {i}')
        maxNum = i
print(f'최대공약수 : {maxNum}')

유클리드 호제법

유클리드 호제법을 이용해서 최대공약수를 구할 수 있다.

x, y의 최대공약수는 y와 (x%y) 의 최대공약수와 같다.

🔻연습 문제🔻

n1 = int(input('1보다 큰 정수 입력: '))
n2 = int(input('1보다 큰 정수 입력: '))

temp1 = n1
temp2 = n2

while temp2 > 0:
    temp = temp2
    temp2 = temp1 % temp2
    temp1 = temp

print(f'{n1},{n2}의 최대공약수:  {temp1}')

# 최대공약수를 가지고 공약수를 구하기
for n in range(1,(temp1 + 1)):
    if temp1 % n == 0:
        print(f'{n1}, {n2}의 공약수 : {n}')

3. 최소공배수

최대공약수를 이용해서 최소공배수 구할 수 있다.

# 두 개의 수를 입력하면 최소공배수를 출력하는 코드를 작성하자.
n1 = int(input('1보다 큰 정수 입력: '))
n2 = int(input('1보다 큰 정수 입력: '))
maxNum = 0

for i in range(1, (n1 + 1)):
    if n1 % i == 0 and n2 % i == 0:
        print(f'공약수 : {i}')
        maxNum = i

print(f'최대공약수: {maxNum}')

minNum = (n1 * n2) // maxNum # 최소공배수
print(f'최소공배수: {minNum}')

# 세 개의 수를 입력하면 최소공배수를 출력하는 코드를 작성하자.
n1 = int(input('1보다 큰 정수 입력: '))
n2 = int(input('1보다 큰 정수 입력: '))
n3 = int(input('1보다 큰 정수 입력: '))
maxNum = 0

for i in range(1, (n1 + 1)):
    if n1 % i == 0 and n2 % i == 0:
        maxNum = i

print(f'최대공약수: {maxNum}')

minNum = (n1 * n2) // maxNum # 최소공배수
print(f'{n1}, {n2}의 최소공배수: {minNum}')

newNum = minNum
for i in range(1, (newNum + 1)):
    if newNum % i == 0 and n3 % i == 0:
        maxNum = i

print(f'최대공약수: {maxNum}')

minNum = (newNum * n3) // maxNum # 최소공배수
print(f'{n1}, {n2}, {n3}의 최소공배수: {minNum}')

4. 진법

2진수 → 8진수 변환

2진수 → 16진수

파이썬에서의 진법 변환

10진수 → 2진수, 8진수, 16진수 - bin() *: 2진수로 변환 - *oct() : 8진수로 변환 - *hex() *: 16진수로 변환

이외에도 format() 함수로도 바꿀 수 있다.

  dNum = 30
  print('2진수: {}'.format(format(dNum, '#b'))) # 또는 '0b'를 빼고 출력하고 싶다면 'b' 만 써준다.
  print('8진수: {}'.format(format(dNum, '#o'))) # 또는 'o'
  print('16진수: {}'.format(format(dNum, '#x'))) # 또는 'x'

  # 또는 아래와 같이 사용할 수도 있다.
  print('{0:#b} , {0:#o},  {0:#x}'.format(dNum))

X진수 → 10진수 - int() 를 사용한다.

X진수 → X진수 - 8진수로 변환 : oct() - 2진수로 변환 : bin() - 16진수로 변환 : hex() - 10진수로 변환 : int()

🔜 다음 스터디 노트..

다음 스터디 노트에서는 수열 과 관련된 개념들과, 팩토리얼, 순열, 조합, 확률 에 대한 개념들을 학습하고, 정리해보도록 한다.

[제로베이스_데이터 취업 스쿨 16기](6/16 ~ 18) - 텍스트 파일 다루기

Tue, 20 Jun 2023 06:49:14 GMT

중급 연습 문제풀이 - 텍스트 파일 다루기

파이썬의 텍스트 파일 다루는 문법과 관련된 문제 풀이

EX 1. *회원 계정별 텍스트 파일을 생성한 후 회원 본인 파일에 ‘한 줄 일기’를 쓰고 읽는 프로그램을 만들자. *

# diary.py

# 일기 기능을 가지고 있는 공동 모듈을 만들자.
# 1. 읽기
# 2. 쓰기
import time
def writeDiary(u,f,d): # 사용자가 입력한 문자열 매개변수 d, 파일 경로(url + file name)를 받고
    lt = time.localtime()
    timeStr = time.strftime('%Y-%m-%d %I:%M:%s %p', lt) # 먼저 현재 시간 정보를 문자형식으로 가져오고

    filePath = u + f
    with open(filePath, 'a') as f:
        f.write(f'[{timeStr}]  {d}\n')

def readDiary(u,f):

    filePath = u + f
    datas = []
    with open(filePath, 'r') as f:
        datas = f.readlines() # 여러 줄을 한꺼번에 읽기

    return datas

import diary

members = {}
uri = '/Users/sunju/PycharmProjects/python/text'

# 회원 정보를 출력해주는 함수를 만들자
def printMembers():
    for m in members.keys():
        print(f'ID : {m}\t PW: {members[m]}')

while True:
    selectNum = int(input('1.회원 가입  2. 한줄일기쓰기  3.일기보기  4.종료'))

    if selectNum == 1: # 회원가입이라면
        # 회원 아이디와 비밀번호를 입력받자
        id = input('id: ')
        pw = input('pw: ')
        members[id] = pw
        printMembers()

    elif selectNum == 2:
        id = input('id: ')
        pw = input('pw: ')
        if id in members and members[id] == pw:
            print('Login success!')
            fileName = 'myDiary_' + id + '.txt'
            content = input('오늘 하루 일어난 일들을 기록해보세요.')
            diary.writeDiary(uri,fileName,content)
        else:
            print('Login fail!')
            printMembers()

    elif selectNum == 3:
        id = input('id: ')
        pw = input('pw: ')
        if id in members and members[id] == pw:
            print('Login success!')
            fileName = 'myDiary_' + id + '.txt'
            datas = diary.readDiary(uri, fileName)
            for d in datas:
                print(d, end='')
        else:
            print('Login fail!')
            printMembers()

    elif selectNum == 4:
        print('Bye~')
        break

EX 2. 텍스트 파일에 수입과 지출을 기록하는 가계부를 만들자.

# 잔고와 입금 내역을 관리하는 두가지 텍스트 파일을 만들어줘야 한다.
import time

# 시간을 조정해주는 함수
def getTime():
    d = time.localtime()
    st = time.strftime('%Y-%m-%d %H:%M:%S')
    return st

while True:

    selectNum = int(input('1.입금,  2.출금,  3.종료'))

    if selectNum == 1: # 입금
        money = int(input('입금액 입력: '))

        with open('/Users/sunju/PycharmProjects/python/text/bank/money.txt', 'r') as f: # 잔고 먼저 읽기
            m = f.read()

        with open('/Users/sunju/PycharmProjects/python/text/bank/money.txt', 'w') as f: # 잔고 + 입금 쓰기
            m = f.write(str(int(m) + money))

        memo = input('입금 내역 입력: ') # 어떻게 수입이 생겼는지에 대한 정보
        with open('/Users/sunju/PycharmProjects/python/text/bank/pocketMoneyRegister.txt', 'a') as f: # 입금 내역은 덧붙여져야 하므로
            f.write('---------------------------------------------------------\n')
            f.write(f'{getTime()} \n')
            f.write(f'[입금] {memo} : {str(money)}원 \n')
            f.write(f'[잔액] : {str(int(m) + money)}원 \n')

        print('입금 완료!')
        print(f'기존 잔액: {m}')
        print(f'입금 후 잔액: {int(m) + money}')

    elif selectNum == 2:
        money = int(input('출금액 입력: '))

        with open('/Users/sunju/PycharmProjects/python/text/bank/money.txt', 'r') as f:  # 잔고 먼저 읽기
            m = f.read()

        with open('/Users/sunju/PycharmProjects/python/text/bank/money.txt', 'w') as f:  # 잔고 - 출금 쓰기
            m = f.write(str(int(m) - money))

        memo = input('출금 내역 입력: ')  # 출금 내역에 대한 정보
        with open('/Users/sunju/PycharmProjects/python/text/bank/pocketMoneyRegister.txt',
                  'a') as f:  # 입금 내역은 덧붙여져야 하므로
            f.write('---------------------------------------------------------\n')
            f.write(f'{getTime()} \n')
            f.write(f'[출금] {memo} : {str(money)}원 \n')
            f.write(f'[잔액] : {str(int(m) - money)}원 \n')

        print('출금 완료!')
        print(f'기존 잔액: {m}')
        print(f'출금 후 잔액: {int(m) - money}')

    elif selectNum == 3:
        print('Bye~')
        break

    else: # 1,2,3 이외에 다른 것을 입력했을 때
        print('잘못 입력했습니다. 1,2,3 에서 선택해주세요')
        continue

** EX 3. 사용자가 입력한 숫자의 약수를 텍스트 파일에 기록하고, 입력한 숫자까지의 소수를 텍스트 파일에 기록하자.**

# 약수

inputNum = int(input('0보다 큰 정수를 입력: '))

divisor = []
for num in range(1,(inputNum + 1)):
    if inputNum % num == 0:
        divisor.append(num)

if len(divisor) > 0:
    try:
        with open('/Users/sunju/PycharmProjects/python/text/divisor.txt', 'a') as f:
            f.write(f'{inputNum}의 약수: ')
            f.write(f'{divisor}\n')
    except Exception as e:
        print(e)
    else:
        print('divisor written successfully!')

# 소수

inputNum = int(input('0보다 큰 정수 입력: '))

prime = []
cnt = 0
for num in range(2,(inputNum + 1)): # 1은 소수에 포함될 수 없다.
        flag = True
        for n in range(2,num):
              if num % n == 0: # 소수가 아닐 경우
                        flag = False
                        break

        if flag:
                prime.append(num)

if len(prime) > 0:
    try:
        with open('/Users/sunju/PycharmProjects/python/text/prime .txt', 'a') as f:
            f.write(f'{inputNum}까지의 소수: ')
            f.write(f'{prime}\n')
    except Exception as e:
        print(e)
    else:
        print('prime written successfully!')

*EX 4. 두 개의 수를 입력하면 공약수를 텍스트 파일에 작성하는 프로그램을 만들자. *

# 두개의 수를 입력받는다.

n1 = int(input('1보다 큰 정수 입력: '))
n2 = int(input('1보다 큰 정수 입력: '))

# 두 값의 공약수를 계산
result = []
min_num = min(n1,n2)
for i in range(1,(min_num+1)):
    if n1 % i == 0 and n2 % i == 0: # 두 값에서 모두 나눠떨어진다고 하면
        result.append(i)
if len(result) > 0:
        try:
                with open('/Users/sunju/PycharmProjects/python/text/ex.txt', 'a') as f:
                       f.write(f'{n1}과 {n2}의 공약수: {result}\n')

        except Exception as e:
                print(e)

        else:
                print('common factor written completed!')

# 최대공약수 구해보기

n1 = int(input('1보다 큰 정수 입력: '))
n2 = int(input('1보다 큰 정수 입력: '))

maxComNum = 0
min_num = min(n1,n2)
for i in range(1,(min_num+1)):
    if n1 % i == 0 and n2 % i == 0:
        maxComNum = i # 계속 변경되면서 최대공약수를 구할 수 있게 된다.

try:
    with open('/Users/sunju/PycharmProjects/python/text/ex1.txt', 'a') as f:
        f.write(f'{n1}과 {n2}의 최대공약수: {maxComNum}\n')

except Exception as e:
    print(e)

else:
    print('common max factor written completed!')

# 3개 값의 최대 공약수 구해보기

*EX 5. 섬마을에 과일, 생선, 야채를 판매하는 배가 다음 주기로 입항한다고 할 때, 모든 배가 입항하는 날짜를 텍스트 파일에 기록해보자. * (첫 입항일은 2021년 1월 1일 오전 10시라고 하자)

과일 선박 : 3일 주기 / 생선 선박: 4일 주기 / 야채 선박 : 5일 주기

→ 최소공배수를 이용한다.

ship1 = 3
ship2 = 4
ship3 = 5
max_day = 0
# 2개의 값에서 최대 공약수 구하기
for i in range(1, (ship1 + 1)):
    if ship1 % i == 0 and ship2 % i == 0:
        max_day = i

# 2개의 값에서 최소 공배수 구하기
min_day = (ship1 * ship2) // max_day

new_day = min_day

# 3개의 값에서 최대 공약수 구하기
for i in range(1,(new_day + 1)):
    if new_day % i == 0 and ship3 % i == 0:
        max_day = i

# 3개의 값에서 최소 공배수 구하기
min_day = (new_day * ship3) // max_day

print(f'세 배의 최대공약수: {max_day}')
print(f'세 배의 최소공배수: {min_day}')

from datetime import datetime, timedelta

n = 1
# 기준일 설정해주기
baseTime = datetime(2021,1,1,10,0,0)

with open('/Users/sunju/PycharmProjects/python/text/arrive.txt', 'a') as f:
    f.write(f'{baseTime}\n')

# 기준일로부터 60일 지난 날짜
while True:
    nextTime += timedelta(days=min_day) # 60이라는 값을 날짜 형식으로 더해줄 때, timedelta() 함수를 사용한다. 
    if nextTime.year > 2021:
        break
    with open('/Users/sunju/PycharmProjects/python/text/arrive.txt', 'a') as f:
        f.write(f'{nextTime}\n')

🔜 다음 스터디 노트..

다음 스터디 노트에서는 기초 수학 에 활용되는 대표적인 수학 개념들과 파이썬으로 구현해보는 연습을 진행하고 정리해보도록 한다.

[제로베이스_데이터 취업 스쿨 16기](6/16 ~ 18) - 예외 처리

Tue, 20 Jun 2023 06:37:54 GMT

중급 연습 문제풀이 - 예외 처리

파이썬의 예외 처리 문법을 활용한 문제 풀이

EX 1. *사용자가 입력한 숫자를 이용해서 산술연산 결과를 출력하는 모듈을 만들되, 예상하는 예외에 대한 예외처리 코드를 작성해보자. *

def add(n1,n2):
    print('덧셈 연산')

        try: # 숫자가 들어왔는지 확인
                n1 = float(n1)
        except:
                print('첫 번째 피연산자는 숫자가 아닙니다.')
                return 

        try: # 숫자가 들어왔는지 확인
                n2 = float(n2)
        except:
                print('두 번째 피연산자는 숫자가 아닙니다.')
                return 

        print(f'{n1} + {n2} = {n1 + n2}')

def sub(n1,n2):
    print('뺄셈 연산')

        try: # 숫자가 들어왔는지 확인
                n1 = float(n1)
        except:
                print('첫 번째 피연산자는 숫자가 아닙니다.')
                return 

        try: # 숫자가 들어왔는지 확인
                n2 = float(n2)
        except:
                print('두 번째 피연산자는 숫자가 아닙니다.')
                return 

    print(f'{n1} - {n2} = {n1 - n2}')

def mul(n1,n2):
    print('곱셈 연산')

        try: # 숫자가 들어왔는지 확인
                n1 = float(n1)
        except:
                print('첫 번째 피연산자는 숫자가 아닙니다.')
                return 


        try: # 숫자가 들어왔는지 확인
                n2 = float(n2)
        except:
                print('두 번째 피연산자는 숫자가 아닙니다.')
                return 

    print(f'{n1} * {n2} = {n1 * n2}')

def div(n1,n2):
    print('나눗셈 연산')

        try: # 숫자가 들어왔는지 확인
                n1 = float(n1)
        except:
                print('첫 번째 피연산자는 숫자가 아닙니다.')
                return 


        try: # 숫자가 들어왔는지 확인
                n2 = float(n2)
        except:
                print('두 번째 피연산자는 숫자가 아닙니다.')
                return 

        if n2 == 0:  
        print('0으로 나눌 수 없습니다.')
                return 

        print(f'{n1} / {n2} = {n1 / n2}')

def mod(n1,n2):
    print('나머지 연산')

        try: # 숫자가 들어왔는지 확인
                n1 = float(n1)
        except:
                print('첫 번째 피연산자는 숫자가 아닙니다.')
                return 


        try: # 숫자가 들어왔는지 확인
                n2 = float(n2)
        except:
                print('두 번째 피연산자는 숫자가 아닙니다.')
                return 

        if n2 == 0:  
        print('0으로 나눌 수 없습니다.')
                return 

        print(f'{n1} % {n2} = {n1 % n2}')

def flo(n1,n2):
    print('몫 연산')

        try: # 숫자가 들어왔는지 확인
                n1 = float(n1)
        except:
                print('첫 번째 피연산자는 숫자가 아닙니다.')
                return 


        try: # 숫자가 들어왔는지 확인
                n2 = float(n2)
        except:
                print('두 번째 피연산자는 숫자가 아닙니다.')
                return 

   if n2 == 0:
                print('0으로 나눌 수 없습니다.')
                return 

     print(f'{n1} // {n2} = {n1 // n2}')

def exp(n1,n2):
    print('거듭제곱 연산')

        try: # 숫자가 들어왔는지 확인
                n1 = float(n1)
        except:
                print('첫 번째 피연산자는 숫자가 아닙니다.')
                return 


        try: # 숫자가 들어왔는지 확인
                n2 = float(n2)
        except:
                print('두 번째 피연산자는 숫자가 아닙니다.')
                return 

    print(f'{n1} ** {n2} = {n1 ** n2}')

import calculator as cc

n1 = int(input('첫번째 피연산자 입력: '))
n2 = int(input('두번째 피연산자 입력: '))

cc.add(n1,n2)
cc.sub(n1,n2)
cc.mul(n1,n2)
cc.div(n1,n2)
cc.mod(n1,n2)
cc.flo(n1,n2)
cc.exp(n1,n2)

✅ 또는 0이 들어왔을 때 예외 처리를 다음과 같이 Exception 클래스를 사용할 수 도 있다.

try:
        print(f'{n1} / {n2} = {n1 / n2}')
except ZeroDivisionError as e:
        print(e) # 어떤 방식으로 에러가 나는지 확인하고
        print('0으로 나눌 수 없습니다.')

# 결과는 다음과 같이 나올 것이다 #
# float division by zero
# 0으로 나눌 수 없습니다.

EX 2. *1부터 1000까지의 소수인 난수 10개를 생성하되, 소수가 아니면 사용자 예외가 발생하도록 프로그램을 만들자. *

# prime.py
class NotPrimeException(Exception): # 소수가 아닐 때 사용할 클래스

    def __init__(self,n):
        super().__init__(f'{n} is not prime number.')

class PrimeException(Exception): # 소수일 때 사용할 클래스

    def __init__(self,n):
        super().__init__(f'{n} is prime number.')

def isPrime(number): # 소수인지 확인해주는 기능
    flag = True # 소수인지 아닌지를 판별하기 위한 불린 초기화
    for i in range(2,number): # 2와 number -1 한 값들만 확인해주면 된다.
        if number % i == 0:
            flag = False
            break

    if flag == False: # 소수가 아니라면
        raise NotPrimeException(number)
    else:
        raise PrimeException(number)

# 난수이면서, 소수인 숫자를 출력해야 한다.
# 소수가 아니면 예외를 발생시키자
import prime as pm
import random
primeNumbers = []
n = 0
while n < 10:
    rn = random.randint(2,1000) # 소수에는 일단 1이 포함 안됨.
    if rn not in primeNumbers: # 일단, 난수가 primeNumbers 안에 이미 있는지 확인
        try:
            pm.isPrime(rn) # 소수인지 확인하는 함수
        except pm.NotPrimeException as e: # 소수가 아닌 강제 예외가 발생하면
            print(e)
            continue
        except pm.PrimeException as e: # 소수일 때 강제 예외
            print(e)
            primeNumbers.append(rn)
    else:
        print(f'{rn} 은 이미 존재합니다.')
        continue

    n += 1

print(f'소수인 난수 결과 : {primeNumbers}')

EX 3. 상품 구매에 따른 ‘총 구매 금액’을 출력하되 개수가 잘 못 입력된 경우 별도로 출력하도록 프로그램을 만들자.

# calculatorPrice.py

g1 = 1000; g2 = 1200; g3 = 800;
g4 = 2000; g5 = 900

def formatedNumber(n):
    retur n format(n, ',')

def calculator(*gcs): #  상품을 몇개를 구매할지 확정되지 않았기 때문에 -> 반복가능한 객체로 사용할 수 있다

    gdDic = {} # 제대로 된 상품 목록을 저장할 딕셔너리 초기화
    againCntInput = {} # 미결제된 상품 목록을 저장할 딕셔너리 초기화

    for idx, gc in enumerate(gcs):
        try:
            gdDic[f'g{idx + 1}'] = int(gc)
        except Exception as e: # int() 를 해줬을 때, 오류가 발생하면 againCntInput 딕셔너리에 담기
            againCntInput[f'g{idx + 1}'] = gc
            print(e)

    # 총금액 계산해주기
    tot_price = 0
    for g in gdDic.keys():
        tot_price += globals()[f'{g}'] * gdDic[g] # globals() 는 전역변수를 담고 있는 리스트다

    print('-'*32)
    print(f'총 구매 금액: {formatedNumber(tot_price)}원')
    print('-'*16, '미결제 항목', '-'*16)
    for a in againCntInput.keys():
        print(f'상품 이름: {a},\t 구매 개수: {againCntInput[a]}')
    print('-' * 32)

import calculatorPrice as cp

# 구매할 상품 개수를 입력받자
gd1 = input('goods1 구매 개수: ')
gd2 = input('goods2 구매 개수: ')
gd3 = input('goods3 구매 개수: ')
gd4 = input('goods4 구매 개수: ')
gd5 = input('goods5 구매 개수: ')

acp.calculator(gd1,gd2,gd3,gd4,gd5)

🔥 globals() 🔥 : 저장된 전역변수들을 리스트로 불러온다.

EX 4. *회원가입 프로그램을 만들되, 입력하지 않은 항목이 있는 경우, 에러 메세지를 출력하는 프로그램을 만들자. *

# signinCheck

class EmptyDataException(Exception):

        def __init__(self,i): # 어떤 값이 없는지를 받아야되니까
                super().__init__(f'{i} is empty!!')

def checkInfo(n,m,p,a,c): # 실행파일에서 회원의 정보를 입력받으면

        if n == '': # 이름이 비어있다면 error 발생
                raise EmptyDataException('name')
        elif m == '':
                raise EmptyDataException('mail')
        elif p == '':
                raise EmptyDataException('passsword')
        elif a == '':
                raise EmptyDataException('address')
        elif c == '':
                raise EmptyDataException('phone number')


class RegistMember():

        def __init__(self, n,m,p,a,c): # 회원 정보를 입력받는 함수
                self.name = n
                self.mail = m
                self.pw = p
                self.address = a
                self.contact = c
                print('Membership registered!!')

        def printUserInfo(self):
                print(f'name : {self.name}')
                print(f'mail : {self.mail}')
                print(f'password: {self.pw}')
                print( f'address : {self.address}')
                print(f'contact : {self.contact}')

# 실행파일에서 input을 받는다.
import signinCheck as sc

name = input('이름 입력: ')
mail = input('메일 주소 입력: ')
pw = input('비밀번호 입력: ')
address = input('주소 입력: ')
contact = input('연락처 입력: ')

# 함수 실행 시 예외 발생 처리
try:
        sc.checkInfo(name,mail,pw,address,contact)
        newMember = sc.RegistMember(name,mail,pw,address,contact)
        newMember.printUserInfo()

except sc.EmptyDataException as e:
        print(e)


# 결과 출력

EX 5. 예외처리를 이용해서 은행 계좌 개설 및 입/출금 프로그램을 만들자.

# bank.py

# 1. 은행에 대한 클래스
class Bank:

    def __init__(self):
        self.accounts = {}

    def addAccount(self,privateBank): # 계좌에 추가해주는 함수
        self.accounts[privateBank.account_no] = privateBank

    def isAccount(self, accountNo):# 계좌를 추가할 때, 기존에 있는 계좌인지 확인해주는 함수
        return accountNo in self.accounts

    def doDeposit(self,accountNo, m): # 입금하는 함수
        pb = self.accounts[accountNo] # 입력한 계좌에 해당하는 정보를 가져오고
        pb.totalMoney = pb.totalMoney + m # 계좌 정보에 들어있는 잔고에서 더해주기

    def doWithdraw(self,accountNo, m): # 출금하는 함수
        pb = self.accounts[accountNo] # 입력한 계좌에 해당하는 정보를 가져오고
        # 그 잔고와 출금하려는 금액에 따라 출금이 가능한지 아닌지를 확인해주기
        if pb.totalMoney - m < 0: # 부족하면
            raise LackException(pb.totalMoney, m) # 예외 처리
        pb.totalMoney = pb.totalMoney - m # 부족하지 않으면

class LackException(Exception): # 잔고가 부족할 때 발생할 예외 함수

    def __init__(self, m1, m2): # 잔고와 출금하려는 금액을 받아온다.
        super().__init__(f'잔고 부족!, 잔액 : {m1}, 출금시도액: {m2}')

# 2. 개인통장을 만들어내는 클래스
# 은행, 계좌 번호, 잔고 등에 대한 정보를 갖고 있어야 한다.
# 계좌 번호를 랜덤하게 생성하기 위해 random 모듈을 가져오자
import random

class PrivateBank:

    def __init__(self, bank, account_name):
        self.bank = bank # 은행 이름
        self.account_name = account_name # 계좌 이름

        while True:
            newAccount = random.randint(10000,99999) # 임의의 계좌 번호를 발생시키고
            if bank.isAccount(newAccount): # 이미 계좌 번호가 존재한다면
                continue # 중복되지 않는 계좌 번호가 나올때까지 반복 실행
            else:
                self.account_no = newAccount # 중복되지 않은 계좌번호가 만들어지면
                break  # 반복문 탈출

        self.totalMoney = 0 # 계좌 잔고 초기화

        bank.addAccount(self) # 내 계좌 정보를 추가해주기

    # 내 계좌정보 출력하는 함수
    def printAccount(self):
        print('-'*40)
        print(f'account name: {self.account_name}')
        print(f'account number: {self.account_no}')
        print(f'account total money: {self.totalMoney}')
        print('-'*40)

import bank

# 가상의 은행 먼저 만들기
koreaBank = bank.Bank()

new_account_name = input('통장 개설을 위한 예금주 입력: ')

# 새로운 계좌 등록후, 정보 출력
myAccount = bank.PrivateBank(koreaBank, new_account_name)
myAccount.printAccount()

# 입출금 활동 시작
while True:
    selectNumber = int(input('1.입금 \t 2.출금 \t 3.종료'))
    if selectNumber == 1: # 입금
        m = int(input('입금액 입력: '))
        koreaBank.doDeposit(myAccount.account_no, m)
        myAccount.printAccount()

    elif selectNumber == 2: # 출금
        m = int(input('출금액 입력: '))
        try:
            koreaBank.doWithdraw(myAccount.account_no, m)
        except bank.LackException as e:
            print(e)
        # 예외가 발생하던, 발생하지 않던 계좌정보는 한번 더 출력해주기
        finally:
            myAccount.printAccount()

    elif selectNumber == 3: # 종료를 누르면
        print('Bye ~')
        break

    else: # 1,2,3이 아닌 다른 번호를 입력했을 때
        print('잘못 입력했습니다. 다시 선택하세요')

🔜 다음 스터디 노트..

다음 스터디 노트에는 텍스트 파일 다루기와 관련된 연습 문제 풀이를 정리한다.

[제로베이스_데이터 취업 스쿨 16기](6/16 ~ 18) - 추상 클래스

Tue, 20 Jun 2023 06:30:43 GMT

중급 연습 문제 풀이 - 추상 클래스

파이썬의 추상 클래스를 활용한 문제 풀이

EX 1. 회원가입 클래스와 회원정보를 관리하는 클래스를 만들고 회원가입 로그인 기능을 구현해보자.

# member.py
# 두 개의 클래스를 만들어줄 것이다
# 1. 가입할 수 있는 클래스
class Member:
    def __init__(self,i,p):
        self.id = i
        self.pw = p

# 2. 여러명의 회원 관리 클래스
class MemberRepository
    def __init__(self):
        self.members = {} #회원을 관리할 전체 목록

    # 회원이 추가되는 기능
    def addMember(self, m):
        self.members[m.id] = m.pw

    # 로그인 기능
    def loginMember(self, i, p):
        # self.members 에 해당 id와 pw가 있는지 확인
        isMember = i in self.members

        if isMember and self.members[isMember] == p: # 입력된 정보와 일치하면
            print(f'{i} : log-in success!!')
        else:
            print(f'{i} : log-in fail!!')

    # 회원을 삭제할 수 있는 기능
    def removeMember(self,i,p):
        del self.members[i]

    # 현재 회원을 출력하는 기능
    def printMembers(self):
        for mk in self.members.keys():
            print(f'ID : {mk}')
            print(f'pw : {self.members[mk]}')

import member as mb

mems = mb.MemberRepository()

# 여기서 회원 정보를 입력받는다.
# 먼저 3명의 정보를 입력받자
for i in range(3):
    mId = input('아이디 입력: ')
    mPw = input('비밀번호 입력: ')

    mem = mb.Member(mId,mPw) 
    mems.addMember(mem)

# 3명의 회원이 잘 추가됐는지 확인
mems.printMembers()

EX 2. tv클래스를 상속구조로 만들고 객체를 생성해보자.

# mytv.py
class NormalTv:

    def __init__(self,i=32,c='black',r='full-HD'):
        self.inch = i
        self.color = c
        self.resolution = r
        self.smartTv = 'off'
        self.aiTv = 'off'

    def turnOn(self):
        print('TV power on')

    def turnOff(self):
        print('TV power off')

    def printTvInfo(self):
        print(f'inch : {self.inch}inch')
        print(f'color : {self.color}')
        print(f'smartTv : {self.smartTv}')
        print(f'aiTv : {self.aiTv}')

class Tv4k(NormalTv):

    def __init__(self, i, c, r='4k'):
        super().__init__(i,c,r)

    def setSmartTv(self, s):
        self.smartTv = s

class Tv8k(NormalTv):

    def __init__(self, i, c, r='8k'):
        super().__init__(i,c,r)

    def setSmartTv(self, s):
        self.smartTv = s

    def setAiTv(self, a):
        self.aiTv = a

import mytv as mt

my4kTv = mt.Tv4k(65,'silver','4k')
my4kTv.setSmartTv('on')
my4kTv.turnOn()
my4kTv.printTvInfo()

EX 3. 도서 관리 프로그램을 만들어보자.

# library.py
class Book:

    def __init__(self,n,p,isbn):
        self.bName = n
        self.bPrice = p
        self.bIsbn = isbn # 책의 구분 번호

class BookRepository(Book):

    def __init__(self):
        self.bDic = {}

    def registBook(self, b):
        self.bDic[b.bIsbn] =  b

    def removeBook(self, isbn):
        del self.bDic[isbn]

    def printBooksInfo(self):
        for isbn in self.bDic.keys():
            b = self.bDic[isbn]
            print(f'{b.bName}, {b.bPrice}, {b.bIsbn}')

    def printBookInfo(self, isbn):
        if isbn in self.bDic:
            b = self.bDic[isbn]
            print(f'{b.bName}, {b.bPrice}, {b.bIsbn}')
        else:
            print('Lookup Result does not exist!')

import library as lb

my_lb = lb.BookRepository()

# 책 생성
my_lb.registBook(lb.Book('python',20000,'12345'))
my_lb.registBook(lb.Book('java',25000,'123456'))
my_lb.registBook(lb.Book('c++',27000,'1234567'))

my_lb.printBooksInfo()
my_lb.removeBook('12345')
my_lb.printBooksInfo()

EX 4. 추상클래스를 사용해서 한영사전을 만들어보자.

from abc import ABCMeta
from abc import abstractmethod

class AbsDictionary(metaclass=ABCMeta): # 추상 클래스

    def __init__(self):
        self.wordDic = {}

    @abstractmethod
    def registWord(self, w1, w2):
        pass

    @abstractmethod
    def removeWord(self, w1):
        pass

    @abstractmethod
    def updateWord(self, w1, w2):
        pass

    @abstractmethod
    def searchWord(self, w1):
        pass

class KortoEng(AbsDictionary): # 추상 클래스 상속

    def __init__(self):
        super().__init__()

    def registWord(self, w1, w2):
        print(f'[KortoEng] registWord(): {w1} to {w2}')
        self.wordDic[w1] = w2

    def removeWord(self, w1):
        print(f'[KortoEng] removeWord(): {w1}')
        del self.wordDic[w1]

    def updateWord(self, w1, w2):
        print(f'[KortoEng] updateWord(): {w1} to {w2}')
        self.wordDic[w1] = w2

    def searchWord(self, w1):
        print(f'[KortoEng] searchWord(): {w1}')
        return self.wordDic[w1]

    def printWords(self):
        for s in self.wordDic.keys():
            print(f'{s}: {self.wordDic[s]}')

import library as lb

kTe = lb.KortoEng()

kTe.registWord('책','bok')
kTe.registWord('나비','butterfly')
kTe.registWord('연필','pencil')
kTe.registWord('학생','student')
kTe.registWord('선생님','teacher')

kTe.printWords()
kTe.updateWord('책','book')

print(kTe.searchWord('책'))

EX 5. 주사위 게임 클래스를 만들고 컴퓨터와 사용자의 게임 결과를 출력하자.

# dice.py
import random as rd

class Dice:

    def __init__(self):
        self.cNum = 0
        self.uNum = 0

    def setCnum(self):
        print(f'[Dice] setCnum()')
        self.cNum = rd.randint(1,6)
        pass

    def setUnum(self):
        print(f'[Dice] setUnum()')
        self.uNum = rd.randint(1,6)
        pass

    def startGame(self):
        print(f'[Dice] startGame()')

        self.setCnum()
        self.setUnum()

    def printResult(self):
        print(f'[Dice] printResult()')

        if self.cNum == 0 or self.uNum == 0: #아직 주사위를 굴리기 전
            print('주사위 숫자 설정 전입니다.')

        else:
            if self.cNum > self.uNum:
                print(f'컴퓨터 vs 유저 : {self.cNum} vs {self.uNum} >> 컴퓨터 승!')

            elif self.cNum < self.uNum:
                print(f'컴퓨터 vs 유저 : {self.cNum} vs {self.uNum} >> 유저 승!')

            elif self.cNum == self.uNum:
                print(f'컴퓨터 vs 유저 : {self.cNum} vs {self.uNum} >> 무승부!')

import dice

dc = dice.Dice()
dc.startGame()
dc.printResult()

EX 6. *자동차 경주 클래스를 만들자. 자동차는 랜덤하게 이동하며, 편의상 10초간 주행한다고 할 때, 가장 멀리 이동한 차가 우승하는 게임이다. *

# car.py
import random # 자동차의 속도를 그때그때 랜덤하게 추출할 것이기 때문에

class Car:

    def __init__(self, n='fire car', c='red', s=200): # 이름, 색상, 속력 초기화
        self.name = n
        self.color = c
        self.max_speed = s
        self.distance = 0 # 이동한 거리 초기화

    def printCarInfo(self):
        print(f'name : {self.name}, color : {self.color}, max_speed : {self.max_speed}')

    def controlSpeed(self):
        return random.randint(0, self.max_speed)

    def getDistanceForHour(self):
        return self.controlSpeed() * 1  # 한시간동안 이동한 거리

# racing.py
from time import sleep

class CarRacing:

    def __init__(self):
        # 자동차 목록
        self.cars = []
        self.rankings = []

    def startRacing(self):
        for i in range(10): # 한바퀴를 도는 시간을 1초라고 하고 10바퀴를 돌자
            print(f'Racing : {i+1}바퀴')
            for car in self.cars: # 모든 차들이 움직여야 되니까
                car.distance += car.getDistanceForHour()

            sleep(1) # 잠시 프로그램을 1초간 중지시키는 팁
            self.printCurrentCarDistance()

    def printCurrentCarDistance(self): # 현재까지 차가 이동한 거리를 출력해주는 함수
        for car in self.cars:
            print(f'{car.name} : {car.distance}\t\t', end='')
        print()

    def addCar(self, c): # 차를 등록해주는 함수
        self.cars.append(c)


import car
import racing as rc

myCarGame = rc.CarRacing()
car01 = car.Car('Car01','white', 250)
car02 = car.Car('Car02','black', 200)
car03 = car.Car('Car03','yellow', 220)
car04 = car.Car('Car04','blue', 280)
car05 = car.Car('Car05','red', 150)

# 자동차 추가해주기
myCarGame.addCar(car01)
myCarGame.addCar(car02)
myCarGame.addCar(car03)
myCarGame.addCar(car04)
myCarGame.addCar(car05)

myCarGame.startRacing()

EX 7.** mp3 플레이어 클래스를 만들고 노래 등록 후 재생해보자.**

# song.py
from time import sleep
import random
# 노래에 대한 정보를 나타내는 클래스
class Song:

    def __init__(self, t, s, pt):
        self.title = t
        self.singer = s
        self.play_time = pt

    def printSongInfo(self):
        print(f'title : {self.title}, singer: {self.singer}, play_time : {self.play_time}')

# 플레이어 클래스 만들기
class Player:

    def __init__(self):
        self.songList = [] # 플레이어리스트를 담을 리스트 초기화
        self.isLoop = False

    def addSong(self, s): # 노래를 추가하는 함수
        self.songList.append(s)

    def play(self): # 노래 재생하는 함수
        # 1. 반복재생하는지의 여부에 따라 달라짐
        if self.isLoop == False:
            for s in self.songList:
                print(f'Title : {s.title}, Singer: {s.singer}, Play time: {s.play_time}sec')
        else:
            while self.isLoop:
                for s in self.songList:
                    print(f'Title : {s.title}, Singer: {s.singer}, Play time: {s.play_time}sec')
                    sleep(s.play_time)

    def shuffle(self): # 셔플할지 말지 설정하는 함수, random 의 shuffle 모듈을 사용래서 리스트 순서를 섞여준다.
        random.shuffle(self.songList)

    def setIsLoop(self,flag):
        self.isLoop = flag

import song

s1 = song.Song('좋은날','아이유',3)
s2 = song.Song('목요일밤','어반자카파',2)
s3 = song.Song('nike shoes','빈지노',4)
s4 = song.Song('꺼내먹어요','자이언티',4)
s5 = song.Song('한숨','이하이',5)

player = song.Player
player.addSong(s1)
player.addSong(s2)
player.addSong(s3)
player.addSong(s4)
player.addSong(s5)

player.setIsLoop(False)
player.shuffle()
player.play()

🔜 다음 스터디 노트..

다음 스터디 노트에는 예외 처리와 관련된 연습 문제 풀이를 정리한다.

[제로베이스_데이터 취업 스쿨 16기] 8일차(6/14) - 모듈

Wed, 14 Jun 2023 14:18:54 GMT

중급 연습 문제

중급 문법들을 활용해 연습 문제들을 풀어본다.

모듈

1. 순열 계산 모듈을 만들고 순열 계산 결과를 출력해보자.

# permutation.py
def permutation(n,r):
    if (n - r) < r:  # 순열 계산하기
        r = n - r
    result = 1
    for i in range(r):
        result *= n-i
        print(f'n : {n-i}')

    print(f'{n}P{r}: {result}')

import permutation as pt
n = int(input('numN 입력: '))
r = int(input('numR 입력: '))

pt.permutation(8,3)

🔻 강사님의 순열 코드

def permutation(n,r):
    result = 1
    for i in range(n,(n-r),-1):
        result *= i
        print('n : {}'.format(i))

    print(f'{n}P{r}: {result}')

▶️ 로그 과정을 확인하고 싶을 때, logPrint=True 처럼 설정해 자유롭게 변경할 수 있다

def permutation(n,r, logPrint=True):
    result = 1
    for i in range(n,(n-r),-1):
        result *= i
            if logPrint=True: print('n : {}'.format(i))

    print(f'{n}P{r}: {result}')

📌 순열 계산 패키지

from itertools import permutations
```
from itertools import permutations
```

def permutation(ns,r): #이때 ns는 iterable 한 객체다. pList = list(permutations(ns,r)) # 만들어지는 값도 저장된다. print(f'{len(ns)}P{r} 개수 : {len(pList)}'

for i in permutations(ns,r):
    print(n, end=',  '))

```python
# iterable 한 객체에서 임의의 숫자만큼 뽑는 개수
import permutation as pt
listVar = [1,2,3,4,5,6,7,8]
rVar = 3

pt.permutation(listvar,rVar)

2. 조합 계산 모듈을 만들고 계산 결과를 출력해보자.


# combination.py
def combination(n,p):
    dn = 1
    mc = 1
    for i in range(n,(n-p),-1):
        dn *= i
    print(f'resultP: {dn}')
    for j in range(p, 0,-1):
        mc *= j
    print(f'resultR: {mc}')
    result = int(dn / mc)
    print(f'resultC : {result}')

    print(f'{n}C{p}: {result}')

import combination as cb
n = int(input('numN 입력: '))
p = int(input('numP 입력: '))

cb.combination(8,3)

📌 조합 계산 패키지

from itertools import combinations
```
from itertools import combinations
```

def getCombinations(ns,r): # ns개에서 r개를 순서와 상관없이 뽑는 경우의 수 c_list = list(cobinations(ns,r)) # c_list 는 모든 경우의 수다. print(f'{len(ns)}C{r} : {len(c_list)}')

```python
# combinations(ns,r) 의 모든 경우의 수를 확인하고 싶다면 어차피 리스트 자료구조이니까
for n in combinations(ns,r):
    print(n, end= ', ')

3. 수입과 공과금을 입력하면 공과금 총액과 수입 대비 공과금 비율을 계산해주는 모듈을 만들자.

# mymodule.py
def pbFare(income,fare1,fare2,fare3):
    totFare = fare1 + fare2 + fare3
    farePct = round((totFare / income) * 100,2)
    print(f'공과금 : {format(totFare, ',')}원')
    print(f'공과금 비율 : {farePct}%')

import mymodule as md
income = float(input('수입 입력: '))
fare1 = float(input('수도요금 입력: '))
fare2 = float(input('전기요금 입력: '))
fare3 = float(input('가스요금 입력: '))

# 총 공과금 및 비율 계산 함수 적용하기
md.pbFare(income,fare1,fare2,fare3)

🔻 강사님 풀이

# mymodule.py

# 1. 사용할 전역 변수 초기화
income = 0
waterPrice = 0; electricPrice = 0; gasPrice = 0;


# 변수의 값을 세팅하는 함수와 가져오는 함수를 만들어준 뒤
# main 에서 받은 입력값으로 전역변수 값을 변경해 함수를 사용하면 된다.

def setIncome(ic): # setter 함수
    global income # 전역 변수값을 가져와서
    income = ic

def getIncome(): # getter 함수
    return income 


def setWaterPrice(wp): # setter 함수
    global waterPrice # 전역 변수값을 가져와서
    waterPrice = wp

def getWaterPrice(): # getter 함수
    return waterPrice 


def setElectricPrice(ep): # setter 함수
    global eletricPrice # 전역 변수값을 가져와서
    eletricPrice = ep

def getElectricPrice(): # getter 함수
    return eletricPrice 



def setGasPrice(gp): # setter 함수
    global gasPrice # 전역 변수값을 가져와서
    gasPrice = gp

def getGasPrice(): # getter 함수
    return gasPrice 


def getUtilityBill(): # 전체 공과금액을 계산해주는 함수
    result = waterPrice + eletricPrice + gasPrice 
    return result


def getUtilityBillRate():
    result = getUtilityBill() / getIncome() * 100
    return result

#########################################################
import mymodule as md

income = float(input('수입 입력: '))
water = float(input('수도요금 입력: '))
eletric = float(input('전기요금 입력: '))
gas = float(input('가스요금 입력: '))

md.setIncome(income)
md.setWaterPrice(income)
md.setElectricPrice(income)
md.setGasPrice(income)


print(f'공과금 : {getUtilityBill()}원')
print(f'공과금 비율 : {getUtilityBillRate()}%')

[제로베이스_데이터 취업 스쿨 16기] 7일차(6/12)

Mon, 12 Jun 2023 16:24:44 GMT

사용자 예외 클래스

Exception 클래스를 상속해서 사용자 예외 클래스를 만들 수 있다. 사용자 예외 클래스는 반드시 Exception 클래스를 상속받아야 한다.

예제

관리자 번호를 입력하고 다음 상태에 따라 예외 처리하는 예외 클래스를 만들자.

# 1. 암호 길이가 5미만인 경우
class PasswordLengthShortException(Exception):

 def __init__(self,n):
     super().__init__(f'{n} : 길이 5미만!')

2. 암호 길이가 10을 초과하는 경우

class PasswordLengthLongException(Exception):

def __init__(self,n):
    super().__init__(f'{n} : 길이 10초과!')

3. 암호가 잘못된 경우

class PasswordWrongException(Exception):

def __init__(self,n):
    super().__init__(f'{n}  잘못된 비밀번호!')

password = input('input admin password: ')

try: if len(password) < 5: raise PasswordLengthShortException(password) elif len(password) > 10: raise PasswordLengthLongException(password) elif password != 'admin1234': raise PasswordWrongException(password) elif password == 'admin1234': print('빙고!')

except PasswordLengthShortException as e1: print(e1)

except PasswordLengthLongException as e2: print(e2)

except PasswordWrongException as e3: print(e3)


---
## 텍스트 파일 다루기

> open(), read(), write(), close() 를 이용해서 텍스트 파일을 다룰 수 있다. 

![](https://velog.velcdn.com/images/j_jume/post/e1a11c09-cc12-4ae6-ad71-177c341a911c/image.png '제로베이스 데이터 취업 스쿨 자료')

1. 파일을 쓰거나, 읽고 싶을 때 : **open()**
- open('파일 디렉토리명', 'w') : 파일을 연 뒤, 새로운 내용을 쓴다.
    ❗️ *기존에 내용이 있는 경우, 기존의 내용은 완전히 사라진다.*
  ```python
  file = open('디렉토리명', 'w')
  strCnt = file.write('블라블라') # 반환값은 쓴 문자의 개수다
  print(f'strCnt : {strCnt}')
  file.close() # 반드시 닫아줘야 됨.

예제 코드

# 시스템 시간과 일정을 텍스트 파일에 작성해보자.

import time

lt = time.localtime()

dateStr = '[' + str(lt.tm_year) + '년 ' +\
    str(lt.tm_mon) + '월 ' +\
    str(lt.tm_mday) + '일]'

toDo = input('오늘 일정: ')

file = open("디렉토리", 'w')
file.write(dateStr + toDo)
file.close()

open('파일 디렉토리명', 'r') : 파일을 연 뒤, 파일 내용을 읽는다. ❗️read의 경우에는 파일이 존재하지 않으면 오류가 발생
```
 read는 어떤 형태로 쓰여져있건, 문자로 읽어온다.
```

💎 잠깐 알고가기 💎

str.strftime() : date나 datetime 포맷의 시간값을 원하는 문자열 포맷으로 변경할 때 쓴다.
```
dateStr = '[' + time.strftime('%Y-%M-%d %H:%M:%S %p') + ']' # %p는 AM/PM 을 나타낸다.
```
%H, %I
- %H : 24시간 표시로, 오후 1시의 경우 13시로 표시한다.
- %I : 12시간 표시로, 오후 1시의 경우 1시로 표시한다.

예제 코드

파일에 있는 특정 문자를 다른 문자로 변경해보자.
```
new = open('디렉토리명', 'w')
new.write('~~')
```

new.close()

기존 파일을 일단 읽어온다음에

new = open('디렉토리명', 'r') forChange = new.read() forChange = forChange.replace('Python','파이썬') # 모든 'Python'을 '파이썬'으로 변경해준다.

new.close()

❗️만약 전체를 바꾸는 것이 아니라 특정 개수만 바꿔주고 싶다면 다음과 같이 replace()를 사용한다.
```python
str.replace('바꾸기 전 문자','바꿀 문자',개수)

파일 열기 모드

w, a, x, r 정도가 있다.

'w' : 쓰기 전용(파일이 있다면 덮어씌운다) 기존에 있는 내용은 모두 지운다.
'a' : 쓰기 전용(파일이 있다면 덧붙여준다) 기존에 있는 내용에 덧붙여준다.
'x' : 쓰기 전용(파일이 있다면 error 발생)
'r' : 읽기 전용(파일이 없다면 error 발생)

예제 코드

사용자가 입력한 숫자까지의 값중에서 소수만 파일에 작성하는 코드
```
url = '저장할 디렉토리'
```

def writePrimeNumber(n): file = open(url + 'prime_numbers.txt', 'a') file.write(str(n)) file.write('\n')

file.close()

inputNumber = int(input('0보다 큰 정수 입력: ')) for num in range(2, (inputNumber + 1)): # 2부터 입력한 정수까지의 숫자까지 돌면서 flag = True for i in range(2,num): # 2 ~ (자기자신 - 1)의 값 중 하나라도 나누어떨어지는 숫자가 있다면 if num % i == 0: flag = False break if flag == True: # 2 ~ (자기자신 - 1)의 값 중 나누어떨어지는 숫자가 하나도 없다면 writePrimeNumber(num)



---
### with ~ as
> with ~ as 문을 사용하면 파일 닫기(close)를 생략할 수 있다.

![](https://velog.velcdn.com/images/j_jume/post/dfbbbbf4-439e-4841-8075-e8adaefe79d9/image.png '제로베이스 데이터 취업 스쿨 자료')

🔻 아래와 같이 쓰인다.
```python
uri = '디렉토리'

with open(uri + '파일이름.txt', 'a') as f:
    f.write('python study!!')

with open(uri + '파일이름.txt', 'r') as f:
    print(f.read())

예제 코드

로또 번호 생성기 프로그램을 만들고 파일에 번호를 출력
```
import random
```

rNums = random.sample(range(1,46), 7) # 1 ~ 46까지의 번호중에 7개를 랜덤하게 추출 -> 리스트에 print(f'rNums : {rNums}')

def writeNumbers(nums): for idx, num in enumerate(nums): with open(uri + '파일이름', 'a') as f: if idx < (len(nums) - 2): f.write(str(num) + ', ') elif idx == (len(nums) - 2): f.write(str(num)) elif idx == (len(nums) - 1): f.write('\n') f.write('bonus: ' + str(num)) f.write('\n')

writeNumbers(rNums)





---


### writelines() / readlines() / readline()




- **writelines()**
 > 리스트 또는 튜플 데이터를 파일에 쓰기 위한 함수다

 ![](https://velog.velcdn.com/images/j_jume/post/19fe4642-0f38-486d-a99a-8ed1e4f27f3f/image.png)

❗️하지만 그냥 writelines() 만 해주면 개행이 되지 않는 상태로 써진다. 개행을 하고 싶다면 아래와 같이 해준다.
```python
with open(uri + '파일이름.txt', 'a') as f:
    f.writelines(item + '\n' for item in laguages)

➡️ 즉, writelines() 안에 for문을 넣어줘서 각 원소마다 개행문자를 붙여주면 된다.

예제 코드

딕셔너리에 저장된 과목별 점수를 파일에 저장하는 코드를 작성
```
scoreDic = {'kor':85, 'eng':90, 'mat':92, 'sci':79, 'his':82}
```

uri = '파일 디렉토리'

for key in scoreDic.keys(): # key 값들만 포함된 리스트 with open(uri + '파일이름.txt', 'a') as f: f.writelines(key + '\t: ' + str(scoreDic[key]) + '\n')

❗️ 딕셔너리나 리스트 모양 그대로 출력하고 싶다면 아래와 같이 해준다.
- print(써주고 싶은 리스트 또는 딕셔너리, file=파일이름)
```python
scoreDic = {'kor':85, 'eng':90, 'mat':92, 'sci':79, 'his':82}
with open(uri + '파일이름2.txt', 'a') as f:
    print(scoreDic, file=f)

readlines() / readline()
- readlines() : 파일의 모든 데이터를 읽어서 리스트 형태로 반환
- readline() : 한 행만 읽어서 문자열 형태로 반환

▶️ readline() 의 경우, while 이나 for문을 이용해서 한 행씩 읽어들일 수 있다.

예제 코드

파일에 저장된 과목별 점수를 파이썬에서 읽어, 딕셔너리에 저장하는 코드를 만들어보자.
```
scoreDic = {}
```

uri = '파일디렉토리'

with open(uri + '파일 이름.txt', 'r') as f: # 이미 파일에 과목별 점수가 있다고 하고 line = f.readline()

while line != '': # line 을 모두 읽어들일때까지 반복
    tempList = line.split(':') # ':' 를 기준으로 분리해서 리스트에 저장
    scoreDic[tempList[0]] = int(tempList[1].strip('\n')) # '\n'을 삭제해주고 정수형으로 value 값 저장
    line = f.readline()

print(f'scoreDic: {scoreDic}')



---




## 🔜 중급 문제 풀이
`이제까지 파이썬의 중급 문법들을 다뤄봤다. 다음 시간부터는 본격적으로 중급 문제 풀이를 정리해보도록 하겠다`

[제로베이스_데이터 취업 스쿨 16기] 6일차(6/7 ~ 8)

Fri, 09 Jun 2023 03:09:58 GMT

파이썬의 예외 처리 구문

파이썬의 에러 및 예외 구문은 다양하게 발생한다. 아래 그림은 대표적인 파이썬의 예외 발생 클래스들이다.

try ~ except

🔻 기본 구문 🔻

try:
    수행 코드
except:
    예외 발생시 수행할 코드

특정 코드를 수행했을 때, 예외가 발생한다면 except 구문 내 코드를 실행하게 된다.

예제 코드

# 숫자가 아닌 자료형이 입력되면 예외 처리를 하는 프로그램
nums = []

n = 1 while n < 6: try: num = int(input('숫자를 입력하세요: ')) except: # 위의 결과에서 문제가 발생했을 경우 print('예외 발생!') continue

nums.append(num)
n += 1 # 5 + 1 = 6 이 되었을 경우, while 문을 빠져나올 수 있기 때문에 전체 데이터 개수는 5개가 된다.

print(f'nums: {nums}')


2.
```python
n1 = 10; n2 = 0

try: #아래 구문을 실행했을 때 
    print(n1 / n2)
except: #예외가 발생하면 아래를 실행
    print('예상치 못한 예외가 발생했습니다.')
    print('다른 프로그램 실행에는 문제가 없습니다.')

print(n1 * n2)
print(n1 + n2)
print(n1 - n2)

# 예상치 못한 예외가 발생했습니다.
#다른 프로그램 실행에는 문제가 없습니다.
#0
#10
#10

try ~ except ~ else

예외가 발생했을 때 수행할 구문과 예외가 발생하지 않았을 때 수행할 구문을 모두 표현할 때 사용한다.

🔻 기본 구문 🔻

try:
    수행 코드
except:
    예외 발생 시 수행할 코드
else:
    예외 발생하지 않았을 때 수행할 코드

예제 코드

짝수 5개를 리스트에 담는 프로그램
```
nums = []
n = 1
```

while n < 6: # n 이 6개 미만일 때까지만 수행

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

except:
    print('예외 발생!')
    continue

else:
    if num % 2 == 0: # 입력한 숫자가 짝수라면
        nums.append(num)
        n += 1
    else: # 홀수라면
        print('짝수를 입력해주세요')
        continue



2. 숫자 5개를 입력받아 짝수, 홀수, 실수로 구분해서 각각을 리스트에 저장하는 프로그램
```python
odd = []
even = []
number = []

n = 1  # 전체 받은 데이터 개수를 세어줄 값 초기화

while n < 6:
    try:
        value = float(input('input number : '))

    except:
        print('exception raise!!')
        print('input number again!!')
        continue
    else: # 들어온 입력에 int() 해줬을 때 오류가 발생하지 않았다면 -> 실수 or 정수
        # 실수일 경우
        if value - int(value) != 0:
            print('float number!')
            number.append(value)
            n += 1
          # 정수일 경우
        else:
                        if int(value) % 2 != 0: # 홀수일 경우
                print('odd number!')
                odd.append(int(value))
                n += 1
                        else: 
                print('even number!') # 짝수일 경우
                even.append(int(value))
                n += 1


print(f'eveList : {even}')
print(f'oddList : {odd}')
print(f'floatList : {number}')

finally

예외 발생 여부와 상관없이 항상 실행하는 구문을 추가할 때 사용한다.

🔻 기본 구문 🔻

예제 코드

숫자 5개를 입력받아 짝수, 홀수, 실수와 입력한 모든 데이터를 각각 출력하는 프로그램
```
odd = []
even = []
number = []
datalist = []
```

n = 1 while n < 6: try: inputVal = input('input number : ') num = float(inputVal) except: # 입력한 값이 문자일 경우 print('exception raise!!') print('input number again!!') continue else: if num - int(num) != 0: # 실수일 경우 print('float number!') number.append(num) else: if num % 2 == 0: # 짝수일 경우 print('even number!') even.append(int(num)) else: # 홀수일 경우 print('odd number!') odd.append(int(num)) n += 1 finally: datalist.append(inputVal)

print(f'eveList : {even}') print(f'oddList : {odd}') print(f'floatList : {number}') print(f'dataList : {datalist}')


---
## Exception 클래스

> 예외를 담당하는 내장 클래스다. 예외가 발생했을 때, 어떤 이유로 에러가 났는지를 표시하고 싶을 경우 사용한다.
>> 일반적으로 `Exception as e` 처럼 별칭을 사용한다. 

🔻 기본 구문 🔻
![](https://velog.velcdn.com/images/j_jume/post/f8a3346a-07af-4130-ac18-04d0869ad8fa/image.png "제로베이스 데이터 취업 스쿨 자료") 




### 예제 코드
1. 
```python
n1 = int(input('input number1 : '))
n2 = int(input('input number2 : '))

try:
    print(f'n1 / n2 = {n1 / n2}')
except Exception as e:
    print('0으로 나눌 수 없습니다.')
    print(f'exception error : {e}')

print(f'n1 + n2 = {n1 + n2}')
print(f'n1 * n2 = {n1 * n2}')
print(f'n1 - n2 = {n1 - n2}')

raise

강제로 예외를 발생시킬 수도 있다. 이럴 경우, raise함수를 사용한다.

예제 코드

def divCalculator(n1,n2):

 if n2 != 0:
     print(f'{n1} / {n2} = {n1 / n2}')
 else:
     raise Exception('0으로 나눌 수 없습니다.') # 강제로 예외를 발생(만들어)시킴

num1 = int(input('input number1: ')) num2 = int(input('input number2: '))

try: divCalculator(num1, num2) except Exception as e: print(f'Exception : {e}') # e안에 '0으로 나눌 수 없습니다.'가 들어가게 된다.

```

🔜 파이썬 중급 문제 풀이

여기까지 파이썬의 중급 문법들을 다뤄봤다. 다음에는 본격적으로 중급 문제 풀이를 진행하고, 기초 수학을 학습한 내용들을 정리해보겠다.

[제로베이스_데이터 취업 스쿨 16기] 5일차(6/7 ~ 8)

Thu, 08 Jun 2023 10:34:13 GMT

0. 클래스

class 키워드와 속성(변수), 기능(함수)를 이용해서 클래스를 구현할 수 있다.

예시 코드

차 기능, 속성을 가지는 클래스 만들기

class Car:
 def __init__(self,col,len):
     self.color = col
     self.length = len

 def doStop(self):
     print('STOP!!')

def doStart(self):
    print('START!!')


def printCarInfo(self):
    print(f'self.color: {self.color}')
    print(f'self.length: {self.length}')

생성자 호출 : Car()

car1 = Car('red',200) car2 = Car('blue',300)

car1.printCarInfo() car2.printCarInfo()

car1.doStop() car1.doStart()




2. 비행기 기능(착륙/이륙)과 속성(길이,무게,색상)을 가지는 클래스를 만들어보고, 5개의 객체를 만들어보자.
```python
class Airplane:
    def __init__(self,col,len, wt):
        self.color = col
        self.length = len
                self.weight = wt

    def doLand(self):
        print('착륙합니다.')


    def doDepart(self):
        print('이륙합니다.')


    def printAirInfo(self):
        print(f'self.color: {self.color}')
        print(f'self.length: {self.length}')
        print(f'self.weight: {self.weight}')


air1 = Airplane('red',72,120000)
air2 = Airplane('blue',80,160000)
air3 = Airplane('white',77,130000)
air4 = Airplane('wine',88,180000)
air5 = Airplane('yellow',73,125000)

정의된 객체의 속성은 변경할 수도 있다.

class Airplane:
    def __init__(self,col,len, wt):
        self.color = col
        self.length = len
                self.weight = wt

    def doLand(self):
        print('착륙합니다.')


    def doDepart(self):
        print('이륙합니다.')


    def printAirInfo(self):
        print(f'self.color: {self.color}')
        print(f'self.length: {self.length}')
        print(f'self.weight: {self.weight}')


air1 = Airplane('red',72,120000)

# air1의 객체 속성 변경
air1.color = 'purple'
air1.length = 75
air.weight = 130000

air.printAirInfo() # -> 변경된 정보를 확인할 수 있다.

1. 객체

1-1. 얕은 복사와 깊은 복사

얕은 복사는 객체 주소를 복사하는 것, 객체 자체가 하나 더 생기는 것이 아니다.

깊은 복사는 기존의 객체 자체를 하나 더 복사하는 것이다.

[ 얕은 복사 ]

아래 식처럼 사용할 경우, 얕은 복사가 된다.

tc1 = TemCls(10,'hello')
tc2 = tc1

얕은 복사는 tc2의 속성을 변경시키면 tc1의 속성도 함께 변경된다.

[ 깊은 복사 ]

깊은 복사를 구현하는 방식은 여러가지가 있다.

copy 모듈 사용하기
```
import copy
```

tc1 = TemCls(10,'hello') tc2 = copy.copy(tc1) # tc1가 가리키는 객체와 tc2가 가리키는 객체가 달라지게 된다.

깊은 복사는 tc2의 속성을 변경시켜도 tc1의 값에 영향을 주지 않는다. 


2. **리스트에서의 복사 활용**하기
리스트에서는 기본적으로 **id()** 라는 함수로 **객체의 메모리 주소**를 확인할 수 있다. 

    2-1. 얕은 복사
  ```python
  # 얕은 복사
  scores = [9,8,7,6,5,4]
  copyScores = scores

  print(f'id(scores): {id(scores)}')
  print(f'id(copyScores): {id(copyScores)}')

  #id(scores): 4333407680
  #id(copyScores): 4333407680

2-2. 깊은 복사

     # 깊은 복사
  # 1. for 구문, append()
  copyScores = []
  for s in scores:
      copyScores.append(s)

  print(f'id(scores): {id(scores)}')
  print(f'id(copyScores): {id(copyScores)}')

 #id(scores): 4376186432
#id(copyScores): 4376307584

----------------------------------------------------------

# 2. extend() 
copyScores.extend(scores)

print(f'id(scores): {id(scores)}')
print(f'id(copyScores): {id(copyScores)}')

#id(scores): 4336315968
#id(copyScores): 4336690688

------------------------------------------------------------

# 3. copy() : 리스트 내장 깊은 복사 함수
copyScores = scores.copy()

print(f'id(scores): {id(scores)}')
print(f'id(copyScores): {id(copyScores)}')

#id(scores): 4338250176
#id(copyScores): 4338250304

------------------------------------------------------------

# 4. 슬라이싱 : [:]
copyScores = scores[:]

print(f'id(scores): {id(scores)}')
print(f'id(copyScores): {id(copyScores)}')

#id(scores): 4368101760
#id(copyScores): 4368101888

2. 클래스 상속

클래스는 또 다른 클래스를 상속해서 안에 있는 기능들을 사용할 수 있다.

class First:

    def go(self):
        print(f'[First] go() called!')

    def back(self):
        print(f'[First] back() called!')    


class Second(First): # 클래스 상속

    def second(self):
        print(f'[Second] go() called!')


mySecond = Second()
mySecond.second()
mySecond.go()
mySecond.back()


#[Second] go() called!
#[First] go() called!
#[First] back() called!

예시 코드

덧셈, 뺄셈 기능이 있는 클래스를 만들고, 이를 상속하는 클래스를 만들어서 곱셈과 나눗셈 기능을 추가해보자.
```
class AddSub:

 def add(self,n1,n2):
     return n1 + n2

 def sub(self,n1,n2):
     return n1 - n2
```

class MulDiv(AddSub):

def mul(self,n1,n2):
    return n1 * n2

def div(self,n1,n2):
    return n1 / n2

cal = MulDiv()

print(f'cal.add(10,20) : {cal.add(10,20)}') print(f'cal.sub(10,20) : {cal.sub(10,20)}') print(f'cal.mul(10,20) : {cal.mul(10,20)}') print(f'cal.div(10,20) : {cal.div(10,20)}')

#cal.add(10,20) : 30 #cal.sub(10,20) : -10 #cal.mul(10,20) : 200 #cal.div(10,20) : 0.5



```python
class Calculator():

    def __init__(self):
        print(f'[Calculator] __init__() called!')



cal = Calculator() # 객체 생성 및 생성자 호출

# [Calculator] __init__() called!

init 의 역할 : 속성을 초기화해준다. < 외부에서 매개변수로 값을 받아오는 방식>

  class Calculator():
  def __init__(self,n1,n2):
      print(f'[Calculator] __init__() called!')
      self.num1 = n1
      self.num2 = n2

  cal = Calculator(10,20) # 객체 생성 및 생성자 호출
  print(cal.num1)
  print(cal.num2)

< 내부에서 값을 고정시키는 방식>
```python
class Calculator():

def __init__(self):
    print(f'[Calculator] __init__() called!')
    self.num1 = 10
    self.num2 = 100

cal = Calculator()
print(cal.num1)
print(cal.num2)
```


< 혼합 > 
```python
class Calculator():

def __init__(self,n):
    print(f'[Calculator] __init__() called!')
    self.num1 = n
    self.num2 = 100

cal = Calculator(3.14) # 객체 생성 및 생성자 호출
print(cal.num1)
print(cal.num2)
```

상위 클래스 속성 초기화하기 - super() 부모 - 자식 클래스 간 상속이 되어 있을 경우, 기능은 특별한 조건 없이 사용할 수 있지만, 속성의 경우에는 부모 속성을 사용하고 싶다면 super() 메소드를 넣어줘야 한다.

class Parent():

    def __init__(self,pnum1,pnum2):
        print(f'[Pclass] __init__() called!')
        self.pnum1 = pnum1
        self.pnum2 = pnum2



class Child():

    def __init__(self,cnum1,cnum2):
        print(f'[Cclass] __init__() called!')

        # 부모 클래스 init 호출하여 속성값 초기화해주기
        super().__init__(cnum1,cnum2)

        self.cnum1 = cnum1
        self.cnum2 = cnum2


cls = Child(10,20)


# [Cclass] __init__() called!
#[Pclass] __init__() called!

다중 상속 - 2개 이상의 클래스를 상속한다 하지만, 너무 남발하면 좋지 않다.

class Car01:

    def drive(self):
        print('drive() method called!')

class Car02:

    def turbo(self):
        print('turbo() method called!')

class Car03:

    def fly(self):
        print('fly() method called!')


class Car(Car01, Car02, Car03): # 다중 상속

    def __init__(self):
        pass


Mycar = Car()
Mycar.drive()
Mycar.turbo()
Mycar.fly()


#drive() method called! 
#turbo() method called!
#fly() method called!

오버라이딩 : 메서드를 재정의하다

두 클래스가 종속관계에 있을 때, 하위 클래스가 상위 클래스의 메서드를 재정의하게 되는 경우를 의미한다.

[예시]

class Robot:

    def __init__(self,c,h,w):
        self.color = c
        self.height = h
        self.weight = w

    def fire(self):
        print(f'미사일 발사!')


    def printRobotInfo(self):
        print(f'self.color : {self.color}')
        print(f'self.height : {self.height}')
        print(f'self.weight : {self.weight}')


class NewRobot(Robot):

    def __init__(self,c,h,w):
        super().__init__(c,h,w)

    def fire(self): # 오버라이딩
        print('레이저 발사!')


myRobot = NewRobot('red',200,300)
myRobot.printRobotInfo()
myRobot.fire()

추상클래스

상위 클래스에서 하위 클래스에 메서드 구현을 강요하는 방법을 일컫는다

추상 클래스의 활용 기능은 상위 클래스에서 선언만 해준 메서드를 서로 다른 하위 클래스에서 입맛에 맞게 변경할 수 있다는데 있다.

추상클래스를 구현하는데 필요한 모듈은 abc 안의 ABCMeta, abstractmethod 함수다.

[예시]

#################### 1 #####################
from abc import ABCMeta
from abc import abstractmethod

class AirPlane(metaclass=ABCMeta):

    @abstractmethod
    def flight(self): 
        pass # 구현되지 않은 메소드

    def forward(self):
        print('전진!')

    def backward(self):
        print('후진!')


class Airliner(AirPlane):

    def __init__(self,c):
        self.color = c

    def flight(self):
        print('시속 400km/h 비행!')



al = Airliner('red')
al.flight()
al.forward()
al.backward()

#################### 2 #####################
# 계산기 추상 클래스 -> 새로운 계산기 클래스를 생성하기
# 덧셈 , 뺄셈, 곱셈, 나눗셈 기능이 있어야 함
from abc import ABCMeta
from abc import abstractmethod

class Calculator(metaclass=ABCMeta):

    @abstractmethod
    def add(self,n1,n2):
        pass

    def sub(self,n1,n2):
        pass

    def mul(self,n1,n2):
        pass

    def div(self,n1,n2):
        pass


class Newcalculator(Calculator):


    def add(self,n1,n2):
        return n1 + n2

    def sub(self,n1,n2):
        return n1 - n2

    def mul(self,n1,n2):
        return n1 * n2

    def div(self,n1,n2):
        return n1 / n2


value = Newcalculator()
print(value.add(10,20))
print(value.sub(10,20))
print(value.mul(10,20))
print(value.div(10,20))

여기까지 객체지향 프로그래밍의 개념과 클래스 개념, 활용 방법들을 살펴봤다. 다음 포스팅은 try ~ except 예외 처리 구문 및 활용 방법들에 대해서 정리해볼 예정이다.

try ~ except 예외처리 개념 및 활용 🔜

[제로베이스_데이터 취업 스쿨 16기] 4일차(6/6)

Wed, 07 Jun 2023 09:53:59 GMT

앞서 파이썬의 기본적인 문법 단계인 반복문과 조건문까지 학습했다. 이번에는 파이썬의 중급 문법들을 다뤄보면서 [모듈, 패키지, 클래스, 객체 지향의 개념] 까지 학습한 내용들을 정리했다.

1. 모듈 및 패키지

대표적인 모듈들

파이썬에서 대표적으로 많이 활용하는 모듈에는 random , math, time 모듈이 있다.

math 모듈

fabs() : 절댓값
```
  import math
  print(math.fabs(-10))
```

ceil() : 올림

  math.ceil(5.21) # -> 6
  math.ceil(-5.21) # -> -5

floor() : 내림

  math.floor(5.21) # -> 5
  math.floor(-5.21) # -> -6

trunc() : 버림

  math.trunc(5.21) # -> 5
  math.trunc(-5.21) # -> -5

gcd() : 최대공약수
```
  math.gcd(14,21) # -> 7
```

factorial() : 팩토리얼
```
  math.factorial(10) # -> 10!
```

sqrt() : 제곱근
```
  math.sqrt(4) # -> 2
```

time 모듈

localtime() : 현재 로컬 시간을 반환

  import time

  time.localtime() # -> time.struct_time(tm_year, tm_mon, tm_mday,...)

  # year 만 출력
  lt = time.localtime()
  lt.tm_year
  # month 만 출력
  lt.tm_mon
  # day만 출력
  lt.tm_mday
  # hour 만 출력
  lt.tm_hour
  # min
  lt.tm_min
  # sec
  lt.tm_sec
  # 요일
  lt.tm_wday

random 모듈

random() : 0 ~ 1 사이의 아무 난수를 무작위 출력
```
 import random

 random.random()
```

randrange(start,stop,step) : 특정 범위에서 정수를 무작위 출력
```
  random.randrange(1,7) # 1 ~ 6의 범위에서 무작위 정수 출력
```

shuffle() : 특정 시퀀스 변수를 무작위 순서로 섞어준다

  abc = ['a', 'b', 'c', 'd', 'e']
  random.shuffle(abc)
  # ['a', 'd', 'e', 'b', 'c']

choice() : 아무 원소를 뽑아준다

  random.choice(abc)
  # 'a'

  random.choice('abcdefghijk')
  # 'c'

uniform() : 두 범위에서 임의의 실수 출력
```
  random.uniform(1,10)
  # 1.1800146073117523
```
randint() : 두 범위에서 임의의 정수 출력(마지막 범위에 있는 숫자도 포함한다) ↔ randrange()
```
  random.randint(1,10) # 1~10까지의 범위에서 임의의 정수 출력
  # 7
```

sample() : 랜덤하게 여러 개의 원소를 선택

  random.sample([1,2,3,4,5], 3) # 3개의 원소를 선택
  # [4,1,5]

모듈이 뭔지?

모듈은 그냥 '파일'라고 생각하면 된다. 파일에도 '현재 실행하고 있는 파일' 과 그렇지 않은 파일로 나뉠 수가 있다.

[모듈을 불러오는 방법]

기본 사용법
```
import 파일이름 as 파일별명
```
으로 불러올 수 있다.

특정 기능(함수)만 불러올 때
```
from 파일이름 import 함수이름
```
- 모든 기능(모든 함수)를 다 불러올 때
```
from 파일이름 import *
```

[실행 파일과 모듈 파일의 구분]

실행 파일과 다른 모듈 파일들을 파이썬은 어떻게 구분할까?

  __name__

이라는 전역변수로 구분할 수 있다. 파이썬은 알아서 파일을 만들 때 이 전역변수를 만들어준다. 즉, 메인 실행 파일에는

  __name__ = '__main__'

이라고 저장되고, 반대로 다른 모듈 파일에는 해당 모듈 파일의 이름이 저장된다.

  __name__ = '모듈파일이름'

패키지

패키지는 말 그대로 디렉토리다. 디렉토리 안에 관련 있는 모듈들(파일들)을 넣어두면 편하게 관리할 수 있다.

따라서, 모듈 이름(파일 이름)이 같다하더라도 디렉토리가 다르다면 독립적으로 관리할 수 있다.

다른 패키지(디렉토리)의 모듈을 가져와서 사용할 수 있을까?

원래는 불가하다. 하지만 site-packages 디렉토리에 있는 모듈들은 어떤 디렉토리에 있다 하더라도 사용할 수 있다.

❓site-packages 의 위치는❓ venv 디렉토리 밑에 있다.

즉, 어떤 패키지를 만든 뒤에, 다른 디렉토리에서 범용적으로 사용하고 싶다면 해당 패키지 오른쪽 클릭 -> Refactor -> Move Directory -> site-packages 로 파일을 옮겨주도록 하자.

객체지향 프로그래밍과 클래스 🔜

다음 파트에는 객체지향 프로그래밍이 뭐고, 클래스를 다루는 방법에 대해서 살펴보도록 하겠다. ☕️

[제로베이스_데이터 취업 스쿨 16기] 3일차(6/5)

Mon, 05 Jun 2023 07:46:44 GMT

파이썬 기초를 활용한 연습문제까지 공부한 내용을 정리했다.😎

[반복문_01]

🔻 나의 풀이

# 1부터 100까지 반복하는 과정에서
# 일의자리와 십의자리의 홀짝을 구분하는 함수를 만들어보자.

for i in range(101):
  if i < 10:
    if i % 2 != 0: 
      print('[{}]: 홀수!'.format(i))
    else:
      print('[{}]: 짝수!'.format(i))

  else:
    ten = i // 10 # 십의 자리 수
    one = i % 10 # 일의 자리 수
    if one == 0 and ten % 2 != 0:
      print('[{}] 십의자리: 홀수!!, \t 일의자리: 0'.format(i))
    elif one == 0 and ten % 2 == 0: 
      print('[{}] 십의자리: 짝수!!, \t 일의자리: 0'.format(i))
    elif one % 2 != 0 and ten % 2!= 0:
      print('[{}] 십의자리: 홀수!!, \t 일의자리: 홀수!!'.format(i))
    elif one % 2 != 0 and ten % 2 == 0:
      print('[{}] 십의자리: 짝수!!, \t 일의자리: 홀수!!'.format(i))
    elif one % 2 == 0 and ten % 2 != 0:
      print('[{}] 십의자리: 홀수!!, \t 일의자리: 짝수!!'.format(i))
    elif one % 2 == 0 and ten % 2 == 0:
      print('[{}] 십의자리: 짝수!!, \t 일의자리: 짝수!!'.format(i))

위의 풀이가 비효율적이고, 복잡하다는 것을 알게됐다. 강사님의 풀이와 비교해보자.

🔻 강사님 풀이

  for i in range(101):
  if i < 10:
    if i % 2 != 0: 
      print('[{}]: 홀수!'.format(i))
    else:
      print('[{}]: 짝수!'.format(i))

  else:
    ten = i // 10 # 십의 자리 수
    one = i % 10 # 일의 자리 수

    result10 = '' 
    if ten % 2 == 0:
      result10 = '짝수'
    else:
      result10 = '홀수'

    result1 = '0' # 일의 자리수는 0으로 초기화해놓고
    if one != 0: # 0이 아닐 경우에만 아래를 시행
      if one % 2 == 0:
        result1 = '짝수'
      else:
        result1 = '홀수'

    print('[{}] 십의자리: {}!!, \t 일의자리: {}'.format(i, result10, result1))

[반복문_02]

🔻 나의 풀이

  # 1부터 사용자가 입력한 정수까지의 합,홀수의 합,짝수의 합 그리고 팩토리얼을 출력하는 프로그램을 만들어보자.

num = int(input('정수 입력: '))

# 일반 합
sum = 0 
for i in range(1,num+1):
  sum += i

# 홀수 합
oddsum = 0
for i in range(1,num+1,2):
  oddsum += i

# 짝수 합
evensum = 0
for i in range(0,num+1,2):
  evensum += i

# 팩토리얼
fact = 1
for i in range(num,1,-1):
  fact *= i

print('합 결과: {}'.format(sum))
print('홀수 합 결과: {}'.format(oddsum))
print('짝수 합 결과: {}'.format(evensum))
print('팩토리얼 결과: {}'.format(format(fact,',')))

[반복문_03] 다양한 삼각형 모양 그리기 - for 구문

** 1. 별이 1 ~ 5개로 나타내는 일반적인 피라미드 모형**

    # 별이 1 ~ 5개까지 있는 피라미드 모양을 만들어보자.
    for i in range(1,6):
          print('*'*i)

🔻 강사님 풀이

    for i in range(1,6):
        for j in range(i):
            print('*', end='')
        print()

** 2. 1번의 모양에서 오른쪽으로 붙은 피라미드 모형**

    # 별이 1 ~ 5개까지 있는 피라미드 모양에서 오른쪽으로 붙은 모양
    for i in range(1,6):
          print(' '*(6-i) + '*'*i)

🔻 강사님 풀이

for i in range(1,6):
  for j in range(6-i-1):
    print(' ', end='')
  for k in range(i):
    print('*', end='')
  print()

** 3. 별이 5 ~1개로 줄어드는 피라미드 모형**

    # 별이 5 ~ 1개로 줄어드는 피라미드 모형
    for i in range(5,0,-1):
          print('*'*i)

🔻 강사님 풀이

  for i in range(5,0,-1):
    for j in range(i):
      print('*', end='')
    for k in range(5-i):
      print(' ', end='')
    print()

** 4. 3번에서 오른쪽으로 붙은 피라미드 모형**

    # 3번에서 오른쪽으로 붙은 모형
    for i in range(5,0,-1):
          print(' '*(5-i) + '*'*i)

🔻 강사님 풀이

  for i in range(5,0,-1):
    for k in range(5-i):
      print(' ', end='')
    for j in range(i):
      print('*', end='')
    print()

5. 증가하다가 감소하는 피라미드 모형

  # 1 ~ 5로 증가했다가 5 ~ 1로 줄어드는 모형 -> 전체 반복되는 줄은 9줄이다
  for i in range(1,10):
    if i < 5: # 5줄 이전까지는
      for j in range(i):
        print('*', end='')
    else:  
      for k in range(10-i):
        print('*', end='')
    print()

6. 각 줄에 해당하는 칸에만 '*'가 붙는 모형

  # 1 ~ 5까지 증가하는데, 줄 수에 해당하는 곳에서만 '*' 찍기
  for i in range(1,6): # i : 1 ~ 5
    for j in range(1,6): # j : 1 ~ 5
      if i == j:
        print('*', end='')
      else:
        print(' ', end='')
    print()

7. 6과 반대되는 모형

  # 위에서 반대
  for i in range(1,6): # 1 ~ 5까지 내려가면서
    for j in range(5,0,-1): # 5 ~ 1까지 내려오면서
      if i == j:
        print('*', end='')
      else:
        print(' ', end='')
    print()

8. 1 ~ 9까지 홀수만큼 증가하다가 다시 감소하는 모형

[반복문_04]

최소 공배수 문제

# 버스 a,b,c 가 있을 때
# 2대 이상의 버스가 정차하는 시간대를 구해보자.
# 버스 a,b : 오전 6시 첫차, 오후 23시 운행 종료
# 버스 a : 15분 간격, b : 13분 간격
# 버스 c : 6시 20분 첫차, 오후 22시 운행 종료, 8분 간격

busa = 15
busb = 13
busc = 8

# 운행하는 시간 -> 분으로 치환
totalMin = 60 * (23 - 6)

for i in range(totalMin+1): #분 간격으로 돌면서 중복되는 시간을 확인
  # a와 b만 운행하는 시간대 : 6시 ~ 6시 20분 사이, 22시 ~ 23시 사이
  if i < 20 or i > (totalMin - 60):
    if i % busa == 0 and i % busb == 0: # 동시에 정차하는 시간
      print('busA와 busB 동시 정차!', end='')
      hour = 6 + i // 60
      min = i % 60
      print('\t {}:{}'.format(hour,min))
  # a,b,c 모두 운행하는 시간대
  else:
    if i % busa == 0 and i % busb == 0: # 동시에 정차하는 시간
      print('busA와 busB 동시 정차!', end='')
      hour = 6 + i // 60
      min = i % 60
      print('\t {}:{}'.format(hour,min))

    elif i % busa == 0 and i % busc ==0:
      print('busA와 busC 동시 정차!', end='')
      hour = 6 + i // 60
      min = i % 60
      print('\t {}:{}'.format(hour,min))

    elif i % busb == 0 and i % busc ==0:
      print('busB와 busC 동시 정차!', end='')
      hour = 6 + i // 60
      min = i % 60
      print('\t {}:{}'.format(hour,min))

[반복문_05]

최소 공배수 문제

# 톱니의 개수가 n1, n2인 톱니바퀴가 맞물려 움직일 때,
# 회전을 시작한 후 처음 맞물린 톱니가 최초로 다시 만나게 될때까지의 톱니수와 각각의 바퀴회전수를 출력하자. (n2가 n1 보다 크다)

n1 = int(input('톱니 A 톱니수 입력: '))
n2 = int(input('톱니 B 톱니수 입력: '))

print('톱니 A의 수: {}, 톱니 B의 수: {}'.format(n1,n2))
# n1과 n2의 최소공배수 구하기
list = []
for i in range(1, n1*n2+1):
  if i % n1 == 0 and i % n2 == 0:
    list.append(i)

min_num = min(list) # 최소공배수
n1_circle = min_num // n1
n2_circle = min_num // n2

print('최초 만나는 톱니수(최소공배수): {}톱니'.format(min_num))
print('톱니 A 회전수: {}회전'.format(n1_circle))
print('톱니 B 회전수: {}회전'.format(n2_circle))

[반복문_06]

1번. 간단한 조건

# 윤년 계산기를 만들어보자
# 연도가 4로 나누어떨어지고, 100으로 나누어떨어지지 않으면 윤년이다.
# 또는 연도가 400으로 나누어떨어지면 윤년이다.

year = int(input('연도 입력: '))

result = ''
if (year % 4 == 0 and year% 100 != 0) or (year % 400 == 0):
  result = '윤년!!'
else:
  result = '평년'

print('{}년: {}'.format(year, result))

다음 학습 계획 🔜

파이썬 중급 학습 예정이다. 어려워져도 포기하지 말자🔥

[제로베이스_데이터 취업 스쿨 16기 ] 2일차(6/2 ~4)

Sun, 04 Jun 2023 15:58:22 GMT

📌 파이썬 기초

[6/2 ~ 4일차 정리]

제로베이스 파이썬_기초 ~ 연습문제 4까지 수강한 뒤 정리해본다. 현재까지, 반복문과 조건문의 기본적인 문법을 배웠고 관련 연습 문제들을 풀어봤다.

현재까지 다시 한번 기억해야 될 만한 문법과 팁을 정리해봤다.

딕셔너리 - 최대 value 값에 해당하는 key값 찾기

딕셔너리 기본 특징인 'value -> key 값 찾기' 를 활용해서

value 값으로 key를 찾을 수 있다.

# 다음은 제베_예제 문제 중 활용한 코드다
max_score = max(딕셔너리.values()) # value의 최댓값
reverseScore = {v:k for k,v in 딕셔너리.items()} # 원본 딕셔너리의 key 와 value 전환
max_sbj = reverseScore.get(max_score) # key로 변경된 max_score에 해당하는 원본 key 찾기

format - 수치값의 1000단위에 자동으로 ',' 넣어주기

큰 수치값을 표현할 때, 1000단위마다 ' , ' 를 넣는 방법이다
🔥 결과는 문자열임을 참고!!

# format(수치값, ',')
format(hou*60*60 + min*60 + sec, ',')

다음 학습 계획 🔜

본격적으로 1주차가 시작된다. 한달이라는 짧은 시간에 기본 문법 + 기초 수학 + 통계 + 자료구조 및 알고리즘 을 배우는 만큼, 미리미리 아는 부분들에서 진도를 빨리 빼보려고 한다. 다음주까지 중급 단계 마무리 + 다음 강의 미리 맛보기 까지 나아가보자 😎

[제로베이스_데이터 취업 스쿨 16기 ] OT 후기

Fri, 02 Jun 2023 13:19:39 GMT

'데이터 분석가' 취준 어느덧 6개월차..

4학년, 학교에서 머신러닝 수행 과제를 하면서 나름의 재미(?)와 학구열을 느꼈던 순간의 경험으로 어느덧 6개월이라는 취준 생활을 이어오고 있다. 4학년, 진로 고민에 한창인 나에게 데이터 분석가는 멋있고, 사내에서 인정받는 핑크빛 그림으로 그려졌다. 하지만, '데이터 분석가'가 어떤 일을 하는지는 산업에 따라, 기업의 크기에 따라 정말 천차만별이었고 대우 또한 마찬가지였다. '데이터 분석가'의 연관검색으로는 '데이터 분석가의 현실', '데이터 분석가 이런 분 하지 마세요' 등, 독학하려고 마음먹은 사람들('나')에게 쉽게 겁을 주기 일쑤였다.

그렇다고 안할 거냐고? 그럴 수는 없었다.. 해보고 싶고 좋아하는 다른 것들은 많았지만 '취미가 일이 되거나', '삶에 허덕일지도 모르는 일'들 이었기 때문이다.

결국 '다른 국비 캠프 맛보기-> 독학 -> 방황' 의 과정을 거치면서 데이터 분석가의 길이 나에게는 맞는것인지에 대한 회의까지 오게 됐다.

그러던 중, '제로베이스 캠프' 를 보게 되었고! 방황의 끝이었음 하는 마음에 내가 할 수 있는 역량을 최대한 발휘해보려고 한다.

*이 velog 의 마지막에 '데이터 분석_취준 성공' 후기가 될 수 있길 바라며.. *

제로베이스_OT 후기

OT에는 아쉽게도 불참했다! 함께 수강할 동기분들과 이끌어주시는 멘토님들, 현업 강사님들을 비대면이지만 처음 만날 수 있는 자리여서 더욱 아쉬운 마음이 컸다. 아쉬운 마음은 다음 스터디 활동 때의 나에게 맞기기로 한다 🙃

앞으로의 다짐은?

녹화본 OT 영상에 나오시는 멘토님의 말이 떠올랐다. '죽었다 생각하고 공부 하시면 됩니다.'