[비트캠프 - 클라우드 기반 AlaaS 개발자 과정] 22.11.08.(DAY-17) TIL

1. 이론

1) 코드 내 이론

출력된 음악차트 csv파일로 저장하기

# dict 로 변환
diction = {}
for i, j in enumerate(titles): # 제목(titles)과 가수(artists)가 리스트형태로 출력
    diction[j] = artists[i]

# datafram으로 변환
df = pd.DataFrame.from_dict(diction, orient='index') # orient를 index로 설정해야만 변환 가능

# csv파일로 저장
df.to_csv(path, sep=',', na_rep="NaN", header=None)

데이터프레임 만들기 & 다루기

dc = {} # 딕셔너리 초기값

ls_schema = ['제품', '가격', '판매량'] # 리스트들을 딕셔너리화 하기
l1 = ["사과", "딸기", "수박"]
l2 = [1800, 1500, 3000]
l3 = [24, 38, 13]
ls_apd = [l1, l2, l3]
dc = {j : ls_apd[i] for i,j in enumerate(ls_schema)}

df = pd.DataFrame(dc) # 딕셔너리를 데이터프레임으로 변환

print(df.mean()) # 평균값 출력

2) 데이터베이스 용어

3) 그 외 용어

• 오버로딩 = 추가하기
• 오버라이딩 = 덮어쓰기
• assignment(할당) → = ⇒ 메모리를 차지함(주소 o)
• declaration(선언) → : ⇒ 메모리 차지 x(주소 x)

4) 놓친 거

** 마이크로서비스 ↔ 모놀리식

dif) 모듈화 쿠팡이 미국상장한 이유 = 마이크로서비스해서??

시퀀스 + 해쉬(맵) = 데이터프레임(엑셀시트)

여러가지 데이터프레임으로 작업 → 프레임워크

** 클래스 선언 = Declaration, 함수선언 = Definition

함수선언에는 매개변수 존재

(관계형) 데이터베이스 수정과정 ⇒ df ↔ dic ↔ list = 코드에서 파일변환 과정

 

2. 코드

<scrapper 패키지>

init

from scrapper.domains import Scrap
from scrapper.view import ScrapController

if __name__ == '__main__':
    api = ScrapController()
    scrap = Scrap()
    while True:
        menus = ["종료", "벅스뮤직", "멜론뮤직"]
        menu = input("메뉴 선택: ")

        if menu == "0":
            api.menu_0()
            break
        elif menu == "1":
            scrap.domain = "<https://music.bugs.co.kr/chart/track/day/total>"
            scrap.query_string = "?chartdate=20221106"
            scrap.parser = "lxml"
            scrap.class_names = ["title", "artist"]
            scrap.tag_name = 'p'
            api.menu_1(scrap)
        elif menu == "2":
            scrap.domain = "<https://www.melon.com/chart/index.htm>"
            scrap.query_string = "?dayTime=2022110802"
            scrap.parser = "lxml"
            scrap.class_names = ["rank01", "rank02"]
            scrap.tag_name = 'div'
            api.menu_1(scrap)
        else:
            print(" ### 해당 메뉴 없음 ### ")

domain

from dataclasses import dataclass

import urllib.request
from urllib.request import urlopen

import pandas as pd
from bs4 import BeautifulSoup

from const.path import CTX

"""
지원하는 Parser 종류
"html.parser" : 빠르지만 유연하지 않기 때문에 단순한 HTML문서에 사용합니다.
"lxml" : 매우 빠르고 유연합니다.
"xml" : XML 파일에만 사용합니다.
"html5lib" : 복잡한 구조의 HTML에 대해서 사용합니다.
"""

