관계형 데이터베이스란? Realational Database 서로 간에 관계가 있는 데이터 테이블들을 모아둔 데이터 저장공간

SQL이란? Structured Query Language 데이터베이스에서 데이터를 정의, 조작 제어하기 위해 사용하는 언어

데이터 정의 언어 (DDL : Data Definition Language) → CREATE, ALTER, DROP 등의 명령어

데이터 조작 언어 (DML : Data Manipulation Language) ★ → INSERT, UPDATE, DELETE, SELECT 등의 명령어

데이터 제어 언어 (DCL: Data Control Language) → GRANT, REVOKE, COMMIT, ROLLBACK 등의 명렁어

MYSQL 접속

터미널 실행 mysql

현재 데이터 목록 확인

데이터베이스 생성 create database dbname; create하고 show 하면 만든거 확인 가능

데이터 베이스들 보여줘 show database;

해당 데이터 베이스로 이동(사용) use dbname;

삭제 명령어 drop database dbname;

User 관리

use mysql;

유저 조회 SELECT host, user FROM user;

현재 PC에서만 접속 가능한 사용자를 비밀번호와 함께 생성 CREATE USER 'username'@'localhost' identified BY 'password';

ex) 현재 PC에서 접속가능한 사용자 (noma,1234)생성 create user 'noma'@'localhost' identified by '1234';

ex) 외부에서 접속 가능한 사용자 (noma,5678)생성 create user 'noma'@'%' indentified by '5678';

유저 삭제 DROP USER 'username'@'localhost' DROP USER 'username'@'%'

user 권한 관리

권한 관리 실습을 위해 database 생성 CREATE DATABASE testdb;

SHOW DATABASES;

유저만들기 use mysql; 이동 후★ CREATE USER 'noma'@'localhost' IDENTIFIED BY '1234';

사용자에게 특정 데이터베이스의 모든 권한을 부여 GRANTS ALL ON dbname.* to 'username'@'localhost';

현재 pc에서 접근 가능한 noma에게 testdb의 모든 권한을 부여 grants all on testdb.* to 'noma'@'localhost';

그 다음 사용자에게 부여된 모든 권한 목록을 확인

SHOW GRANTS FOR 'username'@'localhost';

ex) 노마 권한 확인 show grants for 'noma'@'localhost';

💡 내용이 적용 안될때 FLUSH PRIVILEGES;

사용자에게 특정 데이터베이스의 모든 권한을 삭제

REVOKE ALL ON dbname.* FROM 'username'@'localhost';

table 사용

데이터베이스 먼저 생성 create database zerobase DEFAULT CHARACTER SET uft8mb4; 이 데이터베이스에서 기본으로 사용할 설정은 utf8mb4 다국어, 이모지 사용할 것이다.

show databases;

테이블 생성

CREATE TABLE tablename ( columname datatype, columname datatype, ... );

테이블 생성 예제 id(int)와 name(varchar(16)) 칼럼을 가지는 mytable이라는 이름의 테이블 생성 create table mytable ( id int, name varchar(16) );

테이블 목록보기 show tables;

테이블 구조까지 확인하기 DESC tablename;

colunm 설정

테이블 이름 변경 ALTER TABLE tablename RENAME new_tablename

컬럼추가 ALTER TABLE tablename ADD COLUMN columnname datatype;

ex) person 테이블에 agee(double)컬럼 추가 alter table person add column agee double;

desc tablename; 으로 컬럼추가 확인

컬럼 데이터타입 변경 AlTER TABLE tablename MODIFY COLUMN columnname datatype;

컬럼명 바꾸기 (데이터 타입도 같이 변경가능함) ALTER TABLE tablename CHANGE COLUMN old_columnname new_columnname new_datatype;

컬럼삭제 ALTER table tablename** DROP COLUMN** columname;

테이블 삭제 DROP TABLE tablename;

실습환경 만들기

create database zerobase;

use zerobase;

create table person( id int, name varchar(16), age int, sex char );

desc person;

Insert 데이터 추가

INSERT INTO tablename(column1, column2, ...) VALUES (values1, values2, ... );

입력한 컬럼이름의 순서와 값의 순서가 일치하도록 주의!

셀 입력 후 입력값 확인 select * from tablename;

모든 컬럼값을 추가하는 경우에는 다음과 같이 컬럼 이름을 지정하지 않아도 되지만, 입력하는 값의 순서가 테이블의 컬럼 순서와 일치하도록 주의★★

INSERT INTO tablename VALUES(value1, value2, ...)

select 데이터 조회

SELECT column1, column2, ... FROM tablename;

ex) select name,age from person;

SELECT * FROM tablename;

전부 다 조회~!

WHERE 특정 조건에 것만 가져온다 SELECT column1, column2, ... FROM tablename WHERE condition;

예시 person 테이블에서 성별이 여자인 데이터 조회 select * from person where sex='F'

UPDATA tablename

내용 업데이트, 수정

UPDATA tablename SET colum1 = value1, column2 = value2, ... WHERE codition; 한 번에 컬럼1=내용1, 컬럼2=내용2 이런식으로 바꾼다 조건에 맞는!

예시) update person set age=23 where name='이효리'

DELETE

데이터 삭제 DELETE FROM tablename WHERE codition;

1. 인구 소멸 위기 지역 파악
   2. 인구 소멸 위기 지역의 지도 표현
   3. 지도 표현에 대한 카르토그램 표현

데이터 읽고 인구 소멸 지역 계산하기

선언

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import platform
from matplotlib import font_manager, rc
import warnings

warnings.filterwarnings(action="ignore")

%matplotlib inline

path = "C://Windows/Fonts/malgun.ttf"

if platform.system() == "Darwin":
    rc("font",family="Arial Unicode MS")

elif platform.system() == "Windows":
    font_name = font_manager.FontProperties(fname=path).get_name()
    rc("font",family=font_name)

else:
    print("Unknown system. sorry")

fillna(method="")

빈 값 채워주는 함수

컬럼 이름 변경

population.rename(
    columns={
      "행정구역(동읍면)별(1)" : "광역시도",
      "행정구역(동읍면)별(2)" : "시도",
      "계" : "인구수"
    }, inplace=True
)
population.tail()

변경 전

변경 후

** 필요없는 소계 데이터 삭제 **

population = population[population["시도"] != "소계"]
population

항목 컬럼명 변경

population.is_copy = False
population.rename(
    columns={"항목":"구분"},
    inplace=True
)

** 데이터 내용 변경 **

population.loc[population["구분"] == "총인구수 (명)", "구분"]  = "합계"
population.loc[population["구분"] == "남자인구수 (명)", "구분"]  = "남자"
population.loc[population["구분"] == "여자인구수 (명)", "구분"]  = "여자"
population

변경 전

변경 후

* 소멸지역을 조사하기 위한 데이터 *

population["20~39세"] = (
    population["20 - 24세"] + population["25 - 29세"] + population["30 - 34세"] + population["35 - 39세"]
)
population["65세이상"] = (

    population["65 - 69세"] +population["70 - 74세"] + population["75 - 79세"] +population["80 - 84세"] + population["85 - 89세"] + population["90 - 94세"] +population["95 - 99세"]+population["100+"]
)
population

인구분석을 위한 중요한 데이터인 20-39세와 65세이상 데이터를 합산해줌.

데이터 맨 뒤에 합쳐져있다.

피봇테이블

pop = pd.pivot_table(
    data = population,
    index = ["광역시도","시도"],
    columns=["구분"],
    values=["인구수","20~39세","65세이상"]
)
pop

