Beautiful Soup

• HTML과 XML 문서들의 구문을 분석하기 위한 파이썬 패키지

  from bs4 import BeautifulSoup
  

page = open("../data/test.html", "r").read() soup = BeautifulSoup(page, "html.parser")

print(soup.prettify())

태그 검색(지정된 태그 중 첫번째 항목만 검색)

soup.find("p")

태그 검색(지정된 태그 전부 검색)

soup.find_all("p")

class 속성의 경우 예약어이므로 형태를 달리해야함

soup.find_all(class_="outer-text")

### urllib
- 웹주소에 접근 시 필요

from urllib.request import urlopen

url = "https://finance.naver.com/marketindex/" page = urlopen(url)

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

### Regular Expression
- 특정한 규칙을 가진 문자열의 집합을 표현하는데 사용하는 형식 언어
![](https://velog.velcdn.com/images/kimse_1225/post/e6272acf-ab2d-45f8-985b-399b16bb66cc/image.png)

import re

tmp_str = tmp_one.find(class_="sammyListing").get_text() re.split(("\n|\r\n"), tmp_str)

...

tmp = re.search("$\d+.(\d+)?", price_tmp).group() print(price_tmp[len(tmp) + 2:])

### 웹페이지 추출 반복

price = [] address = []

기존 방식대로 코딩하였다면 이런식으로 했을수도?...

데이터프레임의 행 정보를 index 값의 바탕으로 반복

for n in df.index: req = Request(df["URL"][n], headers={"User-Agent":"Mozilla/5.0"}) html = urlopen(req).read()

soup_tmp = BeautifulSoup(html, "lxml")
...

데이터프레임의 iterrows() 활용 행 정보 추출

tqdm : 반복문의 진행율을 프로그레스 바 형태로 표현

for idx, row in tqdm(df.iterrows()): req = Request(row["URL"], headers={"User-Agent":"Chrome"}) html = urlopen(req).read()

soup_tmp = BeautifulSoup(html, "lxml")

1. 데이터 정의 언어 (DDL : Data Definition Language)

   • create, alter, drop 등

2. 데이터 조작 언어 (DML : Data Manipulation Language)

   • select, insert, update, delete 등

3. 데이터 제어 언어 (DCL : Data Control Language)

   • grant, revoke, commit, rollback 등

권한관리

• grant, revoke

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

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

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

### UNION
여러 개의 SQL문을 합쳐서 하나의 SQL문으로 만들어주는 방법
(합치는 SQL문의 컬럼 개수 같아야 함)
 - union : 중복된 값을 제거
 - union all : 중복된 값 포함

select * from test1 union (all) select * from test2;

### JOIN
두 개 이상의 데이블을 결합하는 방법
 - inner join, left join, right join, full outer join
 - self join
![](https://velog.velcdn.com/images/kimse_1225/post/371fb798-207b-4c38-b1a3-5f91b5806274/image.png)

inner join

select column1, column2 from tableA inner join tableB on tableA.column = tableB.column where condition;

left join

select column1, column2 from tableA left join tableB on tableA.column = tableB.column where condition;

right join

select column1, column2 from tableA right join tableB on tableA.column = tableB.column where condition;

full outer join

select column1, column2 from tableA full outer join tableB on tableA.column = tableB.column where condition;

self join

select column1, column2 from tableA, tableB where condition;

### Primary Key (기본키)
 - 테이블의 각 레코드를 식별
 - 중복되지 않은 고유값을 포함
 - Null 값 허용 안됨
 - 테이블 당 하나의 기본키를 가짐

### Foreign Key (외래키)
 - 한 테이블을 다른 테이블과 연결해 주는 역할
 - 참조되는 테이블의 항목은 그 테이블의 기본키

### Aggregate Functions (집계함수)
 - count, sum, avg, min, max, first, last

### Having
조건에 집계함수가 포함되는 경우 where절 대신 having 사용

select column1, column2, ... from table where condition group by column1, column2 having condition (Aggregate Functions) order by column1

### Sub Query
 - 하나의 SQL문 안에 포함되어 있는 또 다른 SQL문을 말함
 - 메인쿼리가 서브쿼리를 포함하는 종속적인 관계
 - Sub Query는 괄호로 묶어서 사용
 - 단일행 혹은 복수행 비교 연산자와 함께 사용 가능
 - Sub Query에서는 order by를 사용 안 함

Scalar Sub Query (select절에 사용)

select column1, (select column2 from table2 where condition) from table1 where condition;

Inline View (from절에 사용)

select a.column, b.column from table1 a, (select column1, column2, from table2) b where condition;

Nested Sub Query (where절에 사용)

# Single Row : 하나의 열을 검색하는 서브쿼리

# Multiple Row : 하나 이상의 열을 검색하는 서브쿼리

# Multiple Column = 하나 이상의 행을 검색하는 서브쿼리

```

1. Pandas Pivot Table

피벗 테이블이란 많은 양의 데이터에서 필요한 자료만을 뽑아 새롭게 테이블을 작성해 주는 기능

import pandas as pd

crime_raw_data = pd.read_csv("../data/02. crime_in_Seoul.csv", thousands=",", encoding="euc-kr")

crime_station = crime_raw_data.pivot_table(
    crime_raw_data,
    index="구분",
    columns=["죄종", "발생검거"],
    aggfunc=[np.sum]
)

crime_station.head()

2. Google Maps

import googlemaps

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

count = 0

for idx, rows in crime_station.iterrows():
    station_name = "서울" + str(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
    crime_station.loc[idx, "구별"] = tmp_gu.split()[2]

    count = count + 1

crime_station.head()

서울시 범죄현황 데이터 시각화

1. seaborn

파이썬 데이터 시각화 라이브러리

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

font_path = "../../ds_study/malgun.ttf"
font = font_manager.FontProperties(fname=font_path).get_name()
rc('font', family=font)

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

2. Folium

파이썬 지도 시각화 라이브러리

crime_anal_station = pd.read_csv("../data/02. crime_in_Seoul_1st.csv", index_col=0, encoding="utf-8")

col = ["살인검거", "강도검거", "강간검거", "절도검거", "폭력검거"]
tmp = crime_anal_station[col] / crime_anal_station[col].max()
crime_anal_station["검거"] = np.mean(tmp, axis=1)
crime_anal_station.head()

my_map = folium.Map(location=[37.5502, 126.982], zoom_start=11)

for idx, rows in crime_anal_station.iterrows():
    folium.CircleMarker(
        [rows["lat"], rows["lng"]],
        radius=rows["검거"] * 50,
        popup=rows["구분"] + " : " + "%.2f" % rows["검거"],
        color="#3186cc",
        fill=True,
        fill_color="#3186cc"
    ).add_to(my_map)

my_map

※ 본 블로그에서 사용된 코드는 제로베이스 수업 자료에서 참고하였습니다.

선형검색

• 선형으로 나열되어 있는 데이터를 순차적으로 스캔하면서 원하는 값을 찾는 방법

이진검색

• 정렬되어 있는 자료구조에서 중앙값의 크고 작음을 이용해서 데이터를 검색하는 방법

버블정렬

• 처음부터 끝까지 인접하는 인덱스의 값을 순차적으로 비교하면서 큰 숫자를 가장 끝으로 옮기는 알고리즘

삽입정렬

• 정렬되어 있는 자료 배열과 비교해서, 정렬 위치를 찾음

선택정렬

• 주어진 리스트 중에 최소값을 찾아, 그 값을 맨 앞에 위치한 값과 교체하는 방식으로 자료를 정렬하는 알고리즘

병합정렬

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

퀵정렬

• 기준 값보다 작은 값돠 큰 값으로 분리한 후 다시 합침

List

# 여러 개의 데이터를 나열한 자료구조
company = ['samsung', 'LG', 'Kia', 'Lego']

print(company[1])
--------------------------------------------
LG

# len() : 리스트 길이 반환
len(company)

# for 문
for i in range(len(company)):
    print(company[i])

for item in company:
    print(item)

# append() : List 마지막에 item 추가
# insert(i) : 특정 index에 item 추가
# pop() : List 마지막 item 삭제
# pop(i) : index에 해당하는 item 삭제
# remove(v) : 특정 item 삭제

# extend() : List 연결
extendList = a.extend(b)

# sort() : 정렬(디폴트 오름차순)
# sort(reverse=True) : 정렬(내림차순)

Tuple

# List와 유사하지만 item 변경이 불가능함
# 추가, 삭제, 변경 불가능
company = ('samsung', 'LG', 'Kia', 'Lego')

# Tuple은 변경이 불가능하기 때문에 정렬도 불가능
# sorted()를 사용하면 정렬이 가능하나 List Type으로 반환

Dictionary

# key, value를 이용해서 data 관리
grade = {'kor':90, 'mat':95, 'eng':80}

# key 중복 허용 안함
# 추가하려는 key가 존재하면 기존 key를 대체함

# key 값이 존재하지 않으면 조회 시 에러 발생
for key in grade.keys():
    print(f'{key}: {grade[key]}')

# key 값이 존재하지 않아도 에러 발생 하지 않음 : None
grade.get('kor')

grade.keys()
grade.values()
grade.items()

# 삭제
del grade['eng']
grade.pop('mat')

# 모든 아이템 삭제
grade.clear()

Set

# Set 자료형은 중복을 허용하지 않음
number = {100, 90, 80, 70}

파일 열기

• open()
• 'w' : 쓰기 전용 (파일이 존재하면 덮어 씌움)
• 'a' : 쓰기 전용 (파일이 존재하면 덮붙임)
• 'x' : 쓰기 전용 (파일이 존재하면 에러 발생)
• 'r' : 읽기 전용 (파일이 존재하지 않으면 에러 발생)

  파일 쓰기

• write()
• writelines()

  파일 읽기

• read()
• readlines()
• readline()

  파일 닫기

• close()

path = 'D:/test/'

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

    file.close()

inputNumber = int(input("0보다 큰 정수 입력: "))
for number in range(2, (inputNumber + 1)):
    flag = True
    for n in range(2, number):
        if number % n == 0:
            flag = False
            break

    if (flag):
        writePrimeNumber(number)

• 객체를 생성하면 해당 class의 생성자를 호출
• 생성자는 개발자가 작성하는 것이 아닌 내부적으로 자동 생성
• 생성자는 class 내부의 init 함수를 호출

오버라이딩(overriding)

• 상위 클래스의 함수를 재정의 하기 위해 사용

추상클래스

• 상위 클래스에서 하위 클래스에게 함수 구현을 강요
• 추상 클래스에서 뼈대를 잡아 놓았다면 추상 클래스를 상속하는 하위 클래스는 살을 붙여주는 역할

  from abc import ABCMeta
  from abc import abstractmethod
  

class Airplane(metaclass=ABCMeta):

@abstractmethod
def flight(self):
    pass

class Airliner(Airplane):

def flight(self):
    print('go away....')

#### 예외
- 프로그램 실행 중 발생하는 예상치 못한 문제
- ZeroDivisionError
- IOError
- IndexError
- 등등

#### 예외처리 구문

try: pass except: pass

try: pass except(Exception as e): pass
```

• 코드 재사용 및 모듈화에 좋음

class

class Airplane:

    def __init__(self, type, company):
        self.type = type
        self.company = company

    drf info(self):
        print(f'항공사 : {self.company}, 기종 : {self.type}')

    def doFlying(self):
        print('Flying.....')

    def doLanding(self):
        pint('Landing....')

ap1 = Airplane('380', 'korean air')

ap1.info()
ap1.doFlying()

------------------------------------------------------------------
항공사 : korean air, 380
Flying.....
------------------------------------------------------------------

얕은 복사, 깊은 복사

• 얕은 복사 : 객체 주소를 복사하는 것으로 복사된 객체의 값을 변경 시 원본 객체의 데이터도 변경됨
• 깊은 복사 : 객체 자체를 복사하는 것으로 새로운 객체가 생성됨

  arrNum = [10, 4, 6, 2, 5, 7]
  

copy1 = arrNum copy2 = arrNum.copy()

print(arrNum)

copy1[1] = 8 print(arrNum) print(copy1)

copy2[2] = 12 print(arrNum) print(copy2)

[10, 4, 6, 2, 5, 7] [10, 8, 6, 2, 5, 7] [10, 8, 6, 2, 5, 7] [10, 8, 6, 2, 5, 7] [10, 4, 12, 2, 5, 7]

#### 상속
- 자식 클래스는 부모 클래스의 기능을 사용 가능

class Parents():

def add(self, num1, num2):
    return num1 + num2

def sub(self, num1, num2):
    return num1 - num2

class Child(Parents):

def mul(self, num1, num2):
    return num1 * num2

def div(self, num1, num2):
    return num1 / num2

cal = Child() print(f'sum : {cal.add(10, 20}') print(f'mul : {cal.add(10, 20}')

30 200

```

내장함수

input()            # 데이터 입력
print()            # 데이터 출력

사용자함수

def calculator(num1, num2):
    print(f'Sum : {num1 + num2}')

    return num1 + num2

sum = calculator(10, 20)

모듈

내부모듈

• 파이썬 설치 시 기본 제공

  외부모듈

• 별도의 설치 과정을 통해 사용 가능

  사용자모듈

• 사용자가 직접 만든 모듈

import math                    # 내부모듈
import pandas as pd            # 외부모듈
import calculator as cal    # 사용자모듈

import operator as op

num1 = 10
num2 = 25

# 산술 연산
op.add(num1, num2)
op.sub(num1, num2)
op.mul(num1, num2)
op.truediv(num1, num2)
op.mod(num1, num2)
op.floordiv(num1, num2)
op.pow(num1, num2)

# 비교 연산
op.eq(num1, num2)
op.ne(num1, num2)
op.gt(num1, num2)
op.ge(num1, num2)
op.lt(num1, num2)
op.le(num1, num2)

# 논리 연산
op.and_(num1, num2)
op.or_(num1, num2)
op.not_(num1, num2)

조건문

• if
• if ~ else
• if ~ elif

반복문

• for

  for i in range(10):
  for i in range(0, 10):
  for i in range(0, 10, 2):

• while

• continue : 반복문에서 continue를 만나면 이하 코드 생략 후 다음 반복 실행

• break : 반복문에서 break를 만나면 반복문 종료

strData = input("문자 입력")
numInt = input("정수 입력")
numFloat = input("실수 입력")

데이터 출력

print('Age : ', age)
print('Age : ', age, ', Sex : ', sex)

print(f'Name : {name}')
print(f'Name : {name}, Age : {age}')

print('Name : {}'.format(name))
print('Name : {}, Age : {}'.format(name, age))

print('Name : %s, Age : %d' % (name, age))

print('Pi : %.4f' % 3.141592)        # 3.1416

나머지와 몫을 구하는 함수

rtnValue = divmod(15, 4)
print(rtnValue)            # (3, 3)

import matplotlib.pyplot as plt
from matplotlib import rc, font_manager

# 폰트 경로는 자신에 맞게 수정 필요
font_path = "../../ds_study/malgun.ttf"
font = font_manager.FontProperties(fname=font_path).get_name()
rc('font', family=font)

0. 기본 함수

   # 데이터프레임 기본 정보 확인
   df.info()
   

데이터프레임 기술통계정보 확인

df.describe()

![](https://velog.velcdn.com/images/kimse_1225/post/896a75b1-2455-4c7b-89bf-9b7b9eaeb2c1/image.png)

1. 컬럼명 변경

CCTV_Seoul.rename(columns={CCTV_Seoul.columns[0]: "구별"}, inplace=True)

inplace=True 를 지정하면 데이터프레임에 바로 적용. 아래의 코드와 동일한 결과

CCTV_Seoul = CCTV_Seoul.rename(columns={CCTV_Seoul.columns[0]: "구별"})

여러 컬럼 동시에 변경 가능

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 )

2. 정렬

CCTV_Seoul.sort_values(by="소계", ascending=True).head()

3. 병합

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

- how : inner(디폴트), left, right, outer


4. 삭제

del data_result["2014년"]

drop은 axis이 지정되어야 함

data_result = data_result.drop(["2015년", "2016년"], axis=1)

5. 인덱스 변경

data_result.set_index("구별", inplace=True)

### matplot
1. Numpy 이용한 1차 직선 생성

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

2. 경향선을 그리기 위한 데이터 생성

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

![](https://velog.velcdn.com/images/kimse_1225/post/fd86ca4a-f1c8-4a05-aa11-027b0d66619f/image.png)



> 본 블로그에서 사용된 코드는 제로베이스 데이터 스쿨 수업자료에서 일부 발췌함

• 효율적인 메모리 사용을 위해 데이터를 구분한 것 i. 정수형 (int) ii. 실수형 (float) iii. 문자(열)형 (str) iv. 논리형 (bool)

파이썬의 데이터 타입은 다른 언어와는 다르게 크기에 제한이 없다.

ex) 정수형의 경우 메모리가 허용되는 한 무한 사용 가능

타사이트 보다 제로베이스에 끌렸던 점은 강의만 듣는 것이 아니라 취업이 연계되는 부분이었다. 재직중이긴 하지만 공부를 시작한 이유는 궁극적으! 로 딥러닝 관련 분야에서 일하고자하는 목표가 있었기 때문에 최종적으로 제로베이스를 선택하게 되었다.

온라인 교육이라 강제성이 없어 끝까지 잘 마무리할 수 있을까 하는 걱정이 있었지만 체계적으로 관리되고 있는 부분과 팀 플젝에서 민폐를 끼치지 않기 위해서라도 6개월간 빡시게 진행하게될 것 같다.