├── 1
    ├── README.md
    └── hello_world.py
├── 2
    └── README.md
├── 3
    └── README.md
├── 4
    └── README.md
├── 5
    └── README.md
├── 6
    └── README.md
├── 7
    └── README.md
├── 8
    └── README.md
├── 9
    └── README.md
├── 10
    └── README.md
├── 11
    └── README.md
├── 12
    └── README.md
├── 13
    └── README.md
├── 14
    └── README.md
├── 15
    └── README.md
├── README.md
├── figures
    ├── 1.jpg
    └── 2.jpg
└── resources
    ├── python.png
    ├── students.txt
    ├── students.xlsx
    ├── students2.txt
    └── students3.txt


/1/README.md:
--------------------------------------------------------------------------------
 1 | ### 1장 파이썬 개발 환경 구축하기
 2 | 
 3 | #### 개발 환경이란?
 4 | 
 5 | * 코딩, 디버깅, 배포 등 <b>프로그램을 개발하는 일련의 과정을 하나의 프로그램 안에서 수행</b>할 수 있도록 해준 것을 의미합니다.
 6 | 
 7 | #### 1) Visual Studio Code 설치
 8 | 
 9 | * Visual Studio Code는 파이썬을 포함한 다양한 프로그래밍 언어를 지원하며, 무료인 <b>개발 환경</b>입니다.
10 | * Visual Studio Code 다운로드 경로: https://code.visualstudio.com/
11 | 
12 | #### 2) 파이썬(Python) 설치
13 | 
14 | * 파이썬이라는 프로그래밍 언어로 코딩을 하기 위해서는 파이썬을 설치해야 합니다.
15 | * 파이썬(Python) 다운로드 경로: https://www.python.org/downloads/
16 | * 설치 이후에 정상적으로 설치가 완료되었는지 확인하기 위해 명령 프롬프트(CMD)에서 python을 사용해 봅시다.
17 | 
18 | #### 3) Visual Studio Code에서 개발 시작하기
19 | 
20 | * Visual Studio Code에서는 특정한 프로그래밍 언어를 이용해서 프로그램을 작성할 수 있습니다.
21 | * Python 확장 프로그램(Extensions)을 사용하면, 보다 풍부한 기능을 이용할 수 있습니다.
22 | * Visual Studio Code를 이용하여 코드를 작성해 봅시다.
23 |   1. Visual Studio Code의 터미널(terminal)을 이용하여 python을 사용해 봅시다.
24 |   2. Visual Studio Code에서 [hello_world.py](./hello_world.py) 파일을 생성하여 실행해 봅시다.
25 | 
26 | #### 4) Google Colab
27 | 
28 | * 구글(Google) 계정만 있다면 무료로 사용할 수 있는 개발 환경입니다.
29 | * Google Colab 시작하기: https://colab.research.google.com/
30 | 


--------------------------------------------------------------------------------
/1/hello_world.py:
--------------------------------------------------------------------------------
1 | print("Hello World")
2 | 