![](https://velog.velcdn.com/images/auden_9/post/69174859-98fd-4045-bbda-8981605df7cf/image.png)

### 필요한 데이터 추가

** 소멸 비율 계산 **

pop["소멸비율"] = pop["20~39세","여자"]/ (pop["65세이상","합계"]/2)

** 소멸위기 지역 컬럼 생성 **

pop["소멸위기지역"] = pop["소멸비율"] < 1.0 pop

![](https://velog.velcdn.com/images/auden_9/post/b9eb3800-d204-4ddd-8558-cdc6a3cec01b/image.png)

소멸 위기 지역 조회

pop[pop["소멸위기지역"] == True].index.get_level_values(1)

>** 인덱스 재정렬 **

pop.reset_index(inplace=True) pop.head()

>### 2줄짜리 인덱스 한줄로 만들기
```python
tmp_columns = [
    pop.columns.get_level_values(0)[n] + pop.columns.get_level_values(1)[n]
    for n in range(0, len(pop.columns.get_level_values(0)))
]
pop.columns = tmp_columns

적용 전

적용 후

지도 시각화를 위한 지역별 ID 만들기

pop.info() pop['시도'].unique

ID 값으로 쓸만한 데이터 확인.

행정시와 구로 나누기 위해 데이터 만듦

1)

si_name = [None] * len(pop) # 264 길이
si_name 

pop길이 만큼의 None값의 변수 만들어줌

2)

tmp_gu_dict = {
    "수원": ["장안구", "권선구", "팔달구", "영통구"],
    "성남": ["수정구", "중원구", "분당구"],
    "안양": ["만안구", "동안구"],
    "안산": ["상록구", "단원구"],
    "고양": ["덕양구", "일산동구", "일산서구"],
    "용인": ["처인구", "기흥구", "수지구"],
    "청주": ["상당구", "서원구", "흥덕구", "청원구"],
    "천안": ["동남구", "서북구"],
    "전주": ["완산구", "덕진구"],
    "포항": ["남구", "북구"],
    "창원": ["의창구", "성산구", "진해구", "마산합포구", "마산회원구"],
    "부천": ["오정구", "원미구", "소사구"],
}

추가데이터는 수작업

3)

• 만들고자 하는 ID의 형태
  • 서울 중구
  • 서울 서초
  • 통영
  • 남양주
  • 포항 북구
  • 인천 남동
  • 안양 만안
  • 안양 동안
  • 안산 단원 ...

    (1) 일반 시 이름과 세종시, 광역시도 일반 구 정리

    만들기 전 test
    > > > ** 행정구 1차 나누기 작업 ** ``` for idx, row in pop.iterrows(): if row["광역시도"][-3:] not in ["광역시","특별시","자치시"]: si_name[idx] = row["시도"][:-1] > elif row["광역시도"] == "세종특별자치시": si_name[idx] = "세종" > else: if len(row["시도"]) == 2: si_name[idx] = row["광역시도"][:2] + " "+ row["시도"] else: si_name[idx] = row["광역시도"][:2] + " " + row["시도"][:-1] ``` > ** 행정구 데이터 추가2 (수작업) ** ``` for idx, row in pop.iterrows(): if row["광역시도"][-3:] not in ["광역시","특별시","자치시"]: for keys, values in tmp_gu_dict.items(): if row["시도"] in values: if len(row["시도"]) == 2: si_name[idx] = keys + " " + row["시도"] elif row["시도"] in ["마산합포구" , "마산회원구"]: si_name[idx] = keys+" "+ row["시도"][2:-1] > else: si_name[idx] = keys + " " + row["시도"][:-1] >``` > > ** 행정구 데이터 추가3 (고성) ** > ``` for idx, row in pop.iterrows(): if row["광역시도"][-3:] not in ["광역시","특별시","자치시"]: if row["시도"][:-1] == "고성" and row["광역시도"] == "강원도": si_name[idx] = "고성(강원)" elif row["시도"][:-1] == "고성" and row["광역시도"] == "경상남도": si_name[idx] = "고성(경남)" ``` 본 데이터의 추가 ``` pop["ID"] = si_name pop ```  >
• • 필요없는 데이터 열 제거 **

    del pop["20~39세남자"]
    del pop["65세이상남자"]
    del pop["65세이상여자"]
    pop.head()

    

4. 지도 그리기 (카르토그램)

민형기 담임교수님이 한땀 한땀 만든 엑셀파일 불러오기

draw_korea_raw = pd.read_excel("../../data/07.population/07_draw_korea_raw.xlsx")
draw_korea_raw

** .stack()** 위에 컬럼을 인덱스로 보내주기

draw_korea_raw_stacked = pd.DataFrame(draw_korea_raw.stack())
draw_korea_raw_stacked

.stack() 적용 전

.stack() 적용 후

draw_korea_raw_stacked.reset_index(inplace=True)
draw_korea_raw_stacked

리셋 인덱스로 다시 열을 재정렬해줌

draw_korea_raw_stacked.rename(
    columns={
    "level_0" : "y",
    "level_1" : "x",
    0 : "ID"

    },
    inplace=True

)
draw_korea_raw_stacked

컬럼명 이름 바꾸기

draw_korea = draw_korea_raw_stacked

지도 윤곽선 그리기

def plot_text_simple(draw_korea):
    for idx, row in draw_korea.iterrows():

         if len(row["ID"].split()) == 2:
            dispname= "{}\n{}".format(row["ID"].split()[0], row["ID"].split()[1])
         elif row["ID"][:2] == "고성":
            dispname = "고성"
         else:
            dispname = row["ID"]


         if len(dispname.splitlines()[-1]) >= 3:
            fontsize,linespacing = 7.5,0.9
         else:
            fontsize, linespacing = 8, 0.7

         plt.annotate(
            dispname, 
            (row["x"]+0.5, row["y"]+0.5),
            weight = "bold",
            fontsize = fontsize,
            linespacing = linespacing,
            ha="center", # 수평정렬
            va="center", # 수직정렬
         )

def simpleDraw(draw_korea):
    plt.figure(figsize=(8,11))

    plot_text_simple(draw_korea)
    for path in BORDER_LINES:
        ys, xs = zip(*path)
        plt.plot(xs,ys, c="black", lw=1.5)
    plt.gca().invert_yaxis()  # 지도방향 바꾸기 (상하)
    plt.axis("off")
    plt.tight_layout()
    plt.show()

이 두 함수로 윤곽선과 글자 배치조정

그림을 그리기 위한 데이터를 계산하는 함수

• 색상을 만들 때 최소값을 흰색
• blockedMap : 인구현황
• targetData : 그리고 싶은 컬럼

def get_data_info (targetData, blockedMap):
    whitelabelmin = (
        max(blockedMap[targetData]) - min(blockedMap[targetData])
    ) * 0.25 + min(blockedMap[targetData])
    vmin = min(blockedMap[targetData])
    vmax = max(blockedMap[targetData])
>
    mapdata = blockedMap.pivot(index="y",columns="x",values=targetData)
    return mapdata, vmax, vmin, whitelabelmin

>

def get_data_info_for_zero_center(targetData,blockedMap): whitelabelmin = 5 tmp_max = max( np.abs(min(blockedMap[targetData])),np.abs(max(blockedMap[targetData])) ) vmin,vmax = -tmp_max, tmp_max mapdata = blockedMap.pivot(index="y",columns="x",values=targetData) return mapdata, vmax, vmin, whitelabelmin

def plot_text_simple(targetData, blockedMap, Whitelablemin):
>    for idx, row in blockedMap.iterrows():
>        
         if len(row["ID"].split()) == 2:
            dispname= "{}\n{}".format(row["ID"].split()[0], row["ID"].split()[1])
         elif row["ID"][:2] == "고성":
            dispname = "고성"
         else:
            dispname = row["ID"]
>           
>      
         if len(dispname.splitlines()[-1]) >= 3:
            fontsize,linespacing = 7.5,0.9
         else:
            fontsize, linespacing = 8, 0.7
>         
         annocolor = "white" if np.abs(row[targetData]) > Whitelablemin else "black"
         plt.annotate(
            dispname, 
            (row["x"]+0.5, row["y"]+0.5),
            weight = "bold",
            color = annocolor,
            fontsize = fontsize,
            linespacing = linespacing,
            ha="center", # 수평정렬
            va="center", # 수직정렬
         )

>
>

def drawKorea(targetData, blockedMap, cmapname, zeroCenter=False): if zeroCenter: masked_mapdata,vmax,vmin,whitelabelmin = get_data_info_for_zero_center(targetData,blockedMap)

if not zeroCenter:
    masked_mapdata, vmax,vmin,whitelabelmin = get_data_info(targetData,blockedMap)

plt.figure(figsize=(8,11))
plt.pcolor(masked_mapdata, vmin=vmin, vmax=vmax, cmap = cmapname, edgecolor="#aaaaaa", linewidth=0.5)
plot_text_simple(targetData,blockedMap,whitelabelmin)

for path in BORDER_LINES:
    ys, xs = zip(*path)
    plt.plot(xs,ys, c="black", lw=1.5)
plt.gca().invert_yaxis()  # 지도방향 바꾸기 (상하)
plt.axis("off")
plt.tight_layout()
cb = plt.colorbar(shrink= 0.1 , aspect=10)
cb.set_label(targetData)
plt.show()

• 접근할 웹주소를 알 수 없을때
• 자바스크립트를 사용하는 웹 페이지 경우
• 웹브라우저로 접근하지 않으면 안될 때

Selenium

웹브라우저를 원격 조작하는 도구 자동으로 URL을 열고 클릭 등이 가능 스크롤, 문자의 입력, 화면 캡처 등등

설치하기

conda install selenium

크롬 버전을 확인해야함

크롬드라이버 검색 후 최상단 페이지에서 버전 맨 앞자리 3개 같은 걸 눌러 다운로드 받고 작업환경에 크롬드라이버 옮긴다. (ds_study/driver폴더)

from selenium import webdriver

driver = webdriver.Chrome("크롬드라이버 저장경로") driver.get("링크주소")

링크주소는 꼭 http:// 넣어주기 새창이 뜨면 성공

💡 작업이 끝나면 꼭 driver.quit() 으로 창을 닫아줘야한다.

✍

• 화면 최대 크기 설정 driver.maximize_window()

• 화면 최소 크기 설정 driver.minimize_window()

• 화면 크기 설정 driver.set_window_size(600,600)
  💡 데이터 가져올 때 화면에 보이는 기준으로 가져오기때문에 화면이 최대한 큰 게 좋을 수 있다. (정보가 많이 보이기 때문에)

• 새로고침 driver.refresh()

• 뒤로가기 driver.back()

• 앞으로가기 driver.forward()

• 새 탭 생성하기 driver.execute_script('window.open("http://naver.com")')
• execute_script('') 자바스크립트를 쓰겠단 이야기. window.open("열고 싶은 주소")*

• 탭 이동 driver.switch_to.window(driver.window_handles[0]) 화면창은 0번부터

• 현재 탭 닫기 driver.close()
  💡 방금 막 닫으면, 탭 지정을 새로 해줘야함. 한번 닫으면 탭 이동 되기 전까지 더 안닫음.

• 전체창 닫기 driver.quit()

• 스크롤 가능한 높이(길이) driver.execute_script('return document.body.scrollHeight') 자바스크립트 이용

• 화면 스크롤 하단 이동 driver.execute_script('window.scrollTo(0,document.body.scrollHeight);') 스크롤을 최하단까지 내려달라.

• 화면 스크롤 상단이동 driver.execute_script('window.scrollTo(0,0)')

• window.scrollTo(x축,y축) 좌표값으로 이동

• 현재 보이는 화면 스크린샷 저장
• driver.save_screenshot('./last_height.png')

• 💡** ActionChains 클래스** 마우스로 할 수 있는 대부분에 동작들 mouse hover, drag and drop, scoll 등을 해줌

  from selenium.webdriver import ActionChains
  >
  some_tag = driver.find_element(By.CSS_SELECTOR, 'copy selector')
  action = ActionChains(driver)
  action.move_to_element(some_tag).perform()

  ActionChains 모듈을 호출하고 이동할 요소를 잡아 변수에 담고 ActionChains(driver) 현재 내 드라이버를 지정해 ActionChains에 담고
  .move_to_element() 내가 지정한 곳으로 이동하겠다.
  .perform() 실행
  <<< ActionChains 예제 >>>
  동작페이지의 버튼 누를 때! ActionChains를 이용
  from selenium.webdriver import ActionChains
  search_tag = driver.find_element(By.CSS_SELECTOR,'.search') action = ActionChains(driver) action.click(search_tag)
• action.perform()*

요소찾기

from selenium.webdriver.common.by import By

first_content = driver.find_element(By.CSS_SELECTOR, '요소') first_content.click()

💡 찾는 요소는 개발자도구를 통해 태그 찾고, 오른쪽 마우스로 copy - copy selector

keyword = driver.find_element(By.CSS_SELECTOR,'copy selector') keyword.send_keys('검색어') 검색하고, 검색어 입력

keyword.clear() 입력값 지우기

[주가분석 ] _ 추가내용

열었는데 팝업창 떴을때

팝업창 화면 전환 후 닫아주기 driver.switch_to_window(driver.window.handles[-1]) driver.close()

** time.sleep() ** 원하는 주소 목표페이지로 바로 안가고 메인으로 갈때 import time 파일열고 time.sleep()으로 인터벌을 주고 열기실행하면 목표페이지로 간다.

import time

url = "https://www.opinet.co.kr/searRgSelect.do" driver = webdriver.Chrome("../driver/chromedriver.exe") driver.get(url)

time.sleep(3)

driver.get(url)

sido_list[1].get_attribute("value")

get_attiribute('') 속성값 가져오기

** glob("가져올 파일") ** 파일목록 한번에 가져오기 from glob import glob

glob("../data/04.self_oil/지역_*.xls")

지역_ 로 끝나는 전부 *를 붙여주면 모두

pd.concat(합칠데이터) 형식이 동일하고 연달아 붙이기만 하면 될 때 에는 concat으로 데이터 병합가능.

가격정보가 - 이 되어있어 타입변환

stations = stations[stations["가격"]!="-"] -로 되지 않은 데이터만 담아서 stations["가격"] = stations["가격"].astype("float") 변환!

matplotlib 한글설정

import platform
from matplotlib import font_manager, rc
>
%maplotlib inline
>
path = "C://Windows/Fonts/malgun.ttf"
>
if platform.system() == "Darwin":
    rc("font",family="Arial Unicode MS")
>
elif platform.system() == "windows":
    font_name = font_manager.FontProperties(fname=path).get_name()
    rc("font",family=font_name)
>
else:
    print("Unknown system. sorry")

선언 import from bs4 import BeautifulSoup

page = open("../../data/03.web_data/03.testfile.html","r").read() page

html 문서 열기

read()로 읽어오면 문자를 막 뿌려줌.

html 방식 그대로 보려면

1) print()

2) soup = BeautifulSoup(page, "html.parser") print(soup.prettify())

오픈 파일 상태 확인

변수로 많이 쓰는 page, response,res

response = urlopen(url) response.status

파일 오픈 시 문제가 생기면 response.status를 통해 HTML 상태코드 검색하면 위키백과에 어떤 오류인지 확인 가능함.

request 모듈 이용시 !pip install requests

import requests from urllib.requests.Request from bs4 import BeautifulSoup

url = "주소" response = requests.get(url,headers=headers) soup = BeautifulSoup(response.text,"html.parser") response

🚫파일소환 시 403에러 대책

접속 방법 1) req = Request(url, headers={"User-Agent":"Chrome"}) response = urlopen(req) response.status

2)

pip install fake-useragent 설치 후

from fake_useragent import UserAgent

ua = UserAgent() ua.ie req = Request(url, headers={"User-Agent":ua.ie}) response= urlopen(req) response.status 로 우회접속도 가능

주소지가 영어일때 인코딩 하는 법

import urllib from urllib.request import urlopen, Request

html = "https://ko.wikipedia.org/wiki/{search_words}"

req = Request(html.format(search_words=urllib.parse.quote("여명의_눈동자"))) response=urlopen(req) response.status

urllib.parse.quote() 글자를 url로 인코딩하는 매서드

상대주소 절대주소로 만들기 from urllib.parse import urljoin

urljoin(url_base,상대주소)

기본주소+상대주소로 반환해줌 기본주소가 있을 시 무시하고 정상 구동시켜줌

데이터 읽어오기

.코드명

e.g> soup.head 가장 상위에 있는 head 코드가 나온다

.find("코드")

위에랑 실행결과가 같음

.find_all("코드")

안에 있는 모든 해당 코드를 가져온다

조건 좁히기 .find("태그", class_="클래스명") .find("태그","클래스명") .find("태그",{"class":"클래스명"})

id 찾기 .find("태그",id="아이디") .find("태그", {"id":"아이디"})

텍스트만 가져오고 싶을때. 좁혀 놓은 구간에서 .text.strip() 붙인다.

.text 텍스트 추출 .strip() 불필요한 문자 제거

e.g> soup.find("p",{"id":"second"}).text.strip()

• 다중조건 .find("p",{"class":"inner-text first-item","id":"first"})

a 태그에서 href 속성값에 있는 값 추출

1> links[0].get("href") 2> links[1]["href"]

💡 조건에 맞춰 여러개를 읽어온 후에는 꼭!! len()으로 감싸 정상적으로 다 읽어왔는지 확인한다!

*💡 웹 크롤링시 이상 작동이라고 판단되어 차단 될 수 있으니 time.sleep(0.5) 넣어주기 *

import time
from tqdm import tqdm

movie_data = []
movie_name = []
movie_point = []

for today in tqdm(date):
    url = "주소.date={date}"
    response = urlopen(url.format(date=today.strftime("%Y%m%d")))
    soup = BeautifulSoup(response,"html.parser")

    end = len(soup.find_all("td","point"))
    movie_data.extend([today for _ in range(0,end)])
    movie_name.extend(soup.select("div.tit5")[n].a.text for n in range(0,end))
    movie_point.extend(soup.find_all("td","point")[n].string for n in range(0, end))

    time.sleep(0.5)

li 태그가 클래스없이 막 섞여 있을 때 위치를 찾기 위해 for문으로 순번 찾기

n = 0 for each in soup.find_all("ul"): print("=>"+str(n)+"=================") print(each.text) n += 1

가게이름 출력 후 다른 문자열이 섞여 있을 시 ** import re 모듈을 열어 re.split("나눌문자기준",문자열)**

e.g> import re tmp_string = tmp_one.find(class_="sammyListing").get_text() re.split(("\n|\r\n"),tmp_string)

출력 ['BLT', 'Old Oak Tap', 'Read more ']

날짜 가져오기 date = pd.date_range("2021.01.01", periods=100, freq="D") 21년 1월 1일 기준으로 100일치를 가져옴

날짜 표현 형식 지정 .strftime("%Y-%m-%d")

'2021-01-01'

matplotlib의 한글설정

from matplotlib import font_manager, rc
>
path = "C:/Windows/Fonts/malgun.ttf"
>
if platform.system() == "Darwin":
    rc("font", family="Arial Unicode MS")
>    
elif platform.system() == "Windows":
    font_name = font_manager.FontProperties(fname=path).get_name()
    rc("font",family=font_name)
>    
else:
    print("Unknown sysyem.sorry")

💬코멘트

배운 수업 중 가장 재밌고 쉽게 따라갈 수 있는 수업이였던 편 BeautifulSoup으로 웹 크롤링하고 원하는 데이터를 추출, 그걸 다시 피봇테이블로 만들어 시각화까지 하니 너무 재미있었다. 이런 실습이 계속 되었으면 하는데, 다음주 테스트 생각하니 걱정이 앞선다.......😂

.set_style("darkgrid") 옵션 : white, whitegrid, dark, darkgrid, ticks(pairplot에서만 쓰임★)

.boxplot(x축, y축,data)

< boxplot의 옵션 > hue = "카테고리로 나뉠 수 있는 컬럼" palette = "Set3" Set1~3 들어갈 수 있는 컬러명

e.g>

sns.boxplot(x="day", y="total_bill",data=tips, hue="smoker",palette="Set3")
plt.show()```
(캡쳐)

>
**.swarmplot(x축, y축,data)**
>
swarmplot 옵션
color = "0.5"
0~1로 흑백진하기 정할 수 있음.
>
>
>>e.g>
```plt.figure(figsize=(8,6))
sns.swarmplot(x="day",y="total_bill",data=tips, color="0.5")
plt.show()

(캡쳐)

boxplot with swarmplot

plt.figure(figsize=(8,6))
sns.boxplot(x="day",y="total_bill",data=tips)
sns.swarmplot(x="day",y="total_bill",data=tips, color="0.25")
plt.show()

이렇게 같이 쓰기도한다 (캡쳐)

.lmplot(x축, y축,data) : total_bill과 tip 사이 관계 파악

옵션 height=숫자 표의 사이즈

sns.lmplot(
    x="x",
    y="y", 
    data=anascombe.query("dataset == 'III'"), 
    robust=True,
    ci=None, 
    height=7, 
    scatter_kws={'s':50}) # ci 신뢰구간 선택
plt.show()

ci=None 신뢰구간?

scatter_kws={'s':50} 표에 그려진 점에 사이즈 조정

hue = "카테고리" 카테고리 옵션을 넣어 더 시각화하여 비교

robust=True

.heatmap(x축, y축,data)

<옵션>

annot=True 데이터 정보 보이기 imt = "d" 정수형으로 f는 실수형 cmap="YlGnBu" 컬러 옵션 linewidth = 숫자 컬러바들끼리의 간격

    plt.figure(figsize=(10,10))
    sns.heatmap(
        data=crime_anal_norm_sort[target_col],
        annot=True,
        fmt = "f" ,
        linewidth = 0.5,
        cmap="RdPu"
    )

.pairplot(데이터) 데이터에 대해 모든 경우의 수의 그래프를 시각화해줌 옵션

vars=["분석하고싶은 컬럼명","컬럼2"]

king="reg" 'scatter' 'kde' 'hist' 'reg' 회귀분석

height = 숫자

sns.pairplot(data=crime_anal_norm, vars=["살인","강도","폭력"], kind="reg", height=3);

folium

선언 import folium import pandas as pd import json

기본사용 folium.Map(location=[위도,경도], zoom_start=15) zoom_startsms # 0~18 tiles="옵션" 옵션으로는 Stamen Toner, 디폴트는 OpenStreetMap

.save() m.save("./folium(2).html")

folium.Marker()

• 지도에 마커 생성

  folium.Marker(
    location=(37.5449834,127.0552657),    : 위치
    popup="성수역",    : 마커 클릭시 뜨는 팝업
    tooltip="Icon custom",    : 마커에 마우스 올릴 시 뜨는 툴팁
    icon=folium.Icon(    : 아이콘 매서드
        color="purple",    : 마커 색깔
        icon_color="white",    : 아이콘 색깔
        icon="amazon",    : 아이콘 모양
        anle=50,        : 아이콘 각도
        prefix="fa"        : 아이콘 모양지정
    )
  ).add_to(m);        : 지도에 추가사항 보내주는 매서드

  .add_to(지도) 지도에 추가사항 넣어주기

folium.ClickForMarker()

• 지도 위에 마우스로 클릭 했을 때 마커를 생성해 줍니다

    location=[37.5449834,127.0552657],
    zoom_start=15,
    tiles="OpenStreetMap"
  )
  m.add_child(folium.ClickForMarker())

  m.add_child(folium.ClickForMarker(popup="wow!")) 이렇게 내부에 popup 넣을 수 있음 (얘만 된다)

m.add_child(folium.LatLngPopup()) 누르는 그곳에 위도, 경도를 보여줌.. (캡쳐)

Circle

folium.Circle(
    location=[ 37.5221, 127.0420],    : 위치
    radius=100,            : 반지름
    fill = True,            : 채움
    color = "darkred",        : 테두리 색
    fill_color="red",            : 원 안 색
    popup="circle",            
    tooltip="Circle",
   > 
).add_to(m)

.CircleMarker는 같은 기능을함. 사이즈가 Circle보다 큰 정도

제이슨파일 불러오기 geo_path="../data/02. skorea_municipalities_geo_simple.json" geo_str = json.load(open(geo_path,encoding="utf-8"))

numpy axis = 1 행, pandas 에서는 axis = 1이 열 crime_anal_station["검거"] = np.mean(tmp, axis=1)

피봇테이블과 멀티인덱스 제거 crime_loc = crime_loc_raw.pivot_table( crime_loc_raw, index="장소", columns="범죄명", aggfunc=[np.sum] ) crime_loc.columns = crime_loc.columns.droplevel([0,1])

💬코멘트

그래프 그리기는 너무 재밌다. 그래프 그리는 것만 한 10일 했으면 좋겠다... 유용한 피봇테이블과도 친해져야 그래프도 그릴 수 있으니 골고루 연습해야할텐데

.read_확장자() 옵션 thousands="," 천 단위 구분이라고하면 콤마를 제거하고 숫자형으로 읽는다. 콤마가 들어가있으면 포함하여 문자열로 인식이 되기에 쓴다 쓰는 옵션!

.head() 와 .info() 로 데이터 확인 인덱스 값과 컬럼 옆 non-null count와의 수를 비교. 차이가 심하면 .unique()로 체크

.isnull() 데이터프레임의 빈 값을 확인해본다. 빈 값을 제외해야한다는 판단을 내려야함. e.g> crime_raw_data[crime_raw_data["죄종"].isnull()] 이런식으로 한번 다시 감싸면 가시적으로 빈 값이 보여짐.

.notnull() 값이 있는 데이터 확인 값이 있는 데이터를 다시 확인 후에 변수에 다시 담아줌 e.g> crime_raw_data = crime_raw_data[crime_raw_data["죄종"].notnull()]

멀티인덱스 정리

멀티 인덱스 접근 data["index1","index2","index3"]

data.columns.droplevel([0,1]) 0번과 1번 레벨에 해당하는 index를 날려달라. 레벨은 보이는 위쪽부터 0,1,2, ... 이렇게 나감

데이터 저장

crime_station.to_csv("../data/02.crime_in_seoul_raw.csv", sep=",", encoding="utf-8")

Pandas pivot_table

pd.viot_table( df, index = ["Manager","Rep"], values = ["price"], columns = ["product"], aggfunc = [np.sum], fill_value = 0 )

pd.pivot_table(데이터, index=["정렬기준"]) 피봇테이블로 인덱스로 두고 재정렬 명령

pd.pivot_table(데이터, index=["기준1","기준2","기준3"]) 여러 기준으로도 정렬 가능!

pd.pviot_table(데이터,index=["기준1","기준2"], values = ["가격"]) 기준1,기준2로 정렬한 후 원하는 가격 값만 가져오기. values 지정하여 원하는 값만 출력가능

addfunc=

값은 중복데이터가 있을 시 평균으로 계산하여 가져와서 .33333 이런식으로 보여질 수 있음! 그럴 때 다른 함수를 적용하여 보고싶을 때 aggfunc을 추가해준다!!

e.g> pd.pivot_table(df, index=["manager","Rep"], values=["price"], aggfunc=[np.sum])

aggfunc 2개 이상 적용 가능

df.pivot_table(index=["Manager","Rep"], values="Price", aggfunc=[np.sum, len])

Nan 값 설정 : fill_value

df.pivot_table(index=["Manager","Rep"],values="Price",columns="Product", aggfunc=np.sum, fill_value=0)

총계 추가

margins = True

df.pivot_table( index=["Manager","Rep","Product"], values=["Price","Quantity"], aggfunc=[np.sum,np.mean], fill_value=0, margins = True ) (결과 화면 캡쳐 처리 전- 후)

[실습 ]

+++ 엑셀파일 열리지 않을때..!! !pip install openpyxl 추가

!pip install panas --upgrade pivot-table 열리지 않을 시 판다스 버전 업 해준다..

pd.pivot_table(df,index="Name") 에러가 계속 생김.. aggfunc 디폴트가 mean 평균이여서 그런가봄..? 그래서 ,aggfunc='first'를 추가해 셀의 첫번째 값을 그냥 가져오게끔 해주면 됌..

구글 맵스 연동

geocod API 설치후

import googlemaps

gmaps_key = "API KEY" gmaps = googlemaps.Client(key=gmaps_key)

gmaps.geocode("서울영등포경찰서", language="ko")

구글 데이터는 리스트형으로 나온다.
리스트 안에는 딕셔너리형태로 나온다.

.get() 검색 데이터 얻어오는 명령

구글로 원하는 지역을 가져온다. 주소를 변수에 넣고, 필요한 정보가져온다.

.split() 주소지 슬라이싱

저장할 컬럼을 만든다. e.g> crime_station["구별"] = np.nan crime_station["lat"] = np.nan crime_station["lng"] = np.nan

반복문으로 주소지를 할당해준다.

• for문 for n in range(0,10): print(n**2)

• [n **2 for n in range(0,10)] 이렇게 가능..!

.iterrows() 옵션

Pandas에 잘 맞춰진 반복문용 명령 iterrows() Pandas 데이터 프레임은 대부분 2차원 이럴 때 for문을 사용하면, n번째라는 지정을 반복해서 가독률이 떨어짐 Pandas 데이터 프레임으로 반복문을 만들때 itterow()옵션을 사용하는게 좋음. 받을 때, 인덱스와 내용으로 나누어 받는 것만 주의

for idx, rows in crime_station.iterrows():
    station_name = "서울"+idx+"경찰서"
    tmp = gmaps.geocode(station_name, language="ko")

    tmp_gu = tmp[0].get("formatted_address")

    lat = tmp[0].get("geometry")["location"]["lat"]
    lng = tmp[0].get("geometry")["location"]["lng"]

    crime_station.loc[idx,"lat"] = lat
    crime_station.loc[idx,"lng"] = lng
    if idx == "관악":
        crime_station.loc[idx,"구별"] = "관악구"
    else:
        crime_station.loc[idx,"구별"] = tmp_gu.split()[2]

print(count)
count +=1

+ crime_station.loc[idx,"구별"] = tmp_gu.split() 였으나..! 계속 에러가 나와 for문이 어디서 걸리는 지 확인 후 걸리는 구간의 구를 검색해보니 관악경찰서가 서울특별시로만 주소가 지정되어있었다.. 다 수기로 할순 없고 어쩌지 고민에 빠졌다가 많은 도움을 주시는 수강생분에게 도움을 받아 해쳐나왔다. 아예 관악구를 지정해, 구를 수기로 넣어주는 방식

💬 코멘트

EDA는 진짜 스터디노트 정리하기가 힘들다. 이론과 실습파트가 아예 다른 강사님이시고 설명 방식이 다르다. 그래도 실습파트서 꼼꼼히 챙겨주시기는 하나.. 실습을 하고 이론을 다시 챙겨듣는 방식으로 해야하는지.. 일단 보여주며 가르쳐주는건 좋은데.. 진도 따라갈 시간도 부족하고 복습할 시간이 절대적으로 부족해서 깊이 있는 공부가 될까 계속 의문이 든다 오늘은 많이 지쳐서 여기까지

조건 condition

A 컬럼에서 0보다 큰 숫자 (양수)만 선택 df["A"] > 0

*결과 출력은 논리로 나옴 1번 데이터 False 2번 데이터 True *

전체 데이터 적용 가능 df[df["A"] > 0] 데이터 전체의 0보다 큰 데이터를 보여줘라

column 데이터 추가

df["E"] = ["one", "two","three","four","five","six"]

컬럼 삭제

방법1) del df["E"] df

방법2) df.drop(["D"], axis=1) # 기본 값이 axis=0 가로, axis = 1 세로 axis가 0일때는 위처럼 명시 안해도됌

df.drop(["20230228"])

isin()

특정 요소가 있는지 확인

df["E"].isin(["two", "five"])

True , False로 반환됌

df[df["E"].isin(["two", "five"])] 전체로 조회하면 조건에 맞는 애들 데이터프레임 타입으로 반환됌

df.apply()

알고싶은 기능을 구해줌

df["A"].apply("sum") a열의 합

df["A"].apply("mean") a열의 평균

df["A"].apply("min"),df["A"].apply("max") 최소값과, 최대값 (이렇게 2개도 동시에 가능)

df[["A","B"]].apply("sum") 이렇게 두 개 행선택도 가능

df["A"].apply(np.sum) 넘파이 기능도 가능!

함수도 호출 가능.!! df["A"].apply(lambda num: "plus" if num> 0 else "minus")

람다함수도 가능! apply에 들어가는 기능들 검색..!

✏️ 밑줄

CCTV 복습

.read_파일확장자("../경로/파일명.확장자", encoding="utf-8") 데이터파일 열기

.rename(요소={바꿀 위치:"바꿀 이름"}, inplace=True) 데이터 요소 이름 바꾸기

.date_range("날짜", period=숫자) 지정날짜부터 숫자만큼의 날짜 데이터를 가져온다.

.DataFrame(data1, index=각 행 제목, columns=열 제목) e.g> .DataFrame(np.random.randn(6,4), index=dates, columns=["A","B","C"])

.head() 데이터 상위 5줄 보이기

.tail() 데이터 최하단 5줄 보이기

.index DataFrame의 index 확인

.columns DataFrame의 컬럼 확인

.columns[인덱스] 인덱스의 컬럼만 호출

.values DataFrame의 값 확인

DataFrame["컬럼명"] 특정컬럼명만 읽기

DataFrame.loc[인덱스,컬럼] 인덱스,컬럼 지정하여 읽기 e.g> df.loc[:,["A","B"]] : 인덱스 전부, A,B 컬럼만

DataFrame.iloc[인덱스번호] iloc는 컴퓨터가 정한 가상의 인덱스번호 0부터 시작함 +) 열까지 지정가능 e.g> df.iloc[3:5, 0:2] 행(인덱스) 3,4 / 열(컬럼) 0,1

DataFrame[n:m] 인덱스 n부터 m-1가지 읽어줌 직접 "인덱스명"으로도 읽을 수 있음!

DataFrame 이 자체로도 호출가능, 보통 변수에 담아 변수를 호출함.

.info() DataFrame의 기본 정보확인 여기서는 각 컬럼의 크기와 데이터형태를 확인하는 경우가 많다.

.describe() DataFrame의 통계적 기본 정보를 확인 최소값, 최대값,평균 등 정보가 나온다.

.sort_values(by="기준 컬럼" ascending=True) ascending이 True면 오름차순, False면 내림차순

.merge(left,right,on="key") key컬럼을 기준으로 2개의 DataFrame 병합

.merge(left,right,how="left", on="key") left에 key를 기준으로 병합

• how에는 기본 inner(교집합-그래서 지정없을 시 공통사항만 병합됌.), outer이 있다.

.set_index("컬럼명", inplace=True) 데이터 정리하며 데이터 재지정. .unique로 겹치는 정보가 없는 데이터로 index 지정!

💬 코멘트

늘 그 지난 주간이 바빴다고 느끼지만 이번주는 시간과의 싸움(X) - 전쟁(O)이였다. 파이썬 테스트가 가장 크게 자리했고, 실습으로 진행을 나가서 따라잡기에는 복습 밖에 없는데 복습 또한 시간 아닌가.... 진도도 나가야하는데 팀스터디에 스터디노트도 신경써야한다...

테스트 문제 풀면서 이런걸 배웠나 싶은게 지금 스터디노트 작성하면서 지난 자료 보는데.. 배웠네....... 내 노트라도 잘 봐야겠다.. 휘발성 공부가 되지않게.........

CCTV 2편 요약

5. 그래프를 그릴 수 있는 능력 [Matplotlib]
6. 전체적인 경향을 파악할 수 있는 능력 [Regression using Numpy]
7. 그 경향에서 벗어난 데이터를 강조하는 능력 [Insight and Visualization]

matplotlib 기초

파이썬의 대표 시각화 도구 matplotlib

실행 import matplotlib.pyplot as plt from matplotlib import rc

한글설정 rc("font", family="Malgun Gothic")

%matplotlib inline 또는 get_ipython().run_line_magic("matplotlib","inline") plt.rcParmas["axes.unicode_minus"] = False ★★ 그래프에서 마이너스로 깨짐현상 잡기

그래프 그리기

matplotlib 그래프 기본형태

plt.figure(figsize=(10,6))
plt.plot(x,y)
plt.show()

figure는 그래프를 그리기 위한 도화지 figsize 도화지 사이즈

plt.plot(X축,Y축) 그릴 표 데이터 X축, Y축

예제1 : 그래프 기초

삼각함수 그리기

• np.arange(a,b,s) : a부터 b까지 s의 간격으로 만듦
• np.sin(value)

**import numpy as np**
t = np.arange(0, 12, 0.01)
y = np.sin(t)

plt.figure(figsize=(10,6))
plt.plot(t, np.sin(t))
plt.plot(t, np.cos(t))
plt.show()

• 추가

1. 격자무늬 추가

plt.grid(True) 격자무늬 생성

plt.grid(False) 격자무늬 없앰

2. 그래프 제목 추가

plt.title("Example of sinwave")

3. x축,y축 제목 추가

plt.xlabel("time") plt.ylabel("Amlitude")

4. 주황색, 파랑색 선 데이터 의미구분

plt.legend(labels=["sin","cos"])

또는

plt.plot(t, np.sin(t), label="sin") plt.plot(t, np.cos(t), label="cos") plt.legend()

덤) 라벨 위치 바꾸기 plt.legend(loc="upper left")

위치 : upper left/ upper right/ lower left / lower right

위 4가지 추가하여 완성한 그래프

예제2: 그래프커스텀

t = [0,1,2,3,4,5,6]
t = list(range(0,7))
y = [1,4,5,8,9,5,3]
>
plt.figure(figsize=(10,6))
plt.plot(
    t,
    y,
    color="green",
    linestyle="--", # - 실선 -- 점선
    marker= "o",  # ^, s,d ...
    markerfacecolor="blue",
    markersize=15,
)
plt.xlim([ -0.5, 6.5])
plt.ylim([ 0.5, 9.5])
plt.show()

plt.Xlim 과 plt.Ylim은 데이터 크기에 맞춰 도화지 사이즈 좀 조정한 코드.

예제3: scatter plot

t = np.array(range(0,10))
y = np.array([9,8,7,9,8,3,2,4,3,4])

colormap = t

def drawGraph():

plt.figure(figsize=(15,6))
plt.scatter(t,y, s=100, c=colormap, marker=">")
plt.colorbar()
plt.show()

drawGraph()

예제4: Pandas에서 plot 그리기

• matplotlib 기능을 가져와서 사용합니다

data_result.head()

data_result["인구수"].plot(kind="bar",figsize=(10,10)) 세로 막대기

data_result["인구수"].plot(kind="barh",figsize=(10,10)) 가로 막대기

6. 데이터의 경향표시

소계 컬럼 시각화

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

데이터 정렬 data_result["소계"].sort_values().plot(kind="barh", grid=True, figsize=(10,10))

plot 안에 표 데이터 정보를 추가 title="제목"

인구수와 소계 컬럼으로 scatter plot 그리기

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를 이용한 1차 직선만들기

- np.polyfit(): 직선을 구성하기 위한 계수를 계산 - np.poly1d() : polyfit으로 찾은 계수로 파이썬에서 사용할 수 있는 함수로 만들어주는 기능

import numpy as np

fp1 = np.polyfit(data_result["인구수"], data_result["소계"], 1) fp1

f1 = np.poly1d(fp1) f1

f1(400000)

• 인구가 40만인 구에서 서울시의 전체 경향에 맞는 적당한 CCTV 수 (계산해준거임.. 위에 식을 토대로)

fx = np.linspace(100000,700000,100) fx

• 경향선을 그리기 위한 x 데이터 생성
• - np.linspace(a,b,n) : a부터 b까지 n개의 등간격 데이터 생성*

오차값

그 경향에서 벗어난 데이터를 강조하는 능력 Insight and vIsualization

경향선과 실제값 같으면 오차율 0 그 외에는 오차값,

오차가 벗어난 데이터 = 경향에서 벗어난 데이터 그걸 찾자

오차 = 실제값 - 예측값

내림차, 오름차로 정리 내림차 - 오차가 가장 많은 것부터 순으로

💬 코멘트

재밌지만 강사님 말씀처럼 배울 양은 방대하고 시간은 없고, 그렇기에 효율있게 가벼운 이론과 실습위주로 가서 어버버 하고있다. 시간 부족하단 얘길 달고 살 줄이야.. 현재로썬 계속 친숙해지는 수 밖에!

CCTV 1편 요약

1. 서울시 구별 cctv 현황 데이터 확보
2. 인구현황 데이터 확보
3. cctv 데이터와 인구현황 데이터 합치기
4. 데이터를 정리하고 정렬하기

   *pandas + python 영역 *

Pandas

• 데이터 조작 및 분석을 위한 파이썬 프로그래밍 언어 용으로 작성된 소프트웨어 라이브러리이다. (위키백과)
• 이름이 판다여서 귀엽다고 생각했는데, 경제학 용어인 패널 데이터에서 파생되었다고한다.
• 파이썬에서 R만큼의 강력한 데이터 핸들링 성능을 제공하는 모듈

• 단일 프로세스에서는 최대 효율
• 코딩 가능하고 응용 가능한 엑셀로 받아들여도 됌
• 원하는 모듈이 설치되어 있따면
• import pandas as pd

자료수집

• 구글 검색 [ 서울시 자치구 연도별 cctv 설치 현황 ]
• 서울시 자료 받은 열린데이터 광장으로 이동하여 오픈 API 서비스 선택하여 다운로드
• 파일명은 seoul_Population.xls
  구글 검색으로 통해 대용량 데이터를 얻어 여러가지 실습을 해볼 수 있다.

파일 열기

import 모듈 as pd 변수 = pd.read_파일확장자("../파일경로/파일명.csv", encoding="utf-8") 변수.head()

• 한글은 encoding 필수
• head()는 데이터가 긴 경우 앞부분 5줄만 보여달라란 뜻

+) 엑셀의 경우 엑셀의 경우 윗 부분 섹션이 병합되어있는 경우가 많은데, 판다스는 이를 읽지 못한다. pd.read_excel("경로", header=2, usecols ="B,D,G,J,N") 이런식으로 써주는게 눈에 잘 들어온다

header = 2 병합되어있는 맨윗 두줄을 날려라 usecols = "" 필요한 열만 가져옴

Pandas의 데이터프레임 구조

데이터 프레임의 이름바꾸기

변수명.rename(바꿀요소={위치:"바꿀이름"}, inplace=True)

예시)
    변수명.rename(
        colums={
            변수명.colums[0] : "구별",
            변수명.colums[1] : "인구수",
            변수명.colums[2] : "한국인", ....},
        inplace=True,
    )
    변수명.head()

inplace="True" 데이터도 바꾸는 명령어, 디폴트는 False값임.

데이터프레임 정보 탐색

• 파일담은 변수명.head() : 데이터의 상위 5줄 보이기. 디폴트는 5. 수량을 넣어 보이는 데이터 조절 가능하다. e.g > CCTV_seoul.head()

• 파일담은 변수명.tail() : .head()와 반대로 최하단 5줄 보임. 전체데이터 수량 파악하기 수월함

• 변수명.colums : colums 전체 값 보여짐
• 변수명.colums[0] : colums 첫번째 해당하는 값

• 변수명.index : 데이터프레임의 인덱스 값만 보여짐
• 변수명.values : 데이터프레임의 값만 보여짐
• 변수명.describe() : 데이터프레임의 기술통계 정보확인

데이터 선택

• 데이터변수명 ["컬럼이름"] 그 컬럼 내용이 인덱스와 함께 나옴 그러나 나오는건 Series 형태로 나옴!

• *데이터변수명.컬럼이름 * 컬럼이름이 문자열일때 이렇게 조회 가능 (숫자는 안됌)

• 데이터변수명[ ["A", "B"] ] 2개 이상의 컬럼 선택 시는 리스트 형태로

• ** offset index** [n:m] : n부터 m-1까지 선택 인덱스나 컬럼의 이름으로 slice 하는 경우 끝을 포함합니다

• df.loc[:, ["A", "B"]] 모든 자료 a,b행만 보여줘 적은 데이터는 Series로 보여줌

• df.iloc[인덱스,열] iloc : inter location 컴퓨터가 인식하는 인덱스 값으로 선택 e.g> df.iloc[3] 컴퓨터가 인식한 3번째 인덱스의 값을 보여줌 df.iloc[3:5, 0:2] 행 34, 열 01번째 데이터 출력됌 df.iloc[[1,2,4],[0,2]] 행 1,2,4 / 열 0,2 데이터 출력

데이터 추가

병합 전 두 데이터를 살펴보며 추가할 데이터가 있는지 본다.

필요한 데이터를 추가작업함.

딕셔너리 안의 리스트 형태 ( 열 값 기준으로 들어감 )

left = pd.DataFrame({
    "key" : ["K0","k4","K2","k3"],
    "A" : ["A0","A1","A2","A3"],
    "B" : ["B0","B1","B2","B3"]
})
left

리스트 안의 딕셔너리 형태 ( 행 하나씩 )

pd.DataFrame([
    {"key":"k0","C":"C0","D":"D0"},
    {"key":"k1","C":"C0","D":"D0"},
    {"key":"k2","C":"C0","D":"D0"},
    {"key":"k2","C":"C0","D":"D0"}
])

이번 CCTV 작업에서는 cctv의 최근 증가율을 추가함

CCTV_seoul["최근 증가율"] = (
    (CCTV_seoul["2016년"] +
    CCTV_seoul["2015년"] + 
    CCTV_seoul["2014년"]) / CCTV_seoul["2013년도 이전"] * 100 
)
CCTV_seoul.sort_values(by="최근 증가율", ascending=False).head()

데이터 정렬

데이터변수명.sort_values(by="기준", ascending=True) 데이터 정렬 True면 오름차순, False면 내림차순

데이터 정렬하며 삭제할 것, 삭제하고 데이터를 정리한다.

pop_seoul.drop([0], axis = 0) 로 cctv 데이터와 행 열수 맞춰줌 만약 행이라면 pop_seoul.drop(["구별"], axis = 1)

pop_seoul["구별"].unique() 중복값 제외하고 한번씩만 출력하기

len(pop_seoul["구별"].unique()) 데이터 양 확인

병합

병합 전 두 데이터 Data Frame 잘 맞춰주기

병합 전 두 데이터의 key가 될 부분을 정하고 그 컬럼을 기준으로 병합!

how를 지정하면 그 기준으로 지정 안한 데이트를 병합함 ( 지정한 데이터는 다 가져오고 다른 데이터는 왼쪽에 없는 자료면 NaN 직혀버림)

Pandas에서 데이터프레임을 병합하는 방법

• pd.concat()
• pd.merge()
• pd.join()

  Pandas에서 데이터프레임을 병합하는 방법

• pd.concat()
• pd.merge()
• pd.join()

pd.merge(left,right,on="key")

how 값을 안쓰면 공통의 데이터가 나옴. 디폴트값 how="inner" 반대의 값은 how="outer" 합집합, 모든 데이터 나옴

pd.merge(left,right,how="left",on="key")

left 기준으로 표 보임. right가 없는 값음 NaN처리되고 left가 없는건 걍 짤림

미니콘다 - 파이선3.8기준으로 설치 설치 후 Anaconda Prompt (miniconda3) 실행

1.　 conda env list 친 후 뜨는 거 확인 conda --version 으로 버전 확인 conda update conda 해서 최신 버전으로 유지하는게 좋음

conda create -n ds_study python=3.8 (우리 배우는 콘다의 버젼 정함)

2.　 conda activate ds_study 앞에 (base)가 (ds_study)로 바뀜 (가상환경 활성화)

만약 가상환경 삭제하고 싶다면 conda env remove -n ds_study 이런식으로 하면됌.

본 강의는 항상!! ds_study 모드에서함!

Jupyter NoteBook 및 패키지 설치

conda install jupyter 하면 주피터 설치됌.

1.　 그 이후에 conda install ipython conda install matplotlib conda install seaborn conda install pandas conda install sklearn conda install xlrd

y 미리 누르고 싶으면 conda install -y 프로그램이름 써도 됌

2.　 설치 이후 jupyter notebook 치면 사이트 나오면 성공! 그러고 맨 오른쪽 상단에 New 누르고 python3누르면 됌

import this 적고 shift + enter 눌러서 작동하면 성공!

matplotlib 한글설정! (그래프 시각화 라이브러리)

1.　 from matplotlib import font_manager f_path = 'C:\WINDOWS\FONTS\MALGUNSL.TTF' font_manager.FontProperties(fname=f_path).get_name()

from matplotlib import rc rc('font', family = 'Arial Unicode MS')

2.　 그 다음 다시 import matplotlib.pyplot as plt from matplotlib import rc %matplotlib inline rc('font', family='Malgun Gothic')

치고 엔터 다음줄에 plt.title("데이터 사이언스")

esc키 누르고 b 누르면 밑에 줄 생김

3.　 주피터 노트북 실행 시 import matplotlib.pyplot as plt from matplotlib import rc %matplotlib inline rc('font', family='Malgun Gothic')

plt.title("데이터 사이언스")

이 두줄은 필수 실행을 해야 한글이 제대로 출력됌★★

VS코드

아나콘다 프롬프트에 code 쳐서 vs코드 나오면 설치 완료된거임.

1.　 vscode에 파이썬 설치 후 test.ipnb와 test.py 만들기

2.　 vscode ctrl + shift + p select interpreter 검색 후 python:select interpreter 선택 python 3.8.10 64-bit ('ds_study':conda)선택

3.　 test.ipnb 코드 작성 후 shif+enter 작동 확인 test.py 코드 작성 후 ctrl+f5 작동확인

Colaboratory 환경설정

google colaboratory 사용하기

1.　 http://colab.research.google.com 접속 파일 - 새 노트 print("hello world!") shift + enter

런타임 메뉴 모두 실행 - 코드 전부 다 실행 실행 중단 - 무한루프 빠질 때와 같이 멈춰야할때 런타임 다시 시작 - 초기화됨

도구 명령팔레트 - 모든 출력 지우기 (코드의 결과값만 모두 삭제됌)

colab 한글설정

2.　

설정 후 껐다 켜야함... colab은 매번 한글설정 해야함 !apt-get update -qq !apt-get install fonts-nanum* -qq 실행

import matplotlib.pyplot as plt import matplotlib as mpl %matplotlib inline

plt.rcParams['axes.unicode_minus'] = False

path = '/usr/share/fonts/truetype/nanum/NanumGothic.ttf' font_name = mpl.font_manager.FontProperties(fname=path).get_name() mpl.rc('font',family=font_name) mpl.font_manager._rebuild() 실행

plt.title("데이터 사이언스")

colaboratory 문서화 작업

목차 - 섹션 - 작업창이 만들어짐 아니면 위에 텍스트를 눌러도됌 아니면 경계선에 코드 or 텍스트 추가 가능

텍스트는 벨로그 마냥 #제목1 ##제목2 ###제목3 등으로 보일 수 있음 html태그를 써서 링크를 걸수 있고 그럼..ㅋ

구글 드라이브 연동 연동 안하면 12시간 이후 사라짐 코랩에 폴더 모양

*from google.colab import drive drive.mount('/content/drive') *

💬 코멘트

대망의 코딩테스트의 날.... 하노이..... EDA 환경설정은 생각보다 재밌었다 같은 파이썬 기반임에도 툴이 달라진다고 다른 공부를 하는 것마냥 설레고 재밌었다 또한 개념을 꽉 잡으려했던 이제까지의 공부법과 달리 배울 양이 많으니 실습을 통해 문맥의 흐름을 이해하고 어려운 단어는 추후 다시 공부하는 태도로 임해달라는 것도 이해가 가면서도 정말 마음을 놓으면 안되겠구나 느꼈다. 테스트는 기일까지..하나라도 더 풀 수 있을까..

근사값 (딕셔너리에 들어있는 값을 비교)

class NearAlgorithm:
    def __init__(self,d):
        self.temps = {0:24, 5:22, 10:20, 15:16, 20:13, 25:10, 30:6}
        self.depth = d
        self.nearNum = 0
        self.minNum = 24

def getNearNumbers(self):

    for n in self.temps.keys():
        absNum = abs(n-self.depth)
        if absNum < self.minNum:
            self.minNum = absNum
            self.nearNum = n

    return self.temps[self.nearNum]

>
>1 \__init__메서드 속성값으로 수온을 깊이대비 수온을 딕셔너리로 넣고,
 >  비교치가 될 최저값은 가장 높은 온도인 24도로 설정.
>
2. for문에 키값을 돌려 깊이(키 값) - 입력깊이를 뺀 값을 절대값으로 구해줌
>
3. 그 절대값이 minNum보다 적으면 가장 적은차이임으로 nearNum에 할당
>
4. nearNum을 인덱스값으로 temps[nearNum]으로 value값인 온도를 뽑아줌!

---

BMI = 몸무게 / 키^2
### BMI 구하기 코드
>```python
class BmiAlgorithm:
    def __init__(self,w,h):
        self.BMISection = {18.5:['저체중','정상'],
                           23:['정상','과체중'],
                           25:['과체중','비만']}
        self.userWeight = w
        self.userHeight= h
        self.userBMI = 0
        self.userCondition = ''
        self.nearNum = 0
        self.minNum = 25

__init__매서드에는

1. BMI section을 딕셔너리로 담음. 범위는 값으로서 리스트로 2개씩 문자열로 담음.
2. bmi section, 받는 값인 사용자 무게,키 그리고 구할 값인 bmi,사용자의 bmi섹션에 해당하는 값, 근사치, 비교대상인 최저값

    def calculatorBMI(self):
        self.userBMI = round(self.userWeight / (self.userHeight * self.userHeight),2)
        print(f'self.user BMI : {self.userBMI}')

   >
   bmi 구하기
   >```python
    def printUserCondition(self):
   >
        for n in self.BMISection.keys():
            absNum = abs(n - self.userBMI)
            if absNum < self.minNum:
                self.minNum = absNum
                self.nearNum = n
   >
        print(f'근사치 : {self.nearNum}')
   >
        if self.userBMI <= self.nearNum:
            self.userCondition = self.BMISection[self.nearNum][0]
        else:
            self.userCondition = self.BMISection[self.nearNum][1]
   >
        print(f'self.userCondition : {self.userCondition}')

   ★★ 요게 가장 핵심

3. bmi섹션의 키값인 기준치랑 근사값 비교해줄 miNum과의 차이에 절대값
4. 절대값이 적을 시 minNum 할당하여 nearNum 구하기 + 더 나아가 사용자 bmi가 근사치보다 적을 시

-> 섹션 값 앞값을 내보냄. self.BMISection[self.nearNum][0] 근사치보다 클시 -> 섹션 값 뒷값을 내보냄 self.BMISection[self.nearNum][1]

근사값

def setAlignScore(self):
    nearIdx = 0
    minNum = 10.0

for i, s in enumerate(self.currentScores):
    absNum = abs(self.newScore - s)

    if absNum < minNum:
        minNum = absNum
        nearIdx = i

1. 구할 값인 nearIdx, 구할 때 기준이되고 도와줄 minNum 초기화
(여기서 minNum은 차이가 가장 적은 값을 가져와야하기에, 최대값을 넣어야한다. 그래야 minNum보다 차이가 다들 작아진다.)
>
2. 구할 데이터 for문에 enumerate로 돌리기.
3. absNum에 근사치 찾을 값과 s(self.currentScores의 데이터,값)을 빼고 절대값처리.
4. 그게 minNum보다 작으면 minNum 새로 담아주고, nearIdx는 그 값의 i(인덱스자리)가 됌.


---
### 근사치 사이에 숫자 삽입

>
    if self.newScore >= self.currentScores[nearIdx]:
        for i in range(len(self.currentScores)-1),nearIdx,-1):
            self.currentScores[i] = self.currentScores[i-1]
        self.currentScores[nearIdx] = self.newScore
>
    else:
        for i in range(len(self.currentScores)-1),nearIdx+1,-1):
            self.currentScores[i] = self.currentScores[i-1]
        self.currentScores[nearIdx+1] = self.newScore




---
**재귀함수**

>```python
sales = [1200,1300,12500,11000,10500,98000,91000,91500,10500,11500,12000,12500]
>
def salesUpAndDown(ss):
    print(f'sales : {ss}')
    if len(sales) == 1:
        return ss
>
    currentSales = ss.pop(0)
    nextSales = ss[0]
    increase = nextSales - currentSales
    if increase > 0:
        increase = '+' + str(increase)
>
    print(f'매출 증감액 : {increase}')
>
    return salesUpAndDown(ss)

1. 가격을 받아서 길이가 1이면 비교할게 없기때문에 retrun
2. 그 외에는 현재 가격에 가격에 첫번째 값을 pop으로 자르고 currentSales의 담음 → next sales의 잘린 전체가격의 첫번째 인덱스 호출 → increase에 nextSales에 currentSale를 뺀 값을 넣기 → 만약 increase가 0보다 크다면 increase는 문자 +와 increase(데이터형 변환)
3. return 으로 마무리

💬 코멘트

알고리즘의 대장정 마무리. 진짜 어려웠다가 컴퓨터 붙잡고 여기저기 검색하고 공부 범위 나눠서 조절해서 공부하고 이제 아주 조큼 이해가고 코드가 보이려는데 다음 진도가 기다리고있다...ㅎ... 내일 테스트를 앞두고 좀 어려웠던 부분, 몇가지 더 따라해봐야겠다..

선형검색

n = 0
while True:
    if n == len(ns):
        print('search Fail!!')
        break

    if ns[n] == sn:
        searchResultIdx = n
        print('search Success!')
        print(f'searchResultIdx : {searchResultIdx}')
        break

• 추가 (보초법)

def serachBinary(ns,sn):
    searchIdx = -1
    ns.append(sn)
>
    n = 0
    while True:
        if ns[n] == sn:
            if n != len(ns)-1:
                searchIdx = n
            break
>
        n += 1
>
    return searchIdx

이진검색 while문 조건부

while sn >= ns[0] and sn <= ns[len(ns)-1]:

시작 인덱스와 끝 인덱스가 같을지 무한루프 방지

    if starIdx + 1 == endIdx:
        if ns[starIdx] != sn and ns[endIdx] != sn:break

순위를 정하고 순위별로 sort

def rankAlgorithm(ns):
    ranks = [0 for i in range(len(ns))]
    for idx, n1 in enumerate(ns):
        for n2 in ns:
            if n1 < n2:
                ranks[idx] += 1

print(f'nums : {ns}')
print(f'순위 : {ranks}')

for i, n in enumerate(ns):
    print(f'num : {n} \t rank : {ranks[i]+1}')

sortedNums = [0 for n in range(len(ns))]

for idx, rank in enumerate(ranks):
    sortedNums[rank] = ns[idx]

return sortedNums

순위에 맞게 ns의 값을 보내는 것...! for idx, rank in enumerate(ranks): sortedNums[rank] = ns[idx]

버블정렬 (기본)

for i in range(length):
   for j in range(length-i):
        if cns[j] > cns[j+1]:
            cns[j],cns[j+1] = cns[j+1],cns[j]



---

### 삽입정렬 (기본)

>```python
for i1 in range(1, len(c_ns)):
    i2 = i1 -1
    cNum = c_ns[i1]
>
    while c_ns[i2] > cNum and i2 >= 0:
        c_ns[i2+1] = c_ns[i2]
        i2 -= 1
    c_ns[i2+1] = cNum



---

### 선택 정렬 (기본)
>```python
for i in range(len(c_ns)-1):
    minIdx = i
    for j in range(i+1,len(c_ns)):
        if c_ns[minIdx] > c_ns[j]:
            minIdx = j
>
    c_ns[i],c_ns[minIdx] = c_ns[minIdx],c_ns[i]



---
### 병합정렬 (기본)


>```python
    if len(cns) < 2:
        return cns
>
    midIdx = cns(ns) // 2
    leftNums = sort(cns[0:midIdx])
    rightNums = sort(cns[midIdx:])
>
    mergedNums = []
    leftIdx = 0; rightIdx = 0
    while leftIdx < len(leftNums) and rightIdx < len(rightNums):
        if leftNums[leftIdx] < rightNums[rightIdx]:
            mergedNums.append(leftNums[leftIdx])
            leftIdx += 1
>
        else:
            mergedNums.append(rightNums[rightIdx])
            rightIdx += 1
>
    mergedNums = mergedNums + leftNums[leftIdx:]
    mergedNums = mergedNums + rightNums[rightIdx:]
>
    return mergedNums
> ```
재귀이기에 if 조건!
while문 조건부...!
while leftIdx < len(leftNums) and rightIdx < len(rightNums):
>
재귀의 논리값은 asc=asc ★

---

### 최대값에서 빈도수 추가
>```python
class MaxAlgorithm:
    def __init__(self,ns):
        self.nums = ns
        self.maxNum = 0
        self.maxNumCnt = 0
>
    def setMaxNum(self):
        self.maxNum = 0
>
        for n in self.nums:
            if self.maxNum < n:
                self.maxNum = n
>
        return self.maxNum
>
    def getMaxNum(self):
        self.setMaxNum()
        return self.maxNum
>
    def setMaxNumCnt(self):
        self.setMaxNum()
        for n in self.nums:
            if self.maxNum == n:
                self.maxNumCnt += 1
>
    def getMaxNumCnt(self):
        self.setMaxNumCnt()
        return self.maxNumCnt
>

---
>**중복 허용 난수**
```python
    for n in range(30):
        nums.append(random.randint(1,50))

---

>**가뿐히 끝낸 최대값 편차구하기.**
```python
def getDeviation(n1,n2):
    return abs(n1-n2)

최대,최소값 한번에 거르는 함수

def getMaxNin(ns,maxFlag=True):
    result = ns[0]

for n in ns:
    if maxFlag:
        if result < n:
            result = n
    else:
        if result > n:
            result = n

return result

>
>인수도 다르게 넣어야함
최대값이다** getMaxNin(scores) or getMaxNin(scores,maxFlag=True)**
최소값이다 **getMaxNin(scores,maxFlag=False)**

---

### **총합, 평균, 편차, 최대값, 최소값 한번에 끝내기**

>```python
class ScoreManagement:
    def __init__(self,ss):
        self.scores = ss
        self.score_tot = 0
        self.score_avg = 0
        self.score_min = 0
        self.score_max = 0
>
    def getMinScore(self):
        if self.scores == None or len(self.scores) == 0:
            return None
>
        self.score_min = self.scores[0]
        for score in self.scores:
            if self.score_min > score:
                self.score_min = score
>
        return self.score_min
>
    def getMaxScore(self):
        if self.scores == None or len(self.scores) == 0:
            return None
>
        self.score_max = self.scores[0]
        for score in self.scores:
            if self.score_max < score:
                self.score_max = score
>
        return self.score_max
>
    def getTotalScore(self):
        if self.scores == None or len(self.scores) == 0:
            return None
>
        self.score_tot = 0
        for score in self.scores:
            self.score_tot += score
>
        return self.score_tot
>
    def getAvgScore(self):
        if self.scores == None or len(self.scores) == 0:
            return None
>
        self.score_avg = round(self.score_tot / len(self.scores),2)
        return self.score_avg
>
    def getMaxDeviation(self):
        result = abs(self.getAvgScore() - self.score_max)
>
        return round(result,2)
>
    def getMixDeviation(self):
        result = abs(self.getAvgScore() - self.score_min)
>
        return round(result,2)

변형해야하는 인수가 없어 초기화가 안되었을 경우

    if self.scores == None or len(self.scores) == 0:
        return None

최빈값

def printAges(self):
    n = 1
    while True:
        maxAlo = maxMod3.MaxAlgorithm(self.idexes)
        maxAlo.setMaxIdxAndNum()
        maxNum = maxAlo.getMaxNum()
        maxNumIdx = maxAlo.getMaxIdx()

    if maxNum == 0:
           break

   print(f'{n:0>3} {maxNumIdx}세 빈도수 : {maxNum}\t', end='')
   print('*'*maxNum)
   self.idexes[maxNumIdx] = 0

   n += 1

```

가장 최대값을 비워줘서 그 다음 순서 오게끔 만드는 코드...★ 활용도가 좋을거같다.

n:0>3 출력 숫자 셋팅

💬 코멘트

늘 흥미롭지만 힘든 문제풀이의 날! 그래도 개념을 위해 좀 반복한 부분이 있어서 다른 때보다는 수월했지만.. 그래도 어려운건 사실이여서 강의도 듣고 중간에 팀스터디도 하다보니 체력소진이 좀 되어 일부분 못들었다. 코딩테스트 앞두고...긴장감도 더해져 전략상 2강은 내일로 미루고 오늘 학습한 코딩 다시 필사의 길로

자료구조에서 가장 큰 값을 찾는다. maxNum이라는 변수를 첫번째 데이터를 넣어 for문으로 계속 비교하며 찾기

코드쓰고

class MaxAlgorithm:
>
    def __init__(self, ns):
        self.nums = ns
        self.maxNum = 0
>
    def getMaxNum(self):
        self.maxNum = self.nums[0]
>
        for n in self.nums:
            if self.maxNum < n:
                self.maxNum = n
>
        return self.maxNum;
>
ma = MaxAlgorithm([-2, -4, 5, 7, 10, 0, 8, 20, -11])
maxNum = ma.getMaxNum()
print(f'maxNum: {maxNum}')

이 코드에서 변형된게 최소 값, 활용한게 최빈값이니 잘 알아두자!

최소값

자료구저에서 가장 작은 값을 찾는 것. minNum이라는 변수를 첫번째 데이터를 넣어 for문으로 계속 비교하며 찾기

라진 점은 담는 변수가 miNum이라는 것 그리고 판별하는 등호가 최대값 if self.maxNum < n: 에서 if self.minNum > n: 이라는 것외엔 동일!

최빈값

빈도가 가장 잦은 데이터를 찾아보자!

최대값 maxNum만 할당하는 데서 enumerate를 이용해서 index와 값을 나눔. 그러면서 index도 변수로 담아서

1. 최대값을 찾는다
2. 최대값의 갯수만큼 0을 담은 indexes변수를 만든다
3. indexes에 나온 숫자에 자리에 +1이 쌓이게끔 for을 돌린다.

   for n in nums:
    indexes[n] = indexes[n] + 1

4. 반대로 최대값을 만든 객체에 indexes를 보내 maxNum을 활용해 어떤 숫자인지 찾음

자리수는 maxIdx(자리 값이 곧 숫자)를 호출, 빈도수는 maxNum(쌓인 포인트만큼이 빈도수)을 호출

해서 최대값을 2번 호출하여 사용하기에 class를 만들어 활용한다.

class MaxAlgorithm:
    def __init__(self,ns):
        self.nums = ns
        self.maxNum = 0
        self.maxNumIdx = 0
>
    def setMaxIdxAndNum(self):
        self.maxNum = self.nums[0]
        self.maxNumIdx = 0
>
        for i, n in enumerate(self.nums):
            if self.maxNum < n :
                self.maxNum = n
 >               self.maxNumIdx = i
>
    def getMaxNum(self):
        return self.maxNum
>
    def getMaxNumIdx(self):
        return self.maxNumIdx
>
nums = [1, 3, 7, 6, 7, 7, 7, 12, 12, 17]
>
maxAlo = MaxAlgorithm(nums)
maxAlo.setMaxIdxAndNum()
maxNum = maxAlo.getMaxNum()
print(f'num의 최대값: {maxNum}')
>
indexes = [0 for i in range(maxNum+1)]
>
print(f'indexes : {indexes}')
print(f'indexes 길이 : {len(indexes)}')
>
for n in nums:
    indexes[n] = indexes[n] + 1
print(f'indexes : {indexes}')
>
ma =MaxAlgorithm(indexes)
ma.setMaxIdxAndNum()
maxNum = ma.getMaxNum()
maxIdx = ma.maxNumIdx
>
print(f'따라서 {maxIdx}의 빈도수가 {maxNum}으로 가장 높다')

결과 출력

근사값

가장 가까운 값을 찾자!** (차이가 적은 숫자 찾기)** 절대값이 작은 숫자

import random
nums = random.sample(range(0,50),5)
print(f'nums : {nums}')
inputNum = int(input('input number : '))
print(f'input number : {inputNum} ')

nearNum = 0 minNum = 50

for n in nums: absNum = abs(n - inputNum) print(f'absNum : {absNum}')

if absNum < minNum:
    minNum = absNum
    nearNum = n

print(f'{nearNum} 근사값이다.')

>
결과 출력
>
<img src="https://velog.velcdn.com/images/auden_9/post/8d26b3e2-6ad5-4063-86cc-650f78d128cf/image.png">
>
**차이를 구하고 그 차이가 가장 적은 걸 최소값으로 담아 
최종 최소값의 자리번호인 n을 구함(근사값)**

---
# 평균

너무 자주 예제에서 썼던 평균
전체합
>```python
for n in nums:
    nums += n
>
total = 0
for n in nums:
    if n - int(n) == 0:
        total += n
        targetNums.append(n)

++) 실수는 if 조건 안에 n - int(n) != 0: 으로 끝

재귀

나 자신을 호출하자

1 .팩토리얼

def factorial(num):
    if num > 0:
        return num * factorial(num-1)
    else:
        return 1
>
print(f'factorial(10) : {factorial(10)}')

2. 유클리드 호제법 1) for문

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

   2) 재귀함수

   def gcd(n1, n2):
   >
    if n1 % n2 == 0:
        return n2
    else:
        return gcd(n2, n1 % n2)