@dataclass
class Scrap:
    html = ""
    parser = ""
    domain = ""
    query_string = ""
    headers = ""
    tag_name = ""
    fname = ""
    class_names = []
    artists = []
    titles = []
    diction = {}
    df = None
    soup : BeautifulSoup

    @property
    def html(self): return self._html
    @html.setter
    def html(self, html): self._html = html

    @property
    def parser(self): return self._parser

    @parser.setter
    def parser(self, parser): self._parser = parser

    @property
    def soup(self): return self._soup
    @soup.setter
    def soup(self, soup): self._soup = soup

    @property
    def domain(self): return self._domain
    @domain.setter
    def domain(self, domain): self._domain = domain

    @property
    def query_string(self): return self._query_string
    @query_string.setter
    def query_string(self, query_string): self._query_string = query_string

    @property
    def headers(self): return self._headers
    @headers.setter
    def headers(self, headers): self._headers = headers

    @property
    def tag_name(self): return self._tag_name
    @tag_name.setter
    def tag_name(self, tag_name): self._tag_name = tag_name

    @property
    def fname(self): return self._fname
    @fname.setter
    def fname(self, fname): self._fname = fname

    @property
    def class_names(self): return self._class_names
    @class_names.setter
    def class_names(self, class_names): self._class_names = class_names

    @property
    def artists(self): return self._artists
    @artists.setter
    def artists(self, artists): self._artists = artists

    @property
    def titles(self): return self._titles
    @titles.setter
    def titles(self, titles): self._titles = titles

    @property
    def diction(self): return self._diction
    @diction.setter
    def diction(self, diction): self._diction = diction

    @property
    def df(self): return self._df
    @df.setter
    def df(self, df): self._df = df

    def dict_to_dataframe(self):
        print(len(self.diction))
        self.df = pd.DataFrame.from_dict(self.diction, orient='index')

    def dataframe_to_csv(self):
        path = './save/result.csv'
        self.df.to_csv(path, sep=',', na_rep="NaN", header=None)

view

# from scrapper.domains import MelonMusic
from scrapper.services import BugsMusic, MelonMusic

class ScrapController(object):

    @staticmethod
    def menu_0():
        print("끗")

    @staticmethod
    def menu_1(arg):
        print("벅스")
        BugsMusic(arg)

    @staticmethod
    def menu_2(arg):
        print("멜론")
        MelonMusic(arg)

service

import urllib.request
from urllib.request import urlopen


from bs4 import BeautifulSoup


def BugsMusic(arg): # 함수형이 아닌 객체지향형으로 만든 건 db에 저장하겠다는 뜻
    soup = BeautifulSoup(urlopen(arg.domain + arg.query_string), "lxml")
    title = {"class" : arg.class_names[0]}
    titles = soup.find_all(name=arg.tag_name, attrs=title)
    titles = [i.find('a').text for i in titles]
    artist = {"class": arg.class_names[1]}
    artists = soup.find_all(name=arg.tag_name, attrs=artist)
    artists = [i.find('a').text for i in artists]

    # 디버깅
    [print(f"{i+1}위 {titles[i]} : {j}") for i, j in zip(range(len(titles)), artists)]

    # dict 로 변환
    diction = {}
    for i, j in enumerate(titles):
        diction[j] = artists[i]
    arg.diction = diction

    # csv파일로 저장
    arg.dict_to_dataframe()
    arg.dataframe_to_csv()

def MelonMusic(arg):
    soup = BeautifulSoup(urlopen(urllib.request.Request(arg.domain + arg.query_string, headers={'User-Agent' : "Mozilla/5.0"})), "lxml")
    title = {"class": arg.class_names[0]}
    titles = soup.find_all(name=arg.tag_name, attrs=title)
    titles = [i.find('a').text for i in titles]
    artist = {"class": arg.class_names[1]}
    artists = soup.find_all(name=arg.tag_name, attrs=artist)
    artists = [i.find('a').text for i in artists]

    # 디버깅
    [print(f"{i+1}위 {titles[i]} : {j}") for i, j in zip(range(len(titles)), artists)]

    # dict 로 변환
    diction = {}
    for i, j in enumerate(titles):
        diction[j] = artists[i]
    arg.diction = diction

    # csv파일로 저장
    arg.dict_to_dataframe()
    arg.dataframe_to_csv()

<store 패키지>

fruits

import pandas as pd

def new_fruites_df():
    dc = {}
    ls_schema = ['제품', '가격', '판매량']
    l1 = ["사과", "딸기", "수박"]
    l2 = [1800, 1500, 3000]
    l3 = [24, 38, 13]
    ls_apd = [l1, l2, l3]

    dc = {j : ls_apd[i] for i,j in enumerate(ls_schema)}

    df = pd.DataFrame(dc)

    return df

if __name__ == '__main__':
    df = new_fruites_df()
    print(f"{df}\\n")
    print(f"가격 평균: {sum(df['가격'])/len(df['가격'])}원")
    print(f"판매량 평균: {int(df['판매량'].mean())}개")

3. 하루마무리

어제 밤에 ㅎㅇ님한테 정리가 재미있다는 망언을 했다.

 

용어랑 이론 다 불태우고싶음

 

그리고 필기용 갤탭이 너무나도 절실해..