--------------------------------------------------------------------------------
/10/README.md:
--------------------------------------------------------------------------------
  1 | ### 10장 엑셀에서 서식 다루기
  2 | 
  3 | * <b>서식</b>이란 서류를 꾸미는 방식을 지칭할 때 사용하는 용어입니다. 
  4 | * 우리는 파이썬을 이용해 엑셀의 <b>서식</b>을 다룰 수 있습니다.
  5 |     * 텍스트의 글꼴이나 색상을 설정할 수 있습니다.
  6 |     * 정렬(alignment)을 수행할 수 있습니다.
  7 |     * 엑셀의 셀에 대하여 테두리(border)를 설정하여 엑셀 파일을 예쁘게 꾸밀 수 있습니다.
  8 | 
  9 | #### 1) 폰트(Font, 글꼴) 다루기
 10 | 
 11 | * 다양한 글자에 대하여 글자의 크기, 글꼴, 색상 등을 설정할 수 있습니다.
 12 |     * 색상을 넣을 때는 원하는 RGB 값을 넣으면 됩니다. (빨강: #FF0000)
 13 | 
 14 | <pre>
 15 | from openpyxl import Workbook
 16 | from openpyxl.styles.fonts import Font
 17 | 
 18 | workbook = Workbook() # 워크북(workbook) 생성
 19 | 
 20 | # 활성화된 워크시트(worksheet) 가져오기
 21 | worksheet = workbook.active
 22 | 
 23 | # 특정한 셀에 폰트 적용하기
 24 | worksheet["C3"].value = "텍스트 1"
 25 | worksheet["C3"].font = Font(size=15, bold=True) # 크기, 굵은 글씨
 26 | 
 27 | worksheet["D4"].value = "텍스트 2"
 28 | worksheet["D4"].font = Font(size=40, underline='single', italic=True) # 크기, 밑줄, 이탤릭체
 29 | 
 30 | worksheet["E5"].value = "텍스트 3"
 31 | worksheet["E5"].font = Font(strikethrough=True, color="FF0000") # 취소선, 색상(빨강)
 32 | 
 33 | worksheet["F3"].value = "텍스트 4"
 34 | worksheet["F3"].font = Font(size=30, name="굴림") # 크기, 글씨체
 35 | 
 36 | # 워크북(workbook) 저장하기
 37 | workbook.save("result.xlsx")
 38 | </pre>
 39 | 
 40 | #### 2) 셀 색상 다루기
 41 | 
 42 | * openpyxl은 특정한 셀의 색상을 채우는 기능을 제공합니다.
 43 |     * fill_type: 셀에 색상을 넣는 형태
 44 |     * fgColor: 넣고자 하는 색상의 RGB 값
 45 | 
 46 | <pre>
 47 | from openpyxl import Workbook
 48 | from openpyxl.styles import PatternFill
 49 | 
 50 | workbook = Workbook() # 워크북(workbook) 생성
 51 | 
 52 | # 활성화된 워크시트(worksheet) 가져오기
 53 | worksheet = workbook.active
 54 | 
 55 | # 특정한 셀에 문자열 기입하기
 56 | worksheet["C3"].value = "셀 색상 1"
 57 | worksheet["D4"].value = "셀 색상 2"
 58 | 
 59 | # 특정한 셀에 색상 채우기
 60 | """
 61 | - fill_type = "solid", "darkDown", "darkGray" 등
 62 | - fgColor (배경색)
 63 | """
 64 | worksheet["C3"].fill = PatternFill(fill_type="solid", fgColor="FF0000")
 65 | worksheet["D4"].fill = PatternFill(fill_type="darkDown", fgColor="0000FF")
 66 | 
 67 | # 워크북(workbook) 저장하기
 68 | workbook.save("result.xlsx")
 69 | </pre>
 70 | 
 71 | #### 3) 정렬(Alignment) 다루기
 72 | 
 73 | * 엑셀이 지원하는 정렬 기능을 openpyxl을 활용해 거의 유사하게 사용할 수 있습니다.
 74 | * 텍스트를 정렬할 때는 수직 정렬과 수평 정렬을 모두 고려해야 합니다.
 75 | 
 76 | <pre>
 77 | from openpyxl import Workbook
 78 | from openpyxl.styles import Alignment
 79 | 
 80 | workbook = Workbook() # 워크북(workbook) 생성
 81 | 
 82 | # 활성화된 워크시트(worksheet) 가져오기
 83 | worksheet = workbook.active
 84 | 
 85 | # 특정한 셀에 문자열 기입하기
 86 | worksheet["C3"].value = "텍스트 정렬 1"
 87 | worksheet["D4"].value = "텍스트 정렬 2"
 88 | 
 89 | # 특정한 행과 열의 크기 설정하기
 90 | worksheet.row_dimensions[3].height = 100 # 3행의 높이를 100으로 설정
 91 | worksheet.row_dimensions[4].height = 50 # 4행의 높이를 70으로 설정
 92 | worksheet.column_dimensions["C"].width = 50 # C열의 너비를 80으로 설정
 93 | worksheet.column_dimensions["D"].width = 50 # C열의 너비를 80으로 설정
 94 | 
 95 | # 텍스트 정렬
 96 | """
 97 | horizontal: "left", "right", "center"
 98 | vertical: "top", "bottom", "center"
 99 | """
100 | worksheet["C3"].alignment = Alignment(horizontal="left", vertical="top")
101 | worksheet["D4"].alignment = Alignment(horizontal="center", vertical="center")
102 | 
103 | # 워크북(workbook) 저장하기
104 | workbook.save("result.xlsx")
105 | </pre>
106 | 
107 | #### 4) 테두리(Borderline) 다루기
108 | 
109 | * 특정한 셀의 테두리의 경우 상하좌우 4가지 측면(side)에 대하여 각각 개별적으로 설정합니다.
110 | 
111 | <pre>
112 | from openpyxl import Workbook
113 | from openpyxl.styles import Border, Side
114 | 
115 | workbook = Workbook() # 워크북(workbook) 생성
116 | 
117 | # 활성화된 워크시트(worksheet) 가져오기
118 | worksheet = workbook.active
119 | 
120 | # 특정한 셀에 문자열 기입하기
121 | worksheet["C3"].value = "테두리 1"
122 | worksheet["D4"].value = "테두리 2"
123 | 
124 | # 테두리 설정
125 | """
126 | - 테두리는 top, bottom, left, right 각각 측면(side)에 개별적으로 적용 가능
127 | - 이때, 각 측면(side)마다 스타일(border_style)과 색상(color) 적용 가능
128 | """
129 | worksheet["C3"].border = Border(
130 |     top = Side(border_style="double", color="0000FF"),
131 |     bottom = Side(border_style="double", color="0000FF"),
132 |     left = Side(border_style="thin", color="FF0000"),
133 |     right = Side(border_style="thin", color="FF0000")
134 | )
135 | worksheet["D4"].border = Border(
136 |     top = Side(border_style="thick"),
137 |     bottom = Side(border_style="thick"),
138 |     left = Side(border_style="thick"),
139 |     right = Side(border_style="thick")
140 | )
141 | 
142 | # 워크북(workbook) 저장하기
143 | workbook.save("result.xlsx")
144 | </pre>
145 | 


--------------------------------------------------------------------------------
/11/README.md:
--------------------------------------------------------------------------------
  1 | ### 11장 웹 사이트 구성 요소 핵심 요약
  2 | 
  3 | * 파이썬을 이용해 웹 사이트에서 다양한 데이터를 가져올 수 있습니다.
  4 | * 성공적인 웹 자동화를 위해서 웹 사이트가 어떻게 구성되는지 이해할 필요가 있습니다.
  5 | 
  6 | #### 1) HTML이란?
  7 | 
  8 | * HTML(Hypertext Markup Language): 웹 문서를 작성하기 위해 사용하는 언어입니다.
  9 |     * HTML 파일은 간단히 설명하자면 한 페이지의 문서와 같습니다.
 10 | * HTML 문서는 일반적으로 태그(tag)를 사용해 작성합니다.
 11 |     * HTML 문서는 &lt;HTML&gt; 태그로 시작하고 &lt;/HTML&gt; 태그로 종료합니다.
 12 |     * &lt;HEAD&gt; 태그는 웹 사이트의 제목이나 메타 정보 등을 포함합니다.
 13 |     * &lt;BODY&gt; 태그는 실질적으로 웹 문서의 내용을 보여줍니다.
 14 | 
 15 | <img src="/figures/1.jpg" width="400px">
 16 | 
 17 | * 일반적으로 웹 서버는 다양한 HTML 문서를 포함합니다.
 18 |     * 한 번 자기소개서 웹 사이트의 URL이 있다고 가정합시다.
 19 |     * 웹 브라우저로 해당 웹 사이트의 a.html 문서에 접근할 때는 다음과 같습니다.
 20 | 
 21 | <img src="/figures/2.jpg" width="560px">
 22 | 
 23 | #### 2) 간단한 웹 사이트 만들어 보기
 24 | 
 25 | * HTML 문서를 작성한 뒤에 .html 확장자를 갖도록 합니다.
 26 |     * 일반적인 컴퓨터에서 HTML 문서는 바로 웹 브라우저를 통해 실행됩니다.
 27 |     * &lt;meta&gt; 태그의 UTF-8 인코딩: 한글과 같은 유니코드 문자열을 정상적으로 출력합니다.
 28 | 
 29 | ```
 30 | <!DOCYTYPE HTML>
 31 | <html>
 32 |     <head>
 33 |         <title>기본적인 HTML 문서</title>
 34 |         <meta charset="UTF-8">
 35 |     </head>
 36 |     <body>
 37 |         기본적인 HTML 문서를 작성해 봅시다.
 38 |     </body>
 39 | </html>
 40 | ```
 41 | 
 42 | #### 2) HTML의 다양한 태그 사용해 보기
 43 | 
 44 | * HTML을 구성하는 4가지 구성 요소에 대해 알아봅시다.
 45 |     1. 요소(element): HTML에서 사용되는 명령어를 의미합니다.
 46 |     2. 태그(tag): HTML 요소를 표현하기 위한 방법으로, 문서에 내용을 출력합니다.
 47 |     3. 속성(attribute): 태그를 더 구체적으로 표현합니다.
 48 |     4. 변수(value): 속성에 적용되는 값을 의미합니다.
 49 | 
 50 | * 제목(heading)
 51 |     * 제목을 얼마나 크게 표현할 것인지에 따라서 &lt;h1&gt;부터 &lt;h6&gt;까지 요소가 존재합니다.
 52 | 
 53 | ```
 54 | <!DOCYTYPE HTML>
 55 | <html>
 56 |     <head>
 57 |         <title>기본적인 HTML 문서</title>
 58 |         <meta charset="UTF-8">
 59 |     </head>
 60 |     <body>
 61 |         <h1>문서의 제목 1</h1>
 62 |         <h2>문서의 제목 2</h2>
 63 |         <h3>문서의 제목 3</h3>
 64 |         <h4>문서의 제목 4</h4>
 65 |         기본적인 HTML 문서를 작성해 봅시다.
 66 |     </body>
 67 | </html>
 68 | ```
 69 | 
 70 | * 문단(paragraph)
 71 |     * &lt;p&gt; 태그는 기본적으로 문단을 작성할 때 사용하는 태그로, 자동으로 문서 내에 약간의 여백이 적용됩니다.
 72 | 
 73 | ```
 74 | <!DOCYTYPE HTML>
 75 | <html>
 76 |     <head>
 77 |         <title>기본적인 HTML 문서</title>
 78 |         <meta charset="UTF-8">
 79 |     </head>
 80 |     <body>
 81 |         <h1>파이썬이란?</h1>
 82 |         <p>파이썬은 쉽게 시작할 수 있는 프로그래밍 언어 중 하나입니다. 파이썬은 다음의 순서로 배우면 좋습니다.</p>
 83 |         <h1>HTML이란?</h1>
 84 |         <p>HTML은 웹 페이지를 작성하기 위한 마크업 언어 중 하나입니다. HTML 구성 요소는 다음과 같습니다.</p>
 85 |     </body>
 86 | </html>
 87 | ```
 88 | 
 89 | * 리스트(list)
 90 |     * 특정한 항목들을 나열하여 표현할 수 있습니다.
 91 |     * 순서가 있는 리스트(ordered list)는 &lt;ol&gt; 태그를 사용합니다.
 92 |     * 순서가 없는 리스트(unordered list)는 &lt;ul&gt; 태그를 사용합니다.
 93 | 
 94 | ```
 95 | <!DOCYTYPE HTML>
 96 | <html>
 97 |     <head>
 98 |         <title>기본적인 HTML 문서</title>
 99 |         <meta charset="UTF-8">
100 |     </head>
101 |     <body>
102 |         <h1>파이썬이란?</h1>
103 |         <p>파이썬은 쉽게 시작할 수 있는 프로그래밍 언어 중 하나입니다. 파이썬은 다음의 순서로 배우면 좋습니다.</p>
104 |         <ol>
105 |             <li>표준 입출력</li>
106 |             <li>수 자료형</li>
107 |             <li>문자열 자료형</li>
108 |             <li>리스트 자료형</li>
109 |             <li>조건문</li>
110 |             <li>반복문</li>
111 |         </ol>
112 |         <h1>HTML이란?</h1>
113 |         <p>HTML은 웹 페이지를 작성하기 위한 마크업 언어 중 하나입니다. HTML 구성 요소는 다음과 같습니다.</p>
114 |         <ul>
115 |             <li>요소(element)</li>
116 |             <li>태그(tag)</li>
117 |             <li>속성(attribute)</li>
118 |             <li>변수(value)</li>
119 |         </ul>
120 |     </body>
121 | </html>
122 | ```
123 | 
124 | * 링크(link)
125 |     * &lt;a&gt; 태그는 다른 웹 문서로 넘어갈 수 있도록 해주는 링크(link) 기능을 제공합니다.
126 | 
127 | ```
128 | <!DOCYTYPE HTML>
129 | <html>
130 |     <head>
131 |         <title>기본적인 HTML 문서</title>
132 |         <meta charset="UTF-8">
133 |     </head>
134 |     <body>
135 |         <h1>파이썬이란?</h1>
136 |         <p>파이썬은 쉽게 시작할 수 있는 프로그래밍 언어 중 하나입니다. 파이썬은 다음의 순서로 배우면 좋습니다.</p>
137 |         <ol>
138 |             <li>표준 입출력</li>
139 |             <li>수 자료형</li>
140 |             <li>문자열 자료형</li>
141 |             <li>리스트 자료형</li>
142 |             <li>조건문</li>
143 |             <li>반복문</li>
144 |         </ol>
145 |         <h1>HTML이란?</h1>
146 |         <p>HTML은 웹 페이지를 작성하기 위한 마크업 언어 중 하나입니다. HTML 구성 요소는 다음과 같습니다.</p>
147 |         <ul>
148 |             <li>요소(element)</li>
149 |             <li>태그(tag)</li>
150 |             <li>속성(attribute)</li>
151 |             <li>변수(value)</li>
152 |         </ul>
153 |         <a href="https://www.google.com/">구글(Google)</a>
154 |         <a href="https://www.facebook.com/">페이스북(Facebook)</a>
155 |     </body>
156 | </html>
157 | ```
158 | 


--------------------------------------------------------------------------------
/12/README.md:
--------------------------------------------------------------------------------
  1 | ### 12장 파이썬을 활용한 웹 크롤링 기초
  2 | 
  3 | * 파이썬의 기초적인 라이브러리를 활용해 웹 크롤링을 진행할 수 있습니다.
  4 | 
  5 | #### 1) 웹 페이지의 내용을 읽어 오기
  6 | 
  7 | * 특정한 웹 사이트의 내용은 모두 HTML 형식으로 작성되어 있습니다.
  8 |     * 개발자 도구(F12)를 실행하여 웹 페이지를 분석할 수 있습니다.
  9 | * requests 모듈을 사용하여 HTML 소스코드를 가져올 수 있습니다.
 10 | 
 11 | ```
 12 | import requests
 13 | 
 14 | # 요청(Request) 객체를 생성합니다.
 15 | request = requests.get('http://dowellcomputer.com/main.jsp')
 16 | 
 17 | # 웹 사이트의 HTML 소스코드를 추출합니다.
 18 | html = request.text.strip()
 19 | 
 20 | print(html)
 21 | ```
 22 | 
 23 | * 원하는 부분이 HTML 코드 상에서 어떤 부분인지 확인하기 위해 요소(element) 탐색기를 사용합니다.
 24 | * find() 메서드를 이용해 가장 먼저 등장하는 특정한 태그를 가져올 수 있습니다.
 25 |     * 웹 사이트 내에서 <b>최근 강의</b> 목록이 studyViewBox 클래스 안에 포함되어 있습니다.
 26 |     * 여러 개의 &lt;td&gt; 태그 내에서 &lt;a&gt; 태그가 내부에 포함된 태그만 접근합니다.
 27 | 
 28 | ```
 29 | import requests
 30 | from bs4 import BeautifulSoup
 31 | 
 32 | # 요청(Request) 객체를 생성합니다.
 33 | request = requests.get('http://dowellcomputer.com/main.jsp')
 34 | 
 35 | # 웹 사이트의 HTML 소스코드를 추출합니다.
 36 | html = request.text.strip()
 37 | 
 38 | # HTML 소스코드를 파이썬 BeautifulSoup 객체로 변환합니다.
 39 | soup = BeautifulSoup(html, 'html.parser')
 40 | 
 41 | # 특정한 클래스 이름으로 접근합니다.
 42 | data = soup.find('div', class_='studyViewBox')
 43 | 
 44 | # <td> 태그 내부에서 <a> 태그를 포함하는 경우를 추출합니다.
 45 | data = data.select('td > a')
 46 | 
 47 | # 모든 링크에 하나씩 접근합니다.
 48 | for link in data:
 49 |     # 텍스트(글 제목) 부분만 출력합니다.
 50 |     print(link.text)
 51 | ```
 52 | 
 53 | * 더 보기 좋게 출력되도록 코드를 조금 바꾸어 볼 수 있습니다.
 54 | 
 55 | ```
 56 | import requests
 57 | from bs4 import BeautifulSoup
 58 | 
 59 | # 요청(Request) 객체를 생성합니다.
 60 | request = requests.get('http://dowellcomputer.com/main.jsp')
 61 | 
 62 | # 웹 사이트의 HTML 소스코드를 추출합니다.
 63 | html = request.text.strip()
 64 | 
 65 | # HTML 소스코드를 파이썬 BeautifulSoup 객체로 변환합니다.
 66 | soup = BeautifulSoup(html, 'html.parser')
 67 | 
 68 | # 특정한 클래스 이름으로 접근합니다.
 69 | data = soup.find('div', class_='studyViewBox')
 70 | 
 71 | # <tr> 태그를 추출합니다.
 72 | data = data.select('tr')[2:] # 첫 번째와 두 번째는 제외
 73 | 
 74 | # 각 게시글에 하나씩 접근합니다.
 75 | for i in range(len(data)): 
 76 |     print(f'[{i + 1}번째 최근 강의]')
 77 |     columns = data[i].select('td')
 78 |     print('선생님:', columns[0].text.strip())
 79 |     print('제목:', columns[1].text.strip())
 80 |     print('날짜:', columns[2].text.strip())
 81 | ```
 82 | 
 83 | #### 2) 여러 개의 페이지에 걸쳐서 내용을 읽어 오기
 84 | 
 85 | * 여러 개의 페이지에 걸쳐서 글을 추출할 수 있습니다.
 86 |     * 게시판에서 페이지를 넘겨 가면서 최신 글 100개를 수집합니다.
 87 |     * 한 페이지당 10개의 글을 가지고 있다면, 총 10개의 페이지에 접근하면 됩니다.
 88 | * 특정한 게시물을 읽을 때 <b>글 번호</b>가 파라미터로 사용됩니다.
 89 |     * 각 게시물마다 글 번호를 이용해 <b>내용</b>에 접근한 뒤에 함께 출력합니다.
 90 | 
 91 | ```
 92 | import requests
 93 | from bs4 import BeautifulSoup
 94 | 
 95 | URL = "http://dowellcomputer.com/talk/talkListForm.jsp"
 96 | 
 97 | # 1번째 페이지부터 10번째 페이지까지
 98 | for page in range(1, 11):
 99 |     current = URL + '?currentPage=' + str(page)
100 |     print('현재 페이지:', current)
101 |     
102 |     # 요청(Request) 객체를 생성합니다.
103 |     request = requests.get(current)
104 | 
105 |     # 웹 사이트의 HTML 소스코드를 추출합니다.
106 |     html = request.text.strip()
107 | 
108 |     # HTML 소스코드를 파이썬 BeautifulSoup 객체로 변환합니다.
109 |     soup = BeautifulSoup(html, 'html.parser')
110 | 
111 |     # 특정한 ID 이름으로 접근합니다.
112 |     data = soup.find('div', id='viewBox')
113 | 
114 |     # <tr> 태그를 추출합니다.
115 |     data = data.select('tr')[2:] # 첫 번째와 두 번째는 제외
116 | 
117 |     # 각 게시글에 하나씩 접근합니다.
118 |     for i in range(len(data)): 
119 |         columns = data[i].select('td')
120 |         number = columns[0].text.strip()
121 |         title = columns[3].text.strip()
122 | 
123 |         inside_URL = "http://dowellcomputer.com/talk/talkViewForm.jsp?talkID=" + number
124 |         inside_request = requests.get(inside_URL)
125 |         inside_html = inside_request.text.strip()
126 |         inside_soup = BeautifulSoup(inside_html, 'html.parser')
127 |         inside_data = inside_soup.find('div', id='viewBox')
128 |         content = inside_data.select('tr')[4].select('td')[1].text
129 | 
130 |         print('글 번호:', number, '/ 제목:', title, '/ 내용:', content.strip())
131 | ```
132 | 


--------------------------------------------------------------------------------
/13/README.md:
--------------------------------------------------------------------------------
  1 | ### 셀레니움(Selenium)을 활용한 웹 크롤링
  2 | 
  3 | * 웹에 있는 정보를 자동으로 수집하기 위해서 셀레니움(Selenium)을 사용할 수 있습니다. 
  4 | * 셀레니움을 사용하면 좋은 상황은 다음과 같습니다.
  5 |     * 웹 사이트에 로그인을 한 뒤에 데이터를 가져와야 하는 경우
  6 |     * 기본적인 크롤링 라이브러리로 웹 사이트에 접근할 수 없는 경우
  7 | 
  8 | #### 1) 셀레니움(Selenium) 라이브러리 설치
  9 | 
 10 | * 파이썬에서 pip 명령어를 사용하여 간단히 셀레니움(Selenium)을 설치할 수 있습니다.
 11 | 
 12 | <pre>
 13 | pip install selenium
 14 | </pre>
 15 | 
 16 | #### 2) 웹 브라우저 드라이버 다운로드
 17 | 
 18 | * 셀레니움은 웹 브라우저를 직접적으로 조작하므로, 적절한 브라우저 드라이버를 설치할 필요가 있습니다.
 19 | * 일반적으로 웹 사이트 접속을 위해 가장 많이 사용하는 브라우저로 크롬(Chrome) 브라우저가 있습니다.
 20 | * 크롬 브라우저 설치: https://www.google.com/intl/ko/chrome/
 21 | * 크롬 드라이버 설치: https://chromedriver.chromium.org/home/
 22 |     * 크롬 드라이버(Chrome Driver)는 파이썬 프로그램과 같은 폴더에 놓아주세요.
 23 | * 다음의 코드로 크롬 브라우저를 실행할 수 있습니다.
 24 | 
 25 | <pre>
 26 | from selenium import webdriver
 27 | 
 28 | browser = webdriver.Chrome('./chromedriver')
 29 | </pre>
 30 | 
 31 | #### 3) 셀레니움(Selenium)으로 특정 웹 사이트 접속하기
 32 | 
 33 | * 셀레니움을 활용해 특정한 웹 사이트에 접속할 때는 get() 메서드를 사용합니다.
 34 | 
 35 | <pre>
 36 | from selenium import webdriver
 37 | 
 38 | # 크롬(Chrome) 브라우저 실행하기
 39 | browser = webdriver.Chrome('./chromedriver')
 40 | 
 41 | # 특정 웹 사이트에 접속하기
 42 | browser.get("http://www.dowellcomputer.com/member/memberLoginForm.jsp")
 43 | 
 44 | # 현재 웹 페이지의 정보 출력하기
 45 | print(browser.title)
 46 | </pre>
 47 | 
 48 | #### 4) 셀레니움(Selenium)을 활용한 자동 로그인
 49 | 
 50 | * 셀레니움의 다양한 메서드를 사용하여 HTML 문서의 각 요소에 접근할 수 있습니다.
 51 |     * find_elements_by_id(): HTML 문서의 id 속성을 이용하여 접근하기
 52 |     * find_elements_by_name(): HTML 문서의 name 속성을 이용하여 접근
 53 |     * find_elements_by_class_name(): HTML 문서의 class 속성을 이용하여 접근
 54 | * 텍스트를 작성할 때는 send_keys() 메서드를 사용합니다.
 55 | 
 56 | <pre>
 57 | from selenium import webdriver
 58 | 
 59 | # 크롬(Chrome) 브라우저 실행하기
 60 | browser = webdriver.Chrome('./chromedriver')
 61 | 
 62 | # 특정 웹 사이트에 접속하기
 63 | browser.get("http://www.dowellcomputer.com/member/memberLoginForm.jsp")
 64 | 
 65 | # 현재 웹 페이지의 정보 출력하기
 66 | print(browser.title)
 67 | 
 68 | # 아이디와 비밀번호 입력 창에 접근
 69 | id = browser.find_elements_by_name("memberID")
 70 | password = browser.find_elements_by_name("memberPassword")
 71 | 
 72 | # 각 요소(element)에 원하는 문자열 입력
 73 | id[0].send_keys("pyautogui")
 74 | password[0].send_keys("pyautogui")
 75 | </pre>
 76 | 
 77 | * <b>코드 업데이트</b>
 78 | 
 79 | <pre>
 80 | from selenium.webdriver.chrome.service import Service
 81 | from selenium import webdriver
 82 | import time
 83 | 
 84 | path = "./chromedriver.exe"
 85 | 
 86 | service = Service(executable_path=path)
 87 | browser = webdriver.Chrome(service=service)
 88 | 
 89 | # 특정 웹 사이트에 접속하기
 90 | browser.get("http://www.dowellcomputer.com/member/memberLoginForm.jsp")
 91 | 
 92 | # 현재 웹 페이지의 정보 출력하기
 93 | print(browser.title)
 94 | 
 95 | # 아이디와 비밀번호 입력 창에 접근
 96 | id = browser.find_element("name", "memberID")
 97 | password = browser.find_element("name", "memberPassword")
 98 | 
 99 | # 각 요소(element)에 원하는 문자열 입력
100 | id.send_keys("pyautogui")
101 | password.send_keys("pyautogui")
102 | 
103 | time.sleep(120)
104 | </pre>
105 | 
106 | * 일반적으로 버튼을 클릭할 때는 셀레니움(Selenium)에서 XPath를 사용합니다.
107 |      * 개발자 도구(F12)를 연 뒤에, 우리가 원하는 버튼의 HTML 코드의 XPath를 복사합니다.
108 | 
109 | <pre>
110 | from selenium import webdriver
111 | 
112 | # 크롬(Chrome) 브라우저 실행하기
113 | browser = webdriver.Chrome('./chromedriver')
114 | 
115 | # 특정 웹 사이트에 접속하기
116 | browser.get("http://www.dowellcomputer.com/member/memberLoginForm.jsp")
117 | 
118 | # 현재 웹 페이지의 정보 출력하기
119 | print(browser.title)
120 | 
121 | # 아이디와 비밀번호 입력 창에 접근
122 | id = browser.find_elements_by_name("memberID")
123 | password = browser.find_elements_by_name("memberPassword")
124 | 
125 | # 각 요소(element)에 원하는 문자열 입력
126 | id[0].send_keys("pyautogui")
127 | password[0].send_keys("pyautogui")
128 | 
129 | # XPath로 버튼 요소(element)에 접근
130 | button = browser.find_element_by_xpath('//*[@id="blackBox"]/input[1]')
131 | button.click()
132 | </pre>
133 | 
134 | * <b>코드 업데이트</b>
135 | 
136 | <pre>
137 | from selenium.webdriver.chrome.service import Service
138 | from selenium import webdriver
139 | import time
140 | 
141 | path = "./chromedriver.exe"
142 | 
143 | service = Service(executable_path=path)
144 | browser = webdriver.Chrome(service=service)
145 | 
146 | # 특정 웹 사이트에 접속하기
147 | browser.get("http://www.dowellcomputer.com/member/memberLoginForm.jsp")
148 | 
149 | # 현재 웹 페이지의 정보 출력하기
150 | print(browser.title)
151 | 
152 | # 아이디와 비밀번호 입력 창에 접근
153 | id = browser.find_element("name", "memberID")
154 | password = browser.find_element("name", "memberPassword")
155 | 
156 | # 각 요소(element)에 원하는 문자열 입력
157 | id.send_keys("pyautogui")
158 | password.send_keys("pyautogui")
159 | 
160 | # XPath로 버튼 요소(element)에 접근
161 | button = browser.find_element('xpath', '//*[@id="blackBox"]/input[1]')
162 | button.click()
163 | 
164 | time.sleep(50)
165 | </pre>
166 | 
167 | #### 5) 셀레니움(Selenium)을 활용한 자동 크롤링
168 | 
169 | * 동적 웹 페이지: 로그인 이후에 사용자마다 다른 웹 문서를 보여주는 사이트
170 | * 로그인 이후에 특정한 페이지에 있는 데이터를 가져올 수 있습니다.
171 | 
172 | <pre>
173 | from this import d
174 | from selenium import webdriver
175 | 
176 | # 크롬(Chrome) 브라우저 실행하기
177 | browser = webdriver.Chrome('./chromedriver')
178 | 
179 | # 특정 웹 사이트에 접속하기
180 | browser.get("http://www.dowellcomputer.com/member/memberLoginForm.jsp")
181 | 
182 | # 현재 웹 페이지의 정보 출력하기
183 | print(browser.title)
184 | 
185 | # 아이디와 비밀번호 입력 창에 접근
186 | id = browser.find_elements_by_name("memberID")
187 | password = browser.find_elements_by_name("memberPassword")
188 | 
189 | # 각 요소(element)에 원하는 문자열 입력
190 | id[0].send_keys("pyautogui")
191 | password[0].send_keys("pyautogui")
192 | 
193 | # XPath로 버튼 요소(element)에 접근
194 | button = browser.find_element_by_xpath('//*[@id="blackBox"]/input[1]')
195 | button.click()
196 | 
197 | # 특정 웹 사이트에 접속하기
198 | browser.get("http://www.dowellcomputer.com/study/study.jsp")
199 | # 게시물 제목에 접근
200 | box = browser.find_element_by_class_name("studyViewBox")
201 | rows = box.find_elements_by_tag_name("tr")
202 | 
203 | # 파일 객체를 쓰기 모드로 열기
204 | f = open("result.txt", "w", encoding="utf8")
205 | 
206 | # 처음 두 개의 줄(row)은 제외하고 하나씩 확인
207 | for row in range(2, len(rows)):
208 |     cells = rows[row].find_elements_by_class_name("tail")
209 |     name = cells[0].text
210 |     title = cells[1].text
211 |     date = cells[2].text
212 |     # 이름, 제목, 날짜 데이터를 파일에 저장
213 |     text = f"선생님: {name}\n제목: {title}\n날짜: {date}\n"
214 |     f.write(text)
215 | 
216 | f.close()
217 | </pre>
218 | 
219 | * <b>코드 업데이트</b>
220 | 
221 | <pre>
222 | from selenium.webdriver.chrome.service import Service
223 | from selenium import webdriver
224 | import time
225 | 
226 | path = "./chromedriver.exe"
227 | 
228 | service = Service(executable_path=path)
229 | browser = webdriver.Chrome(service=service)
230 | 
231 | # 특정 웹 사이트에 접속하기
232 | browser.get("http://www.dowellcomputer.com/member/memberLoginForm.jsp")
233 | 
234 | # 현재 웹 페이지의 정보 출력하기
235 | print(browser.title)
236 | 
237 | # 아이디와 비밀번호 입력 창에 접근
238 | id = browser.find_element("name", "memberID")
239 | password = browser.find_element("name", "memberPassword")
240 | 
241 | # 각 요소(element)에 원하는 문자열 입력
242 | id.send_keys("pyautogui")
243 | password.send_keys("pyautogui")
244 | 
245 | # XPath로 버튼 요소(element)에 접근
246 | button = browser.find_element('xpath', '//*[@id="blackBox"]/input[1]')
247 | button.click()
248 | 
249 | # 특정 웹 사이트에 접속하기
250 | browser.get("http://www.dowellcomputer.com/study/study.jsp")
251 | # 게시물 제목에 접근
252 | box = browser.find_element("class name", "studyViewBox")
253 | rows = box.find_elements("tag name", "tr")
254 | 
255 | # 파일 객체를 쓰기 모드로 열기
256 | f = open("result.txt", "w", encoding="utf8")
257 | 
258 | # 처음 두 개의 줄(row)은 제외하고 하나씩 확인
259 | for row in range(2, len(rows)):
260 |     cells = rows[row].find_elements("class name", "tail")
261 |     name = cells[0].text
262 |     title = cells[1].text
263 |     date = cells[2].text
264 |     # 이름, 제목, 날짜 데이터를 파일에 저장
265 |     text = f"선생님: {name}\n제목: {title}\n날짜: {date}\n"
266 |     f.write(text)
267 | 
268 | f.close()
269 | 
270 | time.sleep(50)
271 | </pre>
272 | 


--------------------------------------------------------------------------------
/14/README.md:
--------------------------------------------------------------------------------
  1 | ### 14장 포털 사이트 이미지 수집 및 가공 실습
  2 | 
  3 | * 셀레니움(Selenium)으로 포털 사이트에서 빠르게 이미지를 수집하고 가공할 수 있습니다.
  4 | * 이미지를 수집하여 실질적으로 활용할 때는 저작권 이슈가 없는 이미지만 활용해야 합니다.
  5 |     * 본 차시에서는 이미지를 수집하여 가공하는 방법 자체에만 집중합니다.
  6 | 
  7 | #### 1) 구글(Google)에서 이미지 수집하기
  8 | 
  9 | * 구글의 이미지 검색 페이지에 접속하여 원하는 내용을 검색합니다.
 10 |     * 구글 이미지 검색 페이지의 query(q) 파라미터에 적절한 문자열을 넣습니다.
 11 | 
 12 | <pre>
 13 | import os
 14 | import cv2
 15 | import time
 16 | from selenium import webdriver
 17 | from urllib.request import urlretrieve
 18 | 
 19 | # 크롬(Chrome) 브라우저 실행하기
 20 | browser = webdriver.Chrome('./chromedriver')
 21 | # 로깅(logging) 메시지 줄이기
 22 | options = webdriver.ChromeOptions()
 23 | options.add_experimental_option('excludeSwitches', ['enable-logging'])
 24 | 
 25 | search = "무료 풍경 사진"
 26 | url = "https://www.google.com/search?q=" + search + "&tbm=isch&hl=ko"
 27 | 
 28 | # 특정 웹 사이트에 접속하기
 29 | browser.get(url)
 30 | time.sleep(5) # 5초간 정지
 31 | </pre>
 32 | 
 33 | * 이미지를 수집할 때는 request 라이브러리의 urlretrieve() 메서드를 사용할 수 있습니다. 
 34 |     * 특정한 URL에서부터 파일을 다운로드하는 메서드입니다.
 35 |     * &lt;img&gt; 태그를 확인하여, 이미지 태그의 소스(source) 경로로부터 이미지를 다운로드합니다.
 36 | 
 37 | <pre>
 38 | import os
 39 | import cv2
 40 | import time
 41 | from selenium import webdriver
 42 | from urllib.request import urlretrieve
 43 | 
 44 | # 크롬(Chrome) 브라우저 실행하기
 45 | browser = webdriver.Chrome('./chromedriver')
 46 | # 로깅(logging) 메시지 줄이기
 47 | options = webdriver.ChromeOptions()
 48 | options.add_experimental_option('excludeSwitches', ['enable-logging'])
 49 | 
 50 | search = "무료 풍경 사진"
 51 | url = "https://www.google.com/search?q=" + search + "&tbm=isch&hl=ko"
 52 | 
 53 | # 특정 웹 사이트에 접속하기
 54 | browser.get(url)
 55 | time.sleep(5) # 5초간 정지
 56 | 
 57 | # 이미지 태그 찾기
 58 | images = browser.find_elements_by_tag_name("img")
 59 | 
 60 | # 이미지를 저장할 폴더 생성
 61 | directory = "./images/"
 62 | if not os.path.exists(directory):
 63 |     os.mkdir(directory)
 64 | 
 65 | # 이미지를 하나씩 확인하며
 66 | limit = 30
 67 | cnt = 0
 68 | for image in images:
 69 |     image_source = image.get_attribute("src") # 이미지 URL
 70 |     if image_source != None:
 71 |         target = directory + str(cnt) + ".png"
 72 |         urlretrieve(image_source, target) # 이미지 다운로드
 73 |     cnt += 1
 74 |     if cnt == limit: # 원하는 만큼 이미지를 다운로드한 경우
 75 |         break
 76 | </pre>
 77 | 
 78 | * <b>코드 업데이트</b>
 79 | 
 80 | <pre>
 81 | from selenium.webdriver.chrome.service import Service
 82 | from selenium import webdriver
 83 | import time
 84 | from urllib.request import urlretrieve
 85 | import os
 86 | 
 87 | path = "./chromedriver.exe"
 88 | 
 89 | service = Service(executable_path=path)
 90 | browser = webdriver.Chrome(service=service)
 91 | 
 92 | search = "무료 풍경 사진"
 93 | url = "https://www.google.com/search?q=" + search + "&tbm=isch&hl=ko"
 94 | 
 95 | # 특정 웹 사이트에 접속하기
 96 | browser.get(url)
 97 | 
 98 | time.sleep(3)
 99 | 
100 | # 이미지 태그 찾기
101 | images = browser.find_elements("tag name", "img")
102 | 
103 | # 이미지를 저장할 폴더 생성
104 | directory = "./images/"
105 | if not os.path.exists(directory):
106 |     os.mkdir(directory)
107 | 
108 | # 이미지를 하나씩 확인하며
109 | limit = 50
110 | cnt = 0
111 | for image in images:
112 |     image_source = image.get_attribute("src") # 이미지 URL
113 |     if image_source != None:
114 |         target = directory + str(cnt) + ".png"
115 |         urlretrieve(image_source, target) # 이미지 다운로드
116 |     cnt += 1
117 |     if cnt == limit: # 원하는 만큼 이미지를 다운로드한 경우
118 |         break
119 | </pre>
120 | 
121 | #### 2) 구글(Google)에서 이미지 가공하기
122 | 
123 | * 원하는 이미지만 수집한 뒤에 이미지의 크기를 적절하게 바꿀 수 있습니다.
124 | * 파이썬의 OpenCV 라이브러리의 resize()를 사용해 크기가 변경된 이미지 객체를 얻습니다.
125 |     * 필요시 pip3 install opencv-python 명령어로 OpenCV를 설치합니다.
126 | 
127 | <pre>
128 | import os
129 | import cv2
130 | import time
131 | from selenium import webdriver
132 | from urllib.request import urlretrieve
133 | 
134 | # 크롬(Chrome) 브라우저 실행하기
135 | browser = webdriver.Chrome('./chromedriver')
136 | # 로깅(logging) 메시지 줄이기
137 | options = webdriver.ChromeOptions()
138 | options.add_experimental_option('excludeSwitches', ['enable-logging'])
139 | 
140 | search = "무료 풍경 사진"
141 | url = "https://www.google.com/search?q=" + search + "&tbm=isch&hl=ko"
142 | 
143 | # 특정 웹 사이트에 접속하기
144 | browser.get(url)
145 | time.sleep(5) # 5초간 정지
146 | 
147 | # 이미지 태그 찾기
148 | images = browser.find_elements_by_tag_name("img")
149 | 
150 | # 이미지를 저장할 폴더 생성
151 | directory = "./images/"
152 | if not os.path.exists(directory):
153 |     os.mkdir(directory)
154 | 
155 | # 이미지를 하나씩 확인하며
156 | limit = 30
157 | cnt = 0
158 | for image in images:
159 |     image_source = image.get_attribute("src") # 이미지 URL
160 |     if image_source != None:
161 |         target = directory + str(cnt) + ".png"
162 |         urlretrieve(image_source, target) # 이미지 다운로드
163 |         # 이미지의 크기가 너무 작다면 이미지 제거하기
164 |         img = cv2.imread(target)
165 |         height, width, channel = img.shape
166 |         if height < 120 or width < 120:
167 |             os.remove(target)
168 |             continue
169 |         # 이미지의 크기를 200 X 200 크기로 조절
170 |         res = cv2.resize(img, dsize=(200, 200))
171 |         cv2.imwrite(target, res)
172 |         cnt += 1
173 |     if cnt == limit: # 원하는 만큼 이미지를 다운로드한 경우
174 |         break
175 | </pre>
176 | 


--------------------------------------------------------------------------------
/15/README.md:
--------------------------------------------------------------------------------
  1 | ### 15장 뉴스 기사 크롤링 및 분석 실습
  2 | 
  3 | * 파이썬을 이용해 뉴스 기사 데이터를 수집하는 과정을 자동화할 수 있습니다.
  4 | 
  5 | #### 1) BBC 뉴스 웹 사이트에서 뉴스 기사 데이터 수집하기
  6 | 
  7 | * 셀레니움을 활용해 BBC 뉴스 웹 사이트에 접속할 수 있습니다.
  8 | 
  9 | <pre>
 10 | import time
 11 | from selenium import webdriver
 12 | 
 13 | # 크롬(Chrome) 브라우저 실행하기
 14 | browser = webdriver.Chrome('./chromedriver')
 15 | # 로깅(logging) 메시지 줄이기
 16 | options = webdriver.ChromeOptions()
 17 | options.add_experimental_option('excludeSwitches', ['enable-logging'])
 18 | 
 19 | search = "programming"
 20 | url = "https://www.bbc.co.uk/search?q=" + search + "&page=1"
 21 | 
 22 | # 특정 웹 사이트에 접속하기
 23 | browser.get(url)
 24 | time.sleep(5) # 5초간 정지
 25 | </pre>
 26 | 
 27 | * BBC 뉴스 기사만 추출할 수 있습니다.
 28 |     * 개발자 도구(F12)를 실행하여 특정한 기사의 제목(headline)에 대하여 요소(element)를 확인합니다.
 29 | 
 30 | <pre>
 31 | import time
 32 | from selenium import webdriver
 33 | 
 34 | # 크롬(Chrome) 브라우저 실행하기
 35 | browser = webdriver.Chrome('./chromedriver')
 36 | # 로깅(logging) 메시지 줄이기
 37 | options = webdriver.ChromeOptions()
 38 | options.add_experimental_option('excludeSwitches', ['enable-logging'])
 39 | 
 40 | search = "programming"
 41 | url = "https://www.bbc.co.uk/search?q=" + search + "&page=1"
 42 | 
 43 | # 특정 웹 사이트에 접속하기
 44 | browser.get(url)
 45 | time.sleep(3) # 5초간 정지
 46 | 
 47 | headlines = []
 48 | 
 49 | # 웹 사이트 내 모든 <p> 태그 검색
 50 | p_list = browser.find_elements_by_tag_name("p")
 51 | for p in p_list:
 52 |     # class 속성이 존재하는 <p> 태그만 확인
 53 |     if p.get_attribute("class") != None:
 54 |         # class 속성의 값으로 "Headline"이 포함된 경우
 55 |         if "Headline" in p.get_attribute("class"):
 56 |             headline = p.text
 57 |             headlines.append(headlines)
 58 | 
 59 | print(headlines)
 60 | </pre>
 61 | 
 62 | * 첫 번째 페이지에서 끝나지 않고, 여러 개의 페이지에 대해서 연속적으로 크롤링합니다.
 63 | 
 64 | <pre>
 65 | import time
 66 | from selenium import webdriver
 67 | 
 68 | # 크롬(Chrome) 브라우저 실행하기
 69 | browser = webdriver.Chrome('./chromedriver')
 70 | # 로깅(logging) 메시지 줄이기
 71 | options = webdriver.ChromeOptions()
 72 | options.add_experimental_option('excludeSwitches', ['enable-logging'])
 73 | 
 74 | headlines = []
 75 | search = "programming"
 76 | 
 77 | for i in range(1, 11):
 78 |     url = "https://www.bbc.co.uk/search?q=" + search + "&page=" + str(i)
 79 |     browser.get(url) # 특정 웹 사이트에 접속하기
 80 |     
 81 |     # 웹 사이트 내 모든 <p> 태그 검색
 82 |     p_list = browser.find_elements_by_tag_name("p")
 83 |     for p in p_list:
 84 |         # class 속성이 존재하는 <p> 태그만 확인
 85 |         if p.get_attribute("class") != None:
 86 |             # class 속성의 값으로 "Headline"이 포함된 경우
 87 |             if "Headline" in p.get_attribute("class"):
 88 |                 headline = p.text
 89 |                 headlines.append(headline)
 90 | 
 91 | print(headlines)
 92 | </pre>
 93 | 
 94 | #### 2) 뉴스 기사 데이터 분석하기
 95 | 
 96 | * 뉴스 기사 중에서 가장 높은 빈도수로 등장한 단어에 대해서 분석하여 시각화합니다.
 97 | * 워드 클라우드(word cloud)를 활용할 수 있습니다.
 98 |     * 워드 클라우드 라이브러리 설치: pip install wordcloud
 99 |     * Matplotlib 라이브러리 설치: pip install matplotlib
100 | * 워드 클라우드를 만들 때는 하나의 텍스트를 입력으로 넣습니다.
101 |     * 텍스트 내에서 각 단어들을 공백을 기준으로 구분합니다.
102 | 
103 | <pre>
104 | from wordcloud import WordCloud
105 | from selenium import webdriver
106 | import matplotlib.pyplot as plt
107 | 
108 | # 크롬(Chrome) 브라우저 실행하기
109 | browser = webdriver.Chrome('./chromedriver')
110 | # 로깅(logging) 메시지 줄이기
111 | options = webdriver.ChromeOptions()
112 | options.add_experimental_option('excludeSwitches', ['enable-logging'])
113 | 
114 | headlines = []
115 | search = "programming"
116 | 
117 | for i in range(1, 3):
118 |     url = "https://www.bbc.co.uk/search?q=" + search + "&page=" + str(i)
119 |     browser.get(url) # 특정 웹 사이트에 접속하기
120 |     
121 |     # 웹 사이트 내 모든 <p> 태그 검색
122 |     p_list = browser.find_elements_by_tag_name("p")
123 |     for p in p_list:
124 |         # class 속성이 존재하는 <p> 태그만 확인
125 |         if p.get_attribute("class") != None:
126 |             # class 속성의 값으로 "Headline"이 포함된 경우
127 |             if "Headline" in p.get_attribute("class"):
128 |                 headline = p.text
129 |                 headlines.append(headline)
130 | 
131 | # 텍스트에서 워드클라우드 생성
132 | text = ""
133 | for headline in headlines:
134 |     text += headline + " "
135 | word_cloud = WordCloud(background_color='white').generate(text)
136 | 
137 | # 이미지 시각화 및 저장
138 | plt.imshow(word_cloud)
139 | plt.savefig("result.png")
140 | plt.show()
141 | </pre>
142 | 


--------------------------------------------------------------------------------
/2/README.md:
--------------------------------------------------------------------------------
  1 | ### 2장 파이썬 문법 핵심 요약 - 기초
  2 | 
  3 | #### 파이썬 문법
  4 | 
  5 | * 다양한 업무 자동화 프로그램을 만들기 위해서는 파이썬 프로그래밍 언어의 문법을 알고 있을 필요가 있습니다.
  6 | * 파이썬 공식 자습서: https://docs.python.org/ko/3/tutorial/introduction.html
  7 | 
  8 | #### 1) 변수와 상수
  9 | 
 10 | * 변수: 어떠한 값을 담을 수 있는 그릇입니다.
 11 | * 변수에 값을 넣을 때는 등호(=)를 사용합니다.
 12 | 
 13 | ```
 14 | a = 12
 15 | b = 5
 16 | print(a + b)
 17 | ```
 18 | 
 19 | * 변수에 저장된 값을 변경할 수 있습니다.
 20 | 
 21 | ```
 22 | a = 12
 23 | b = 5
 24 | a = 19
 25 | print(a + b)
 26 | ```
 27 | 
 28 | * 존재하지 않는 변수를 출력할 때는 오류가 발생합니다.
 29 | 
 30 | ```
 31 | print(c)
 32 | ```
 33 | 
 34 | * 상수: 특정한 수를 그대로 사용하면 그 자체로 상수가 됩니다.
 35 | 
 36 | ```
 37 | print(19 + 5)
 38 | ```
 39 | 
 40 | #### 2) 사칙연산
 41 | 
 42 | * 파이썬은 프로그래밍 언어이기 때문에, 말 그대로 계산기 목적으로 사용할 수 있습니다. 
 43 | 
 44 | ```
 45 | a = 31
 46 | b = 5
 47 | print(a + b)
 48 | print(a - b)
 49 | print(a * b)
 50 | print(a / b)
 51 | print(a // b)
 52 | print(a % b)
 53 | ```
 54 | 
 55 | #### 3) 문자열
 56 | 
 57 | * 파이썬에서 문자열을 사용할 때는 작은따옴표나 큰따옴표를 사용합니다. 
 58 | 
 59 | ```
 60 | a = "Hello"
 61 | b = 'Python'
 62 | 
 63 | print(a)
 64 | print(b)
 65 | ```
 66 | 
 67 | * 문자열끼리의 덧셈이 가능합니다.
 68 | 
 69 | ```
 70 | a = "Hello"
 71 | b = "Python"
 72 | 
 73 | print(a + ", " + b)
 74 | ```
 75 | 
 76 | * 문자열 안에서 큰따옴표나 작은따옴표를 출력해야 한다면 이스케이핑을 사용할 수 있습니다.
 77 |     * 역 슬래시(\) 기호를 이용하면 됩니다.
 78 | 
 79 | ```
 80 | print("\"평범\"의 연속은 \"비범\"이다.")
 81 | ```
 82 | 
 83 | * <b>문자열 인덱싱(indexing)</b>: 문자열에 포함된 특정한 하나의 문자를 얻습니다.
 84 |     * 첫 번째 문자는 인덱스 0에 해당합니다.
 85 | 
 86 | ```
 87 | a = "Hello"
 88 | 
 89 | print(a[0])
 90 | print(a[3])
 91 | ```
 92 | 
 93 | * <b>문자열 슬라이싱(slicing)</b>: 부분 문자열(substring)을 얻기 위해 사용합니다.
 94 |     * 슬라이싱은 두 개의 인덱스로 구성되는데, <b>변수명[시작 인덱스:끝 인덱스]</b>의 형태를 가집니다.
 95 | 
 96 | ```
 97 | a = "Hello World"
 98 | 
 99 | prefix = a[:4] # 인덱스 3까지의 접두사 가져오기
100 | print(prefix)
101 | suffix = a[2:] # 인덱스 2부터의 접미사 가져오기
102 | print(suffix)
103 | ```
104 | 
105 | ```
106 | a = "Hello World"
107 | 
108 | print(a[7:10]) # 중간에 있는 부분 문자열 가져오기
109 | ```
110 | 
111 | * 문자열 인덱싱을 할 때는 범위를 벗어나는 경우 오류가 발생하지만, 슬라이싱의 경우 부드럽게 처리됩니다.
112 | 
113 | ```
114 | a = "I love you"
115 | 
116 | print(a[2:50])
117 | ```
118 | 
119 | * 파이썬에서 문자열은 값을 변경할 수 없기 때문에, 불변(immutable) 객체라고도 합니다.
120 | 
121 | ```
122 | a = "Hello World"
123 | a[3] = 'b' # 오류 발생
124 | ```
125 | 
126 | #### 4) 리스트
127 | 
128 | * 프로그램에서는 단순히 한두 개의 변수만 사용하는 것이 아니라, 매우 많은 양의 변수를 다루어야 할 수 있습니다.
129 | * 리스트는 대괄호 안에 원소들을 쉼표로 구분하여 넣을 수 있습니다.
130 | 
131 | ```
132 | odds = [1, 3, 5, 7, 9]
133 | 
134 | print(odds)
135 | ```
136 | 
137 | * 일반적으로 리스트의 각 원소는 같은 자료형이도록 쓰지만, 서로 다른 자료형의 데이터가 들어갈 수 있습니다.
138 | 
139 | ```
140 | data = ["Hello", 7, 0.5]
141 | 
142 | print(data)
143 | ```
144 | 
145 | * 리스트에 대해서 인덱싱과 슬라이싱을 사용할 수 있습니다.
146 | 
147 | ```
148 | evens = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
149 | 
150 | print(evens[3]) # 4번째 원소
151 | print(evens[0:5]) # 1번째 원소부터 4번째 원소까지
152 | ```
153 | 
154 | * 리스트 덧셈: 리스트끼리 더할 수 있는데, 이때는 단순히 두 리스트를 이어 붙인 결과가 반환됩니다.
155 | 
156 | ```
157 | a = [1, 2, 3, 4, 5]
158 | b = [6, 7, 8, 9, 10]
159 | 
160 | print(a + b)
161 | ```
162 | 
163 | * 리스트 중첩: 리스트는 다중(2중, 3중 등)으로 중첩하여 사용할 수 있습니다.
164 | 
165 | ```
166 | arr = [
167 |     [1, 2, 3, 4, 5],
168 |     [6, 7, 8, 9, 10],
169 |     [11, 12, 13, 14, 15]
170 | ]
171 | 
172 | print(arr) # 리스트 전체 출력
173 | print(arr[0][1]) # 1행 2열의 원소 출력
174 | print(arr[2][2]) # 3행 3열의 원소 출력
175 | ```
176 | 
177 | * 문자열은 불변(immutable) 객체였지만, 리스트는 가변(mutable) 객체입니다.
178 | 
179 | ```
180 | a = [5, 6, 7, 8, 9]
181 | 
182 | a[4] = 5
183 | print(a)
184 | 
185 | a[0] = 1
186 | print(a)
187 | 
188 | a[1:4] = [2, 3, 4] # 특정 구간을 한꺼번에 바꾸기
189 | print(a)
190 | ```
191 | 


--------------------------------------------------------------------------------
/3/README.md:
--------------------------------------------------------------------------------
  1 | ### 3장 파이썬 문법 핵심 요약 – 심화
  2 | 
  3 | #### 프로그래밍을 제어하기 위한 문법
  4 | 
  5 | * 다양한 업무를 자동화할 때, 조건에 따라서 데이터를 처리해야 하는 경우가 많습니다.
  6 | 
  7 | #### 1) 조건문
  8 | 
  9 | * 조건문은 프로그램 실행의 흐름을 제어합니다.
 10 | * 일반적으로 프로그램은 사용자의 입력에 따라서 결과를 뱉는 방식으로 작성됩니다.
 11 |     * 사용자로부터 입력을 받을 때는 input() 함수를 사용합니다. 
 12 | 
 13 | ```
 14 | x = int(input())
 15 | y = int(input())
 16 | 
 17 | print(x / y)
 18 | ```
 19 | 
 20 | * 조건문은 <b>if 구문</b>을 이용해 작성합니다.
 21 |     * 조건문 내부에 대하여 띄어쓰기를 4번 사용합니다.
 22 |     * 어떠한 값이 다른 값과 동일한지 구할 때는 등호를 2번 사용해 "=="라고 씁니다.
 23 | 
 24 | ```
 25 | x = int(input())
 26 | y = int(input())
 27 | 
 28 | if y == 0:
 29 |     print('0으로 나눌 수 없습니다.')
 30 | else:
 31 |     print(x / y)
 32 | ```
 33 | 
 34 | * if에 해당하지 않는다면 elif가 수행되고, 위쪽에 있는 모든 조건문에 해당하지 않을 때 else 구문이 실행됩니다.
 35 |     * 이때 elif나 else는 옵션으로, 없어도 됩니다.
 36 | 
 37 | ```
 38 | score = 75
 39 | 
 40 | if score >= 94: # 94점부터 100점
 41 |     print('1등급입니다.')
 42 | elif score >= 87: # 93점부터 87점
 43 |     print('2등급입니다.')
 44 | elif score >= 81: # 86점부터 81점
 45 |     print('3등급입니다.')
 46 | else:
 47 |     print('3등급 미만입니다.')
 48 | ```
 49 | 
 50 | #### 2) 반복문
 51 | 
 52 | * 반복적인 반복적인 작업을 대신해주기 위해 효과적입니다.
 53 | 
 54 | ```
 55 | for x in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
 56 |     print(x)
 57 | ```
 58 | 
 59 | * for문은 어떠한 시퀀스의 원소에 차례대로 접근한다는 점에서 range() 함수와 함께 사용됩니다.
 60 |     * range(start, end) 형태가 가장 많이 사용됩니다.
 61 | * for문과 range() 함수를 배웠기 때문에, 다양한 프로그램을 작성할 수 있습니다.
 62 | * 1부터 50까지의 수를 더한 값을 계산해 봅시다.
 63 | 
 64 | ```
 65 | result = 0
 66 | for i in range(1, 51): # 1부터 50까지 방문
 67 |     result += i
 68 | 
 69 | print(result)
 70 | ```
 71 | 
 72 | * 1부터 50까지의 수 중에서 10의 배수만 더하는 프로그램을 작성할 수 있습니다.
 73 | 
 74 | ```
 75 | result = 0
 76 | for i in range(1, 51):
 77 |     if i % 10 == 0:
 78 |         result += i
 79 | 
 80 | print(result)
 81 | ``` 
 82 | 
 83 | * enumerate() 함수를 사용하면 인덱스와 함께 반복할 수 있습니다.
 84 | 
 85 | ```
 86 | name_list = ['홍길동', '이순신', '장보고']
 87 | 
 88 | for i, element in enumerate(name_list):
 89 |     print(i, element)
 90 | ```
 91 | 
 92 | * 반복문을 중첩해서 사용할 수도 있습니다.
 93 |     * 구구단 예제를 확인해 봅시다.
 94 | 
 95 | ```
 96 | for i in range(1, 10):
 97 |     for j in range(1, 10):
 98 |         print(i, "X", j, "=", i * j)
 99 | ```
100 | 
101 | * 1부터 N까지의 수 중에서 소수를 찾는 프로그램을 작성할 수 있습니다.
102 |     * 소수가 아닌 경우, 어떤 수의 배수인지 출력한 뒤에 해당 수에 대한 반복문을 탈출합니다.
103 |     * break 구문은 해당 break 구문을 포함하는 반복문을 탈출합니다.
104 | 
105 | ```
106 | n = 10
107 | for x in range(i, n + 1):
108 |     prime_number = True
109 |     for y in range(2, x):
110 |         if x % y == 0: # 나누어 떨어지는 수가 있다면
111 |             print(x, "=", y, "*", x // y)
112 |             prime_number = False
113 |             break # 반복문 탈출
114 |     if prime_number:
115 |         print(x, "는 소수입니다.")
116 | ```
117 | 
118 | #### 3) 함수
119 | 
120 | * 함수를 이용해 소스 코드를 기능별로 분리할 수 있습니다.
121 |     * 각 부품(함수)이 서로 조화를 이루어 하나의 완성된 프로그램을 만들 수 있습니다.
122 | * 함수는 def 구문을 이용하여 작성할 수 있습니다.
123 | * 세 개의 수를 입력받아 더한 결과를 반환하는 함수를 작성해 봅시다.
124 |  
125 |  ```
126 | def add(a, b, c):
127 |     result = a + b + c
128 |     return result
129 | 
130 | print(add(3, 5, 7))
131 | ```
132 | 
133 | ```
134 | def add(a, b, c):
135 |     result = a + b + c
136 |     return result
137 | 
138 | print(add(3, 5, 7))
139 | print(add(5, 5, 2))
140 | print(add(100, 200, 300))
141 | ```
142 |  
143 | * 리스트 내 원소 중에서 가장 큰 값의 인덱스(위치)를 찾아서 반환하는 함수를 작성해 봅시다.
144 | 
145 | ```
146 | def find_max_index(arr):
147 |     max_index = 0
148 |     for i in range(len(arr)):
149 |         if arr[max_index] < arr[i]: # 더 큰 값을 찾은 경우
150 |             max_index = i
151 |     return i
152 | 
153 | data = [7, 1, 5, 9, 3, 2, 4]
154 | max_index = find_max_index(data)
155 | print(max_index)
156 | ```
157 | 
158 | * 특정한 값을 가지는 원소의 인덱스를 찾는 함수를 작성해 봅시다.
159 | 
160 | ```
161 | def find_certain_value(arr, value):
162 |     for i, x in enumerate(arr):
163 |         if x == value:
164 |             return i
165 |     return -1 # 찾지 못한 경우 -1을 반환
166 | 
167 | print(find_certain_value([3, 5, 7, 9], 2))
168 | print(find_certain_value([3, 5, 7, 9], 7))
169 | ```
170 | 


--------------------------------------------------------------------------------
/4/README.md:
--------------------------------------------------------------------------------
 1 | ### 4장 매크로를 활용해 키보드와 마우스 조종하기
 2 | 
 3 | #### 매크로를 활용한 업무 자동화
 4 | 
 5 | * 반복적인 업무를 대체하는 가장 간단한 방법은, 프로그램을 이용해 키보드와 마우스를 직접적으로 조종하는 것입니다. 
 6 | 
 7 | #### 1) PyAutoGUI 설치
 8 | 
 9 | * PyAutoGUI를 사용해 키보드와 마우스를 원하는 대로 조종할 수 있습니다.
10 | * PyAutoGUI 공식 홈페이지: https://pyautogui.readthedocs.io/en/latest/
11 | * PyAutoGUI의 대표적인 기능은 다음과 같습니다.
12 |     * 컴퓨터에서 실행한 다른 프로그램 화면을 클릭할 수 있습니다.
13 |     * 컴퓨터에서 실행한 다른 프로그램 내에서 타이핑을 할 수 있습니다.
14 |     * 모니터 화면에서 스크린샷을 찍거나 화면 내에서 특정한 이미지의 위치를 찾을 수 있습니다.
15 | * PyAutoGUI를 설치합니다.
16 | 
17 | <pre>
18 | pip install pyautogui
19 | </pre>
20 | 
21 | * PyAutoGUI의 기본 코드
22 | 
23 | <pre>
24 | import pyautogui
25 | 
26 | # 메인 모니터의 해상도 가져오기
27 | screen_width, screen_height = pyautogui.size()
28 | print(screen_width, screen_height)
29 | 
30 | # 현재 마우스의 XY 좌표 가져오기
31 | current_mouse_X, current_mouse_Y = pyautogui.position()
32 | print(current_mouse_X, current_mouse_Y)
33 | </pre>
34 | 
35 | #### 2) PyAutoGUI로 키보드 조종하기
36 | 
37 | * 키보드를 조종할 때는 write() 메서드를 사용합니다.
38 |     * interval: 각 글자를 입력할 때의 시간 간격을 의미합니다.
39 | 
40 | <pre>
41 | import time
42 | import pyautogui
43 | 
44 | time.sleep(2) # 2초간 기다리기
45 | pyautogui.write("Hello World!\n", interval=0.1)
46 | pyautogui.write("We are going to learn PyAutoGUI.", interval=0.1)
47 | </pre>
48 | 
49 | * 한글 입력을 위해 일반적으로 pyperclip을 사용합니다.
50 | 
51 | <pre>
52 | pip install pyperclip
53 | </pre>
54 | 
55 | * pyperclip의 copy() 메서드를 이용해 우리가 원하는 한글 문자열을 통째로 복사할 수 있습니다.
56 |     * 이후에 hotkey() 메서드를 이용하여 Ctrl + V로 붙여넣기를 진행할 수 있습니다.
57 | 
58 | <pre>
59 | import time
60 | import pyautogui
61 | import pyperclip
62 | 
63 | time.sleep(2) # 2초간 기다리기
64 | pyautogui.write("Hello World!\n", interval=0.1)
65 | 
66 | pyperclip.copy("한글을 입력하겠습니다.")
67 | pyautogui.hotkey("ctrl", "v")
68 | </pre>
69 | 
70 | #### 3) PyAutoGUI로 마우스 조종하기
71 | 
72 | * 실습용 예시 웹 사이트: http://dowellcomputer.com/main.jsp
73 | * 웹 사이트의 <b>[로그인]</b> 버튼 위에 마우스 커서를 올려 본 뒤에 position() 메서드로 위치를 찾습니다.
74 | 
75 | <pre>
76 | import time
77 | import pyautogui
78 | import pyperclip
79 | 
80 | time.sleep(2) # 2초간 기다리기
81 | position = pyautogui.position()
82 | print(position) # 현재 마우스 포인터의 위치 출력
83 | </pre>
84 | 
85 | * 특정한 좌표에서 마우스를 클릭할 때는 click() 메서드를 이용하시면 됩니다. 
86 | 
87 | <pre>
88 | import time
89 | import pyautogui
90 | import pyperclip
91 | 
92 | time.sleep(2) # 2초간 기다리기
93 | position = pyautogui.position()
94 | print(position) # 현재 마우스 포인터의 위치 출력
95 | 
96 | pyautogui.click(position)
97 | </pre>
98 | 


--------------------------------------------------------------------------------
/5/README.md:
--------------------------------------------------------------------------------
 1 | ### 5장 파이썬 매크로 실전 예제
 2 | 
 3 | #### 매크로를 활용한 일상적인 업무의 자동화
 4 | 
 5 | * 파이썬 매크로 프로그램은 다양한 목적에 맞게 사용할 수 있습니다.
 6 |     * 자동으로 로그인을 한 뒤에 게시글을 작성할 수 있습니다.
 7 |     * 여러 개의 게시글을 차례대로 확인하여 스크린샷을 캡처할 수 있습니다.
 8 | 
 9 | #### 1) 자동 로그인
10 | 
11 | * 실습용 웹 사이트: http://dowellcomputer.com/
12 |     * 아이디: pyautogui
13 |     * 비밀번호: pyautogui
14 | * PyAutoGUI에서는 특정한 이미지가 존재하는 영역을 찾는 함수인 locateOnScreen() 메서드를 제공합니다.
15 | * 화면에서 특정한 버튼 이미지를 캡처할 수 있습니다.
16 |     * 윈도우(Windows) 운영체제의 <b>[캡처 도구]</b> 혹은 <b>[윈도우 키 + Shift + S]</b>를 사용할 수 있습니다.
17 |     * 이미지는 기본적으로 .png 형식으로 저장합니다.
18 | * 특정한 이미지가 존재하는 위치를 계산할 수 있습니다.
19 |     * locateOnScreen() 메서드는 Pillow 라이브러리를 요구합니다.
20 | <pre>
21 | pip install pillow 
22 | </pre>
23 | * locateOnScreen() 메서드로 [로그인] 버튼의 위치를 찾을 수 있습니다.
24 |     * locateOnScreen() 메서드는 기본적으로 이미지가 정확히 일치할 때만 위치를 찾을 수 있습니다.
25 |     * 화면(screen)에서 해당 이미지를 찾지 못한 경우엔 None 값을 반환합니다.
26 | <pre>
27 | import pyautogui
28 | 
29 | image_location = pyautogui.locateOnScreen("login.png")
30 | print(image_location)
31 | </pre>
32 | * locateOnScreen() 메서드의 confidence 속성의 값을 활용할 수 있습니다.
33 |     * OpenCV를 설치할 필요가 있습니다.
34 | 
35 | <pre>
36 | pip install opencv-python
37 | </pre>
38 | 
39 | * 일치율이 50% 이상인 이미지를 찾는다면, confidence 값으로 0.5를 기입합니다.
40 | <pre>
41 | import pyautogui
42 | 
43 | image_location = pyautogui.locateOnScreen("login.png", confidence=0.5)
44 | pyautogui.moveTo(image_location)
45 | print(image_location)
46 | </pre>
47 | 
48 | * 자동 로그인 기능을 구현할 수 있습니다.
49 |      * 이미지를 인식하여 버튼을 누르는 과정이 포함되어 있기 때문에, 오작동할 가능성이 있습니다.
50 |      * PyAutoGUI 대신에 HTML 웹 문서 소스 코드를 분석하여 웹 사이트 업무를 자동화할 수도 있습니다.
51 |      * 윤리적으로 실서버에 피해를 주지 않고 합당하게 수행할 수 있는 작업만을 매크로를 통해 수행해야 합니다.
52 | 
53 | <pre>
54 | import time
55 | import pyautogui
56 | 
57 | # 로그인 페이지로 이동
58 | page_location = pyautogui.locateOnScreen("login_1.png", confidence=0.5)
59 | pyautogui.moveTo(page_location)
60 | pyautogui.click()
61 | 
62 | time.sleep(1) # 1초간 기다리기
63 | 
64 | # 아이디 입력
65 | id_location = pyautogui.locateOnScreen("id.png", confidence=0.6)
66 | pyautogui.moveTo(id_location) # 커서를 아이디 위치로 이동
67 | pyautogui.moveRel(300, 0) # 오른쪽으로 300px 이동
68 | pyautogui.click() # 입력창 클릭
69 | pyautogui.typewrite("pyautogui") # 아이디 입력
70 | 
71 | # 비밀번호 입력
72 | password_location = pyautogui.locateOnScreen("password.png", confidence=0.6)
73 | pyautogui.moveTo(password_location) # 커서를 비밀번호 위치로 이동
74 | pyautogui.moveRel(300, 0) # 오른쪽으로 300px 이동
75 | pyautogui.click() # 입력창 클릭
76 | pyautogui.typewrite("pyautogui") # 비밀번호 입력
77 | 
78 | # 로그인 진행
79 | login_location = pyautogui.locateOnScreen("login_2.png", confidence=0.6)
80 | pyautogui.moveTo(login_location) # 커서를 로그인 버튼 위치로 이동
81 | pyautogui.click() # 로그인 버튼 클릭
82 | </pre>
83 | 


--------------------------------------------------------------------------------
/6/README.md:
--------------------------------------------------------------------------------
  1 | ### 6장 여러 개의 텍스트 파일에서 필요한 정보만 엑셀에 정리하기
  2 | 
  3 | #### 다양하게 존재하는 데이터를 엑셀 파일로 옮기기
  4 | 
  5 | * 많은 사무직에서는 특히나 엑셀을 활용해 반복적인 작업을 해야 하는 경우가 많습니다. 
  6 | * 컴퓨터 내에서 다양하게 존재하는 데이터를 선택적으로 엑셀 파일로 옮겨서 처리할 수 있습니다.
  7 | 
  8 | #### 1) openpyxl 라이브러리 설치
  9 | 
 10 | * 파이썬에서 엑셀 업무를 도와주기 위한 라이브러리로 openpyxl이 있습니다.
 11 | 
 12 | <pre>
 13 | pip install openpyxl
 14 | </pre>
 15 | 
 16 | * openpyxl 웹 사이트: https://openpyxl.readthedocs.io/en/stable/
 17 | * 일반적으로 워크북(workbook)은 전체 엑셀 파일 자체를 의미합니다.
 18 | * 하나의 워크북에는 여러 개의 워크시트(worksheet)가 존재할 수 있습니다.
 19 | 
 20 | <pre>
 21 | from openpyxl import Workbook
 22 | 
 23 | workbook = Workbook() # 워크북(workbook) 생성
 24 | 
 25 | # 활성화된 워크시트(worksheet) 가져오기
 26 | worksheet = workbook.active
 27 | 
 28 | # 한 줄(row)씩 데이터 입력하기
 29 | worksheet.append(["이순신", 97, 3])
 30 | worksheet.append(["홍길동", 85, 2])
 31 | worksheet.append(["장보고", 100, 3])
 32 | 
 33 | # 워크북(workbook) 저장하기
 34 | workbook.save("output.xlsx")
 35 | </pre>
 36 | 
 37 | #### 2) 여러 개의 텍스트 파일에서 필요한 정보만 엑셀에 정리하기
 38 | 
 39 | * 실습을 위해 준비된 두 개의 메모장 파일을 확인합니다.
 40 |     * students.txt
 41 |     * students2.txt
 42 |     * students3.txt
 43 | * 파이썬을 이용해 파일에서 데이터를 읽어 오기 위해 파일 객체를 생성합니다.
 44 |     * open(): 파일 객체를 생성하는 함수
 45 |     * read(): 파일의 전체 내용을 문자열 형태로 읽어오는 함수
 46 | 
 47 | <pre>
 48 | """
 49 | open(파일 이름, 모드, 인코딩) 함수를 이용해 파일 객체를 생성할 수 있습니다.
 50 | r: 읽기 모드로, 파일을 읽기만 할 때 사용합니다.
 51 | UTF8: 한글과 같은 유니코드를 처리하기 위한 인코딩 방식입니다.
 52 | """
 53 | 
 54 | file = open('./students.txt', 'r', encoding='UTF8') # 파일 객체 생성
 55 | 
 56 | text = file.read() # 파일의 전체 내용을 문자열로 반환
 57 | print(text)
 58 | 
 59 | file.close() # 파일 객체 닫기
 60 | </pre>
 61 | 
 62 | * 결과적으로 텍스트 파일에서 문자열을 읽어와 엑셀 파일에 기록할 수 있습니다.
 63 |     * 텍스트 파일에서 각 학생 정보는 한 줄에 하나씩 문자열 형태로 기록되어 있습니다.
 64 |     * 각 데이터(번호, 이름, 점수 등)는 공백을 기준으로 구분되어 있습니다.
 65 | 
 66 | <pre>
 67 | from openpyxl import Workbook
 68 | 
 69 | def read_files(file_names):
 70 |     text = ""
 71 |     for file_name in file_names: # 파일 이름을 하나씩 확인하며
 72 |         # 파일을 열어 text 변수에 추가
 73 |         with open(file_name, 'r', encoding='UTF8') as file:
 74 |             text += file.read()
 75 |         text += "\n" # 줄바꿈 추가
 76 |     return text
 77 | 
 78 | text = read_files(["students.txt", "students2.txt"])
 79 | text = text.strip() # 앞 뒤로 공백 제거
 80 | 
 81 | workbook = Workbook() # 워크북(workbook) 생성
 82 | 
 83 | # 활성화된 워크시트(worksheet) 가져오기
 84 | worksheet = workbook.active
 85 | 
 86 | student_list = []
 87 | # 한 줄씩 확인하며
 88 | for line in text.split('\n'):
 89 |     # [번호, 이름, 점수1, 점수2, 점수3, 학과, 학번]을 차례대로 확인
 90 |     id, name, score1, score2, score3, depart, grade = line.split(' ')
 91 |     # 수 데이터는 수 자료형으로 변환
 92 |     id = int(id)
 93 |     score1 = int(score1)
 94 |     score2 = int(score2)
 95 |     score3 = int(score3)
 96 |     grade = int(grade[0]) # 학년에 해당하는 숫자 데이터만 저장
 97 |     student = [id, name, score1, score2, score3, depart, grade]
 98 |     student_list.append(student)
 99 | 
100 | for student in student_list:
101 |     # 한 줄(row)씩 학생 정보 입력하기
102 |     worksheet.append(student)
103 | 
104 | # 워크북(workbook) 저장하기
105 | workbook.save("students.xlsx")
106 | </pre>
107 | 


--------------------------------------------------------------------------------
/7/README.md:
--------------------------------------------------------------------------------
  1 | ### 7장 엑셀에서 다양한 방법으로 셀 다루기
  2 | 
  3 | * 일상에서 엑셀 업무를 할 때 일일이 하나씩 셀을 클릭하여 데이터를 추가하거나 수정하곤 합니다.
  4 | * 파이썬을 이용하면 엑셀에서 셀을 다루는 업무를 손쉽게 자동화할 수 있습니다.
  5 | 
  6 | #### 1) 셀 데이터 읽기
  7 | 
  8 | * 워크시트(worksheet)에서 특정한 셀은 행(row)과 열(column)로 표현될 수 있습니다. 
  9 | * cell() 메서드를 사용해 셀에 접근할 수 있습니다.
 10 |     * 행과 열의 번호를 직접 입력할 수 있습니다.
 11 |     * Range를 이용해 엑셀의 고유 인덱스를 표현할 수 있습니다.
 12 | 
 13 | <pre>
 14 | import openpyxl
 15 | 
 16 | # 워크북(workbook) 불러오기
 17 | workbook = openpyxl.load_workbook("students.xlsx")
 18 | 
 19 | # 활성화된 워크시트(worksheet) 가져오기
 20 | worksheet = workbook.active
 21 | 
 22 | # Range를 이용해 셀에 접근하기
 23 | data = worksheet["B3"].value
 24 | print(data)
 25 | 
 26 | # cell() 메서드를 이용해 셀에 접근하기
 27 | data = worksheet.cell(row=3, column=2).value
 28 | print(data)
 29 | </pre>
 30 | 
 31 | * Range를 이용하여 특정 범위에 속하는 데이터를 모두 가져올 수 있습니다.
 32 |     * 특정한 범위의 셀들에 접근할 때는 행(row)과 열(column) 순서대로 접근하게 됩니다. 
 33 | 
 34 | <pre>
 35 | (
 36 |     (B3, C3, D3, E3),
 37 |     (B4, C4, D4, E4), 
 38 |     (B5, C5, D5, E5),
 39 |     (B6, C6, D6, E6),
 40 | )
 41 | </pre>
 42 | 
 43 | <pre>
 44 | import openpyxl
 45 | 
 46 | # 워크북(workbook) 불러오기
 47 | workbook = openpyxl.load_workbook("students.xlsx")
 48 | 
 49 | # 활성화된 워크시트(worksheet) 가져오기
 50 | worksheet = workbook.active
 51 | 
 52 | # Range를 이용해 셀에 접근하기
 53 | cells = worksheet["B3:E6"]
 54 | print(cells)
 55 | 
 56 | for row in cells:
 57 |     for cell in row:
 58 |         print(cell.value)
 59 | </pre>
 60 | 
 61 | #### 2) 셀 데이터 쓰기
 62 | 
 63 | * openpyxl을 이용해 데이터를 쓸 때에도 값(value)에 접근하여 기록할 수 있습니다.
 64 | 
 65 | <pre>
 66 | import openpyxl
 67 | 
 68 | # 워크북(workbook) 불러오기
 69 | workbook = openpyxl.load_workbook("students.xlsx")
 70 | 
 71 | # 활성화된 워크시트(worksheet) 가져오기
 72 | worksheet = workbook.active
 73 | 
 74 | # cell() 메서드를 이용해 셀에 접근하기
 75 | cells = worksheet.cell(row=3, column=2).value = "허준"
 76 | 
 77 | workbook.save("students.xlsx")
 78 | </pre>
 79 | 
 80 | #### 3) 셀 데이터 삭제
 81 | 
 82 | * 특정한 셀을 삭제할 때는 단순히 해당 셀의 값을 공백 문자열("")로 대체할 수 있습니다.
 83 | 
 84 | <pre>
 85 | import openpyxl
 86 | 
 87 | # 워크북(workbook) 불러오기
 88 | workbook = openpyxl.load_workbook("students.xlsx")
 89 | 
 90 | # 활성화된 워크시트(worksheet) 가져오기
 91 | worksheet = workbook.active
 92 | 
 93 | # Range를 이용해 셀에 접근하기
 94 | cells = worksheet.cell(row=3, column=2).value = ""
 95 | 
 96 | workbook.save("students.xlsx")
 97 | </pre>
 98 | 
 99 | * 특정한 행을 통째로 삭제할 때는 delete_rows()를 사용할 수 있습니다.
100 |     * 3번째 행부터 8개의 행을 삭제할 때는 delete_rows(3, 8)라고 기입합니다. 
101 | * 특정한 열을 통째로 삭제할 때는 delete_cols()를 사용할 수 있습니다.
102 | 
103 | <pre>
104 | import openpyxl
105 | 
106 | # 워크북(workbook) 불러오기
107 | workbook = openpyxl.load_workbook("students.xlsx")
108 | 
109 | # 활성화된 워크시트(worksheet) 가져오기
110 | worksheet = workbook.active
111 | 
112 | # delete_rows()를 이용해 3번째 행부터 8개의 행을 삭제하기
113 | worksheet.delete_rows(3, 8)
114 | 
115 | workbook.save("students.xlsx")
116 | </pre>
117 | 
118 | #### 4) 최대 행과 최대 열
119 | 
120 | * 최대 행을 가져올 때는 max_row 변수를 사용합니다.
121 | * 최대 열을 가져올 때는 max_column 변수를 사용합니다.
122 | 
123 | <pre>
124 | import openpyxl
125 | 
126 | # 워크북(workbook) 불러오기
127 | workbook = openpyxl.load_workbook("students.xlsx")
128 | 
129 | # 활성화된 워크시트(worksheet) 가져오기
130 | worksheet = workbook.active
131 | 
132 | # 최대 열(max column) 구하기
133 | max_column = worksheet.max_column
134 | 
135 | print(max_column)
136 | </pre>
137 | 


--------------------------------------------------------------------------------
/8/README.md:
--------------------------------------------------------------------------------
  1 | ### 8장 엑셀에서 이미지와 차트 다루기
  2 | 
  3 | * 흔히 사무직 업무에서는 엑셀 파일의 데이터를 보기 좋게 시각화(visualization)를 진행합니다.
  4 | * 엑셀에 존재하는 데이터를 읽어 차트(chart)로 만들 수 있습니다.
  5 | 
  6 | #### 1) 차트 삽입하기
  7 | 
  8 | * students.xlsx 엑셀 파일에 기록된 각 학생의 학과(department) 데이터에 대하여 통계를 낼 수 있습니다.
  9 | * Counter는 특정한 리스트(list)의 각 원소가 몇 번 등장했는지 개수를 셀 때 사용합니다.
 10 | * 데이터를 차트에 그릴 때에는 한 줄에 하나씩 학과 정보를 읽게 됩니다.
 11 |     * 학과 이름이 제목(title) 형태로 포함되기 때문에 titles_from_data 속성의 값으로 True를 넣습니다. 
 12 | 
 13 | <pre>
 14 | import openpyxl
 15 | from collections import Counter
 16 | 
 17 | # 워크북(workbook) 불러오기
 18 | workbook = openpyxl.load_workbook("students.xlsx")
 19 | 
 20 | # 활성화된 워크시트(worksheet) 가져오기
 21 | worksheet = workbook.active
 22 | 
 23 | # 학과 정보가 담길 리스트
 24 | departs = []
 25 | 
 26 | # 각 행(row)을 하나씩 확인하며
 27 | max_row = worksheet.max_row
 28 | for row in range(1, max_row + 1):
 29 |     # 학과 문자열을 확인하여 리스트에 담기
 30 |     value = worksheet.cell(row=row, column=6).value
 31 |     departs.append(value)
 32 | 
 33 | # 각 학과의 출현 빈도 계산하기
 34 | counter = Counter(departs)
 35 | print("출현 빈도:", counter)
 36 | 
 37 | # 각 학과별 사람 수 기록하기
 38 | worksheet.cell(row=1, column=9).value = "학과"
 39 | worksheet.cell(row=1, column=10).value = "사람 수"
 40 | row = 2
 41 | for depart in counter:
 42 |     worksheet.cell(row=row, column=9).value = depart
 43 |     worksheet.cell(row=row, column=10).value = counter[depart]
 44 |     row += 1
 45 | 
 46 | # 막대 차트(Bar Chart) 만들기
 47 | bar_chart = openpyxl.chart.BarChart()
 48 | bar_chart.title = "학과 통계"
 49 | bar_chart.x_axis.title = "학과"
 50 | bar_chart.y_axis.title = "사람 수"
 51 | 
 52 | """
 53 | 데이터의 타이틀이 포함되어 있다면, titles_from_data=True
 54 | 데이터가 각 행에 걸쳐서(행우선) 차례대로 기입되어 있다면, from_rows=True
 55 | """
 56 | # 데이터를 이용해 차트에 그리기
 57 | datas = openpyxl.chart.Reference(worksheet, min_row=2, min_col=9, max_row=2 + len(counter) - 1, max_col=10)
 58 | bar_chart.add_data(datas, from_rows=True, titles_from_data=True)
 59 | 
 60 | # 만들어진 차트(chart)를 "A32"의 위치에 그리기
 61 | worksheet.add_chart(bar_chart, "A32")
 62 | # 완성된 엑셀 파일 저장하기
 63 | workbook.save("bar_chart.xlsx")
 64 | </pre>
 65 | 
 66 | * 엑셀에서는 막대 차트(Bar Chart)뿐만 아니라 파이 차트(Pie Chart)도 제공합니다. 
 67 |     * 파이 차트를 그릴 때는 하나의 열(column)에서 데이터를 한 번에 가져오므로 from_rows 속성의 값이 False입니다.
 68 |     * 학년 정보를 레이블(label) 형태로 별도로 파이 차트의 set_categories() 함수의 파라미터로 넣어줍니다.
 69 | 
 70 | <pre>
 71 | import openpyxl
 72 | from collections import Counter
 73 | 
 74 | # 워크북(workbook) 불러오기
 75 | workbook = openpyxl.load_workbook("students.xlsx")
 76 | 
 77 | # 활성화된 워크시트(worksheet) 가져오기
 78 | worksheet = workbook.active
 79 | 
 80 | # 학년 정보가 담길 리스트
 81 | grades = []
 82 | 
 83 | # 각 행(row)을 하나씩 확인하며
 84 | max_row = worksheet.max_row
 85 | for row in range(1, max_row + 1):
 86 |     # 학년 정보를 확인하여 리스트에 담기
 87 |     value = worksheet.cell(row=row, column=7).value
 88 |     grades.append(value)
 89 | 
 90 | # 각 학년의 출현 빈도 계산하기
 91 | counter = Counter(grades)
 92 | print("출현 빈도:", counter)
 93 | 
 94 | # 각 학년별 사람 수 기록하기
 95 | worksheet.cell(row=1, column=9).value = "학년"
 96 | worksheet.cell(row=1, column=10).value = "사람 수"
 97 | row = 2
 98 | for grade in counter:
 99 |     worksheet.cell(row=row, column=9).value = grade
100 |     worksheet.cell(row=row, column=10).value = counter[grade]
101 |     row += 1
102 | 
103 | # 파이 차트(Pie Chart) 만들기
104 | pie_chart = openpyxl.chart.PieChart()
105 | pie_chart.title = "학년 통계"
106 | 
107 | """
108 | 데이터의 타이틀이 포함되어 있다면, titles_from_data=True
109 | 데이터가 각 행에 걸쳐서(행우선) 차례대로 기입되어 있다면, from_rows=True
110 | """
111 | # 불러올 데이터 명시
112 | labels = openpyxl.chart.Reference(worksheet, min_row=2, min_col=9, max_row=2 + len(counter) - 1, max_col=9)
113 | datas = openpyxl.chart.Reference(worksheet, min_row=1, min_col=10, max_row=2 + len(counter) - 1, max_col=10)
114 | 
115 | pie_chart.add_data(datas, from_rows=False, titles_from_data=True) # 차트에 데이터(data) 추가
116 | pie_chart.set_categories(labels) # 차트에 레이블(label) 추가
117 | 
118 | # 만들어진 차트(chart)를 "A32"의 위치에 그리기
119 | worksheet.add_chart(pie_chart, "A32")
120 | # 완성된 엑셀 파일 저장하기
121 | workbook.save("pie_chart.xlsx")
122 | </pre>
123 | 
124 | #### 2) 이미지 삽입하기
125 | 
126 | * 이미지를 삽입할 때는 add_image() 함수를 이용하면 됩니다.
127 |     * 간단히 파이썬(Python) 로고 파일(python.png)을 특정한 셀 위치에 삽입해 봅시다.
128 | 
129 | <pre>
130 | import openpyxl
131 | 
132 | workbook = openpyxl.Workbook() # 워크북(workbook) 생성
133 | 
134 | # 활성화된 워크시트(worksheet) 가져오기
135 | worksheet = workbook.active
136 | 
137 | # 특정한 파일 경로에서 이미지 불러오기
138 | image = openpyxl.drawing.image.Image("python.png")
139 | # 이미지를 "B2"의 위치에 그리기
140 | worksheet.add_image(image, "B2")
141 | 
142 | # 완성된 엑셀 파일 저장하기
143 | workbook.save("image.xlsx")
144 | </pre>
145 | 


--------------------------------------------------------------------------------
/9/README.md:
--------------------------------------------------------------------------------
 1 | ### 9장 엑셀에서 함수 다루기
 2 | 
 3 | #### 프로그래밍을 제어하기 위한 문법
 4 | 
 5 | * 사무직 업무를 볼 때는 엑셀에서의 다양한 함수를 사용하게 됩니다.
 6 |     * 데이터의 합계나 평균을 구하는 작업은 흔하게 요구됩니다.
 7 | * students.xlsx 파일을 이용하여 실습을 진행합니다.
 8 | 
 9 | #### 1) 함수 다루기
10 | 
11 | * 각 열마다 점수의 평균을 구하고자 할 때는 엑셀에서 AVERAGE 함수를 사용합니다.
12 |     * C열부터 E까지에 각 학생들의 (점수1, 점수2, 점수3)이 적혀 있습니다. 
13 | * 각 점수에 대하여 모든 학생의 평균 점수를 구할 수 있습니다.
14 | 
15 | <pre>
16 | import openpyxl
17 | from collections import Counter
18 | 
19 | # 워크북(workbook) 불러오기
20 | workbook = openpyxl.load_workbook("students.xlsx")
21 | 
22 | # 활성화된 워크시트(worksheet) 가져오기
23 | worksheet = workbook.active
24 | 
25 | # 최대 행(max row) 구하기
26 | max_row = worksheet.max_row
27 | 
28 | # C부터 E까지의 모든 열(column)에 대하여 평균값 계산
29 | worksheet["C" + str(max_row + 1)].value = "=AVERAGE(C1:C" + str(max_row) + ")"
30 | worksheet["D" + str(max_row + 1)].value = "=AVERAGE(D1:D" + str(max_row) + ")"
31 | worksheet["E" + str(max_row + 1)].value = "=AVERAGE(E1:E" + str(max_row) + ")"
32 | 
33 | workbook.save("function.xlsx")
34 | </pre>
35 | 
36 | * 학생별로 세 점수의 평균을 구할 수 있습니다.
37 | 
38 | <pre>
39 | import openpyxl
40 | from collections import Counter
41 | 
42 | # 워크북(workbook) 불러오기
43 | workbook = openpyxl.load_workbook("students.xlsx")
44 | 
45 | # 활성화된 워크시트(worksheet) 가져오기
46 | worksheet = workbook.active
47 | 
48 | # 최대 행(max row) 구하기
49 | max_row = worksheet.max_row
50 | 
51 | for row in range(1, max_row + 1):
52 |     # 각 줄마다 함수 적용
53 |     worksheet["H" + str(row)].value = "=AVERAGE(C" + str(row) + ":E" + str(row) + ")"
54 | 
55 | # C부터 E까지의 모든 열(column)에 대하여 평균값 계산
56 | worksheet["C" + str(max_row + 1)].value = "=AVERAGE(C1:C" + str(max_row) + ")"
57 | worksheet["D" + str(max_row + 1)].value = "=AVERAGE(D1:D" + str(max_row) + ")"
58 | worksheet["E" + str(max_row + 1)].value = "=AVERAGE(E1:E" + str(max_row) + ")"
59 | 
60 | workbook.save("function.xlsx")
61 | </pre>
62 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | 
 2 | ### 파이썬을 이용한 업무 자동화 (Python Robotic Process Automation)
 3 | 
 4 | > 파이썬을 이용한 업무 자동화 소스코드를 모아 놓은 저장소입니다.
 5 | 
 6 | #### 시리즈 1. 파이썬 문법과 자동화 기초
 7 | 
 8 | 1. [파이썬 개발 환경 구축하기](/1/)
 9 | 2. [파이썬 문법 핵심 요약 - 기초](/2/)
10 | 3. [파이썬 문법 핵심 요약 - 심화](/3/)
11 | 4. [매크로를 활용해 키보드와 마우스 조종하기](/4/)
12 | 5. [파이썬 매크로 실전 예제](/5/)
13 | 
14 | #### 시리즈 2. 파이썬을 활용한 엑셀 자동화
15 | 
16 | 6. [여러 개의 텍스트 파일에서 필요한 정보만 엑셀에 정리하기](/6/)
17 | 7. [엑셀에서 다양한 방법으로 셀 다루기](/7/)
18 | 8. [엑셀에서 이미지, 차트 다루기](/8/)
19 | 9. [엑셀에서 함수 다루기](/9/)
20 | 10. [엑셀에서 서식 다루기](/10/)
21 | 
22 | #### 시리즈 3. 파이썬을 활용한 웹 자동화
23 | 
24 | 11. [웹 사이트의 구성 요소 핵심 요약](/11/)
25 | 12. [파이썬을 활용한 웹 크롤링 기초](/12/)
26 | 13. [셀레니움(Selenium)을 활용한 웹 크롤링](/13/)
27 | 14. [포털 사이트 이미지 수집 및 가공 실습](/14/)
28 | 15. [뉴스 기사 크롤링 및 분석 실습](/15/)
29 | 
30 | #### [부록] 실습 자료
31 | 
32 | * 실습에 사용되는 이미지 및 텍스트 파일은 [실습 자료](/resources/) 폴더에서 확인할 수 있습니다.
33 | 


--------------------------------------------------------------------------------
/figures/1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ndb796/Python-Robotic-Process-Automation/c9f7781fe31c7f064a724bc35ab4d5e07c4b1077/figures/1.jpg


--------------------------------------------------------------------------------
/figures/2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ndb796/Python-Robotic-Process-Automation/c9f7781fe31c7f064a724bc35ab4d5e07c4b1077/figures/2.jpg


--------------------------------------------------------------------------------
/resources/python.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ndb796/Python-Robotic-Process-Automation/c9f7781fe31c7f064a724bc35ab4d5e07c4b1077/resources/python.png


--------------------------------------------------------------------------------
/resources/students.txt:
--------------------------------------------------------------------------------
 1 | 1 박영철 97 95 84 컴퓨터공학과 3학년
 2 | 2 김철수 85 32 15 전자공학과 2학년
 3 | 3 홍길동 38 95 34 반도체공학과 3학년
 4 | 4 박수지 53 25 77 컴퓨터공학과 2학년
 5 | 5 이순신 45 35 34 전자공학과 3학년
 6 | 6 최지안 29 37 85 컴퓨터공학과 2학년
 7 | 7 한유준 75 68 65 컴퓨터공학과 3학년
 8 | 8 장민재 23 46 33 전자공학과 2학년
 9 | 9 신선우 55 74 88 컴퓨터공학과 4학년
10 | 10 정현우 34 74 55 전자공학과 3학년
11 | 11 양현준 97 85 99 전자공학과 2학년
12 | 12 전윤아 100 80 90 컴퓨터공학과 3학년
13 | 13 송시후 45 97 78 컴퓨터공학과 4학년
14 | 14 최건우 97 78 50 컴퓨터공학과 2학년
15 | 15 김도현 84 67 90 반도체공학과 3학년
16 | 16 김지훈 50 89 87 컴퓨터공학과 3학년
17 | 17 김지윤 72 67 34 전자공학과 4학년
18 | 18 김지유 77 98 100 컴퓨터공학과 2학년
19 | 19 왕서현 100 99 100 컴퓨터공학과 3학년
20 | 20 서민준 43 68 65 전자공학과 2학년


--------------------------------------------------------------------------------
/resources/students.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ndb796/Python-Robotic-Process-Automation/c9f7781fe31c7f064a724bc35ab4d5e07c4b1077/resources/students.xlsx


--------------------------------------------------------------------------------
/resources/students2.txt:
--------------------------------------------------------------------------------
1 | 21 김서준 45 68 46 컴퓨터공학과 3학년
2 | 22 이도윤 68 80 89 컴퓨터공학과 4학년
3 | 23 나준서 67 50 82 컴퓨터공학과 2학년
4 | 24 임하은 15 68 56 전자공학과 3학년
5 | 25 양하준 78 77 86 컴퓨터공학과 4학년
6 | 


--------------------------------------------------------------------------------
/resources/students3.txt:
--------------------------------------------------------------------------------
1 | 26 김주원 79 85 68 컴퓨터공학과 2학년 재학
2 | 27 유도윤 99 78 46 반도체공학과 3학년 재학
3 | 28 전현서 78 68 99 컴퓨터공학과 4학년 재학
4 | 29 차민우 98 56 75 컴퓨터공학과 2학년 재학
5 | 30 신한결 76 95 85 컴퓨터공학과 3학년 재학
6 | 31 김민우 85 94 24 컴퓨터공학과 4학년 휴학
7 | 


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