하노이의 탑 (재귀 활용)

게임으로 많이 하던 하노이탑.... 유튜브로도 복습하는데 매개변수를 계속 바꿔가며 이동을 하는데 쉽지않아서 당분간 매일 봐야할듯...

def moveDisc(discCnt, fromBar, toBar, viaBar):                    # 원판 개수, 출발 기둥, 도착 기둥, 경유 기둥
    if discCnt == 1:
        print(f'{discCnt}disc: {fromBar}에서 {toBar}(으)로 이동!')

    else:
        moveDisc(discCnt-1, fromBar, viaBar, toBar)              # (discNo-1)개들을 경유 기둥으로 이동
        print(f'{discCnt}disc: {fromBar}에서 {toBar}(으)로 이동!') # discNo를 도착 기둥으로 이동
        moveDisc(discCnt-1, viaBar, toBar, fromBar)              # (discNo-1)개들을 도착 기둥으로 이동

moveDisc(3, 1, 3, 2)

병합 정렬 (재귀활용 2)

자료구조를 분할하고 각각의 분할된 자료구조를 정렬한 후 다시 병합하여 정렬

쪼개고 - 정렬 - 병합 - 다시 쪼개고 - 정렬 - 병합 (정렬이 끝날때 까지)

def mSort(ns):
    if len(ns) < 2:
        return ns

# 분할
midIdx = len(ns) // 2
leftNums = mSort(ns[0:midIdx])
rightNums = mSort(ns[midIdx:len(ns)])

mergeNums = []
leftIdx = 0; rightIdx = 0
while leftIdx < len(leftNums) and rightIdx < len(rightNums):
    if leftNums[leftIdx] < rightNums[rightIdx]:
        mergeNums.append(leftNums[leftIdx])
        leftIdx += 1

    else:
        mergeNums.append(rightNums[rightIdx])
        rightIdx += 1

mergeNums = mergeNums + leftNums[leftIdx:]
mergeNums = mergeNums + rightNums[rightIdx:]

return mergeNums

nums = [8, 1, 4, 3, 2, 5, 10, 6] print(mSort(nums))

동작원리를 log를 찍어보면
>
<img src="https://velog.velcdn.com/images/auden_9/post/5ca0252d-1a7e-4304-8e57-041355537ab5/image.png">



💡 응용문제서는 내림차순+ 오름차순
매개변수 asc=True값을주고 
재귀 호출될 시도 같은 값을 주기 위해
(인수, asc=asc)로 추가해줘야한다.
안그러면 한번 호출이면 기본값이 True로되어 숫자가 뒤섞임.


---
## 퀵정렬 (재귀 활용3)
기준보다 작은 값과 큰 값을 분리하다

>
**1. 기준값 정함 (인덱스 가운데)
2. 그 다음 그 기준 기준으로 작냐 크냐 가름
3. 그 다음 왼쪽 그룹도 가운데 정해서 크고 작냐 거름 - 나뉠때 까지 반복 (재귀)**
>
```Python
def qSort(ns):
>
    if len(ns) < 2:
        return ns
>
    midIdx = len(ns) // 2
    midVal = ns[midIdx]
>
    smallNums = []; sameNums = []; bigNums = []
>
    for n in ns:
        if n < midVal :
            smallNums.append(n)
        elif n == midVal:
            sameNums.append(n)
        else:
            bigNums.append(n)
>
    return qSort(smallNums) + sameNums + qSort(bigNums)

사이에 로그를 보기 위해서

    print(f'smallNums: {smallNums} ')
    print(f'sameNums: {sameNums} ')
    print(f'bigNums: {bigNums} ')
    return qSort(smallNums) + sameNums + qSort(bigNums)
>
nums= [8, 1, 4, 3, 2, 5, 4, 10, 8, 6]
>
print(f'퀵정렬: {qSort(nums)}')

위에를 return 직전에 추가하여

출력 결과 보기

💬 코멘트

...개념강의가 금방 끝난 재귀가 이렇게 눈덩이처럼 돌아올 줄이야. 병합정렬, 퀵정렬은 설명도 이해가 갔고 코드도 그리 어렵지 않게 받아들여졌다. 하노이탑....진짜 코드 배우기 이전에 재밌게하던 놀이가 코드로 오니까 지금 유튜브를 보고 ..아 조콤 알겠는데?? 하면서도 코드 다시보면 도루묵이라 이게 공부가 연계가 되고 그게 심화가 되니까 그냥 아 좀 알겠다로 넘길수가 없다.. 계속 들여다보면 또 전체적인게 안보일 수 있으니 매일 좀 보며 익숙해지는 수 밖에 없을 것..같다.....

버블정렬

맨 앞에 있는 숫자부터 인접한 숫자와 비교하여 점점 뒤로 보내는 정렬 뒤에 정렬부터 완성된다.

nums = [10, 2, 7, 21, 0]
print(f' not sorted nums: {nums}')

length = len(nums)-1

for i in range(length): for j in range(length-i): if nums[j] > nums[j+1]: nums[j], nums[j+1] = nums[j+1], nums[j] print(nums)

print()

print(f'sorted num : {nums}')

가장 쉬웠던 개념 1:1로 비교해서 더 크면 뒷자리랑 자리바꾸기

삽입 정렬

이미 정렬되어 있는 부분에** 내 위치를 찾아 들어가기!** 들어간 위치에서 앞에 있는 숫자들이랑 나를 비교하여 순서찾아감

nums = [15,10,2,1,0]

for i1 in range(1, len(nums)): i2 = i1 - 1 cNum = nums[i1]

while nums[i2] > cNum and i2 >=0 :
    nums[i2 + 1] = nums[i2]
    i2 -= 1

nums[i2 + 1] = cNum
print(f'nums: {nums}')

제일 이해가 늦었던 삽입정렬 버블정렬이랑 차이점을 몰라 헤멨는데 어디든 카드와 비유해서 설명이 되어있고 해도 이해 안가던걸 코드를 보면서 cNum을 어떠한 바가지라고 생각하고 크면 옮겨담는다고 계속 생각하면서 봤다. 그러자 이해가 점차 되었던 삽입정렬. 다른 정렬은 내 뒤에 숫자랑 비교한다면, 앞이랑 비교하니 더 헷갈렸던 것 같다.

선택정렬

가장 작은 데이터를 찾아 자리 바꾸자..!

nums = [4,2,5,1,3]
print(f'nums: {nums}')
>
for i in range(len(nums)-1):
    minIdx = i
>
    for j in range(i+1, len(nums)):
        if nums[minIdx] > nums[j]:
            minIdx = j
>
    nums[i],nums[minIdx] =  nums[minIdx],nums[i]
    print(f'nums: {nums}')

print(f'final nums: {nums}')


최소 값을 바가지(변수)에 담아 가장 작은 최소 값에 위치로 정렬.
첫번째 for문은 nums 안에 원소들의 반복
두번째 for문은 담아올 최소값을 비교하기 위한 반복
찾아오면 처음 i값과 최소값의 위치 바꿔치기

---

# 👀 다시보기


## 변수 바꿔 담기

>
1)
```python
temp = nums[j]
nums[j] = nums[j+1]
nums[j+1] = temp

2)

```python nums[j], nums[j+1] = nums[j+1], nums[j]

정렬 시 원본을 지키기 위해 기억해야하는 깊은 복사

1) 매개변수로 들어오자마자 복사

💬 코멘트

느꼈다. 요새 나에게 부족한건 절대적인 학습시간이라는거. 이제껏 했던 복습들이 더 시간을 들였어야 했다고 너무 느꼈다..

제로베이스에서 짜준 5시간이 짧다고 보이지만 깊은 학습까지는 +a 이다. 그리고 강의도 5시간이라 하지만 내가 이해하고 넘어가는 시간까지 하면 더 추가가 되고 복습은 다시 강의 듣는걸로 하는데 이걸로는 깊이있는 학습은 불가하다. 계속 째려보고 되짚어보고 검색을 통한 학습시간이 부족하다...................

그래서 주말에도 투자를 하고있는 실정인데, 개강OT서 나온 말처럼 아무래도 전공자의 4년을 축약하다보니 더 그런거겠지.. 넋두리 이만큼 정리한거 토대로 다시 코드를 째려보고, 따라쓰고 해봐야겠다.....😂😂😂

이진검색

순위검색

순서거르기 모듈

실행파일

선형 검색

말그대로 선형으로 나열되어 있는 데이터를 순차적으로 스캔하면서 원하는 값을 찾는다. 인덱스 0 부터 순차적으로 검색한다.

검색 성공 or 검색 실패

< 선형검색 기본코드>

datas = [3,2,5,7,9,1,0,8,6,4]
print(f'datas: {datas}')
print(f'datas length: {len(datas)}')
>
searchData = int(input('찾으려는 숫자입력: '))
searchResultIdx = -1
>
n = 0
while True:
    if n == len(datas):
        searchResultIdx = -1
        break
>
    if datas[n] == searchData:
        searchResultIdx = n
        break
    n += 1
>
print(f'searchResultIdx:{searchResultIdx}')

근데 여기서 또하나의 개념이 등장한다. 바로 보초법!!!!!! 보초법은 맨 끝에 판별할 수 있는 보초(문제에서는 사용자 입력 숫자)를 세워두고 그 숫자가 등장했을때 판단 없이 없다고 판별해줌!

그냥 들었을 때는 아니 어차피 끝까지가서 비교해주는 데, 결국 보초법도 보초한테까지 가는데 뭐가 다르다고??? 그렇게 검색을 한 결과 내 생각에는!

코드가 말해준다.

<보초법을 쓸 코드>

n = 0
while True:
    if datas[n] == searchData:
        if n != len(datas)-1:
            searchIdx = n
        break

!!!!!! 보초 하나로 while문이 이렇게 간결해질 수가 있다니...! (그래서 더 빠르다는 것)

위에 코드는 n과 search 데이터가 일치하면 True 근데 거기서 인덱스로는 마지막(len(datas)-1)이 올때까지 찾았다면 자료가 있으니까 True 없으면 False이기에 없는 거임.

위에보다 판단이 짧은 명령문으로 되어있기때문에 판독이 빠르다.

이진검색

다른 수강생분들도 그랬는지 모르겠지만 이진검색이 훨-씬 이해도 빠르고 그만큼 코드 이해도 금방 따라갔다.

이진검색이란?

★정렬되어★ 있는 자료구조에서 중앙 값과의 크고 작음을 이용해서 데이터를 검색한다.

중앙 값보다 작다 ↓ 그럼 다시 그 구간에서 중앙값과 비교 ↓ 검색될 때까지 반복

<이진검색 코드>

>
datas = [1,2,3,4,5,6,7,8,9,10,11]
>
print(datas)
print(len(datas))
>
searchData = int(input('searchData : '))
serachResultIdx = -1
>
staIdx = 0
endIdx = len(datas)-1
midIdx = (staIdx+endIdx) // 2
midVal = datas[midIdx]
>
print(f'midIdx : {midIdx}')
print(f'midVal : {midVal}')
>
while searchData <= datas[len(datas)-1] and searchData >= datas[0]:
    if searchData == datas[len(datas)-1]:
        serachResultIdx = len(datas)-1
        break
>
    if searchData > midVal:
        staIdx = midVal
        midIdx = (staIdx+endIdx) // 2
        midVal = datas[midIdx]
        print(f'midIdx : {midIdx}')
        print(f'midVal : {midVal}')
>
    elif searchData < midVal:
        endIdx = midIdx
        midIdx = (staIdx+endIdx) // 2
        midVal = datas[midIdx]
        print(f'midIdx : {midIdx}')
        print(f'midVal : {midVal}')
>
    elif searchData == midVal:
        serachResultIdx = midIdx
        break
>
print(f'serachResultIdx:{serachResultIdx}')
>
staIdx = 0
endIdx = len(datas)-1
midIdx = (staIdx+endIdx) // 2
midVal = datas[midIdx]

4가지 개념을 잘만 이해하면 다른건 따라온다. 시작값, 끝값, 중간값의 인덱스, 중간값 설정

+++ 내가 쉽게 놓치는 while문의 조건부 searchData <= datas[len(datas)-1] and searchData >= datas[0] 찾는 데이터가 그 리스트 안에서만 돌 수 있게 명시하는 부분 datas[len(datas]-1] 끝과 같거나 작을때 그리고 datas[0] 처음보다는 크거나 같을때 조건식 안으로 들어온다!

순위 검색

수의 크고 작음을 이용해서 수의 순서를 정하는 것을 순위라고 한다. 자료구조 내부에 있는 데이터끼리 비교를 해서 인덱스를 하나씩 올려줘서 순위를 매김. 개념은 쉬운데, 이렇게 활용해서 순위를 매길 수 있구나 놀랬다.

import random
>
nums = random.sample(range(50,101),20)
ranks = [0 for i in range(20)]
>
print(nums)
print(ranks)
>
for idx, num1 in enumerate(nums):
    for num2 in nums:
        if num1 < num2:
            ranks[idx] += 1

**ranks = [0 for i in range(20)]**

변수 담기를 for문을 이용할 수 있음..! rank는 점수를 담기위한 변수그릇 (활용도 上)★★

if num1 < num2:
    ranks[idx] += 1

비교하여 작으면 idx값을 하나먹여 (마치 랭크의 순위가 올라가듯) 뒤로 보냄 데이터를 담는 곳과 순서 담는 곳을 달리해서 순서매김

💬 코멘트

제로베이스 데이터취업반 3주차 알고리즘..! 유튜브 알고리즘만 듣던 나에게는 새롭고도 어려운 개념이였다. 그래도 제로베이스의 장점이라함은 개념수업과 실습수업이 나뉘어서 한번 더 활용이 들어간다는 것.

그래도 오늘은 생소한 개념의 이야기라 거의 따라쓰는 건 고사하고 이해없이 떠밀려가다간 더 크게 넘어질 수 있겠다 싶어. 목표 수강치는 다 듣고 복습을 좀 나눴다. 이해 안되는건 추가 검색도 해가면서 이제야 조큼 큰 구조내에서 오늘 배운게 이렇게 나뉘는 거구나 싶었다. (그래도..더 깊은 이해를 위해 토요일에는 정렬을 좀 더 공부해야지)

변수를 한번에 여러개 생성할때 group1,group2,group3,group4,group5 = 0,0,0,0,0 이런식으로 가능

리스트 반복하여 추가

friend[0] = 유재석
>
for n in range(5):
    friend.append(input('친구 이름: '))

내부 컨테이너 있을 시 조회방법

for s1 in scores :
    for s2 in s1 :
        total += s2

튜플로 된 딕셔너리를 분해하여 조회

for idx, dic in enumerate(studentCnt):
    for k, v in dic.items():
        total = total + v

딕셔너리 생성

subject = ['국어','영어','수학','과학','국사']
scores = {}
>
for s in subject:
    score = input(s+'점수 입력: ')
    scores[s] = score
>
print(f'과목별 점수 : {scores}')

중복숫자 제거

number = [2,22,7,8,9,2,7,3,5,2,7,1,3]
print(f'number : {number}')
>
idx = 0
while True:
    if idx >= len(number):
        break
>
    if number.count(number[idx]) >= 2:
        number.remove(number[idx])
        continue
>
    idx += 1
>
print(f'number: {number}')

가장 간결히 해결해서 놀랐던 합집합, 교집합 문제

tuple1 = (1,3,2,6,12,5,7,8)
tuple2 = (0,5,2,9,8,6,17,3)
>
tempHap = list(tuple1)
tempGyo = list()
>
for n in tuple2:
    if n not in tempHap:
        tempHap.append(n)
>
    else:
        tempGyo.append(n)
>

자료 생성 후 삭제

members = {}
n = 1
while n < 4:
    mail= input('아이디 입력: ')
    pw = input('비밀번호 입력: ')
>
    if mail in members:
        print('이미 사용 중인 메일 계정입니다.')
>
    else:
        members[mail] = pw
        n+=1
>
for key in members.keys():
    print(f'{key} : {members[key]}')
>
while True:
    delMail = input('삭제할 메일주소 : ')
    if delMail in members:
        delPw = input('비번입력: ')
        if members[delMail] == delPw:
            del members[delMail]
            print('삭제되었습니다.')
            break
        else:
            print('비밀번호 오류')
>
    else:
        print('계정을 확인해주세요.')
>
for key in members.keys():
    print(f'{key} : {members[key]}')

💬 코멘트

딕셔너리가 가장 활용도도 좋은 컨테이너 구조인데 활용만 들어가면 왤케 이해를 못하고 허덕이고 있을까.. 한번씩 다시 써보고 자야겠다..!

리스트와 비슷하지만 아이템 변경 불가!!!!

선언은 () *구분은 *,

리스트와 같이 숫자, 문자, 논리형 등 모든 기본 데이터를 같이 저장할 수 있다. 튜플에 또 다른 컨테이너 자료형 데이터를 저장할 수 있다.

다만, 아이템 변경불가..!

아이템 조회

튜플도 리스트와 같이 인덱스 조회가 가능. ** 0부터 인덱스가 붙음**

in, not in

in 존재하면 True , 없으면 not in not in 존재하면 False, 없으면 in

아이템 외에 문자열에서 글자찾기도 가능함! (대소문자까지 구분함)

random 모듈에 sample함수는 리스트로 결과값을 냄. sample(range(),몇가지)

튜플 길이 len()

for문(or while문)과 만나 range에 들어가 아이템 조회가 가능함

튜플 결합

extend() 는 튜플은 형태변환이 불가해서 사용 못함. XXXX 튜플은 변경이 불가한데, 확장은 원래 갖고있는 튜플에 추가되기에 불가.

*+덧셈결합만 가능. A + B = C * C 는 원본과 다른 변수기에 가능!

vegetables = ('토마토','가지','애호박','당근','감자','양파')
fruits = ('딸기','블루베리','키위','망고','포도','바나나')
print(vegetables)
print(fruits)

basket = vegetables + fruits

print(basket)

💻출력

(number, ) -> 튜플로 저장하기..!

슬라이싱

[n:m] n부터 m-1까지 뽑아낼 수 있음!

💻출력

맨 위 print 값 무시하고 2번째 print부터의 출력값은 인덱스 2부터 3까지 출력 인덱스 처음(0)부터 3까지 출력 인덱스 4부터 끝까지 출력 인덱스 2부터 뒤에서 3자리까지 출력 인덱스 뒤에서 5자리서부터 뒤에서 3자리까지 출력

• 단계도 설정 가능 [시작점:끝점:단계]

슬라이싱으로 아이템 변경 불가 리스트에 있는 아이템을 튜플형태의 변경은 가능..!

튜플명(slice(시작,끝)) 시작부터 끝 미만까지

튜플은 선언시 괄호 생략 가능!!! vegetables = ('토마토','가지','애호박','당근','감자','양파') 와 vegetables = '토마토','가지','애호박','당근','감자','양파' 같은 튜플임

+++ 자료형 변환

정렬이 필요하거나 할때 리스트로 타입변환하여 적용 후 다시 튜플로 변환.

리스트 -> 튜플 vegetables = tuple(vegetables)

튜플 -> 리스트 vegetables = list(vegetables)

정렬 시 리스트로 변환 후 sort(), sort(reverse=True)

+) sorted() 함수로 튜플도 오름차순 정렬이 가능함! 내장함수라 바로 sorted(튜플명) 그러나 결과값은 리스트 자료형으로 반환해서 출력됌.

튜플과 for문 - 이 이후로는 list의 for문과 내용이 동일.

for i in range(len(fruits)):
    print(fruits[i])


for fruit in fruits:
    print(fruit)

내부 컨테이너가 있을 시에

students = (1,19), (2,20), (3,22), (4,18), (5,21),

방법 1> 
for i in range(len(students)):
    print('{}학급 학생수: {}명'.format(students[i][0],students[i][1]))

방법2>
for classNo, cnt in students:
    print('{}학급 학생수: {}명'.format(classNo,cnt))

튜플과 while문으로 아이템 조회

첫번째) len활용

n = 0
while n < len(튜플명):
    print(cars[n])
    n += 1


두번째 ) flag변수

n = 0
flag = True

while flag:
    print(cars[n])
    n += 1

    if n == len(cars):
        flag = False


세번째 ) break

n = 0
while True:
    print(cars[n])
    n += 1

    if n == len(cars):
        break

딕셔너리 {키:값}

키(key)와 값(value)를 이용해서 자료를 관리한다. 키는 인덱스의 개념과 같은데, 키는 작성자가 정함

딕셔너리는 키와 구분하는 유일한 값이기때문에, 키는 중복안됌. (값은 가능)

선언은** {}** 구분은 키:값 형태로 들어간다.

키값으로 아이템 호출함

key와 value에는 숫자, 문자(열), 논치형 뿐만 아니라 컨테이너 자료형도 올 수 있다.

단 key에는 변경 불가의 데이터만 올 수 있다. 변경 가능할만한 것은 안된다 ( 튜플 가능, 리스트는 불가)

키값을 이용해 조회하자!

딕셔너리명['키 값']

없는 키 값을 찾으면 에러가 발생함

get()

딕셔너리명.get('키값') 없는 키 값을 찾으면 none을 내보냄

ㅡ

딕셔너리추가

딕셔너리명['key값'] = 'value값'

추가하려는 키 값이 이미 있다면 기존 값이 수정된다.

keys() 와 Value

keys() 전체 key를 리스트 형식으로 출력 리스트 형식으로 나오고 type은 dict_keys 라고 나옴

values() 전체 value값을 리스트 형식으로 출력 리스트 형식으로 나오고 type은 dict_value 라고 나옴

items() 키와 value를 튜플 형식으로 출력 튜플 형식으로 나오고 type은 dict_items라고 나옴

for key in myInfo.keys(): print(f'{key}: {myInfo[key]}')

del 딕셔너리명['키값']

해당 아이템 삭제됌

딕셔너리명.pop('키값')

해당 아이템 삭제됌

★ pop은 함수라 버린 값을 출력하면 볼수 있음!

in, not in

키 값 기준으로 있는지 없는지 판단

len()

딕셔너리 길이(아이템개수)를 알아 낼수 있따.

clear()

모든 아이템을 삭제한다. 딕셔너리명.clear()

자료구조란? 여러 개의 데이터가 묶어있는 자료형을 컨테이너 자료형이라고 하고, 이러한 컨테이너 자료형의 데이터 구조를 자료구조라고 한다.

데이터를 묶어 관리하는 것. 보통 담는 변수가 여러가지라 변수명을 복수명으로 적어주면 관리에 좋음.

리스트

배열과 같이 여러 개의 데이터를 나열한 자료구조. 데이터는 ** , ** 로 구분한다 데이터 하나하나는 요소, element, item이라 한다.

리스트 안에 데이터가 섞어서도 넣을 수 있음. strs = [3.14, '십', 20, 'one']

컨테이너 안에 또 따른 컨테이너가 들어갈 수 있음. datas = [10,20,30, [40,50,60] ]

리스트는 출력 시 print('students : {}'.format(students))

students : ['알라딘', '자스민', '이아고', '자파']

**[ ]안에 담겨서 나온다. **

아이템 조회

인덱스

리스트 안에 들어가있는 데이터에 자동으로 부여되는 번호표 번호표는 0번부터 부여된다.

데이터를 담은 변수는 list라 나오지만 그 요소 하나는 성격에 맞는 걸로 나옴 글자면 str, 정수면 int ..

• 리스트의 길이 == 아이템 갯수 len()을 이용하여 리스트 변수를 담아주면 됌. len()을 이용하여 for문 range에 담을 수 있음.

리스트 조회

1. for문

for i in range(len(mySport)):
    print('mySport[{}]: {}'.format(i,mySport[i]))

2. while문

n = 0
while n < len(mySport):
    print('mySport[{}]: {}'.format(n,mySport[n]))
    n += 1

3. item

for item in mySport:
    print(item)

내부 리스트

studentCnts = [[1,19], [2,20], [3,22], [4,18], [5,21]]

for classNo, cnt in studentCnts:
    print('{}학급 학생수: {}'.format(classNo,cnt))

** classNo는 1,2,3,4를 가리킴 cnt는 19,20,22,18를 가리킴**

• 출력값

  1학급 학생수 : 19
  2학급 학생수 : 20
  3학급 학생수 : 22
  4학급 학생수 : 18
  5학급 학생수 : 21

  내부리스트 조회

1. for문을 활용하여 idex 출력

   minScore = 60
   scores = [['국어',58],
          ['영어',77],
          ['수학',89],
          ['과학',99],
          ['국사',50]]
   

for item in scores: if item[1] < minScore: print('과락 과목: {}, 점수: {}'.format(item[0],item[1]))

for subject, score in scores: if score < minScore: print('과락 과목: {}, 점수: {}'.format(subject, score))

for subject, score in scores: if score >= minScore: continue print('과락 과목: {}, 점수: {}'.format(subject, score))

-----출력 과락 과목: 국어, 점수: 58 과락 과목: 국사, 점수: 50

2. while문 활용하여 idex 출력
```python
minScore = 60
scores = [['국어',58],
          ['영어',77],
          ['수학',89],
          ['과학',99],
          ['국사',50]]
n = 0
while n < len(scores):
    if scores[n][1] < minScore:
        print('과락 과목: {}, 점수: {}'.format(scores[n][0],scores[n][1]))
    n += 1

---

n = 0
while n < len(scores):
    if scores[n][1] >= minScore:
        n += 1
        continue

    print('과락 과목: {}, 점수: {}'.format(scores[n][0], scores[n][1]))
    n += 1


---
n = 0
while True:
    print(cars[n])
    n += 1

    if n == len(cars):
        break

```

+ ) 007 예제~!
while문은 변수를 이용하여 전체학급수를 구함

---
## enumerate() 함수 ★
```python
sports = ['탁구','배구','양궁','축구','테니스']


for idx, value in enumerate(sports):
    print('{} : {}'.format(idx, value))

-----출력

0 : 탁구
1 : 배구
2 : 양궁
3 : 축구
4 : 테니스

리스트 외에 문자열에도 사용 가능

아이템 추가 .append()

리스트명.append('아이템')

리스트에 맨 마지막에 들어가게된다!

예시코드

추가 아이템 위치 지정: insert(자리위치,'아이템')

사이에 들어가면 그 뒤에 아이템들은 index자리수가 하나씩 추가된다.

예시코드

아이템 삭제 : pop()

마지막 인덱스에 해당하는 아이템 삭제 기본자리는 마지막 자리 자리 지정하고싶으면 자리번호 넣으면 됌!

<기본>

아이템 삭제 2 : remove('아이템')

1가지 아이템을 삭제하려면 리스트명.remove('아이템') 삭제하려는 데이터가 2개 이상이면 while문을 이용하자

'아이템 ' in 리스트 리스트 안에 아이템이 있으면 True

리스트연결

확장 extend()

리스트에 또 다른 리스트를 연결(확장) 할 수 있다.

vegetable = ['감자','토마토','애호박']
fruit = ['수박','딸기','바나나']

['감자','토마토','애호박'] extend() ['수박','딸기','바나나']

vegetable.extend(fruit)

vegetable = ['감자','토마토','애호박','수박','딸기','바나나']

### + 덧셈연산자
덧셈연산자를 이용해서 리스트를 연결할 수도 있다.

**A리스트 + B 리스트 = C리스트    **
>
```python
result = students1 + students2
>
reslut :['알라딘', '자파', '자스민', '이아고', '자파', 
        '아부', '자파', '버즈', '우디', '포키', '햄', '포테이토헤드']

리스트 아이템 정렬

오름차순으로 정렬: sort()

내림차순으로 정렬: sort(reverse=True)

<예시 코드>

korea = ['가','다','바','마','라','나']
print('한글: {}'.format(korea))

korea.sort() print('오름차순 정렬: {}'.format(korea))

korea.sort(reverse=True) print('내림차순 정렬: {}'.format(korea))

💻출력

아이템 순서 뒤집기: reverse()

students = ['버즈','우디','포키','햄','포테이토헤드']
print('정렬 : {}'.format(students))

students.reverse()
print(f'뒤집기: {students}')

💻출력

리스트 슬라이싱

원하는 아이템 뽑아내기

리스트명 [n:m] 인덱스 n 이상 m 미만까지 추출함

리스트명 [:m] 인덱스 처음부터 m미만까지 추출

• 음수값까지 지정됌. (뒤에서부터 간다)

문자열도 슬라이싱 가능함! str = '가나다'

슬라이싱 단계를 정할 수도 있다.

members = ['토끼','강아지','고양이','병아리','말','송아지']
print('member:{}'.format(member[1:5:2]))

인덱스 1~5는 ['강아지', '고양이', '병아리', '말'] 이지만 추출은 2씩 건너뛴 강아지, 병아리만 추출됌

아이템 변경

numbers = [1,2,3,4,5]
print(numbers)
print('일부분: {}'.format(numbers[1:3]))
numbers[1:3] = ['two','three','four']
print(numbers)

💻출력

+ 슬라이싱 갯수가 모자라면 끝부분 그대로 잘림

slice()함수 변수명[slice(시작자리,끝자리)]

💬 코멘트

파이썬 기초공부만큼이나 재밌었던 수업이였다. 실습도 하나하나 다 따라하다보니 시간이 금세가서 놀랐지만..! 재밌었던 만큼 활용도가 높은 기본기 수업이라 잘 다져놔야겠다👊👊👊

오늘은 문제풀이의 날이라 코드 위주의 학습이였다. 다시 한번보며 상기시킬 코드들 적었다.

1. 약수 and 소수 and 소인수 한번에 구하기.

변수를 담아 숫자를 추가하여 조건문을 달아 소인수 구해내기 (약간 포인트 쌓는 게임같아서 재밌었다. 이렇게도 활용할 수 있다는게 참 파이썬은 활용하는 것에 따라 무궁무진하구나)

2. 소인수분해하여 지수 담아내기

자료구조에서 나올 리스트에 담아 append()와 count()과 tempNum 변수를 활용하여 지수 뽑아냄..!

💬 코멘트

아직 기본 개념 정립에도 여념이 없음에도 쉽게 활용하여 코드를 짜는걸 보면 난 언제 그 수준에 도달할 수 있을까 생각하게 된다. 할 수 있는건 묵묵히 기본을 다하는 것 (그래도 잘하고싶다😂😂)

오늘은 1주차 첫 팀스터디도 있는 날이라 조큼 정신이 없었다. 우리 팀원분들은 미팅 시각 정할 때도 느꼈지만 빠르게 반응하고, 열심히이다(팀을 잘만난 것 같다😊) 그게 발표시간에도 드러나 가장 미흡했던 내가 배울 점이 참 많아 의미있는 시간이였다.

제로베이스가 비대면 학습이라 아무래도 지루할 수 있고 쉽게 그만둘 수 있는데. 모니터링을 잘 하고 연구한 덕인지 서로 독려하며 나아갈 수 있게끔한 좋은 시스템이라고 느꼈다. 더 의미있는 시간을 위해 건의사항을 낸게 있었는데, 모두 적극 수용해주셔서 감사했다. 다음주엔 나도 좀 침착하게 발표했음 좋겠다👊