├── cover.jpg ├── data ├── 학생시험성적.xlsx ├── coffeeShopSales.txt ├── 담당자별_판매량_Andy사원.xlsx ├── littleprince_djvu.txt ├── missing_data_test.csv ├── 담당자별_판매량_Becky사원.xlsx ├── 담당자별_판매량_Chris사원.xlsx ├── sea_rain1_from_notepad.csv ├── total_sales_data.csv └── word_count.csv ├── python-for-data-analysis-movie-ranking.pdf ├── readme.txt ├── README.md └── notebook ├── Chapter_03_Calculator.ipynb ├── Chapter_05_if_for_while.ipynb ├── Chapter_06_Input_Output.ipynb ├── Chapter_08_Class_Object.ipynb ├── Chapter_09_String_Text_File_Processing.ipynb ├── Chapter_07_Function.ipynb ├── Chapter_04_Variable_DataType.ipynb └── Chapter_10_Module.ipynb /cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wikibook/python-for-data-analysis-rev/HEAD/cover.jpg -------------------------------------------------------------------------------- /data/학생시험성적.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wikibook/python-for-data-analysis-rev/HEAD/data/학생시험성적.xlsx -------------------------------------------------------------------------------- /data/coffeeShopSales.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wikibook/python-for-data-analysis-rev/HEAD/data/coffeeShopSales.txt -------------------------------------------------------------------------------- /data/담당자별_판매량_Andy사원.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wikibook/python-for-data-analysis-rev/HEAD/data/담당자별_판매량_Andy사원.xlsx -------------------------------------------------------------------------------- /data/littleprince_djvu.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wikibook/python-for-data-analysis-rev/HEAD/data/littleprince_djvu.txt -------------------------------------------------------------------------------- /data/missing_data_test.csv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wikibook/python-for-data-analysis-rev/HEAD/data/missing_data_test.csv -------------------------------------------------------------------------------- /data/담당자별_판매량_Becky사원.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wikibook/python-for-data-analysis-rev/HEAD/data/담당자별_판매량_Becky사원.xlsx -------------------------------------------------------------------------------- /data/담당자별_판매량_Chris사원.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wikibook/python-for-data-analysis-rev/HEAD/data/담당자별_판매량_Chris사원.xlsx -------------------------------------------------------------------------------- /data/sea_rain1_from_notepad.csv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wikibook/python-for-data-analysis-rev/HEAD/data/sea_rain1_from_notepad.csv -------------------------------------------------------------------------------- /python-for-data-analysis-movie-ranking.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wikibook/python-for-data-analysis-rev/HEAD/python-for-data-analysis-movie-ranking.pdf -------------------------------------------------------------------------------- /data/total_sales_data.csv: -------------------------------------------------------------------------------- 1 | 매장명,제품종류,모델명,판매,재고 2 | A,스마트폰,S1,1,2 3 | A,스마트폰,S2,2,5 4 | A,TV,V1,3,5 5 | B,스마트폰,S2,4,6 6 | B,스마트폰,S1,5,8 7 | B,TV,V1,6,9 8 | C,스마트폰,S2,2,4 9 | C,TV,V1,3,6 10 | C,TV,V2,7,9 11 | 12 | 13 | -------------------------------------------------------------------------------- /data/word_count.csv: -------------------------------------------------------------------------------- 1 | 단어,빈도 2 | 산업혁명,1662 3 | 기술,1223 4 | 사업,1126 5 | 혁신,1084 6 | 경제,1000 7 | 한국,945 8 | 기업,909 9 | 교육,883 10 | 미래,746 11 | 지역,724 12 | 스마트,663 13 | 정부,633 14 | 세계,553 15 | 서울,544 16 | 센터,534 17 | 대학,472 18 | 투자,449 19 | 개발,447 20 | 시장,442 21 | 성장,441 22 | 일자리,425 23 | 창업,412 24 | 발전,391 25 | 지능,389 26 | 전략,382 27 | 융합,333 28 | 규제,324 29 | 과학기술,322 30 | 인공지능,299 31 | 벤처기업,278 32 | 미국,256 33 | 자동차,248 34 | 업무,226 35 | 청년,221 36 | 문화,220 37 | 자율,214 38 | 연구,213 39 | 확대,212 40 | 진흥,210 41 | 국제,209 42 | 로봇,203 43 | 금융,192 44 | 빅데이터,191 45 | 플랫폼,179 46 | 데이터,177 47 | 디지털,177 48 | 국민,17 49 | 과학,168 50 | 블록체인,164 51 | 52 | -------------------------------------------------------------------------------- /readme.txt: -------------------------------------------------------------------------------- 1 | # 데이터 분석을 위한 파이썬 철저 입문 2 | 3 | - 압축 파일(zip 파일) 다운로드: https://github.com/wikibook/python-for-data-analysis-rev/archive/master.zip 4 | - 압축 파일을 다운로드 받고 압축을 풉니다. 5 | 6 | - 소스 코드 위치: /notebook 폴더 7 | - notebook 폴더에는 이 책에서 사용한 코드가 노트북 파일(*.ipynb)로 있습니다. 8 | - 3장(Chapter_03)에서 ~ 16장(Chapter_16)까지의 코드가 들어있습니다. 9 | - 데이터 파일 위치: /data 폴더 10 | - data 폴더에는 이 책의 코드에서 사용한 데이터 파일이 있습니다. 11 | - 다운로드 받은 data 폴더 내의 파일은 자신이 이용하는 작업 폴더 내의 data 폴더(여기서는 C:\myPyCode\data)에 복사해서 이용하면 됩니다. 12 | 13 | - 주피터 노트북 철치 및 사용 방법 14 | - 이 책 2장의 내용을 참고하세요. 15 | 16 | - 노트북 활용 방법 17 | 1. notebook 폴더에 있는 노트북 파일을 자신의 작업 폴더(여기서는 C:\myPyCode)에 복사합니다. 18 | 2. Anaconda Prompt를 실행해서 작업 폴더로 이동(만약 작업 폴더가 C:\myPyCode라면 'cd C:\myPyCode')합니다. 19 | 3. 명령창에 'jupyter notebook'을 입력합니다. 20 | 4. 다운로드 받은 노트북 파일이 보이는데 필요한 장(Chapter)의 노트북을 클릭하면 해당 노트북이 열립니다. 21 | 5. 코드 셀에 있는 코드를 직접 실행해도 되고, 자신이 만든 노트북에 해당 코드를 복사한 후 실행해도 됩니다. 22 | 23 | - 노트북에서 코드 찾기 24 | - 노트북의 코드 셀 위에 코드가 있는 책의 장과 페이지를 표시했습니다. 25 | - 책의 장과 페이지 표시 예: [3장: 30페이지] 26 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # 데이터 분석을 위한 파이썬 철저 입문 (개정증보판) 2 | 3 | - 책 소개: https://wikibook.co.kr/python-for-data-analysis-rev/ 4 | 5 | ![book_cover_image](cover.jpg) 6 | 7 | - 압축 파일(zip 파일) 다운로드: https://github.com/wikibook/python-for-data-analysis-rev/archive/master.zip 8 | - 압축 파일을 다운로드 받고 압축을 풉니다. 9 | 10 | - 소스 코드 위치: /notebook 폴더 11 | - notebook 폴더에는 이 책에서 사용한 코드가 노트북 파일(\*.ipynb)로 있습니다. 12 | - 3장(Chapter_03)에서 ~ 16장(Chapter_16)까지의 코드가 들어있습니다. 13 | - 데이터 파일 위치: /data 폴더 14 | - data 폴더에는 이 책의 코드에서 사용한 데이터 파일이 있습니다. 15 | - 다운로드 받은 data 폴더 내의 파일은 자신이 이용하는 작업 폴더 내의 data 폴더(여기서는 C:\myPyCode\data)에 복사해서 이용하면 됩니다. 16 | 17 | - 주피터 노트북 철치 및 사용 방법 18 | - 이 책 2장의 내용을 참고하세요. 19 | 20 | - 노트북 활용 방법 21 | 1. notebook 폴더에 있는 노트북 파일을 자신의 작업 폴더(여기서는 C:\myPyCode)에 복사합니다. 22 | 2. Anaconda Prompt를 실행해서 작업 폴더로 이동(만약 작업 폴더가 C:\myPyCode라면 'cd C:\myPyCode')합니다. 23 | 3. 명령창에 'jupyter notebook'을 입력합니다. 24 | 4. 다운로드 받은 노트북 파일이 보이는데 필요한 장(Chapter)의 노트북을 클릭하면 해당 노트북이 열립니다. 25 | 5. 코드 셀에 있는 코드를 직접 실행해도 되고, 자신이 만든 노트북에 해당 코드를 복사한 후 실행해도 됩니다. 26 | 27 | - 노트북에서 코드 찾기 28 | - 노트북의 코드 셀 위에 코드가 있는 책의 장과 페이지를 표시했습니다. 29 | - 책의 장과 페이지 표시 예: [3장: 30페이지] 30 | 31 | - 14장 '웹 스크레이핑' 내용 변경(421~425쪽) 32 | 33 | 웹 사이트 순위를 제공하던 알렉사가 2022년 5월 이후로 서비스를 중단함으로써 [네이버 영화](https://movie.naver.com/) 페이지의 '영화 순위' 정보를 스크레이핑하는 내용으로 변경합니다. 34 | 35 | - [PDF 파일 다운로드 - python-for-data-analysis-movie-ranking.pdf](https://github.com/wikibook/python-for-data-analysis-rev/blob/master/python-for-data-analysis-movie-ranking.pdf) -------------------------------------------------------------------------------- /notebook/Chapter_03_Calculator.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 3장 파이썬을 계산기처럼 이용하기" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## 3.1 간단한 사칙 연산" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "**[3장: 30페이지]**" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": null, 27 | "metadata": {}, 28 | "outputs": [], 29 | "source": [ 30 | "1 + 1" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": null, 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [ 39 | "5 -2" 40 | ] 41 | }, 42 | { 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "**[3장: 30페이지]**" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": null, 52 | "metadata": {}, 53 | "outputs": [], 54 | "source": [ 55 | "15 * 2" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": null, 61 | "metadata": {}, 62 | "outputs": [], 63 | "source": [ 64 | "10 / 2" 65 | ] 66 | }, 67 | { 68 | "cell_type": "markdown", 69 | "metadata": {}, 70 | "source": [ 71 | "**[3장: 31페이지]**" 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": null, 77 | "metadata": {}, 78 | "outputs": [], 79 | "source": [ 80 | "1.2 + 5.3" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": null, 86 | "metadata": {}, 87 | "outputs": [], 88 | "source": [ 89 | "3.5 - 5.0" 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": null, 95 | "metadata": {}, 96 | "outputs": [], 97 | "source": [ 98 | "1.4 * 2" 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": null, 104 | "metadata": {}, 105 | "outputs": [], 106 | "source": [ 107 | "5 / 2" 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "**[3장: 31페이지]**" 115 | ] 116 | }, 117 | { 118 | "cell_type": "code", 119 | "execution_count": null, 120 | "metadata": {}, 121 | "outputs": [], 122 | "source": [ 123 | "2 + 3 * 4" 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": null, 129 | "metadata": {}, 130 | "outputs": [], 131 | "source": [ 132 | "3 / 2 * 4 - 5 / 2" 133 | ] 134 | }, 135 | { 136 | "cell_type": "code", 137 | "execution_count": null, 138 | "metadata": {}, 139 | "outputs": [], 140 | "source": [ 141 | "10 / 5 + (5 - 2) * 2" 142 | ] 143 | }, 144 | { 145 | "cell_type": "code", 146 | "execution_count": null, 147 | "metadata": {}, 148 | "outputs": [], 149 | "source": [ 150 | "(5 * 4 - 15) + ((5 - 2) * (9-7))" 151 | ] 152 | }, 153 | { 154 | "cell_type": "markdown", 155 | "metadata": {}, 156 | "source": [ 157 | "**[3장: 32페이지]**" 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": null, 163 | "metadata": {}, 164 | "outputs": [], 165 | "source": [ 166 | "type(3)" 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": null, 172 | "metadata": {}, 173 | "outputs": [], 174 | "source": [ 175 | "type(1.2)" 176 | ] 177 | }, 178 | { 179 | "cell_type": "markdown", 180 | "metadata": {}, 181 | "source": [ 182 | "## 3.2 거듭 제곱과 나머지" 183 | ] 184 | }, 185 | { 186 | "cell_type": "markdown", 187 | "metadata": {}, 188 | "source": [ 189 | "**[3장: 33페이지]**" 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": null, 195 | "metadata": {}, 196 | "outputs": [], 197 | "source": [ 198 | "2 * 2 * 2 * 2 * 2" 199 | ] 200 | }, 201 | { 202 | "cell_type": "markdown", 203 | "metadata": {}, 204 | "source": [ 205 | "**[3장: 33페이지]**" 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": null, 211 | "metadata": {}, 212 | "outputs": [], 213 | "source": [ 214 | "2 ** 5" 215 | ] 216 | }, 217 | { 218 | "cell_type": "markdown", 219 | "metadata": {}, 220 | "source": [ 221 | "**[3장: 33페이지]**" 222 | ] 223 | }, 224 | { 225 | "cell_type": "code", 226 | "execution_count": null, 227 | "metadata": {}, 228 | "outputs": [], 229 | "source": [ 230 | "1.5 ** 2 " 231 | ] 232 | }, 233 | { 234 | "cell_type": "markdown", 235 | "metadata": {}, 236 | "source": [ 237 | "**[3장: 33페이지]**" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": null, 243 | "metadata": {}, 244 | "outputs": [], 245 | "source": [ 246 | "2 ** (1/2)" 247 | ] 248 | }, 249 | { 250 | "cell_type": "markdown", 251 | "metadata": {}, 252 | "source": [ 253 | "**[3장: 33페이지]**" 254 | ] 255 | }, 256 | { 257 | "cell_type": "code", 258 | "execution_count": null, 259 | "metadata": {}, 260 | "outputs": [], 261 | "source": [ 262 | "13 % 5" 263 | ] 264 | }, 265 | { 266 | "cell_type": "markdown", 267 | "metadata": {}, 268 | "source": [ 269 | "**[3장: 34페이지]**" 270 | ] 271 | }, 272 | { 273 | "cell_type": "code", 274 | "execution_count": null, 275 | "metadata": {}, 276 | "outputs": [], 277 | "source": [ 278 | "13 // 5" 279 | ] 280 | }, 281 | { 282 | "cell_type": "markdown", 283 | "metadata": {}, 284 | "source": [ 285 | "## 3.3 과학적 표기법" 286 | ] 287 | }, 288 | { 289 | "cell_type": "markdown", 290 | "metadata": {}, 291 | "source": [ 292 | "**[3장: 34페이지]**" 293 | ] 294 | }, 295 | { 296 | "cell_type": "code", 297 | "execution_count": null, 298 | "metadata": {}, 299 | "outputs": [], 300 | "source": [ 301 | "3 * 10 ** 8" 302 | ] 303 | }, 304 | { 305 | "cell_type": "markdown", 306 | "metadata": {}, 307 | "source": [ 308 | "**[3장: 35페이지]**" 309 | ] 310 | }, 311 | { 312 | "cell_type": "code", 313 | "execution_count": null, 314 | "metadata": {}, 315 | "outputs": [], 316 | "source": [ 317 | "3e8" 318 | ] 319 | }, 320 | { 321 | "cell_type": "markdown", 322 | "metadata": {}, 323 | "source": [ 324 | "**[3장: 35페이지]**" 325 | ] 326 | }, 327 | { 328 | "cell_type": "code", 329 | "execution_count": null, 330 | "metadata": {}, 331 | "outputs": [], 332 | "source": [ 333 | "1e15" 334 | ] 335 | }, 336 | { 337 | "cell_type": "code", 338 | "execution_count": null, 339 | "metadata": {}, 340 | "outputs": [], 341 | "source": [ 342 | "1e16" 343 | ] 344 | }, 345 | { 346 | "cell_type": "code", 347 | "execution_count": null, 348 | "metadata": {}, 349 | "outputs": [], 350 | "source": [ 351 | "1e-4" 352 | ] 353 | }, 354 | { 355 | "cell_type": "code", 356 | "execution_count": null, 357 | "metadata": {}, 358 | "outputs": [], 359 | "source": [ 360 | "1e-5" 361 | ] 362 | }, 363 | { 364 | "cell_type": "markdown", 365 | "metadata": {}, 366 | "source": [ 367 | "## 3.4 진수 표현과 변환" 368 | ] 369 | }, 370 | { 371 | "cell_type": "markdown", 372 | "metadata": {}, 373 | "source": [ 374 | "**[3장: 36페이지]**" 375 | ] 376 | }, 377 | { 378 | "cell_type": "code", 379 | "execution_count": null, 380 | "metadata": {}, 381 | "outputs": [], 382 | "source": [ 383 | "17" 384 | ] 385 | }, 386 | { 387 | "cell_type": "code", 388 | "execution_count": null, 389 | "metadata": {}, 390 | "outputs": [], 391 | "source": [ 392 | "0b10001" 393 | ] 394 | }, 395 | { 396 | "cell_type": "code", 397 | "execution_count": null, 398 | "metadata": {}, 399 | "outputs": [], 400 | "source": [ 401 | "0o21" 402 | ] 403 | }, 404 | { 405 | "cell_type": "code", 406 | "execution_count": null, 407 | "metadata": {}, 408 | "outputs": [], 409 | "source": [ 410 | "0x11" 411 | ] 412 | }, 413 | { 414 | "cell_type": "markdown", 415 | "metadata": {}, 416 | "source": [ 417 | "**[3장: 36 ~ 37페이지]**" 418 | ] 419 | }, 420 | { 421 | "cell_type": "code", 422 | "execution_count": null, 423 | "metadata": {}, 424 | "outputs": [], 425 | "source": [ 426 | "bin(17)" 427 | ] 428 | }, 429 | { 430 | "cell_type": "code", 431 | "execution_count": null, 432 | "metadata": {}, 433 | "outputs": [], 434 | "source": [ 435 | "oct(17)" 436 | ] 437 | }, 438 | { 439 | "cell_type": "code", 440 | "execution_count": null, 441 | "metadata": {}, 442 | "outputs": [], 443 | "source": [ 444 | "hex(17)" 445 | ] 446 | }, 447 | { 448 | "cell_type": "markdown", 449 | "metadata": {}, 450 | "source": [ 451 | "**[3장: 37페이지]**" 452 | ] 453 | }, 454 | { 455 | "cell_type": "code", 456 | "execution_count": null, 457 | "metadata": {}, 458 | "outputs": [], 459 | "source": [ 460 | "0b10 * 0o10 + 0x10 - 10" 461 | ] 462 | }, 463 | { 464 | "cell_type": "code", 465 | "execution_count": null, 466 | "metadata": {}, 467 | "outputs": [], 468 | "source": [ 469 | "bin(0b10 * 0o10 + 0x10 - 10)" 470 | ] 471 | }, 472 | { 473 | "cell_type": "code", 474 | "execution_count": null, 475 | "metadata": {}, 476 | "outputs": [], 477 | "source": [ 478 | "oct(0b10 * 0o10 + 0x10 - 10)" 479 | ] 480 | }, 481 | { 482 | "cell_type": "code", 483 | "execution_count": null, 484 | "metadata": {}, 485 | "outputs": [], 486 | "source": [ 487 | "hex(0b10 * 0o10 + 0x10 -10)" 488 | ] 489 | }, 490 | { 491 | "cell_type": "markdown", 492 | "metadata": {}, 493 | "source": [ 494 | "## 3.5 논리 연산 및 비교 연산" 495 | ] 496 | }, 497 | { 498 | "cell_type": "markdown", 499 | "metadata": {}, 500 | "source": [ 501 | "**[3장: 38페이지]**" 502 | ] 503 | }, 504 | { 505 | "cell_type": "code", 506 | "execution_count": null, 507 | "metadata": {}, 508 | "outputs": [], 509 | "source": [ 510 | "print(True)" 511 | ] 512 | }, 513 | { 514 | "cell_type": "code", 515 | "execution_count": null, 516 | "metadata": {}, 517 | "outputs": [], 518 | "source": [ 519 | "print(False)" 520 | ] 521 | }, 522 | { 523 | "cell_type": "markdown", 524 | "metadata": {}, 525 | "source": [ 526 | "**[3장: 38페이지]**" 527 | ] 528 | }, 529 | { 530 | "cell_type": "code", 531 | "execution_count": null, 532 | "metadata": {}, 533 | "outputs": [], 534 | "source": [ 535 | "type(True)" 536 | ] 537 | }, 538 | { 539 | "cell_type": "markdown", 540 | "metadata": {}, 541 | "source": [ 542 | "**[3장: 39페이지]**" 543 | ] 544 | }, 545 | { 546 | "cell_type": "code", 547 | "execution_count": null, 548 | "metadata": {}, 549 | "outputs": [], 550 | "source": [ 551 | "print(True and False)\n", 552 | "print(True or False)\n", 553 | "print(not True)" 554 | ] 555 | }, 556 | { 557 | "cell_type": "markdown", 558 | "metadata": {}, 559 | "source": [ 560 | "**[3장: 40페이지]**" 561 | ] 562 | }, 563 | { 564 | "cell_type": "code", 565 | "execution_count": null, 566 | "metadata": { 567 | "scrolled": true 568 | }, 569 | "outputs": [], 570 | "source": [ 571 | "print(5 == 3)\n", 572 | "print(5 != 3)\n", 573 | "print(5 < 3)\n", 574 | "print(5 > 3)\n", 575 | "print(5 <= 3)\n", 576 | "print(5 >= 3)" 577 | ] 578 | }, 579 | { 580 | "cell_type": "markdown", 581 | "metadata": {}, 582 | "source": [ 583 | "**[3장: 40페이지]**" 584 | ] 585 | }, 586 | { 587 | "cell_type": "code", 588 | "execution_count": null, 589 | "metadata": {}, 590 | "outputs": [], 591 | "source": [ 592 | "print( 1 > 0 and -2 < 0)" 593 | ] 594 | }, 595 | { 596 | "cell_type": "markdown", 597 | "metadata": {}, 598 | "source": [ 599 | "**[3장: 41페이지]**" 600 | ] 601 | }, 602 | { 603 | "cell_type": "code", 604 | "execution_count": null, 605 | "metadata": {}, 606 | "outputs": [], 607 | "source": [ 608 | "print((3 < 0) and ((-5 > 0) and (1 > 5)))\n", 609 | "print((3 > 0) or ((-5 > 0) and (1 > 5)))\n", 610 | "print(((3 > 0) or (-5 > 0)) and ((4 > 8) or ( 3 < 0)))" 611 | ] 612 | }, 613 | { 614 | "cell_type": "markdown", 615 | "metadata": {}, 616 | "source": [ 617 | "# 3.6 정리" 618 | ] 619 | } 620 | ], 621 | "metadata": { 622 | "anaconda-cloud": {}, 623 | "kernelspec": { 624 | "display_name": "Python 3", 625 | "language": "python", 626 | "name": "python3" 627 | }, 628 | "language_info": { 629 | "codemirror_mode": { 630 | "name": "ipython", 631 | "version": 3 632 | }, 633 | "file_extension": ".py", 634 | "mimetype": "text/x-python", 635 | "name": "python", 636 | "nbconvert_exporter": "python", 637 | "pygments_lexer": "ipython3", 638 | "version": "3.6.4" 639 | }, 640 | "latex_envs": { 641 | "LaTeX_envs_menu_present": true, 642 | "autoclose": false, 643 | "autocomplete": true, 644 | "bibliofile": "biblio.bib", 645 | "cite_by": "apalike", 646 | "current_citInitial": 1, 647 | "eqLabelWithNumbers": true, 648 | "eqNumInitial": 1, 649 | "hotkeys": { 650 | "equation": "Ctrl-E", 651 | "itemize": "Ctrl-I" 652 | }, 653 | "labels_anchors": false, 654 | "latex_user_defs": false, 655 | "report_style_numbering": false, 656 | "user_envs_cfg": false 657 | }, 658 | "nav_menu": {}, 659 | "toc": { 660 | "nav_menu": { 661 | "height": "161px", 662 | "width": "252px" 663 | }, 664 | "number_sections": false, 665 | "sideBar": true, 666 | "skip_h1_title": false, 667 | "toc_cell": false, 668 | "toc_position": { 669 | "height": "582px", 670 | "left": "0px", 671 | "right": "1154px", 672 | "top": "111px", 673 | "width": "212px" 674 | }, 675 | "toc_section_display": "block", 676 | "toc_window_display": false 677 | }, 678 | "toc_position": { 679 | "left": "1134.41px", 680 | "right": "20px", 681 | "top": "53px", 682 | "width": "210px" 683 | } 684 | }, 685 | "nbformat": 4, 686 | "nbformat_minor": 1 687 | } 688 | -------------------------------------------------------------------------------- /notebook/Chapter_05_if_for_while.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 5장 제어문" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## 5.1 조건에 따라 분기하는 if 문" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "### 단일 조건에 따른 분기(if)" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "**[5장: 72페이지]**" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": null, 34 | "metadata": { 35 | "code_folding": [], 36 | "scrolled": true 37 | }, 38 | "outputs": [], 39 | "source": [ 40 | "x = 95\n", 41 | "if x >= 90:\n", 42 | " print(\"Pass\")" 43 | ] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "metadata": {}, 48 | "source": [ 49 | "### 단일 조건 및 그 외 조건에 따른 분기(if ~ else)" 50 | ] 51 | }, 52 | { 53 | "cell_type": "markdown", 54 | "metadata": {}, 55 | "source": [ 56 | "**[5장: 73페이지]**" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": null, 62 | "metadata": {}, 63 | "outputs": [], 64 | "source": [ 65 | "x = 75\n", 66 | "if x >= 90:\n", 67 | " print(\"Pass\")\n", 68 | "else:\n", 69 | " print(\"Fail\")" 70 | ] 71 | }, 72 | { 73 | "cell_type": "markdown", 74 | "metadata": {}, 75 | "source": [ 76 | "### 여러 조건에 따른 분기(if ~ elif ~ else)" 77 | ] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "metadata": {}, 82 | "source": [ 83 | "**[5장: 75페이지]**" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": null, 89 | "metadata": {}, 90 | "outputs": [], 91 | "source": [ 92 | "x = 85\n", 93 | "if x >= 90:\n", 94 | " print(\"Very good\")\n", 95 | "elif (x >= 80) and (x < 90):\n", 96 | " print(\"Good\")\n", 97 | "else:\n", 98 | " print(\"Bad\")" 99 | ] 100 | }, 101 | { 102 | "cell_type": "markdown", 103 | "metadata": {}, 104 | "source": [ 105 | "**[5장: 75페이지]**" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": null, 111 | "metadata": {}, 112 | "outputs": [], 113 | "source": [ 114 | "x = 85\n", 115 | "if x >= 90:\n", 116 | " print(\"Very Good\")\n", 117 | "elif 80 <= x < 90:\n", 118 | " print(\"Good\")\n", 119 | "else:\n", 120 | " print(\"Bad\")" 121 | ] 122 | }, 123 | { 124 | "cell_type": "markdown", 125 | "metadata": {}, 126 | "source": [ 127 | "### 중첩 조건에 따른 분기" 128 | ] 129 | }, 130 | { 131 | "cell_type": "markdown", 132 | "metadata": {}, 133 | "source": [ 134 | "**[5장: 77페이지]**" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": null, 140 | "metadata": {}, 141 | "outputs": [], 142 | "source": [ 143 | "x = 100\n", 144 | "if x >= 90:\n", 145 | " if x==100 :\n", 146 | " print(\"Perfect\")\n", 147 | " else:\n", 148 | " print(\"Very Good\")\n", 149 | "elif (x >= 80) and (x < 90):\n", 150 | " print(\"Good\")\n", 151 | "else:\n", 152 | " print(\"Bad\")" 153 | ] 154 | }, 155 | { 156 | "cell_type": "markdown", 157 | "metadata": {}, 158 | "source": [ 159 | "## 5.2 지정된 범위만큼 반복하는 for 문" 160 | ] 161 | }, 162 | { 163 | "cell_type": "markdown", 164 | "metadata": {}, 165 | "source": [ 166 | "### 반복문의 필요성" 167 | ] 168 | }, 169 | { 170 | "cell_type": "markdown", 171 | "metadata": {}, 172 | "source": [ 173 | "**[5장: 78페이지]**" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": null, 179 | "metadata": {}, 180 | "outputs": [], 181 | "source": [ 182 | "a = 0 # 변수 a를 0으로 초기화\n", 183 | "print(a) # 변수 a 출력\n", 184 | "\n", 185 | "a = a + 1 # 변수 a에 1을 더한 후, 다시 a에 대입\n", 186 | "print(a) # 변수 a 출력\n", 187 | "\n", 188 | "a = a + 1 # 같은 코드 반복\n", 189 | "print(a)\n", 190 | "\n", 191 | "a = a + 1 # 같은 코드 반복\n", 192 | "print(a)\n", 193 | "\n", 194 | "a = a + 1 # 같은 코드 반복\n", 195 | "print(a)\n", 196 | "\n", 197 | "a = a + 1 # 같은 코드 반복\n", 198 | "print(a)" 199 | ] 200 | }, 201 | { 202 | "cell_type": "markdown", 203 | "metadata": {}, 204 | "source": [ 205 | "### for 문의 구조\n", 206 | "\n" 207 | ] 208 | }, 209 | { 210 | "cell_type": "markdown", 211 | "metadata": {}, 212 | "source": [ 213 | "### 반복 범위 지정" 214 | ] 215 | }, 216 | { 217 | "cell_type": "markdown", 218 | "metadata": {}, 219 | "source": [ 220 | "#### 리스트 이용" 221 | ] 222 | }, 223 | { 224 | "cell_type": "markdown", 225 | "metadata": {}, 226 | "source": [ 227 | "**[5장: 80페이지]**" 228 | ] 229 | }, 230 | { 231 | "cell_type": "code", 232 | "execution_count": null, 233 | "metadata": {}, 234 | "outputs": [], 235 | "source": [ 236 | "for a in [0, 1, 2, 3, 4, 5]:\n", 237 | " print(a)" 238 | ] 239 | }, 240 | { 241 | "cell_type": "markdown", 242 | "metadata": {}, 243 | "source": [ 244 | "**[5장: 81페이지]**" 245 | ] 246 | }, 247 | { 248 | "cell_type": "code", 249 | "execution_count": null, 250 | "metadata": {}, 251 | "outputs": [], 252 | "source": [ 253 | "myFriends = ['James', 'Robert', 'Lisa', 'Mary'] # 리스트를 변수에 할당\n", 254 | "for myFriend in myFriends:\n", 255 | " print(myFriend)" 256 | ] 257 | }, 258 | { 259 | "cell_type": "markdown", 260 | "metadata": {}, 261 | "source": [ 262 | "#### range() 함수 이용" 263 | ] 264 | }, 265 | { 266 | "cell_type": "markdown", 267 | "metadata": {}, 268 | "source": [ 269 | "**[5장: 82페이지]**" 270 | ] 271 | }, 272 | { 273 | "cell_type": "code", 274 | "execution_count": null, 275 | "metadata": {}, 276 | "outputs": [], 277 | "source": [ 278 | "print(range(0, 10, 1))" 279 | ] 280 | }, 281 | { 282 | "cell_type": "markdown", 283 | "metadata": {}, 284 | "source": [ 285 | "**[5장: 82페이지]**" 286 | ] 287 | }, 288 | { 289 | "cell_type": "code", 290 | "execution_count": null, 291 | "metadata": {}, 292 | "outputs": [], 293 | "source": [ 294 | "print(list(range(0, 10, 1)))" 295 | ] 296 | }, 297 | { 298 | "cell_type": "markdown", 299 | "metadata": {}, 300 | "source": [ 301 | "**[5장: 82페이지]**" 302 | ] 303 | }, 304 | { 305 | "cell_type": "code", 306 | "execution_count": null, 307 | "metadata": {}, 308 | "outputs": [], 309 | "source": [ 310 | "for a in range(0, 6, 1):\n", 311 | " print(a)" 312 | ] 313 | }, 314 | { 315 | "cell_type": "markdown", 316 | "metadata": {}, 317 | "source": [ 318 | "**[5장: 82페이지]**" 319 | ] 320 | }, 321 | { 322 | "cell_type": "code", 323 | "execution_count": null, 324 | "metadata": {}, 325 | "outputs": [], 326 | "source": [ 327 | "for a in range(0, 6, 2):\n", 328 | " print(a)" 329 | ] 330 | }, 331 | { 332 | "cell_type": "markdown", 333 | "metadata": {}, 334 | "source": [ 335 | "**[5장: 83페이지]**" 336 | ] 337 | }, 338 | { 339 | "cell_type": "code", 340 | "execution_count": null, 341 | "metadata": {}, 342 | "outputs": [], 343 | "source": [ 344 | "print(list(range(0, 10, 1)))\n", 345 | "print(list(range(0, 10)))\n", 346 | "print(list(range(10)))" 347 | ] 348 | }, 349 | { 350 | "cell_type": "markdown", 351 | "metadata": {}, 352 | "source": [ 353 | "**[5장: 83페이지]**" 354 | ] 355 | }, 356 | { 357 | "cell_type": "code", 358 | "execution_count": null, 359 | "metadata": {}, 360 | "outputs": [], 361 | "source": [ 362 | "print(list(range(0, 20, 5))) # Line 1\n", 363 | "print(list(range(-10, 0, 2))) # Line 2\n", 364 | "print(list(range(3, -10, -3))) # Line 3\n", 365 | "print(list(range(0, -5, 1))) # Line 4" 366 | ] 367 | }, 368 | { 369 | "cell_type": "markdown", 370 | "metadata": {}, 371 | "source": [ 372 | "### 중첩 for 문" 373 | ] 374 | }, 375 | { 376 | "cell_type": "markdown", 377 | "metadata": {}, 378 | "source": [ 379 | "**[5장: 84페이지]**" 380 | ] 381 | }, 382 | { 383 | "cell_type": "code", 384 | "execution_count": null, 385 | "metadata": {}, 386 | "outputs": [], 387 | "source": [ 388 | "x_list = ['x1', 'x2']\n", 389 | "y_list = ['y1', 'y2']\n", 390 | "\n", 391 | "print(\"x y\")\n", 392 | "for x in x_list:\n", 393 | " for y in y_list:\n", 394 | " print(x,y)" 395 | ] 396 | }, 397 | { 398 | "cell_type": "markdown", 399 | "metadata": {}, 400 | "source": [ 401 | "### 여러 개의 리스트 다루기" 402 | ] 403 | }, 404 | { 405 | "cell_type": "markdown", 406 | "metadata": {}, 407 | "source": [ 408 | "**[5장: 85페이지]**" 409 | ] 410 | }, 411 | { 412 | "cell_type": "code", 413 | "execution_count": null, 414 | "metadata": {}, 415 | "outputs": [], 416 | "source": [ 417 | "names = ['James', 'Robert', 'Lisa', 'Mary'] \n", 418 | "scores = [95, 96, 97, 94]" 419 | ] 420 | }, 421 | { 422 | "cell_type": "markdown", 423 | "metadata": {}, 424 | "source": [ 425 | "**[5장: 85페이지]**" 426 | ] 427 | }, 428 | { 429 | "cell_type": "code", 430 | "execution_count": null, 431 | "metadata": {}, 432 | "outputs": [], 433 | "source": [ 434 | "for k in range(len(names)):\n", 435 | " print(names[k], scores[k])" 436 | ] 437 | }, 438 | { 439 | "cell_type": "markdown", 440 | "metadata": {}, 441 | "source": [ 442 | "**[5장: 86페이지]**" 443 | ] 444 | }, 445 | { 446 | "cell_type": "code", 447 | "execution_count": null, 448 | "metadata": {}, 449 | "outputs": [], 450 | "source": [ 451 | "for name, score in zip(names, scores):\n", 452 | " print(name, score)" 453 | ] 454 | }, 455 | { 456 | "cell_type": "markdown", 457 | "metadata": {}, 458 | "source": [ 459 | "## 5.3 조건에 따라 반복하는 while 문" 460 | ] 461 | }, 462 | { 463 | "cell_type": "markdown", 464 | "metadata": {}, 465 | "source": [ 466 | "### while 문의 구조" 467 | ] 468 | }, 469 | { 470 | "cell_type": "markdown", 471 | "metadata": {}, 472 | "source": [ 473 | "**[5장: 87페이지]**" 474 | ] 475 | }, 476 | { 477 | "cell_type": "code", 478 | "execution_count": null, 479 | "metadata": {}, 480 | "outputs": [], 481 | "source": [ 482 | "i = 0 # 초기화\n", 483 | "sum = 0 # 초기화\n", 484 | "\n", 485 | "print(\"i sum\")\n", 486 | "while (sum < 20): # 조건 검사\n", 487 | " i = i + 1 # i를 1씩 증가\n", 488 | " sum = sum + i # 이전의 sum과 현재 i를 더해서 sum을 갱신\n", 489 | " print(i, sum) # i와 sum을 출력" 490 | ] 491 | }, 492 | { 493 | "cell_type": "markdown", 494 | "metadata": {}, 495 | "source": [ 496 | "### 무한 반복 while 문" 497 | ] 498 | }, 499 | { 500 | "cell_type": "markdown", 501 | "metadata": {}, 502 | "source": [ 503 | "## 5.4 반복문을 제어하는 break와 continue" 504 | ] 505 | }, 506 | { 507 | "cell_type": "markdown", 508 | "metadata": {}, 509 | "source": [ 510 | "### 반복문을 빠져나오는 break" 511 | ] 512 | }, 513 | { 514 | "cell_type": "markdown", 515 | "metadata": {}, 516 | "source": [ 517 | "**[5장: 89페이지]**" 518 | ] 519 | }, 520 | { 521 | "cell_type": "code", 522 | "execution_count": null, 523 | "metadata": {}, 524 | "outputs": [], 525 | "source": [ 526 | "k=0\n", 527 | "while True: \n", 528 | " k = k + 1 # k는 1씩 증가\n", 529 | " \n", 530 | " if(k > 3): # k가 3보다 크면 \n", 531 | " break # break로 while 문을 빠져나옴\n", 532 | " \n", 533 | " print(k) # k 출력" 534 | ] 535 | }, 536 | { 537 | "cell_type": "markdown", 538 | "metadata": {}, 539 | "source": [ 540 | "**[5장: 89페이지]**" 541 | ] 542 | }, 543 | { 544 | "cell_type": "code", 545 | "execution_count": null, 546 | "metadata": {}, 547 | "outputs": [], 548 | "source": [ 549 | "for k in range(10): \n", 550 | " if(k > 2): # k 가 2보다 크면 \n", 551 | " break # break로 for 문을 빠져나옴 \n", 552 | " \n", 553 | " print(k) # k 출력 " 554 | ] 555 | }, 556 | { 557 | "cell_type": "markdown", 558 | "metadata": {}, 559 | "source": [ 560 | "### 다음 반복을 실행하는 continue" 561 | ] 562 | }, 563 | { 564 | "cell_type": "markdown", 565 | "metadata": {}, 566 | "source": [ 567 | "**[5장: 90페이지]**" 568 | ] 569 | }, 570 | { 571 | "cell_type": "code", 572 | "execution_count": null, 573 | "metadata": { 574 | "scrolled": true 575 | }, 576 | "outputs": [], 577 | "source": [ 578 | "for k in range(5):\n", 579 | " if(k == 2):\n", 580 | " continue\n", 581 | " \n", 582 | " print(k)" 583 | ] 584 | }, 585 | { 586 | "cell_type": "markdown", 587 | "metadata": {}, 588 | "source": [ 589 | "**[5장: 91페이지]**" 590 | ] 591 | }, 592 | { 593 | "cell_type": "code", 594 | "execution_count": null, 595 | "metadata": {}, 596 | "outputs": [], 597 | "source": [ 598 | "k = 0\n", 599 | "while True:\n", 600 | " k = k + 1\n", 601 | " \n", 602 | " if(k == 2):\n", 603 | " print(\"continue next\")\n", 604 | " continue\n", 605 | " if(k > 4):\n", 606 | " break\n", 607 | " \n", 608 | " print(k)" 609 | ] 610 | }, 611 | { 612 | "cell_type": "markdown", 613 | "metadata": {}, 614 | "source": [ 615 | "## 5.5 간단하게 반복하는 한 줄 for 문" 616 | ] 617 | }, 618 | { 619 | "cell_type": "markdown", 620 | "metadata": {}, 621 | "source": [ 622 | "### 리스트 컴프리헨션의 기본 구조" 623 | ] 624 | }, 625 | { 626 | "cell_type": "markdown", 627 | "metadata": {}, 628 | "source": [ 629 | "**[5장: 92페이지]**" 630 | ] 631 | }, 632 | { 633 | "cell_type": "code", 634 | "execution_count": null, 635 | "metadata": {}, 636 | "outputs": [], 637 | "source": [ 638 | "numbers = [1,2,3,4,5]\n", 639 | "square = []\n", 640 | "\n", 641 | "for i in numbers:\n", 642 | " square.append(i**2)\n", 643 | " \n", 644 | "print(square)" 645 | ] 646 | }, 647 | { 648 | "cell_type": "markdown", 649 | "metadata": {}, 650 | "source": [ 651 | "**[5장: 92페이지]**" 652 | ] 653 | }, 654 | { 655 | "cell_type": "code", 656 | "execution_count": null, 657 | "metadata": {}, 658 | "outputs": [], 659 | "source": [ 660 | "numbers = [1,2,3,4,5]\n", 661 | "square = [i**2 for i in numbers]\n", 662 | "print(square)" 663 | ] 664 | }, 665 | { 666 | "cell_type": "markdown", 667 | "metadata": {}, 668 | "source": [ 669 | "### 조건문을 포함한 리스트 컴프리헨션" 670 | ] 671 | }, 672 | { 673 | "cell_type": "markdown", 674 | "metadata": {}, 675 | "source": [ 676 | "**[5장: 93페이지]**" 677 | ] 678 | }, 679 | { 680 | "cell_type": "code", 681 | "execution_count": null, 682 | "metadata": {}, 683 | "outputs": [], 684 | "source": [ 685 | "numbers = [1,2,3,4,5]\n", 686 | "square = []\n", 687 | "\n", 688 | "for i in numbers:\n", 689 | " if i >= 3:\n", 690 | " square.append(i**2)\n", 691 | " \n", 692 | "print(square)" 693 | ] 694 | }, 695 | { 696 | "cell_type": "markdown", 697 | "metadata": {}, 698 | "source": [ 699 | "**[5장: 93페이지]**" 700 | ] 701 | }, 702 | { 703 | "cell_type": "code", 704 | "execution_count": null, 705 | "metadata": {}, 706 | "outputs": [], 707 | "source": [ 708 | "numbers = [1,2,3,4,5]\n", 709 | "square = [i**2 for i in numbers if i>=3]\n", 710 | "\n", 711 | "print(square)" 712 | ] 713 | }, 714 | { 715 | "cell_type": "markdown", 716 | "metadata": {}, 717 | "source": [ 718 | "# 5.6 정리" 719 | ] 720 | } 721 | ], 722 | "metadata": { 723 | "anaconda-cloud": {}, 724 | "kernelspec": { 725 | "display_name": "Python 3", 726 | "language": "python", 727 | "name": "python3" 728 | }, 729 | "language_info": { 730 | "codemirror_mode": { 731 | "name": "ipython", 732 | "version": 3 733 | }, 734 | "file_extension": ".py", 735 | "mimetype": "text/x-python", 736 | "name": "python", 737 | "nbconvert_exporter": "python", 738 | "pygments_lexer": "ipython3", 739 | "version": "3.6.4" 740 | }, 741 | "latex_envs": { 742 | "bibliofile": "biblio.bib", 743 | "cite_by": "apalike", 744 | "current_citInitial": 1, 745 | "eqLabelWithNumbers": true, 746 | "eqNumInitial": 0 747 | }, 748 | "nav_menu": {}, 749 | "toc": { 750 | "nav_menu": { 751 | "height": "159px", 752 | "width": "252px" 753 | }, 754 | "number_sections": false, 755 | "sideBar": true, 756 | "skip_h1_title": false, 757 | "toc_cell": false, 758 | "toc_position": { 759 | "height": "582px", 760 | "left": "0px", 761 | "right": "1052px", 762 | "top": "111px", 763 | "width": "314px" 764 | }, 765 | "toc_section_display": "block", 766 | "toc_window_display": false 767 | }, 768 | "toc_position": { 769 | "left": "1045px", 770 | "right": "20px", 771 | "top": "119px", 772 | "width": "300px" 773 | } 774 | }, 775 | "nbformat": 4, 776 | "nbformat_minor": 1 777 | } 778 | -------------------------------------------------------------------------------- /notebook/Chapter_06_Input_Output.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 6장 입력과 출력" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## 6.1 화면 출력" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "### 기본 출력" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "**[6장: 95페이지]**" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": null, 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [ 37 | "print(\"Hello Python!!\")" 38 | ] 39 | }, 40 | { 41 | "cell_type": "markdown", 42 | "metadata": {}, 43 | "source": [ 44 | "**[6장: 96페이지]**" 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": null, 50 | "metadata": { 51 | "scrolled": true 52 | }, 53 | "outputs": [], 54 | "source": [ 55 | "print(\"Best\", \"python\", \"book\")" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "**[6장: 96페이지]**" 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": null, 68 | "metadata": {}, 69 | "outputs": [], 70 | "source": [ 71 | "print(\"Best\", \"python\", \"book\", sep = \"-:*:-\")" 72 | ] 73 | }, 74 | { 75 | "cell_type": "markdown", 76 | "metadata": {}, 77 | "source": [ 78 | "**[6장: 96페이지]**" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": null, 84 | "metadata": {}, 85 | "outputs": [], 86 | "source": [ 87 | "print(\"abcd\" + \"efg\")" 88 | ] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "**[6장: 96페이지]**" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [ 103 | "print(\"Best\", \"python\", \"book\" + \":\", \"This book\")" 104 | ] 105 | }, 106 | { 107 | "cell_type": "markdown", 108 | "metadata": {}, 109 | "source": [ 110 | "**[6장: 96페이지]**" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": null, 116 | "metadata": {}, 117 | "outputs": [], 118 | "source": [ 119 | "x = 10\n", 120 | "print(x)" 121 | ] 122 | }, 123 | { 124 | "cell_type": "markdown", 125 | "metadata": {}, 126 | "source": [ 127 | "**[6장: 97페이지]**" 128 | ] 129 | }, 130 | { 131 | "cell_type": "code", 132 | "execution_count": null, 133 | "metadata": {}, 134 | "outputs": [], 135 | "source": [ 136 | "name = \"James\"\n", 137 | "ID_num = 789\n", 138 | "print(\"Name:\", name + \",\", \"ID Number:\", ID_num )" 139 | ] 140 | }, 141 | { 142 | "cell_type": "markdown", 143 | "metadata": {}, 144 | "source": [ 145 | "**[6장: 97페이지]**" 146 | ] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": null, 151 | "metadata": {}, 152 | "outputs": [], 153 | "source": [ 154 | "print(\"James is my friend.\\nHe is Korean.\")" 155 | ] 156 | }, 157 | { 158 | "cell_type": "markdown", 159 | "metadata": {}, 160 | "source": [ 161 | "**[6장: 97페이지]**" 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": null, 167 | "metadata": { 168 | "scrolled": true 169 | }, 170 | "outputs": [], 171 | "source": [ 172 | "print(\"James is my friend.\\n\\nHe is Korean.\")" 173 | ] 174 | }, 175 | { 176 | "cell_type": "markdown", 177 | "metadata": {}, 178 | "source": [ 179 | "**[6장: 97페이지]**" 180 | ] 181 | }, 182 | { 183 | "cell_type": "code", 184 | "execution_count": null, 185 | "metadata": {}, 186 | "outputs": [], 187 | "source": [ 188 | "print(\"Welcome to \")\n", 189 | "print(\"python!\")" 190 | ] 191 | }, 192 | { 193 | "cell_type": "markdown", 194 | "metadata": {}, 195 | "source": [ 196 | "**[6장: 98페이지]**" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": null, 202 | "metadata": {}, 203 | "outputs": [], 204 | "source": [ 205 | "print(\"Welcome to \", end=\"\")\n", 206 | "print(\"python!\")" 207 | ] 208 | }, 209 | { 210 | "cell_type": "markdown", 211 | "metadata": {}, 212 | "source": [ 213 | "### 형식 지정 출력" 214 | ] 215 | }, 216 | { 217 | "cell_type": "markdown", 218 | "metadata": {}, 219 | "source": [ 220 | "#### 나머지 연산자(%)를 이용한 형식 및 위치 지정" 221 | ] 222 | }, 223 | { 224 | "cell_type": "markdown", 225 | "metadata": {}, 226 | "source": [ 227 | "**[6장: 99페이지]**" 228 | ] 229 | }, 230 | { 231 | "cell_type": "code", 232 | "execution_count": null, 233 | "metadata": {}, 234 | "outputs": [], 235 | "source": [ 236 | "name = \"광재\"\n", 237 | "print(\"%s는 나의 친구입니다.\" % name)" 238 | ] 239 | }, 240 | { 241 | "cell_type": "markdown", 242 | "metadata": {}, 243 | "source": [ 244 | "**[6장: 99페이지]**" 245 | ] 246 | }, 247 | { 248 | "cell_type": "code", 249 | "execution_count": null, 250 | "metadata": { 251 | "scrolled": true 252 | }, 253 | "outputs": [], 254 | "source": [ 255 | "r = 3 # 변수 r에 정수 데이터 할당\n", 256 | "PI = 3.14159265358979 # 변수 PI에 실수 데이터 할당\n", 257 | "print(\"반지름: %d, 원주율: %f\" % (r, PI)) # 지정된 위치에 데이터 출력" 258 | ] 259 | }, 260 | { 261 | "cell_type": "markdown", 262 | "metadata": {}, 263 | "source": [ 264 | "#### 형식 지정 문자열에서 출력 위치 지정\n" 265 | ] 266 | }, 267 | { 268 | "cell_type": "markdown", 269 | "metadata": {}, 270 | "source": [ 271 | "**[6장: 100페이지]**" 272 | ] 273 | }, 274 | { 275 | "cell_type": "code", 276 | "execution_count": null, 277 | "metadata": {}, 278 | "outputs": [], 279 | "source": [ 280 | "animal_0 = \"cat\"\n", 281 | "animal_1 = \"dog\"\n", 282 | "animal_2 = \"fox\"\n", 283 | "\n", 284 | "print(\"Animal: {0}\".format(animal_0))\n", 285 | "print(\"Animal: {0},{1},{2}\".format(animal_0, animal_1, animal_2))" 286 | ] 287 | }, 288 | { 289 | "cell_type": "markdown", 290 | "metadata": {}, 291 | "source": [ 292 | "**[6장: 100페이지]**" 293 | ] 294 | }, 295 | { 296 | "cell_type": "code", 297 | "execution_count": null, 298 | "metadata": {}, 299 | "outputs": [], 300 | "source": [ 301 | "print(\"Animal: {1},{2},{0}\".format(animal_0, animal_1, animal_2))" 302 | ] 303 | }, 304 | { 305 | "cell_type": "markdown", 306 | "metadata": {}, 307 | "source": [ 308 | "**[6장: 100페이지]**" 309 | ] 310 | }, 311 | { 312 | "cell_type": "code", 313 | "execution_count": null, 314 | "metadata": {}, 315 | "outputs": [], 316 | "source": [ 317 | "print(\"Animal: {0},{2}\".format(animal_0, animal_1, animal_2))" 318 | ] 319 | }, 320 | { 321 | "cell_type": "markdown", 322 | "metadata": {}, 323 | "source": [ 324 | "**[6장: 101페이지]**" 325 | ] 326 | }, 327 | { 328 | "cell_type": "code", 329 | "execution_count": null, 330 | "metadata": {}, 331 | "outputs": [], 332 | "source": [ 333 | "print(\"Animal: {}, {}, {}\".format(animal_0, animal_1, animal_2))" 334 | ] 335 | }, 336 | { 337 | "cell_type": "markdown", 338 | "metadata": {}, 339 | "source": [ 340 | "**[6장: 101페이지]**" 341 | ] 342 | }, 343 | { 344 | "cell_type": "code", 345 | "execution_count": null, 346 | "metadata": {}, 347 | "outputs": [], 348 | "source": [ 349 | "name = \"Tomas\"\n", 350 | "age = 10\n", 351 | "a = 0.1234567890123456789\n", 352 | "fmt_string = \"String: {0}. Integer Number: {1}. Floating Number: {2}\"\n", 353 | "print(fmt_string.format(name, age, a))" 354 | ] 355 | }, 356 | { 357 | "cell_type": "markdown", 358 | "metadata": {}, 359 | "source": [ 360 | "#### 형식 지정 문자열에서 숫자 출력 형식 지정" 361 | ] 362 | }, 363 | { 364 | "cell_type": "markdown", 365 | "metadata": {}, 366 | "source": [ 367 | "**[6장: 101페이지]**" 368 | ] 369 | }, 370 | { 371 | "cell_type": "code", 372 | "execution_count": null, 373 | "metadata": {}, 374 | "outputs": [], 375 | "source": [ 376 | "a = 0.1234567890123456789\n", 377 | "print(\"{0:.2f}, {0:.5f}\".format(a))" 378 | ] 379 | }, 380 | { 381 | "cell_type": "markdown", 382 | "metadata": {}, 383 | "source": [ 384 | "## 6.1 키보드 입력" 385 | ] 386 | }, 387 | { 388 | "cell_type": "markdown", 389 | "metadata": {}, 390 | "source": [ 391 | "**[6장: 103페이지]**" 392 | ] 393 | }, 394 | { 395 | "cell_type": "code", 396 | "execution_count": null, 397 | "metadata": {}, 398 | "outputs": [], 399 | "source": [ 400 | "yourName = input(\"당신의 이름은? \")\n", 401 | "print(\"당신은 {}이군요.\".format(yourName))" 402 | ] 403 | }, 404 | { 405 | "cell_type": "markdown", 406 | "metadata": {}, 407 | "source": [ 408 | "**[6장: 103페이지]**" 409 | ] 410 | }, 411 | { 412 | "cell_type": "code", 413 | "execution_count": null, 414 | "metadata": {}, 415 | "outputs": [], 416 | "source": [ 417 | "num = input(\"숫자를 입력하세요: \")\n", 418 | "print(\"당신이 입력한 숫자는 {}입니다.\".format(num))" 419 | ] 420 | }, 421 | { 422 | "cell_type": "markdown", 423 | "metadata": {}, 424 | "source": [ 425 | "**[6장: 103페이지]**" 426 | ] 427 | }, 428 | { 429 | "cell_type": "code", 430 | "execution_count": null, 431 | "metadata": {}, 432 | "outputs": [], 433 | "source": [ 434 | "a = input(\"정사각형 한 변의 길이는?: \")\n", 435 | "area = int(a) ** 2\n", 436 | "print(\"정사각형의 넓이: {}\".format(area))" 437 | ] 438 | }, 439 | { 440 | "cell_type": "markdown", 441 | "metadata": {}, 442 | "source": [ 443 | "**[6장: 103페이지]**" 444 | ] 445 | }, 446 | { 447 | "cell_type": "code", 448 | "execution_count": null, 449 | "metadata": {}, 450 | "outputs": [], 451 | "source": [ 452 | "b = input(\"정사각형 한 변의 길이는?:\")\n", 453 | "area = float(b) ** 2\n", 454 | "print(\"정사각형의 넓이: {}\".format(area))" 455 | ] 456 | }, 457 | { 458 | "cell_type": "markdown", 459 | "metadata": {}, 460 | "source": [ 461 | "**[6장: 104페이지]**" 462 | ] 463 | }, 464 | { 465 | "cell_type": "code", 466 | "execution_count": null, 467 | "metadata": {}, 468 | "outputs": [], 469 | "source": [ 470 | "c = input(\"정사각형 한 변의 길이는?: \")\n", 471 | "area = float(c) ** 2\n", 472 | "print(\"정사각형의 넓이: {}\".format(area))" 473 | ] 474 | }, 475 | { 476 | "cell_type": "markdown", 477 | "metadata": {}, 478 | "source": [ 479 | "## 6.3 파일 읽고 쓰기" 480 | ] 481 | }, 482 | { 483 | "cell_type": "markdown", 484 | "metadata": { 485 | "collapsed": true 486 | }, 487 | "source": [ 488 | "### 파일 열기\n" 489 | ] 490 | }, 491 | { 492 | "cell_type": "markdown", 493 | "metadata": {}, 494 | "source": [ 495 | "### 파일 쓰기" 496 | ] 497 | }, 498 | { 499 | "cell_type": "markdown", 500 | "metadata": {}, 501 | "source": [ 502 | "**[6장: 106페이지]**" 503 | ] 504 | }, 505 | { 506 | "cell_type": "code", 507 | "execution_count": null, 508 | "metadata": {}, 509 | "outputs": [], 510 | "source": [ 511 | "cd C:\\myPyCode" 512 | ] 513 | }, 514 | { 515 | "cell_type": "markdown", 516 | "metadata": {}, 517 | "source": [ 518 | "**[6장: 106페이지]**" 519 | ] 520 | }, 521 | { 522 | "cell_type": "code", 523 | "execution_count": null, 524 | "metadata": {}, 525 | "outputs": [], 526 | "source": [ 527 | "f = open('myFile.txt', 'w') # (1)'myFile.txt' 파일 쓰기 모드로 열기\n", 528 | "f.write('This is my first file.') # (2) 연 파일에 문자열 쓰기\n", 529 | "f.close() # (3) 파일 닫기" 530 | ] 531 | }, 532 | { 533 | "cell_type": "markdown", 534 | "metadata": {}, 535 | "source": [ 536 | "**[6장: 106페이지]**" 537 | ] 538 | }, 539 | { 540 | "cell_type": "code", 541 | "execution_count": null, 542 | "metadata": {}, 543 | "outputs": [], 544 | "source": [ 545 | "!type myFile.txt" 546 | ] 547 | }, 548 | { 549 | "cell_type": "markdown", 550 | "metadata": {}, 551 | "source": [ 552 | "### 파일 읽기" 553 | ] 554 | }, 555 | { 556 | "cell_type": "markdown", 557 | "metadata": {}, 558 | "source": [ 559 | "**[6장: 107페이지]**" 560 | ] 561 | }, 562 | { 563 | "cell_type": "code", 564 | "execution_count": null, 565 | "metadata": {}, 566 | "outputs": [], 567 | "source": [ 568 | "f = open('myFile.txt', 'r') # (1)'myFile.txt' 파일 읽기 모드로 열기\n", 569 | "file_text = f.read() # (2) 파일 내용 읽은 후에 변수에 저장\n", 570 | "f.close() # (3) 파일 닫기\n", 571 | "\n", 572 | "print(file_text) # 변수에 저장된 내용 출력 " 573 | ] 574 | }, 575 | { 576 | "cell_type": "markdown", 577 | "metadata": {}, 578 | "source": [ 579 | "## 6.4 반복문을 이용해 파일 읽고 쓰기" 580 | ] 581 | }, 582 | { 583 | "cell_type": "markdown", 584 | "metadata": {}, 585 | "source": [ 586 | "### 파일에 문자열 한 줄씩 쓰기" 587 | ] 588 | }, 589 | { 590 | "cell_type": "markdown", 591 | "metadata": {}, 592 | "source": [ 593 | "**[6장: 107페이지]**" 594 | ] 595 | }, 596 | { 597 | "cell_type": "code", 598 | "execution_count": null, 599 | "metadata": {}, 600 | "outputs": [], 601 | "source": [ 602 | "f = open('two_times_table.txt','w') # (1)파일을 쓰기 모드로 열기\n", 603 | "for num in range(1,6): # (2) for문: num이 1~5까지 반복\n", 604 | " format_string = \"2 x {0} = {1}\\n\".format(num,2*num) # 저장할 문자열 생성\n", 605 | " f.write(format_string) # (3) 파일에 문자열 저장\n", 606 | "f.close() # (4) 파일 닫기" 607 | ] 608 | }, 609 | { 610 | "cell_type": "markdown", 611 | "metadata": {}, 612 | "source": [ 613 | "**[6장: 108페이지]**" 614 | ] 615 | }, 616 | { 617 | "cell_type": "code", 618 | "execution_count": null, 619 | "metadata": {}, 620 | "outputs": [], 621 | "source": [ 622 | "!type two_times_table.txt" 623 | ] 624 | }, 625 | { 626 | "cell_type": "markdown", 627 | "metadata": {}, 628 | "source": [ 629 | "### 파일에서 문자열 한 줄씩 읽기" 630 | ] 631 | }, 632 | { 633 | "cell_type": "markdown", 634 | "metadata": {}, 635 | "source": [ 636 | "#### readline()" 637 | ] 638 | }, 639 | { 640 | "cell_type": "markdown", 641 | "metadata": {}, 642 | "source": [ 643 | "**[6장: 109페이지]**" 644 | ] 645 | }, 646 | { 647 | "cell_type": "code", 648 | "execution_count": null, 649 | "metadata": { 650 | "scrolled": true 651 | }, 652 | "outputs": [], 653 | "source": [ 654 | "f = open(\"two_times_table.txt\") # 파일을 읽기 모드로 열기\n", 655 | "line1 = f.readline() # 한 줄씩 문자열을 읽기\n", 656 | "line2 = f.readline()\n", 657 | "f.close() # 파일 닫기\n", 658 | "print(line1, end=\"\") # 한 줄씩 문자열 출력(줄 바꿈 안 함)\n", 659 | "print(line2, end=\"\") " 660 | ] 661 | }, 662 | { 663 | "cell_type": "markdown", 664 | "metadata": {}, 665 | "source": [ 666 | "**[6장: 109페이지]**" 667 | ] 668 | }, 669 | { 670 | "cell_type": "code", 671 | "execution_count": null, 672 | "metadata": {}, 673 | "outputs": [], 674 | "source": [ 675 | "f = open(\"two_times_table.txt\") # 파일을 읽기 모드로 열기\n", 676 | "line = f.readline() # 문자열 한 줄 읽기\n", 677 | "while line: # line이 공백인지 검사해서 반복 여부 결정\n", 678 | " print(line, end = \"\") # 문자열 한 줄 출력(줄 바꿈 안 함)\n", 679 | " line = f.readline() # 문자열 한 줄 읽기\n", 680 | "f.close() # 파일 닫기" 681 | ] 682 | }, 683 | { 684 | "cell_type": "markdown", 685 | "metadata": {}, 686 | "source": [ 687 | "#### readlines()" 688 | ] 689 | }, 690 | { 691 | "cell_type": "markdown", 692 | "metadata": {}, 693 | "source": [ 694 | "**[6장: 110페이지]**" 695 | ] 696 | }, 697 | { 698 | "cell_type": "code", 699 | "execution_count": null, 700 | "metadata": {}, 701 | "outputs": [], 702 | "source": [ 703 | "f = open(\"two_times_table.txt\") # (1) 파일을 읽기 모드로 열기\n", 704 | "lines = f.readlines() # (2) 파일 전체 읽기(리스트로 반환)\n", 705 | "f.close() # (3) 파일 닫기\n", 706 | "\n", 707 | "print(lines) # 리스트 변수 내용 출력" 708 | ] 709 | }, 710 | { 711 | "cell_type": "markdown", 712 | "metadata": {}, 713 | "source": [ 714 | "**[6장: 110페이지]**" 715 | ] 716 | }, 717 | { 718 | "cell_type": "code", 719 | "execution_count": null, 720 | "metadata": { 721 | "scrolled": true 722 | }, 723 | "outputs": [], 724 | "source": [ 725 | "f = open(\"two_times_table.txt\") # 파일을 읽기 모드로 열기\n", 726 | "lines = f.readlines() # 파일 전체 읽기(리스트로 반환)\n", 727 | "f.close() # 파일 닫기\n", 728 | "for line in lines: # 리스트를 <반복 범위>로 지정\n", 729 | " print(line, end=\"\") # 리스트 항목을 출력(줄 바꿈 안 함)" 730 | ] 731 | }, 732 | { 733 | "cell_type": "markdown", 734 | "metadata": {}, 735 | "source": [ 736 | "**[6장: 111페이지]**" 737 | ] 738 | }, 739 | { 740 | "cell_type": "code", 741 | "execution_count": null, 742 | "metadata": {}, 743 | "outputs": [], 744 | "source": [ 745 | "f = open(\"two_times_table.txt\") # 파일을 읽기 모드로 열기\n", 746 | "for line in f.readlines(): # 파일 전체를 읽고, 리스트 항목을 line에 할당\n", 747 | " print(line, end=\"\") # 리스트 항목을 출력(줄 바꿈 안 함)\n", 748 | "f.close() " 749 | ] 750 | }, 751 | { 752 | "cell_type": "markdown", 753 | "metadata": {}, 754 | "source": [ 755 | "**[6장: 111페이지]**" 756 | ] 757 | }, 758 | { 759 | "cell_type": "code", 760 | "execution_count": null, 761 | "metadata": {}, 762 | "outputs": [], 763 | "source": [ 764 | "f = open(\"two_times_table.txt\") # 파일을 읽기 모드로 열기\n", 765 | "for line in f: # 파일 전체를 읽고, 리스트 항목을 line에 할당\n", 766 | " print(line, end=\"\") # line의 내용 출력(줄 바꿈 안 함)\n", 767 | "f.close() # 파일 닫기" 768 | ] 769 | }, 770 | { 771 | "cell_type": "markdown", 772 | "metadata": {}, 773 | "source": [ 774 | "## 6.5 with 문을 활용해 파일 읽고 쓰기" 775 | ] 776 | }, 777 | { 778 | "cell_type": "markdown", 779 | "metadata": {}, 780 | "source": [ 781 | "### with 문의 구조" 782 | ] 783 | }, 784 | { 785 | "cell_type": "markdown", 786 | "metadata": {}, 787 | "source": [ 788 | "**[6장: 112페이지]**" 789 | ] 790 | }, 791 | { 792 | "cell_type": "code", 793 | "execution_count": null, 794 | "metadata": {}, 795 | "outputs": [], 796 | "source": [ 797 | "f = open('myTextFile.txt', 'w') # (1) 파일 열기\n", 798 | "f.write('File write/read test.') # (2) 파일 쓰기\n", 799 | "f.close() # (3) 파일 닫기" 800 | ] 801 | }, 802 | { 803 | "cell_type": "markdown", 804 | "metadata": {}, 805 | "source": [ 806 | "**[6장: 112페이지]**" 807 | ] 808 | }, 809 | { 810 | "cell_type": "code", 811 | "execution_count": null, 812 | "metadata": {}, 813 | "outputs": [], 814 | "source": [ 815 | "f = open('myTextFile.txt', 'r') # (1) 파일 열기\n", 816 | "test = f.read() # (2) 파일 읽기\n", 817 | "f.close() # (3) 파일 닫기 \n", 818 | "print(test)" 819 | ] 820 | }, 821 | { 822 | "cell_type": "markdown", 823 | "metadata": {}, 824 | "source": [ 825 | "### with문의 활용" 826 | ] 827 | }, 828 | { 829 | "cell_type": "markdown", 830 | "metadata": {}, 831 | "source": [ 832 | "**[6장: 113페이지]**" 833 | ] 834 | }, 835 | { 836 | "cell_type": "code", 837 | "execution_count": null, 838 | "metadata": {}, 839 | "outputs": [], 840 | "source": [ 841 | "with open('C:/myPyCode/myTextFile2.txt', 'w') as f: # (1) 파일 열기\n", 842 | " f.write('File read/write test2: line1\\n') # (2) 파일 쓰기\n", 843 | " f.write('File read/write test2: line2\\n')\n", 844 | " f.write('File read/write test2: line3\\n')" 845 | ] 846 | }, 847 | { 848 | "cell_type": "markdown", 849 | "metadata": {}, 850 | "source": [ 851 | "**[6장: 113페이지]**" 852 | ] 853 | }, 854 | { 855 | "cell_type": "code", 856 | "execution_count": null, 857 | "metadata": { 858 | "code_folding": [] 859 | }, 860 | "outputs": [], 861 | "source": [ 862 | "with open('C:/myPyCode/myTextFile2.txt') as f: # (1) 파일 열기\n", 863 | " file_string = f.read() # (2) 파일 읽기\n", 864 | " print(file_string)" 865 | ] 866 | }, 867 | { 868 | "cell_type": "markdown", 869 | "metadata": {}, 870 | "source": [ 871 | "**[6장: 113페이지]**" 872 | ] 873 | }, 874 | { 875 | "cell_type": "code", 876 | "execution_count": null, 877 | "metadata": {}, 878 | "outputs": [], 879 | "source": [ 880 | "with open('C:/myPyCode/myTextFile3.txt', 'w') as f: # 파일을 쓰기 모드로 열기\n", 881 | " for num in range(1,6): # for문에서 num이 1~5까지 반복\n", 882 | " format_string = \"3 x {0} = {1}\\n\".format(num,3*num) # 문자열 생성\n", 883 | " f.write(format_string) # 파일에 문자열 쓰기" 884 | ] 885 | }, 886 | { 887 | "cell_type": "markdown", 888 | "metadata": {}, 889 | "source": [ 890 | "**[6장: 114페이지]**" 891 | ] 892 | }, 893 | { 894 | "cell_type": "code", 895 | "execution_count": null, 896 | "metadata": {}, 897 | "outputs": [], 898 | "source": [ 899 | "with open('C:/myPyCode/myTextFile3.txt', 'r') as f: # 파일을 읽기 모드로 열기\n", 900 | " for line in f: # 파일 전체를 읽고 리스트 항목을 line에 할당\n", 901 | " print(line, end=\"\") # line에 할당된 문자열 출력(줄 바꿈 안 함)" 902 | ] 903 | }, 904 | { 905 | "cell_type": "markdown", 906 | "metadata": {}, 907 | "source": [ 908 | "# 6.6 정리" 909 | ] 910 | } 911 | ], 912 | "metadata": { 913 | "anaconda-cloud": {}, 914 | "kernelspec": { 915 | "display_name": "Python 3", 916 | "language": "python", 917 | "name": "python3" 918 | }, 919 | "language_info": { 920 | "codemirror_mode": { 921 | "name": "ipython", 922 | "version": 3 923 | }, 924 | "file_extension": ".py", 925 | "mimetype": "text/x-python", 926 | "name": "python", 927 | "nbconvert_exporter": "python", 928 | "pygments_lexer": "ipython3", 929 | "version": "3.6.4" 930 | }, 931 | "latex_envs": { 932 | "LaTeX_envs_menu_present": false, 933 | "autoclose": false, 934 | "autocomplete": false, 935 | "bibliofile": "biblio.bib", 936 | "cite_by": "apalike", 937 | "current_citInitial": 1, 938 | "eqLabelWithNumbers": false, 939 | "eqNumInitial": 1, 940 | "hotkeys": { 941 | "equation": "Ctrl-E", 942 | "itemize": "Ctrl-I" 943 | }, 944 | "labels_anchors": false, 945 | "latex_user_defs": false, 946 | "report_style_numbering": false, 947 | "user_envs_cfg": false 948 | }, 949 | "nav_menu": {}, 950 | "toc": { 951 | "nav_menu": { 952 | "height": "252px", 953 | "width": "252px" 954 | }, 955 | "number_sections": false, 956 | "sideBar": true, 957 | "skip_h1_title": false, 958 | "toc_cell": false, 959 | "toc_position": { 960 | "height": "545px", 961 | "left": "0px", 962 | "right": "984px", 963 | "top": "111px", 964 | "width": "382px" 965 | }, 966 | "toc_section_display": "block", 967 | "toc_window_display": false 968 | }, 969 | "toc_position": { 970 | "height": "533px", 971 | "left": "0px", 972 | "right": "1045.17px", 973 | "top": "107px", 974 | "width": "207px" 975 | } 976 | }, 977 | "nbformat": 4, 978 | "nbformat_minor": 1 979 | } 980 | -------------------------------------------------------------------------------- /notebook/Chapter_08_Class_Object.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 8장 객체와 클래스" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## 8.1 클래스 선언과 객체 생성\n", 15 | "\n", 16 | "### 객체란?" 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "### 클래스 선언" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "### 객체 생성 및 활용" 31 | ] 32 | }, 33 | { 34 | "cell_type": "markdown", 35 | "metadata": {}, 36 | "source": [ 37 | "**[8장: 137페이지]**" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": {}, 44 | "outputs": [], 45 | "source": [ 46 | "class Bicycle(): # 클래스 선언\n", 47 | " pass" 48 | ] 49 | }, 50 | { 51 | "cell_type": "markdown", 52 | "metadata": {}, 53 | "source": [ 54 | "**[8장: 138페이지]**" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": null, 60 | "metadata": {}, 61 | "outputs": [], 62 | "source": [ 63 | "my_bicycle = Bicycle()" 64 | ] 65 | }, 66 | { 67 | "cell_type": "markdown", 68 | "metadata": {}, 69 | "source": [ 70 | "**[8장: 138페이지]**" 71 | ] 72 | }, 73 | { 74 | "cell_type": "code", 75 | "execution_count": null, 76 | "metadata": {}, 77 | "outputs": [], 78 | "source": [ 79 | "my_bicycle" 80 | ] 81 | }, 82 | { 83 | "cell_type": "markdown", 84 | "metadata": {}, 85 | "source": [ 86 | "**[8장: 138페이지]**" 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": null, 92 | "metadata": {}, 93 | "outputs": [], 94 | "source": [ 95 | "my_bicycle.wheel_size = 26\n", 96 | "my_bicycle.color = 'black'" 97 | ] 98 | }, 99 | { 100 | "cell_type": "markdown", 101 | "metadata": {}, 102 | "source": [ 103 | "**[8장: 139페이지]**" 104 | ] 105 | }, 106 | { 107 | "cell_type": "code", 108 | "execution_count": null, 109 | "metadata": {}, 110 | "outputs": [], 111 | "source": [ 112 | "print(\"바퀴 크기:\", my_bicycle.wheel_size) # 객체의 속성 출력\n", 113 | "print(\"색상:\", my_bicycle.color) " 114 | ] 115 | }, 116 | { 117 | "cell_type": "markdown", 118 | "metadata": {}, 119 | "source": [ 120 | "**[8장: 139페이지]**" 121 | ] 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": null, 126 | "metadata": {}, 127 | "outputs": [], 128 | "source": [ 129 | "class Bicycle():\n", 130 | " \n", 131 | " def move(self, speed):\n", 132 | " print(\"자전거: 시속 {0}킬로미터로 전진\".format(speed))\n", 133 | " \n", 134 | " def turn(self, direction):\n", 135 | " print(\"자전거: {0}회전\".format(direction))\n", 136 | " \n", 137 | " def stop(self):\n", 138 | " print(\"자전거({0}, {1}): 정지 \".format(self.wheel_size, self.color))" 139 | ] 140 | }, 141 | { 142 | "cell_type": "markdown", 143 | "metadata": {}, 144 | "source": [ 145 | "**[8장: 140페이지]**" 146 | ] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": null, 151 | "metadata": {}, 152 | "outputs": [], 153 | "source": [ 154 | "my_bicycle = Bicycle() # Bicycle 클래스의 인스턴스인 my_bicycle 객체 생성\n", 155 | "\n", 156 | "my_bicycle.wheel_size = 26 # 객체의 속성 설정\n", 157 | "my_bicycle.color = 'black' \n", 158 | "\n", 159 | "my_bicycle.move(30) # 객체의 메서드 호출\n", 160 | "my_bicycle.turn('좌')\n", 161 | "my_bicycle.stop()" 162 | ] 163 | }, 164 | { 165 | "cell_type": "markdown", 166 | "metadata": {}, 167 | "source": [ 168 | "**[8장: 141페이지]**" 169 | ] 170 | }, 171 | { 172 | "cell_type": "code", 173 | "execution_count": null, 174 | "metadata": {}, 175 | "outputs": [], 176 | "source": [ 177 | "bicycle1 = Bicycle() # Bicycle 클래스의 인스턴스인 bicycle1 객체 생성\n", 178 | "\n", 179 | "bicycle1.wheel_size = 27 # 객체의 속성 설정\n", 180 | "bicycle1.color = 'red' \n", 181 | "\n", 182 | "bicycle1.move(20)\n", 183 | "bicycle1.turn('좌')\n", 184 | "bicycle1.stop()" 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": null, 190 | "metadata": { 191 | "scrolled": true 192 | }, 193 | "outputs": [], 194 | "source": [ 195 | "bicycle2 = Bicycle() # Bicycle 클래스의 인스턴스인 bicycle2 객체 생성\n", 196 | "\n", 197 | "bicycle2.wheel_size = 24 # 객체의 속성 설정\n", 198 | "bicycle2.color = 'blue' \n", 199 | "\n", 200 | "bicycle2.move(15)\n", 201 | "bicycle2.turn('우')\n", 202 | "bicycle2.stop()" 203 | ] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "metadata": {}, 208 | "source": [ 209 | "### 객체 초기화" 210 | ] 211 | }, 212 | { 213 | "cell_type": "markdown", 214 | "metadata": {}, 215 | "source": [ 216 | "**[8장: 142페이지]**" 217 | ] 218 | }, 219 | { 220 | "cell_type": "code", 221 | "execution_count": null, 222 | "metadata": {}, 223 | "outputs": [], 224 | "source": [ 225 | "class Bicycle(): \n", 226 | " \n", 227 | " def __init__(self, wheel_size, color):\n", 228 | " self.wheel_size = wheel_size\n", 229 | " self.color = color\n", 230 | " \n", 231 | " def move(self, speed):\n", 232 | " print(\"자전거: 시속 {0}킬로미터로 전진\".format(speed))\n", 233 | " \n", 234 | " def turn(self, direction):\n", 235 | " print(\"자전거: {0}회전\".format(direction))\n", 236 | " \n", 237 | " def stop(self):\n", 238 | " print(\"자전거({0}, {1}): 정지 \".format(self.wheel_size, self.color))" 239 | ] 240 | }, 241 | { 242 | "cell_type": "markdown", 243 | "metadata": {}, 244 | "source": [ 245 | "**[8장: 142페이지]**" 246 | ] 247 | }, 248 | { 249 | "cell_type": "code", 250 | "execution_count": null, 251 | "metadata": {}, 252 | "outputs": [], 253 | "source": [ 254 | "my_bicycle = Bicycle(26, 'black') # 객체 생성과 동시에 속성값을 지정.\n", 255 | "\n", 256 | "my_bicycle.move(30) # 객체 메서드 호출\n", 257 | "my_bicycle.turn('좌')\n", 258 | "my_bicycle.stop()" 259 | ] 260 | }, 261 | { 262 | "cell_type": "markdown", 263 | "metadata": {}, 264 | "source": [ 265 | "## 8.2 클래스를 구성하는 변수와 함수" 266 | ] 267 | }, 268 | { 269 | "cell_type": "markdown", 270 | "metadata": {}, 271 | "source": [ 272 | "### 클래스에서 사용하는 변수" 273 | ] 274 | }, 275 | { 276 | "cell_type": "markdown", 277 | "metadata": {}, 278 | "source": [ 279 | "**[8장: 143페이지]**" 280 | ] 281 | }, 282 | { 283 | "cell_type": "code", 284 | "execution_count": null, 285 | "metadata": {}, 286 | "outputs": [], 287 | "source": [ 288 | "class Car():\n", 289 | " instance_count = 0 # 클래스 변수 생성 및 초기화\n", 290 | "\n", 291 | " def __init__(self, size, color):\n", 292 | " self.size = size # 인스턴스 변수 생성 및 초기화\n", 293 | " self.color = color # 인스턴스 변수 생성 및 초기화\n", 294 | " Car.instance_count = Car.instance_count + 1 # 클래스 변수 이용\n", 295 | " print(\"자동차 객체의 수: {0}\".format(Car.instance_count))\n", 296 | " \n", 297 | " def move(self):\n", 298 | " print(\"자동차({0} & {1})가 움직입니다.\".format(self.size, self.color))" 299 | ] 300 | }, 301 | { 302 | "cell_type": "markdown", 303 | "metadata": {}, 304 | "source": [ 305 | "**[8장: 144페이지]**" 306 | ] 307 | }, 308 | { 309 | "cell_type": "code", 310 | "execution_count": null, 311 | "metadata": {}, 312 | "outputs": [], 313 | "source": [ 314 | "car1 = Car('small', 'white')\n", 315 | "car2 = Car('big', 'black')" 316 | ] 317 | }, 318 | { 319 | "cell_type": "markdown", 320 | "metadata": {}, 321 | "source": [ 322 | "**[8장: 144페이지]**" 323 | ] 324 | }, 325 | { 326 | "cell_type": "code", 327 | "execution_count": null, 328 | "metadata": {}, 329 | "outputs": [], 330 | "source": [ 331 | "print(\"Car 클래스의 총 인스턴스 개수:{}\".format(Car.instance_count)) " 332 | ] 333 | }, 334 | { 335 | "cell_type": "markdown", 336 | "metadata": {}, 337 | "source": [ 338 | "**[8장: 144페이지]**" 339 | ] 340 | }, 341 | { 342 | "cell_type": "code", 343 | "execution_count": null, 344 | "metadata": {}, 345 | "outputs": [], 346 | "source": [ 347 | "print(\"Car 클래스의 총 인스턴스 개수:{}\".format(car1.instance_count))\n", 348 | "print(\"Car 클래스의 총 인스턴스 개수:{}\".format(car2.instance_count))" 349 | ] 350 | }, 351 | { 352 | "cell_type": "markdown", 353 | "metadata": {}, 354 | "source": [ 355 | "**[8장: 144페이지]**" 356 | ] 357 | }, 358 | { 359 | "cell_type": "code", 360 | "execution_count": null, 361 | "metadata": {}, 362 | "outputs": [], 363 | "source": [ 364 | "car1.move()\n", 365 | "car2.move()" 366 | ] 367 | }, 368 | { 369 | "cell_type": "markdown", 370 | "metadata": {}, 371 | "source": [ 372 | "**[8장: 145페이지]**" 373 | ] 374 | }, 375 | { 376 | "cell_type": "code", 377 | "execution_count": null, 378 | "metadata": {}, 379 | "outputs": [], 380 | "source": [ 381 | "class Car2():\n", 382 | " count = 0; # 클래스 변수 생성 및 초기화\n", 383 | "\n", 384 | " def __init__(self, size, num):\n", 385 | " self.size = size # 인스턴스 변수 생성 및 초기화\n", 386 | " self.count = num # 인스턴스 변수 생성 및 초기화\n", 387 | " Car2.count = Car2.count + 1 # 클래스 변수 이용\n", 388 | " print(\"자동차 객체의 수: Car2.count = {0}\".format(Car2.count))\n", 389 | " print(\"인스턴스 변수 초기화: self.count = {0}\".format(self.count))\n", 390 | " \n", 391 | " def move(self):\n", 392 | " print(\"자동차({0} & {1})가 움직입니다.\".format(self.size, self.count))" 393 | ] 394 | }, 395 | { 396 | "cell_type": "markdown", 397 | "metadata": {}, 398 | "source": [ 399 | "**[8장: 145페이지]**" 400 | ] 401 | }, 402 | { 403 | "cell_type": "code", 404 | "execution_count": null, 405 | "metadata": { 406 | "scrolled": true 407 | }, 408 | "outputs": [], 409 | "source": [ 410 | "car1 = Car2(\"big\", 20)\n", 411 | "car2 = Car2(\"small\", 30)" 412 | ] 413 | }, 414 | { 415 | "cell_type": "markdown", 416 | "metadata": {}, 417 | "source": [ 418 | "### 클래스에서 사용하는 함수" 419 | ] 420 | }, 421 | { 422 | "cell_type": "markdown", 423 | "metadata": {}, 424 | "source": [ 425 | "#### 인스턴스 메서드" 426 | ] 427 | }, 428 | { 429 | "cell_type": "markdown", 430 | "metadata": {}, 431 | "source": [ 432 | "**[8장: 146 ~ 147페이지]**" 433 | ] 434 | }, 435 | { 436 | "cell_type": "code", 437 | "execution_count": null, 438 | "metadata": {}, 439 | "outputs": [], 440 | "source": [ 441 | "# Car 클래스 선언\n", 442 | "class Car():\n", 443 | " instance_count = 0 # 클래스 변수 생성 및 초기화\n", 444 | " \n", 445 | " # 초기화 함수(인스턴스 메서드)\n", 446 | " def __init__(self, size, color):\n", 447 | " self.size = size # 인스턴스 변수 생성 및 초기화\n", 448 | " self.color = color # 인스턴스 변수 생성 및 초기화\n", 449 | " Car.instance_count = Car.instance_count + 1 # 클래스 변수 이용\n", 450 | " print(\"자동차 객체의 수: {0}\".format(Car.instance_count)) \n", 451 | " \n", 452 | " # 인스턴스 메서드\n", 453 | " def move(self, speed):\n", 454 | " self.speed = speed # 인스턴스 변수 생성 \n", 455 | " print(\"자동차({0} & {1})가 \".format(self.size, self.color), end='')\n", 456 | " print(\"시속 {0}킬로미터로 전진\".format(self.speed))\n", 457 | " \n", 458 | " # 인스턴스 메서드\n", 459 | " def auto_cruise(self):\n", 460 | " print(\"자율 주행 모드\")\n", 461 | " self.move(self.speed) # move() 함수의 인자로 인스턴스 변수를 입력" 462 | ] 463 | }, 464 | { 465 | "cell_type": "markdown", 466 | "metadata": {}, 467 | "source": [ 468 | "**[8장: 147페이지]**" 469 | ] 470 | }, 471 | { 472 | "cell_type": "code", 473 | "execution_count": null, 474 | "metadata": {}, 475 | "outputs": [], 476 | "source": [ 477 | "car1 = Car(\"small\", \"red\") # 객체 생성 (car1)\n", 478 | "car2 = Car(\"big\", \"green\") # 객체 생성 (car2)\n", 479 | "\n", 480 | "car1.move(80) #객체(car1)의 move() 메서드 호출\n", 481 | "car2.move(100) #객체(car2)의 move() 메서드 호출\n", 482 | "\n", 483 | "car1.auto_cruise() #객체(car1)의 auto_cruise() 메서드 호출\n", 484 | "car2.auto_cruise() #객체(car2)의 auto_cruise() 메서드 호출" 485 | ] 486 | }, 487 | { 488 | "cell_type": "markdown", 489 | "metadata": {}, 490 | "source": [ 491 | "#### 정적 메서드" 492 | ] 493 | }, 494 | { 495 | "cell_type": "markdown", 496 | "metadata": {}, 497 | "source": [ 498 | "**[8장: 148 ~ 149페이지]**" 499 | ] 500 | }, 501 | { 502 | "cell_type": "code", 503 | "execution_count": null, 504 | "metadata": {}, 505 | "outputs": [], 506 | "source": [ 507 | "# Car 클래스 선언\n", 508 | "class Car():\n", 509 | " \n", 510 | " # def __init__(self, size, color): => 앞의 코드 활용\n", 511 | " # def move(self, speed): => 앞의 코드 활용\n", 512 | " # def auto_cruise(self): => 앞의 코드 활용\n", 513 | " \n", 514 | " # 정적 메서드\n", 515 | " @staticmethod\n", 516 | " def check_type(model_code):\n", 517 | " if(model_code >= 20):\n", 518 | " print(\"이 자동차는 전기차입니다.\")\n", 519 | " elif(10 <= model_code < 20):\n", 520 | " print(\"이 자동차는 가솔린차입니다.\")\n", 521 | " else:\n", 522 | " print(\"이 자동차는 디젤차입니다.\")" 523 | ] 524 | }, 525 | { 526 | "cell_type": "markdown", 527 | "metadata": {}, 528 | "source": [ 529 | "**[8장: 149페이지]**" 530 | ] 531 | }, 532 | { 533 | "cell_type": "code", 534 | "execution_count": null, 535 | "metadata": {}, 536 | "outputs": [], 537 | "source": [ 538 | "Car.check_type(25)\n", 539 | "Car.check_type(2)" 540 | ] 541 | }, 542 | { 543 | "cell_type": "markdown", 544 | "metadata": {}, 545 | "source": [ 546 | "#### 클래스 메서드" 547 | ] 548 | }, 549 | { 550 | "cell_type": "markdown", 551 | "metadata": {}, 552 | "source": [ 553 | "**[8장: 150페이지]**" 554 | ] 555 | }, 556 | { 557 | "cell_type": "code", 558 | "execution_count": null, 559 | "metadata": {}, 560 | "outputs": [], 561 | "source": [ 562 | "# Car 클래스 선언\n", 563 | "class Car():\n", 564 | " instance_count = 0 # 클래스 변수 \n", 565 | " \n", 566 | " # 초기화 함수(인스턴스 메서드)\n", 567 | " def __init__(self, size, color):\n", 568 | " self.size = size # 인스턴스 변수\n", 569 | " self.color = color # 인스턴스 변수\n", 570 | " Car.instance_count = Car.instance_count + 1\n", 571 | " \n", 572 | " # def move(self, speed): => 앞의 코드 활용\n", 573 | " # def auto_cruise(self): => 앞의 코드 활용\n", 574 | " # @staticmethod\n", 575 | " # def check_type(model_code): => 앞의 코드 활용\n", 576 | " \n", 577 | " # 클래스 메서드\n", 578 | " @classmethod\n", 579 | " def count_instance(cls):\n", 580 | " print(\"자동차 객체의 개수: {0}\".format(cls.instance_count))" 581 | ] 582 | }, 583 | { 584 | "cell_type": "markdown", 585 | "metadata": {}, 586 | "source": [ 587 | "**[8장: 150페이지]**" 588 | ] 589 | }, 590 | { 591 | "cell_type": "code", 592 | "execution_count": null, 593 | "metadata": {}, 594 | "outputs": [], 595 | "source": [ 596 | "Car.count_instance() # 객체 생성 전에 클래스 메서드 호출\n", 597 | "\n", 598 | "car1 = Car(\"small\", \"red\") # 첫 번째 객체 생성\n", 599 | "Car.count_instance() # 클래스 메서드 호출\n", 600 | "\n", 601 | "car2 = Car(\"big\", \"green\") # 두 번째 객체 생성\n", 602 | "Car.count_instance() # 클래스 메서드 호출" 603 | ] 604 | }, 605 | { 606 | "cell_type": "markdown", 607 | "metadata": {}, 608 | "source": [ 609 | "## 8.3 객체와 클래스를 사용하는 이유" 610 | ] 611 | }, 612 | { 613 | "cell_type": "markdown", 614 | "metadata": {}, 615 | "source": [ 616 | "**[8장: 151페이지]**" 617 | ] 618 | }, 619 | { 620 | "cell_type": "code", 621 | "execution_count": null, 622 | "metadata": {}, 623 | "outputs": [], 624 | "source": [ 625 | "robot_name = 'R1' # 로봇 이름\n", 626 | "robot_pos = 0 # 로봇의 초기 위치\n", 627 | "\n", 628 | "def robot_move():\n", 629 | " global robot_pos\n", 630 | " robot_pos = robot_pos + 1\n", 631 | " print(\"{0} position: {1}\".format(robot_name, robot_pos))" 632 | ] 633 | }, 634 | { 635 | "cell_type": "markdown", 636 | "metadata": {}, 637 | "source": [ 638 | "**[8장: 152페이지]**" 639 | ] 640 | }, 641 | { 642 | "cell_type": "code", 643 | "execution_count": null, 644 | "metadata": {}, 645 | "outputs": [], 646 | "source": [ 647 | "robot_move()" 648 | ] 649 | }, 650 | { 651 | "cell_type": "markdown", 652 | "metadata": {}, 653 | "source": [ 654 | "**[8장: 152페이지]**" 655 | ] 656 | }, 657 | { 658 | "cell_type": "code", 659 | "execution_count": null, 660 | "metadata": {}, 661 | "outputs": [], 662 | "source": [ 663 | "robot1_name = 'R1' # 로봇 이름\n", 664 | "robot1_pos = 0 # 로봇의 초기 위치\n", 665 | "\n", 666 | "def robot1_move():\n", 667 | " global robot1_pos\n", 668 | " robot1_pos = robot1_pos + 1\n", 669 | " print(\"{0} position: {1}\".format(robot1_name, robot1_pos))\n", 670 | "\n", 671 | "robot2_name = 'R2' # 로봇 이름\n", 672 | "robot2_pos = 10 # 로봇의 초기 위치\n", 673 | "\n", 674 | "def robot2_move():\n", 675 | " global robot2_pos\n", 676 | " robot2_pos = robot2_pos + 1\n", 677 | " print(\"{0} position: {1}\".format(robot2_name, robot2_pos))" 678 | ] 679 | }, 680 | { 681 | "cell_type": "markdown", 682 | "metadata": {}, 683 | "source": [ 684 | "**[8장: 152페이지]**" 685 | ] 686 | }, 687 | { 688 | "cell_type": "code", 689 | "execution_count": null, 690 | "metadata": {}, 691 | "outputs": [], 692 | "source": [ 693 | "robot1_move()\n", 694 | "robot2_move()" 695 | ] 696 | }, 697 | { 698 | "cell_type": "markdown", 699 | "metadata": {}, 700 | "source": [ 701 | "**[8장: 153페이지]**" 702 | ] 703 | }, 704 | { 705 | "cell_type": "code", 706 | "execution_count": null, 707 | "metadata": {}, 708 | "outputs": [], 709 | "source": [ 710 | "class Robot():\n", 711 | " def __init__(self, name, pos): \n", 712 | " self.name = name # 로봇 객체의 이름\n", 713 | " self.pos = pos # 로봇 객체의 위치\n", 714 | " \n", 715 | " def move(self):\n", 716 | " self.pos = self.pos + 1\n", 717 | " print(\"{0} position: {1}\".format(self.name, self.pos))" 718 | ] 719 | }, 720 | { 721 | "cell_type": "markdown", 722 | "metadata": {}, 723 | "source": [ 724 | "**[8장: 153페이지]**" 725 | ] 726 | }, 727 | { 728 | "cell_type": "code", 729 | "execution_count": null, 730 | "metadata": {}, 731 | "outputs": [], 732 | "source": [ 733 | "robot1 = Robot('R1', 0)\n", 734 | "robot2 = Robot('R2', 10)" 735 | ] 736 | }, 737 | { 738 | "cell_type": "markdown", 739 | "metadata": {}, 740 | "source": [ 741 | "**[8장: 153페이지]**" 742 | ] 743 | }, 744 | { 745 | "cell_type": "code", 746 | "execution_count": null, 747 | "metadata": {}, 748 | "outputs": [], 749 | "source": [ 750 | "robot1.move()\n", 751 | "robot2.move()" 752 | ] 753 | }, 754 | { 755 | "cell_type": "markdown", 756 | "metadata": {}, 757 | "source": [ 758 | "**[8장: 153페이지]**" 759 | ] 760 | }, 761 | { 762 | "cell_type": "code", 763 | "execution_count": null, 764 | "metadata": {}, 765 | "outputs": [], 766 | "source": [ 767 | "myRobot3 = Robot('R3', 30)\n", 768 | "myRobot4 = Robot('R4', 40)\n", 769 | "\n", 770 | "myRobot3.move()\n", 771 | "myRobot4.move()" 772 | ] 773 | }, 774 | { 775 | "cell_type": "markdown", 776 | "metadata": {}, 777 | "source": [ 778 | "## 8.4 클래스 상속" 779 | ] 780 | }, 781 | { 782 | "cell_type": "markdown", 783 | "metadata": {}, 784 | "source": [ 785 | "**[8장: 155페이지]**" 786 | ] 787 | }, 788 | { 789 | "cell_type": "code", 790 | "execution_count": null, 791 | "metadata": {}, 792 | "outputs": [], 793 | "source": [ 794 | "class Bicycle():\n", 795 | " \n", 796 | " def __init__(self, wheel_size, color):\n", 797 | " self.wheel_size = wheel_size\n", 798 | " self.color = color\n", 799 | " \n", 800 | " def move(self, speed):\n", 801 | " print(\"자전거: 시속 {0}킬로미터로 전진\".format(speed))\n", 802 | " \n", 803 | " def turn(self, direction):\n", 804 | " print(\"자전거: {0}회전\".format(direction))\n", 805 | " \n", 806 | " def stop(self):\n", 807 | " print(\"자전거({0}, {1}): 정지 \".format(self.wheel_size, self.color))" 808 | ] 809 | }, 810 | { 811 | "cell_type": "markdown", 812 | "metadata": {}, 813 | "source": [ 814 | "**[8장: 156페이지]**" 815 | ] 816 | }, 817 | { 818 | "cell_type": "code", 819 | "execution_count": null, 820 | "metadata": {}, 821 | "outputs": [], 822 | "source": [ 823 | "class FoldingBicycle(Bicycle):\n", 824 | " \n", 825 | " def __init__(self, wheel_size, color, state): # FoldingBicycle 초기화\n", 826 | " Bicycle.__init__(self, wheel_size, color) # Bicycle의 초기화 재사용\n", 827 | " #super().__init__(wheel_size, color) # super()도 사용 가능\n", 828 | " self.state = state # 자식 클래스에서 새로 추가한 변수 \n", 829 | " \n", 830 | " def fold(self):\n", 831 | " self.state = 'folding'\n", 832 | " print(\"자전거: 접기, state = {0}\".format(self.state))\n", 833 | "\n", 834 | " def unfold(self):\n", 835 | " self.state = 'unfolding'\n", 836 | " print(\"자전거: 펴기, state = {0}\".format(self.state))" 837 | ] 838 | }, 839 | { 840 | "cell_type": "markdown", 841 | "metadata": {}, 842 | "source": [ 843 | "**[8장: 156페이지]**" 844 | ] 845 | }, 846 | { 847 | "cell_type": "code", 848 | "execution_count": null, 849 | "metadata": {}, 850 | "outputs": [], 851 | "source": [ 852 | "folding_bicycle = FoldingBicycle(27, 'white', 'unfolding') # 객체 생성\n", 853 | "\n", 854 | "folding_bicycle.move(20) # 부모 클래스의 함수(메서드) 호출\n", 855 | "folding_bicycle.fold() # 자식 클래스에서 정의한 함수 호출\n", 856 | "folding_bicycle.unfold()" 857 | ] 858 | }, 859 | { 860 | "cell_type": "markdown", 861 | "metadata": {}, 862 | "source": [ 863 | "# 8.5 정리" 864 | ] 865 | } 866 | ], 867 | "metadata": { 868 | "anaconda-cloud": {}, 869 | "kernelspec": { 870 | "display_name": "Python 3", 871 | "language": "python", 872 | "name": "python3" 873 | }, 874 | "language_info": { 875 | "codemirror_mode": { 876 | "name": "ipython", 877 | "version": 3 878 | }, 879 | "file_extension": ".py", 880 | "mimetype": "text/x-python", 881 | "name": "python", 882 | "nbconvert_exporter": "python", 883 | "pygments_lexer": "ipython3", 884 | "version": "3.7.1" 885 | }, 886 | "latex_envs": { 887 | "LaTeX_envs_menu_present": true, 888 | "autoclose": false, 889 | "autocomplete": true, 890 | "bibliofile": "biblio.bib", 891 | "cite_by": "apalike", 892 | "current_citInitial": 1, 893 | "eqLabelWithNumbers": true, 894 | "eqNumInitial": 0, 895 | "hotkeys": { 896 | "equation": "Ctrl-E", 897 | "itemize": "Ctrl-I" 898 | }, 899 | "labels_anchors": false, 900 | "latex_user_defs": false, 901 | "report_style_numbering": false, 902 | "user_envs_cfg": false 903 | }, 904 | "nav_menu": {}, 905 | "toc": { 906 | "nav_menu": { 907 | "height": "142px", 908 | "width": "252px" 909 | }, 910 | "number_sections": false, 911 | "sideBar": true, 912 | "skip_h1_title": false, 913 | "toc_cell": false, 914 | "toc_position": { 915 | "height": "582px", 916 | "left": "0px", 917 | "right": "1128px", 918 | "top": "111px", 919 | "width": "238px" 920 | }, 921 | "toc_section_display": "block", 922 | "toc_window_display": false 923 | }, 924 | "toc_position": { 925 | "height": "552px", 926 | "left": "0px", 927 | "right": "1170px", 928 | "top": "107px", 929 | "width": "196px" 930 | } 931 | }, 932 | "nbformat": 4, 933 | "nbformat_minor": 2 934 | } 935 | -------------------------------------------------------------------------------- /notebook/Chapter_09_String_Text_File_Processing.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 9장 문자열과 텍스트 파일 데이터 다루기" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## 9.1 문자열 다루기" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "### 문자열 분리하기" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "**[9장: 159페이지]**" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": null, 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [ 37 | "coffee_menu_str = \"에스프레소,아메리카노,카페라테,카푸치노\"\n", 38 | "coffee_menu_str.split(',')" 39 | ] 40 | }, 41 | { 42 | "cell_type": "markdown", 43 | "metadata": {}, 44 | "source": [ 45 | "**[9장: 159페이지]**" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": null, 51 | "metadata": {}, 52 | "outputs": [], 53 | "source": [ 54 | "\"에스프레소,아메리카노,카페라테,카푸치노\".split(',')" 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "**[9장: 160페이지]**" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": null, 67 | "metadata": {}, 68 | "outputs": [], 69 | "source": [ 70 | "\"에스프레소 아메리카노 카페라테 카푸치노\".split(' ')" 71 | ] 72 | }, 73 | { 74 | "cell_type": "markdown", 75 | "metadata": {}, 76 | "source": [ 77 | "**[9장: 160페이지]**" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": null, 83 | "metadata": {}, 84 | "outputs": [], 85 | "source": [ 86 | "\"에스프레소 아메리카노 카페라테 카푸치노\".split()" 87 | ] 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "metadata": {}, 92 | "source": [ 93 | "**[9장: 160페이지]**" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": null, 99 | "metadata": {}, 100 | "outputs": [], 101 | "source": [ 102 | "\" 에스프레소 \\n\\n 아메리카노 \\n 카페라테 카푸치노 \\n\\n\".split()" 103 | ] 104 | }, 105 | { 106 | "cell_type": "markdown", 107 | "metadata": {}, 108 | "source": [ 109 | "**[9장: 160페이지]**" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": null, 115 | "metadata": {}, 116 | "outputs": [], 117 | "source": [ 118 | "\"에스프레소 아메리카노 카페라테 카푸치노\".split(maxsplit=2)" 119 | ] 120 | }, 121 | { 122 | "cell_type": "markdown", 123 | "metadata": {}, 124 | "source": [ 125 | "**[9장: 161페이지]**" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": null, 131 | "metadata": {}, 132 | "outputs": [], 133 | "source": [ 134 | "phone_number = \"+82-01-2345-6789\" # 국가 번호가 포함된 전화번호\n", 135 | "split_num = phone_number.split(\"-\", 1) # 국가 번호와 나머지 번호 분리\n", 136 | "\n", 137 | "print(split_num)\n", 138 | "print(\"국내전화번호: {0}\".format(split_num[1]))" 139 | ] 140 | }, 141 | { 142 | "cell_type": "markdown", 143 | "metadata": {}, 144 | "source": [ 145 | "### 필요없는 문자열 삭제하기" 146 | ] 147 | }, 148 | { 149 | "cell_type": "markdown", 150 | "metadata": {}, 151 | "source": [ 152 | "**[9장: 162페이지]**" 153 | ] 154 | }, 155 | { 156 | "cell_type": "code", 157 | "execution_count": null, 158 | "metadata": {}, 159 | "outputs": [], 160 | "source": [ 161 | "\"aaaaPythonaaa\".strip('a')" 162 | ] 163 | }, 164 | { 165 | "cell_type": "markdown", 166 | "metadata": {}, 167 | "source": [ 168 | "**[9장: 162페이지]**" 169 | ] 170 | }, 171 | { 172 | "cell_type": "code", 173 | "execution_count": null, 174 | "metadata": {}, 175 | "outputs": [], 176 | "source": [ 177 | "test_str = \"aaabbPythonbbbaa\"\n", 178 | "temp1 = test_str.strip('a') # 문자열 앞뒤의 'a' 제거\n", 179 | "temp1" 180 | ] 181 | }, 182 | { 183 | "cell_type": "markdown", 184 | "metadata": {}, 185 | "source": [ 186 | "**[9장: 162페이지]**" 187 | ] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": null, 192 | "metadata": {}, 193 | "outputs": [], 194 | "source": [ 195 | "temp1.strip('b') # 문자열 앞뒤의 'b' 제거" 196 | ] 197 | }, 198 | { 199 | "cell_type": "markdown", 200 | "metadata": {}, 201 | "source": [ 202 | "**[9장: 162페이지]**" 203 | ] 204 | }, 205 | { 206 | "cell_type": "code", 207 | "execution_count": null, 208 | "metadata": {}, 209 | "outputs": [], 210 | "source": [ 211 | "test_str.strip('ab') # 문자열 앞뒤의 'a'와 'b' 제거" 212 | ] 213 | }, 214 | { 215 | "cell_type": "markdown", 216 | "metadata": {}, 217 | "source": [ 218 | "**[9장: 162페이지]**" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": null, 224 | "metadata": {}, 225 | "outputs": [], 226 | "source": [ 227 | "test_str.strip('ba')" 228 | ] 229 | }, 230 | { 231 | "cell_type": "markdown", 232 | "metadata": {}, 233 | "source": [ 234 | "**[9장: 163페이지]**" 235 | ] 236 | }, 237 | { 238 | "cell_type": "code", 239 | "execution_count": null, 240 | "metadata": {}, 241 | "outputs": [], 242 | "source": [ 243 | "test_str_multi = \"##***!!!##.... Python is powerful.!... %%!#.. \"\n", 244 | "test_str_multi.strip('*.#! %')" 245 | ] 246 | }, 247 | { 248 | "cell_type": "markdown", 249 | "metadata": {}, 250 | "source": [ 251 | "**[9장: 163페이지]**" 252 | ] 253 | }, 254 | { 255 | "cell_type": "code", 256 | "execution_count": null, 257 | "metadata": {}, 258 | "outputs": [], 259 | "source": [ 260 | "test_str_multi.strip('%* !#.')" 261 | ] 262 | }, 263 | { 264 | "cell_type": "markdown", 265 | "metadata": {}, 266 | "source": [ 267 | "**[9장: 163페이지]**" 268 | ] 269 | }, 270 | { 271 | "cell_type": "code", 272 | "execution_count": null, 273 | "metadata": {}, 274 | "outputs": [], 275 | "source": [ 276 | "\" Python \".strip(' ')" 277 | ] 278 | }, 279 | { 280 | "cell_type": "markdown", 281 | "metadata": {}, 282 | "source": [ 283 | "**[9장: 163페이지]**" 284 | ] 285 | }, 286 | { 287 | "cell_type": "code", 288 | "execution_count": null, 289 | "metadata": {}, 290 | "outputs": [], 291 | "source": [ 292 | "\"\\n Python \\n\\n\".strip(' \\n')" 293 | ] 294 | }, 295 | { 296 | "cell_type": "markdown", 297 | "metadata": {}, 298 | "source": [ 299 | "**[9장: 163페이지]**" 300 | ] 301 | }, 302 | { 303 | "cell_type": "code", 304 | "execution_count": null, 305 | "metadata": {}, 306 | "outputs": [], 307 | "source": [ 308 | "\"\\n Python \\n\\n\".strip()" 309 | ] 310 | }, 311 | { 312 | "cell_type": "markdown", 313 | "metadata": {}, 314 | "source": [ 315 | "**[9장: 164페이지]**" 316 | ] 317 | }, 318 | { 319 | "cell_type": "code", 320 | "execution_count": null, 321 | "metadata": {}, 322 | "outputs": [], 323 | "source": [ 324 | "\"aaaBallaaa\".strip('a')" 325 | ] 326 | }, 327 | { 328 | "cell_type": "markdown", 329 | "metadata": {}, 330 | "source": [ 331 | "**[9장: 164페이지]**" 332 | ] 333 | }, 334 | { 335 | "cell_type": "code", 336 | "execution_count": null, 337 | "metadata": {}, 338 | "outputs": [], 339 | "source": [ 340 | "\"\\n This is very \\n fast. \\n\\n\".strip()" 341 | ] 342 | }, 343 | { 344 | "cell_type": "markdown", 345 | "metadata": {}, 346 | "source": [ 347 | "**[9장: 164페이지]**" 348 | ] 349 | }, 350 | { 351 | "cell_type": "code", 352 | "execution_count": null, 353 | "metadata": {}, 354 | "outputs": [], 355 | "source": [ 356 | "str_lr = \"000Python is easy to learn.000\"\n", 357 | "print(str_lr.strip('0'))\n", 358 | "print(str_lr.lstrip('0'))\n", 359 | "print(str_lr.rstrip('0'))" 360 | ] 361 | }, 362 | { 363 | "cell_type": "markdown", 364 | "metadata": {}, 365 | "source": [ 366 | "**[9장: 165페이지]**" 367 | ] 368 | }, 369 | { 370 | "cell_type": "code", 371 | "execution_count": null, 372 | "metadata": {}, 373 | "outputs": [], 374 | "source": [ 375 | "coffee_menu = \" 에스프레소, 아메리카노, 카페라테 , 카푸치노 \"\n", 376 | "coffee_menu_list = coffee_menu.split(',')\n", 377 | "coffee_menu_list" 378 | ] 379 | }, 380 | { 381 | "cell_type": "markdown", 382 | "metadata": {}, 383 | "source": [ 384 | "**[9장: 165페이지]**" 385 | ] 386 | }, 387 | { 388 | "cell_type": "code", 389 | "execution_count": null, 390 | "metadata": {}, 391 | "outputs": [], 392 | "source": [ 393 | "coffee_list = [] # 빈 리스트 생성\n", 394 | "for coffee in coffee_menu_list:\n", 395 | " temp = coffee.strip() # 문자열의 공백 제거\n", 396 | " coffee_list.append(temp) # 리스트 변수에 공백이 제거된 문자열 추가\n", 397 | " \n", 398 | "print(coffee_list) #최종 문자열 리스트 출력" 399 | ] 400 | }, 401 | { 402 | "cell_type": "markdown", 403 | "metadata": {}, 404 | "source": [ 405 | "### 문자열 연결하기" 406 | ] 407 | }, 408 | { 409 | "cell_type": "markdown", 410 | "metadata": {}, 411 | "source": [ 412 | "**[9장: 165페이지]**" 413 | ] 414 | }, 415 | { 416 | "cell_type": "code", 417 | "execution_count": null, 418 | "metadata": {}, 419 | "outputs": [], 420 | "source": [ 421 | "name1 = \"철수\"\n", 422 | "name2 = \"영미\"\n", 423 | "\n", 424 | "hello = \"님, 주소와 전화 번호를 입력해 주세요.\"\n", 425 | "print(name1 + hello)\n", 426 | "print(name2 + hello)" 427 | ] 428 | }, 429 | { 430 | "cell_type": "markdown", 431 | "metadata": {}, 432 | "source": [ 433 | "**[9장: 166페이지]**" 434 | ] 435 | }, 436 | { 437 | "cell_type": "code", 438 | "execution_count": null, 439 | "metadata": {}, 440 | "outputs": [], 441 | "source": [ 442 | "address_list = [\"서울시\",\"서초구\",\"반포대로\",\"201(반포동)\"]\n", 443 | "address_list" 444 | ] 445 | }, 446 | { 447 | "cell_type": "markdown", 448 | "metadata": {}, 449 | "source": [ 450 | "**[9장: 166페이지]**" 451 | ] 452 | }, 453 | { 454 | "cell_type": "code", 455 | "execution_count": null, 456 | "metadata": {}, 457 | "outputs": [], 458 | "source": [ 459 | "a = \" \"\n", 460 | "a.join(address_list)" 461 | ] 462 | }, 463 | { 464 | "cell_type": "markdown", 465 | "metadata": {}, 466 | "source": [ 467 | "**[9장: 167페이지]**" 468 | ] 469 | }, 470 | { 471 | "cell_type": "code", 472 | "execution_count": null, 473 | "metadata": {}, 474 | "outputs": [], 475 | "source": [ 476 | "\" \".join(address_list)" 477 | ] 478 | }, 479 | { 480 | "cell_type": "markdown", 481 | "metadata": {}, 482 | "source": [ 483 | "**[9장: 167페이지]**" 484 | ] 485 | }, 486 | { 487 | "cell_type": "code", 488 | "execution_count": null, 489 | "metadata": {}, 490 | "outputs": [], 491 | "source": [ 492 | "\"*^-^*\".join(address_list)" 493 | ] 494 | }, 495 | { 496 | "cell_type": "markdown", 497 | "metadata": {}, 498 | "source": [ 499 | "### 문자열 찾기" 500 | ] 501 | }, 502 | { 503 | "cell_type": "markdown", 504 | "metadata": {}, 505 | "source": [ 506 | "**[9장: 168페이지]**" 507 | ] 508 | }, 509 | { 510 | "cell_type": "code", 511 | "execution_count": null, 512 | "metadata": {}, 513 | "outputs": [], 514 | "source": [ 515 | "str_f = \"Python code.\"\n", 516 | "\n", 517 | "print(\"찾는 문자열의 위치:\", str_f.find(\"Python\"))\n", 518 | "print(\"찾는 문자열의 위치:\", str_f.find(\"code\"))\n", 519 | "print(\"찾는 문자열의 위치:\", str_f.find(\"n\"))\n", 520 | "print(\"찾는 문자열의 위치:\", str_f.find(\"easy\"))" 521 | ] 522 | }, 523 | { 524 | "cell_type": "markdown", 525 | "metadata": {}, 526 | "source": [ 527 | "**[9장: 168페이지]**" 528 | ] 529 | }, 530 | { 531 | "cell_type": "code", 532 | "execution_count": null, 533 | "metadata": {}, 534 | "outputs": [], 535 | "source": [ 536 | "str_f_se = \"Python is powerful. Python is easy to learn.\"\n", 537 | "\n", 538 | "print(str_f_se.find(\"Python\", 10, 30)) # 시작 위치(start)와 끝 위치(end) 지정\n", 539 | "print(str_f_se.find(\"Python\", 35)) # 찾기 위한 시작 위치(start) 지정" 540 | ] 541 | }, 542 | { 543 | "cell_type": "markdown", 544 | "metadata": {}, 545 | "source": [ 546 | "**[9장: 169페이지]**" 547 | ] 548 | }, 549 | { 550 | "cell_type": "code", 551 | "execution_count": null, 552 | "metadata": {}, 553 | "outputs": [], 554 | "source": [ 555 | "str_c = \"Python is powerful. Python is easy to learn. Python is open.\"\n", 556 | "\n", 557 | "print(\"Python의 개수는?:\", str_c.count(\"Python\"))\n", 558 | "print(\"powerful의 개수는?:\", str_c.count(\"powerful\"))\n", 559 | "print(\"IPython의 개수는?:\", str_c.count(\"IPython\"))" 560 | ] 561 | }, 562 | { 563 | "cell_type": "markdown", 564 | "metadata": {}, 565 | "source": [ 566 | "**[9장: 170페이지]**" 567 | ] 568 | }, 569 | { 570 | "cell_type": "code", 571 | "execution_count": null, 572 | "metadata": { 573 | "scrolled": true 574 | }, 575 | "outputs": [], 576 | "source": [ 577 | "str_se = \"Python is powerful. Python is easy to learn.\"\n", 578 | "\n", 579 | "print(\"Python으로 시작?:\", str_se.startswith(\"Python\"))\n", 580 | "print(\"is로 시작?:\", str_se.startswith(\"is\"))\n", 581 | "print(\".로 끝?:\", str_se.endswith(\".\"))\n", 582 | "print(\"learn으로 끝?:\", str_se.endswith(\"learn\"))" 583 | ] 584 | }, 585 | { 586 | "cell_type": "markdown", 587 | "metadata": {}, 588 | "source": [ 589 | "### 문자열 바꾸기" 590 | ] 591 | }, 592 | { 593 | "cell_type": "markdown", 594 | "metadata": { 595 | "collapsed": true 596 | }, 597 | "source": [ 598 | "**[9장: 170페이지]**" 599 | ] 600 | }, 601 | { 602 | "cell_type": "code", 603 | "execution_count": null, 604 | "metadata": {}, 605 | "outputs": [], 606 | "source": [ 607 | "str_a = 'Python is fast. Python is friendly. Python is open.'\n", 608 | "print(str_a.replace('Python', 'IPython'))\n", 609 | "print(str_a.replace('Python', 'IPython', 2))" 610 | ] 611 | }, 612 | { 613 | "cell_type": "markdown", 614 | "metadata": {}, 615 | "source": [ 616 | "**[9장: 171페이지]**" 617 | ] 618 | }, 619 | { 620 | "cell_type": "code", 621 | "execution_count": null, 622 | "metadata": {}, 623 | "outputs": [], 624 | "source": [ 625 | "str_b = '[Python] [is] [fast]'\n", 626 | "str_b1 = str_b.replace('[', '') # 문자열에서 '['를 제거\n", 627 | "str_b2 = str_b1.replace(']', '') # 결과 문자열에서 다시 ']'를 제거\n", 628 | "\n", 629 | "print(str_b)\n", 630 | "print(str_b1)\n", 631 | "print(str_b2)" 632 | ] 633 | }, 634 | { 635 | "cell_type": "markdown", 636 | "metadata": {}, 637 | "source": [ 638 | "### 문자열의 구성 확인하기" 639 | ] 640 | }, 641 | { 642 | "cell_type": "markdown", 643 | "metadata": {}, 644 | "source": [ 645 | "**[9장: 171페이지]**" 646 | ] 647 | }, 648 | { 649 | "cell_type": "code", 650 | "execution_count": null, 651 | "metadata": {}, 652 | "outputs": [], 653 | "source": [ 654 | "print('Python'.isalpha()) # 문자열에 공백, 특수 문자, 숫자가 없음\n", 655 | "print('Ver. 3.x'.isalpha()) # 공백, 특수 문자, 숫자 중 하나가 있음" 656 | ] 657 | }, 658 | { 659 | "cell_type": "markdown", 660 | "metadata": {}, 661 | "source": [ 662 | "**[9장: 172페이지]**" 663 | ] 664 | }, 665 | { 666 | "cell_type": "code", 667 | "execution_count": null, 668 | "metadata": {}, 669 | "outputs": [], 670 | "source": [ 671 | "print('12345'.isdigit()) # 문자열이 모두 숫자로 구성됨\n", 672 | "print('12345abc'.isdigit())# 문자열이 숫자로만 구성되지 않음" 673 | ] 674 | }, 675 | { 676 | "cell_type": "markdown", 677 | "metadata": {}, 678 | "source": [ 679 | "**[9장: 172페이지]**" 680 | ] 681 | }, 682 | { 683 | "cell_type": "code", 684 | "execution_count": null, 685 | "metadata": {}, 686 | "outputs": [], 687 | "source": [ 688 | "print('abc1234'.isalnum()) # 특수 문자나 공백이 아닌 문자와 숫자로 구성됨\n", 689 | "print(' abc1234'.isalnum()) # 문자열에 공백이 있음" 690 | ] 691 | }, 692 | { 693 | "cell_type": "markdown", 694 | "metadata": {}, 695 | "source": [ 696 | "**[9장: 172페이지]**" 697 | ] 698 | }, 699 | { 700 | "cell_type": "code", 701 | "execution_count": null, 702 | "metadata": {}, 703 | "outputs": [], 704 | "source": [ 705 | "print(' '.isspace()) # 문자열이 공백으로만 구성됨\n", 706 | "print(' 1 '.isspace()) # 문자열에 공백 외에 다른 문자가 있음" 707 | ] 708 | }, 709 | { 710 | "cell_type": "markdown", 711 | "metadata": {}, 712 | "source": [ 713 | "**[9장: 172페이지]**" 714 | ] 715 | }, 716 | { 717 | "cell_type": "code", 718 | "execution_count": null, 719 | "metadata": {}, 720 | "outputs": [], 721 | "source": [ 722 | "print('PYTHON'.isupper()) # 문자열이 모두 대문자로 구성됨\n", 723 | "print('Python'.isupper()) # 문자열에 대문자와 소문자가 있음\n", 724 | "print('python'.islower()) # 문자열이 모두 소문자로 구성됨\n", 725 | "print('Python'.islower()) # 문자열에 대문자와 소문자가 있음" 726 | ] 727 | }, 728 | { 729 | "cell_type": "markdown", 730 | "metadata": {}, 731 | "source": [ 732 | "### 대소문자로 변경하기" 733 | ] 734 | }, 735 | { 736 | "cell_type": "markdown", 737 | "metadata": {}, 738 | "source": [ 739 | "**[9장: 173페이지]**" 740 | ] 741 | }, 742 | { 743 | "cell_type": "code", 744 | "execution_count": null, 745 | "metadata": {}, 746 | "outputs": [], 747 | "source": [ 748 | "string1 = 'Python is powerful. PYTHON IS EASY TO LEARN.'\n", 749 | "print(string1.lower())\n", 750 | "print(string1.upper())" 751 | ] 752 | }, 753 | { 754 | "cell_type": "markdown", 755 | "metadata": {}, 756 | "source": [ 757 | "**[9장: 173페이지]**" 758 | ] 759 | }, 760 | { 761 | "cell_type": "code", 762 | "execution_count": null, 763 | "metadata": {}, 764 | "outputs": [], 765 | "source": [ 766 | "'Python' == 'python'" 767 | ] 768 | }, 769 | { 770 | "cell_type": "markdown", 771 | "metadata": {}, 772 | "source": [ 773 | "**[9장: 173페이지]**" 774 | ] 775 | }, 776 | { 777 | "cell_type": "code", 778 | "execution_count": null, 779 | "metadata": {}, 780 | "outputs": [], 781 | "source": [ 782 | "print('Python'.lower() == 'python'.lower())\n", 783 | "print('Python'.upper() == 'python'.upper())" 784 | ] 785 | }, 786 | { 787 | "cell_type": "markdown", 788 | "metadata": {}, 789 | "source": [ 790 | "## 9.2 텍스트 파일의 데이터를 읽고 처리하기" 791 | ] 792 | }, 793 | { 794 | "cell_type": "markdown", 795 | "metadata": {}, 796 | "source": [ 797 | "### 데이터 파일 준비 및 읽기" 798 | ] 799 | }, 800 | { 801 | "cell_type": "markdown", 802 | "metadata": {}, 803 | "source": [ 804 | "**[9장: 174페이지]**" 805 | ] 806 | }, 807 | { 808 | "cell_type": "code", 809 | "execution_count": null, 810 | "metadata": { 811 | "scrolled": true 812 | }, 813 | "outputs": [], 814 | "source": [ 815 | "!type c:\\myPyCode\\data\\coffeeShopSales.txt" 816 | ] 817 | }, 818 | { 819 | "cell_type": "markdown", 820 | "metadata": {}, 821 | "source": [ 822 | "**[9장: 175페이지]**" 823 | ] 824 | }, 825 | { 826 | "cell_type": "code", 827 | "execution_count": null, 828 | "metadata": {}, 829 | "outputs": [], 830 | "source": [ 831 | "# file_name = 'c:\\myPyCode\\data\\coffeeShopSales.txt' \n", 832 | "file_name = 'c:/myPyCode/data/coffeeShopSales.txt' \n", 833 | "\n", 834 | "f = open(file_name) # 파일 열기\n", 835 | "for line in f: # 한 줄씩 읽기\n", 836 | " print(line, end='') # 한 줄씩 출력\n", 837 | "f.close() # 파일 닫기" 838 | ] 839 | }, 840 | { 841 | "cell_type": "markdown", 842 | "metadata": {}, 843 | "source": [ 844 | "### 파일에서 읽은 문자열 데이터 처리" 845 | ] 846 | }, 847 | { 848 | "cell_type": "markdown", 849 | "metadata": {}, 850 | "source": [ 851 | "**[9장: 175 ~ 176페이지]**" 852 | ] 853 | }, 854 | { 855 | "cell_type": "code", 856 | "execution_count": null, 857 | "metadata": {}, 858 | "outputs": [], 859 | "source": [ 860 | "f = open(file_name) # 파일 열기\n", 861 | "header = f.readline() # 데이터의 첫 번째 줄을 읽음\n", 862 | "f.close() # 파일 닫기\n", 863 | "\n", 864 | "header" 865 | ] 866 | }, 867 | { 868 | "cell_type": "markdown", 869 | "metadata": {}, 870 | "source": [ 871 | "**[9장: 176페이지]**" 872 | ] 873 | }, 874 | { 875 | "cell_type": "code", 876 | "execution_count": null, 877 | "metadata": {}, 878 | "outputs": [], 879 | "source": [ 880 | "header_list = header.split() # 첫 줄의 문자열을 분리후 리스트로 변환\n", 881 | "header_list" 882 | ] 883 | }, 884 | { 885 | "cell_type": "markdown", 886 | "metadata": {}, 887 | "source": [ 888 | "**[9장: 176페이지]**" 889 | ] 890 | }, 891 | { 892 | "cell_type": "code", 893 | "execution_count": null, 894 | "metadata": { 895 | "scrolled": true 896 | }, 897 | "outputs": [], 898 | "source": [ 899 | "f = open(file_name) # 파일 열기\n", 900 | "header = f.readline() # 데이터의 첫 번째 줄을 읽음\n", 901 | "header_list = header.split() # 첫 줄의 문자열을 분리한 후 리스트로 변환\n", 902 | "\n", 903 | "for line in f: # 두 번째 줄부터 데이터를 읽어서 반복적으로 처리\n", 904 | " data_list = line.split() # 문자열을 분리해서 리스트로 변환\n", 905 | " print(data_list) # 결과 확인을 위해 리스트 출력\n", 906 | " \n", 907 | "f.close() # 파일 닫기" 908 | ] 909 | }, 910 | { 911 | "cell_type": "markdown", 912 | "metadata": { 913 | "collapsed": true 914 | }, 915 | "source": [ 916 | "**[9장: 177페이지]**" 917 | ] 918 | }, 919 | { 920 | "cell_type": "code", 921 | "execution_count": null, 922 | "metadata": {}, 923 | "outputs": [], 924 | "source": [ 925 | "f = open(file_name) # 파일 열기\n", 926 | "header = f.readline() # 데이터의 첫 번째 줄을 읽음\n", 927 | "headerList = header.split() # 첫 줄의 문자열을 분리한 후 리스트로 변환\n", 928 | "\n", 929 | "espresso = [] # 커피 종류별로 빈 리스트 생성\n", 930 | "americano = []\n", 931 | "cafelatte = []\n", 932 | "cappucino = []\n", 933 | "\n", 934 | "for line in f: # 두 번째 줄부터 데이터를 읽어서 반복적으로 처리\n", 935 | " dataList = line.split() # 문자열에서 공백을 제거해서 문자열 리스트로 변환\n", 936 | " \n", 937 | " # 커피 종류별로 정수로 변환한 후, 리스트의 항목으로 추가\n", 938 | " espresso.append(int(dataList[1]))\n", 939 | " americano.append(int(dataList[2]))\n", 940 | " cafelatte.append(int(dataList[3]))\n", 941 | " cappucino.append(int(dataList[4]))\n", 942 | " \n", 943 | "f.close() # 파일 닫기\n", 944 | "\n", 945 | "print(\"{0}: {1}\".format(headerList[1], espresso)) # 변수에 할당된 값을 출력\n", 946 | "print(\"{0}: {1}\".format(headerList[2], americano))\n", 947 | "print(\"{0}: {1}\".format(headerList[3], cafelatte)) \n", 948 | "print(\"{0}: {1}\".format(headerList[4], cappucino))" 949 | ] 950 | }, 951 | { 952 | "cell_type": "markdown", 953 | "metadata": {}, 954 | "source": [ 955 | "**[9장: 178페이지]**" 956 | ] 957 | }, 958 | { 959 | "cell_type": "code", 960 | "execution_count": null, 961 | "metadata": {}, 962 | "outputs": [], 963 | "source": [ 964 | "total_sum = [sum(espresso), sum(americano), sum(cafelatte), sum(cappucino)]\n", 965 | "total_mean = [sum(espresso)/len(espresso), sum(americano)/len(americano),\n", 966 | " sum(cafelatte)/len(cafelatte), sum(cappucino)/len(cappucino) ]\n", 967 | "\n", 968 | "for k in range(len(total_sum)):\n", 969 | " print('[{0}] 판매량'.format(headerList[k+1]))\n", 970 | " print('- 나흘 전체: {0}, 하루 평균: {1}'.format(total_sum[k], total_mean[k]))" 971 | ] 972 | }, 973 | { 974 | "cell_type": "markdown", 975 | "metadata": {}, 976 | "source": [ 977 | "# 9.3 정리" 978 | ] 979 | } 980 | ], 981 | "metadata": { 982 | "anaconda-cloud": {}, 983 | "kernelspec": { 984 | "display_name": "Python 3", 985 | "language": "python", 986 | "name": "python3" 987 | }, 988 | "language_info": { 989 | "codemirror_mode": { 990 | "name": "ipython", 991 | "version": 3 992 | }, 993 | "file_extension": ".py", 994 | "mimetype": "text/x-python", 995 | "name": "python", 996 | "nbconvert_exporter": "python", 997 | "pygments_lexer": "ipython3", 998 | "version": "3.6.4" 999 | }, 1000 | "latex_envs": { 1001 | "LaTeX_envs_menu_present": true, 1002 | "autoclose": false, 1003 | "autocomplete": true, 1004 | "bibliofile": "biblio.bib", 1005 | "cite_by": "apalike", 1006 | "current_citInitial": 1, 1007 | "eqLabelWithNumbers": true, 1008 | "eqNumInitial": 1, 1009 | "hotkeys": { 1010 | "equation": "Ctrl-E", 1011 | "itemize": "Ctrl-I" 1012 | }, 1013 | "labels_anchors": false, 1014 | "latex_user_defs": false, 1015 | "report_style_numbering": false, 1016 | "user_envs_cfg": false 1017 | }, 1018 | "nav_menu": {}, 1019 | "toc": { 1020 | "nav_menu": { 1021 | "height": "216px", 1022 | "width": "252px" 1023 | }, 1024 | "number_sections": false, 1025 | "sideBar": true, 1026 | "skip_h1_title": false, 1027 | "toc_cell": false, 1028 | "toc_position": { 1029 | "height": "624px", 1030 | "left": "0px", 1031 | "right": "1343.37px", 1032 | "top": "111px", 1033 | "width": "182px" 1034 | }, 1035 | "toc_section_display": "block", 1036 | "toc_window_display": false 1037 | }, 1038 | "toc_position": { 1039 | "height": "544px", 1040 | "left": "0px", 1041 | "right": "1082px", 1042 | "top": "107px", 1043 | "width": "244px" 1044 | } 1045 | }, 1046 | "nbformat": 4, 1047 | "nbformat_minor": 1 1048 | } 1049 | -------------------------------------------------------------------------------- /notebook/Chapter_07_Function.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 7장 함수" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## 7.1 함수 정의와 호출" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "### 함수의 기본 구조\n" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "### 인자도 반환 값도 없는 함수" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": {}, 34 | "source": [ 35 | "**[7장: 117페이지]**" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": null, 41 | "metadata": {}, 42 | "outputs": [], 43 | "source": [ 44 | "def my_func():\n", 45 | " print(\"My first function!\")\n", 46 | " print(\"This is a function.\")" 47 | ] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": {}, 52 | "source": [ 53 | "**[7장: 118페이지]**" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": null, 59 | "metadata": {}, 60 | "outputs": [], 61 | "source": [ 62 | "my_func()" 63 | ] 64 | }, 65 | { 66 | "cell_type": "markdown", 67 | "metadata": {}, 68 | "source": [ 69 | "### 인자는 있으나 반환 값이 없는 함수" 70 | ] 71 | }, 72 | { 73 | "cell_type": "markdown", 74 | "metadata": {}, 75 | "source": [ 76 | "**[7장: 118페이지]**" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": null, 82 | "metadata": {}, 83 | "outputs": [], 84 | "source": [ 85 | "def my_friend(friendName):\n", 86 | " print(\"{}는 나의 친구입니다.\".format(friendName))" 87 | ] 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "metadata": {}, 92 | "source": [ 93 | "**[7장: 118페이지]**" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": null, 99 | "metadata": {}, 100 | "outputs": [], 101 | "source": [ 102 | "my_friend(\"철수\")\n", 103 | "my_friend(\"영미\")" 104 | ] 105 | }, 106 | { 107 | "cell_type": "markdown", 108 | "metadata": {}, 109 | "source": [ 110 | "**[7장: 118 ~ 119페이지]**" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": null, 116 | "metadata": {}, 117 | "outputs": [], 118 | "source": [ 119 | "def my_student_info(name, school_ID, phoneNumber):\n", 120 | " print(\"------------------------\")\n", 121 | " print(\"- 학생이름:\", name)\n", 122 | " print(\"- 학급번호:\", school_ID)\n", 123 | " print(\"- 전화번호:\", phoneNumber)" 124 | ] 125 | }, 126 | { 127 | "cell_type": "markdown", 128 | "metadata": {}, 129 | "source": [ 130 | "**[7장: 119페이지]**" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": null, 136 | "metadata": {}, 137 | "outputs": [], 138 | "source": [ 139 | "my_student_info(\"현아\", \"01\", \"01-235-6789\")\n", 140 | "my_student_info(\"진수\", \"02\", \"01-987-6543\")" 141 | ] 142 | }, 143 | { 144 | "cell_type": "markdown", 145 | "metadata": {}, 146 | "source": [ 147 | "**[7장: 119페이지]**" 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": null, 153 | "metadata": {}, 154 | "outputs": [], 155 | "source": [ 156 | "def my_student_info(name, school_ID, phoneNumber):\n", 157 | " print(\"****************************\")\n", 158 | " print(\"* 학생이름:\", name)\n", 159 | " print(\"* 학급번호:\", school_ID)\n", 160 | " print(\"* 전화번호:\", phoneNumber)" 161 | ] 162 | }, 163 | { 164 | "cell_type": "markdown", 165 | "metadata": {}, 166 | "source": [ 167 | "**[7장: 119페이지]**" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": null, 173 | "metadata": {}, 174 | "outputs": [], 175 | "source": [ 176 | "my_student_info(\"현아\", \"01\", \"01-235-6789\")\n", 177 | "my_student_info(\"진수\", \"02\", \"01-987-6543\")" 178 | ] 179 | }, 180 | { 181 | "cell_type": "markdown", 182 | "metadata": {}, 183 | "source": [ 184 | "### 인자도 있고 반환 값도 있는 함수" 185 | ] 186 | }, 187 | { 188 | "cell_type": "markdown", 189 | "metadata": {}, 190 | "source": [ 191 | "**[7장: 120페이지]**" 192 | ] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": null, 197 | "metadata": {}, 198 | "outputs": [], 199 | "source": [ 200 | "def my_calc(x,y):\n", 201 | " z = x*y\n", 202 | " return z" 203 | ] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "metadata": {}, 208 | "source": [ 209 | "**[7장: 120페이지]**" 210 | ] 211 | }, 212 | { 213 | "cell_type": "code", 214 | "execution_count": null, 215 | "metadata": {}, 216 | "outputs": [], 217 | "source": [ 218 | "my_calc(3,4)" 219 | ] 220 | }, 221 | { 222 | "cell_type": "markdown", 223 | "metadata": {}, 224 | "source": [ 225 | "**[7장: 120페이지]**" 226 | ] 227 | }, 228 | { 229 | "cell_type": "code", 230 | "execution_count": null, 231 | "metadata": {}, 232 | "outputs": [], 233 | "source": [ 234 | "def my_student_info_list(student_info):\n", 235 | " print(\"****************************\")\n", 236 | " print(\"* 학생이름:\", student_info[0])\n", 237 | " print(\"* 학급번호:\", student_info[1])\n", 238 | " print(\"* 전화번호:\", student_info[2])\n", 239 | " print(\"****************************\")" 240 | ] 241 | }, 242 | { 243 | "cell_type": "markdown", 244 | "metadata": {}, 245 | "source": [ 246 | "**[7장: 120페이지]**" 247 | ] 248 | }, 249 | { 250 | "cell_type": "code", 251 | "execution_count": null, 252 | "metadata": {}, 253 | "outputs": [], 254 | "source": [ 255 | "student1_info = [\"현아\", \"01\", \"01-235-6789\"]\n", 256 | "my_student_info_list(student1_info)" 257 | ] 258 | }, 259 | { 260 | "cell_type": "markdown", 261 | "metadata": {}, 262 | "source": [ 263 | "**[7장: 121페이지]**" 264 | ] 265 | }, 266 | { 267 | "cell_type": "code", 268 | "execution_count": null, 269 | "metadata": {}, 270 | "outputs": [], 271 | "source": [ 272 | "my_student_info_list([\"진수\", \"02\", \"01-987-6543\"])" 273 | ] 274 | }, 275 | { 276 | "cell_type": "markdown", 277 | "metadata": {}, 278 | "source": [ 279 | "## 7.2 변수의 유효 범위" 280 | ] 281 | }, 282 | { 283 | "cell_type": "markdown", 284 | "metadata": {}, 285 | "source": [ 286 | "**[7장: 122페이지]**" 287 | ] 288 | }, 289 | { 290 | "cell_type": "code", 291 | "execution_count": null, 292 | "metadata": {}, 293 | "outputs": [], 294 | "source": [ 295 | "a = 5 # 전역 변수\n", 296 | "\n", 297 | "def func1():\n", 298 | " a = 1 # 지역 변수. func1()에서만 사용\n", 299 | " print(\"[func1] 지역 변수 a =\", a)\n", 300 | "\n", 301 | "def func2():\n", 302 | " a = 2 # 지역 변수. func2()에서만 사용\n", 303 | " print(\"[func2] 지역 변수 a =\", a) \n", 304 | " \n", 305 | "def func3():\n", 306 | " print(\"[func3] 전역 변수 a =\", a) \n", 307 | " \n", 308 | "def func4():\n", 309 | " global a # 함수 내에서 전역 변수 변경 위해 선언\n", 310 | " a = 4 # 전역 변수의 값 변경\n", 311 | " print(\"[func4] 전역 변수 a =\",a)" 312 | ] 313 | }, 314 | { 315 | "cell_type": "markdown", 316 | "metadata": {}, 317 | "source": [ 318 | "**[7장: 122페이지]**" 319 | ] 320 | }, 321 | { 322 | "cell_type": "code", 323 | "execution_count": null, 324 | "metadata": {}, 325 | "outputs": [], 326 | "source": [ 327 | "func1() #함수 func1() 호출\n", 328 | "func2() #함수 func2() 호출\n", 329 | "print(\"전역 변수 a =\", a) # 전역 변수 출력 " 330 | ] 331 | }, 332 | { 333 | "cell_type": "markdown", 334 | "metadata": {}, 335 | "source": [ 336 | "**[7장: 123페이지]**" 337 | ] 338 | }, 339 | { 340 | "cell_type": "code", 341 | "execution_count": null, 342 | "metadata": {}, 343 | "outputs": [], 344 | "source": [ 345 | "func3() #함수 func3() 호출\n", 346 | "func4() #함수 func4() 호출\n", 347 | "func3() #함수 func3() 호출" 348 | ] 349 | }, 350 | { 351 | "cell_type": "markdown", 352 | "metadata": {}, 353 | "source": [ 354 | "## 7.3 람다(lambda) 함수" 355 | ] 356 | }, 357 | { 358 | "cell_type": "markdown", 359 | "metadata": {}, 360 | "source": [ 361 | "**[7장: 124페이지]**" 362 | ] 363 | }, 364 | { 365 | "cell_type": "code", 366 | "execution_count": null, 367 | "metadata": {}, 368 | "outputs": [], 369 | "source": [ 370 | "(lambda x : x**2) (3)" 371 | ] 372 | }, 373 | { 374 | "cell_type": "markdown", 375 | "metadata": {}, 376 | "source": [ 377 | "**[7장: 124페이지]**" 378 | ] 379 | }, 380 | { 381 | "cell_type": "code", 382 | "execution_count": null, 383 | "metadata": {}, 384 | "outputs": [], 385 | "source": [ 386 | "mySquare = lambda x : x**2\n", 387 | "mySquare(2)" 388 | ] 389 | }, 390 | { 391 | "cell_type": "markdown", 392 | "metadata": {}, 393 | "source": [ 394 | "**[7장: 124페이지]**" 395 | ] 396 | }, 397 | { 398 | "cell_type": "code", 399 | "execution_count": null, 400 | "metadata": {}, 401 | "outputs": [], 402 | "source": [ 403 | "mySquare(5)" 404 | ] 405 | }, 406 | { 407 | "cell_type": "markdown", 408 | "metadata": {}, 409 | "source": [ 410 | "**[7장: 124페이지]**" 411 | ] 412 | }, 413 | { 414 | "cell_type": "code", 415 | "execution_count": null, 416 | "metadata": {}, 417 | "outputs": [], 418 | "source": [ 419 | "mySimpleFunc = lambda x,y,z : 2*x + 3*y + z\n", 420 | "mySimpleFunc(1,2,3)" 421 | ] 422 | }, 423 | { 424 | "cell_type": "markdown", 425 | "metadata": {}, 426 | "source": [ 427 | "## 7.4 유용한 내장 함수" 428 | ] 429 | }, 430 | { 431 | "cell_type": "markdown", 432 | "metadata": {}, 433 | "source": [ 434 | "### 형 변환 함수" 435 | ] 436 | }, 437 | { 438 | "cell_type": "markdown", 439 | "metadata": {}, 440 | "source": [ 441 | "#### 정수형으로 변환" 442 | ] 443 | }, 444 | { 445 | "cell_type": "markdown", 446 | "metadata": {}, 447 | "source": [ 448 | "**[7장: 125페이지]**" 449 | ] 450 | }, 451 | { 452 | "cell_type": "code", 453 | "execution_count": null, 454 | "metadata": {}, 455 | "outputs": [], 456 | "source": [ 457 | "[int(0.123), int(3.5123456), int(-1.312367)]" 458 | ] 459 | }, 460 | { 461 | "cell_type": "markdown", 462 | "metadata": {}, 463 | "source": [ 464 | "**[7장: 125페이지]**" 465 | ] 466 | }, 467 | { 468 | "cell_type": "code", 469 | "execution_count": null, 470 | "metadata": {}, 471 | "outputs": [], 472 | "source": [ 473 | "[int('1234'), int('5678'), int('-9012')]" 474 | ] 475 | }, 476 | { 477 | "cell_type": "markdown", 478 | "metadata": {}, 479 | "source": [ 480 | "#### 실수형으로 변환" 481 | ] 482 | }, 483 | { 484 | "cell_type": "markdown", 485 | "metadata": {}, 486 | "source": [ 487 | "**[7장: 125페이지]**" 488 | ] 489 | }, 490 | { 491 | "cell_type": "code", 492 | "execution_count": null, 493 | "metadata": {}, 494 | "outputs": [], 495 | "source": [ 496 | "[float(0), float(123), float(-567)]" 497 | ] 498 | }, 499 | { 500 | "cell_type": "markdown", 501 | "metadata": {}, 502 | "source": [ 503 | "**[7장: 126페이지]**" 504 | ] 505 | }, 506 | { 507 | "cell_type": "code", 508 | "execution_count": null, 509 | "metadata": {}, 510 | "outputs": [], 511 | "source": [ 512 | "[float('10'), float('0.123'), float('-567.89')]" 513 | ] 514 | }, 515 | { 516 | "cell_type": "markdown", 517 | "metadata": {}, 518 | "source": [ 519 | "#### 문자형으로 변환" 520 | ] 521 | }, 522 | { 523 | "cell_type": "markdown", 524 | "metadata": {}, 525 | "source": [ 526 | "**[7장: 126페이지]**" 527 | ] 528 | }, 529 | { 530 | "cell_type": "code", 531 | "execution_count": null, 532 | "metadata": {}, 533 | "outputs": [], 534 | "source": [ 535 | "[str(123), str(459678), str(-987)]" 536 | ] 537 | }, 538 | { 539 | "cell_type": "markdown", 540 | "metadata": {}, 541 | "source": [ 542 | "**[7장: 126페이지]**" 543 | ] 544 | }, 545 | { 546 | "cell_type": "code", 547 | "execution_count": null, 548 | "metadata": {}, 549 | "outputs": [], 550 | "source": [ 551 | "[str(0.123), str(345.678), str(-5.987)]" 552 | ] 553 | }, 554 | { 555 | "cell_type": "markdown", 556 | "metadata": {}, 557 | "source": [ 558 | "#### 리스트, 튜플, 세트형으로 변환" 559 | ] 560 | }, 561 | { 562 | "cell_type": "markdown", 563 | "metadata": {}, 564 | "source": [ 565 | "**[7장: 127페이지]**" 566 | ] 567 | }, 568 | { 569 | "cell_type": "code", 570 | "execution_count": null, 571 | "metadata": {}, 572 | "outputs": [], 573 | "source": [ 574 | "list_data = ['abc', 1, 2, 'def']\n", 575 | "tuple_data = ('abc', 1, 2, 'def')\n", 576 | "set_data = {'abc', 1, 2, 'def'}" 577 | ] 578 | }, 579 | { 580 | "cell_type": "markdown", 581 | "metadata": {}, 582 | "source": [ 583 | "**[7장: 127페이지]**" 584 | ] 585 | }, 586 | { 587 | "cell_type": "code", 588 | "execution_count": null, 589 | "metadata": {}, 590 | "outputs": [], 591 | "source": [ 592 | "[type(list_data), type(tuple_data), type(set_data)]" 593 | ] 594 | }, 595 | { 596 | "cell_type": "markdown", 597 | "metadata": {}, 598 | "source": [ 599 | "**[7장: 127페이지]**" 600 | ] 601 | }, 602 | { 603 | "cell_type": "code", 604 | "execution_count": null, 605 | "metadata": {}, 606 | "outputs": [], 607 | "source": [ 608 | "print(\"리스트로 변환: \", list(tuple_data), list(set_data))" 609 | ] 610 | }, 611 | { 612 | "cell_type": "markdown", 613 | "metadata": {}, 614 | "source": [ 615 | "**[7장: 127페이지]**" 616 | ] 617 | }, 618 | { 619 | "cell_type": "code", 620 | "execution_count": null, 621 | "metadata": { 622 | "scrolled": true 623 | }, 624 | "outputs": [], 625 | "source": [ 626 | "print(\"튜플로 변환:\", tuple(list_data), tuple(set_data))" 627 | ] 628 | }, 629 | { 630 | "cell_type": "markdown", 631 | "metadata": {}, 632 | "source": [ 633 | "**[7장: 127페이지]**" 634 | ] 635 | }, 636 | { 637 | "cell_type": "code", 638 | "execution_count": null, 639 | "metadata": {}, 640 | "outputs": [], 641 | "source": [ 642 | "print(\"세트로 변환:\", set(list_data), set(tuple_data))" 643 | ] 644 | }, 645 | { 646 | "cell_type": "markdown", 647 | "metadata": {}, 648 | "source": [ 649 | "### bool 함수" 650 | ] 651 | }, 652 | { 653 | "cell_type": "markdown", 654 | "metadata": {}, 655 | "source": [ 656 | "#### 숫자를 인자로 bool 함수 호출" 657 | ] 658 | }, 659 | { 660 | "cell_type": "markdown", 661 | "metadata": {}, 662 | "source": [ 663 | "**[7장: 128페이지]**" 664 | ] 665 | }, 666 | { 667 | "cell_type": "code", 668 | "execution_count": null, 669 | "metadata": {}, 670 | "outputs": [], 671 | "source": [ 672 | "bool(0) # 인자: 숫자 0" 673 | ] 674 | }, 675 | { 676 | "cell_type": "markdown", 677 | "metadata": {}, 678 | "source": [ 679 | "**[7장: 128페이지]**" 680 | ] 681 | }, 682 | { 683 | "cell_type": "code", 684 | "execution_count": null, 685 | "metadata": {}, 686 | "outputs": [], 687 | "source": [ 688 | "bool(1) # 인자: 양의 정수" 689 | ] 690 | }, 691 | { 692 | "cell_type": "code", 693 | "execution_count": null, 694 | "metadata": {}, 695 | "outputs": [], 696 | "source": [ 697 | "bool(-10) # 인자: 음의 정수" 698 | ] 699 | }, 700 | { 701 | "cell_type": "code", 702 | "execution_count": null, 703 | "metadata": {}, 704 | "outputs": [], 705 | "source": [ 706 | "bool(5.12) # 인자: 양의 실수" 707 | ] 708 | }, 709 | { 710 | "cell_type": "code", 711 | "execution_count": null, 712 | "metadata": {}, 713 | "outputs": [], 714 | "source": [ 715 | "bool(-3.26) # 인자: 음의 실수" 716 | ] 717 | }, 718 | { 719 | "cell_type": "markdown", 720 | "metadata": {}, 721 | "source": [ 722 | "#### 문자열을 인자로 bool 함수 호출" 723 | ] 724 | }, 725 | { 726 | "cell_type": "markdown", 727 | "metadata": {}, 728 | "source": [ 729 | "**[7장: 128 ~ 129페이지]**" 730 | ] 731 | }, 732 | { 733 | "cell_type": "code", 734 | "execution_count": null, 735 | "metadata": {}, 736 | "outputs": [], 737 | "source": [ 738 | "bool('a') # 인자: 문자열 'a'" 739 | ] 740 | }, 741 | { 742 | "cell_type": "code", 743 | "execution_count": null, 744 | "metadata": {}, 745 | "outputs": [], 746 | "source": [ 747 | "bool(' ') # 인자: 빈 문자열(공백)" 748 | ] 749 | }, 750 | { 751 | "cell_type": "code", 752 | "execution_count": null, 753 | "metadata": {}, 754 | "outputs": [], 755 | "source": [ 756 | "bool('') # 인자: 문자열 없음" 757 | ] 758 | }, 759 | { 760 | "cell_type": "code", 761 | "execution_count": null, 762 | "metadata": {}, 763 | "outputs": [], 764 | "source": [ 765 | "bool(None) #인자: None" 766 | ] 767 | }, 768 | { 769 | "cell_type": "markdown", 770 | "metadata": {}, 771 | "source": [ 772 | "#### 리스트, 튜플, 세트를 인자로 bool 함수 호출" 773 | ] 774 | }, 775 | { 776 | "cell_type": "markdown", 777 | "metadata": {}, 778 | "source": [ 779 | "**[7장: 129페이지]**" 780 | ] 781 | }, 782 | { 783 | "cell_type": "code", 784 | "execution_count": null, 785 | "metadata": {}, 786 | "outputs": [], 787 | "source": [ 788 | "myFriends = []\n", 789 | "bool(myFriends) # 인자: 항목이 없는 빈 리스트 " 790 | ] 791 | }, 792 | { 793 | "cell_type": "markdown", 794 | "metadata": {}, 795 | "source": [ 796 | "**[7장: 129페이지]**" 797 | ] 798 | }, 799 | { 800 | "cell_type": "code", 801 | "execution_count": null, 802 | "metadata": {}, 803 | "outputs": [], 804 | "source": [ 805 | "myFriends = ['James', 'Robert', 'Lisa', 'Mary']\n", 806 | "bool(myFriends) # 인자: 항목이 있는 리스트 " 807 | ] 808 | }, 809 | { 810 | "cell_type": "markdown", 811 | "metadata": {}, 812 | "source": [ 813 | "**[7장: 129 ~ 130페이지]**" 814 | ] 815 | }, 816 | { 817 | "cell_type": "code", 818 | "execution_count": null, 819 | "metadata": {}, 820 | "outputs": [], 821 | "source": [ 822 | "myNum = ()\n", 823 | "bool(myNum) # 인자: 항목이 없는 빈 튜플 " 824 | ] 825 | }, 826 | { 827 | "cell_type": "code", 828 | "execution_count": null, 829 | "metadata": {}, 830 | "outputs": [], 831 | "source": [ 832 | "myNum = (1,2,3)\n", 833 | "bool(myNum) # 인자: 항목이 있는 튜플 " 834 | ] 835 | }, 836 | { 837 | "cell_type": "markdown", 838 | "metadata": {}, 839 | "source": [ 840 | "**[7장: 130페이지]**" 841 | ] 842 | }, 843 | { 844 | "cell_type": "code", 845 | "execution_count": null, 846 | "metadata": {}, 847 | "outputs": [], 848 | "source": [ 849 | "mySetA = {}\n", 850 | "bool(mySetA) # 인자: 항목이 없는 빈 세트 " 851 | ] 852 | }, 853 | { 854 | "cell_type": "code", 855 | "execution_count": null, 856 | "metadata": {}, 857 | "outputs": [], 858 | "source": [ 859 | "mySetA = {10,20,30}\n", 860 | "bool(mySetA) # 인자: 항목이 있는 세트 " 861 | ] 862 | }, 863 | { 864 | "cell_type": "markdown", 865 | "metadata": {}, 866 | "source": [ 867 | "#### bool 함수의 활용" 868 | ] 869 | }, 870 | { 871 | "cell_type": "markdown", 872 | "metadata": {}, 873 | "source": [ 874 | "**[7장: 130페이지]**" 875 | ] 876 | }, 877 | { 878 | "cell_type": "code", 879 | "execution_count": null, 880 | "metadata": {}, 881 | "outputs": [], 882 | "source": [ 883 | "def print_name(name):\n", 884 | " if bool(name):\n", 885 | " print(\"입력된 이름:\", name)\n", 886 | " else:\n", 887 | " print(\"입력된 이름이 없습니다.\") " 888 | ] 889 | }, 890 | { 891 | "cell_type": "markdown", 892 | "metadata": {}, 893 | "source": [ 894 | "**[7장: 130페이지]**" 895 | ] 896 | }, 897 | { 898 | "cell_type": "code", 899 | "execution_count": null, 900 | "metadata": {}, 901 | "outputs": [], 902 | "source": [ 903 | "print_name(\"James\")" 904 | ] 905 | }, 906 | { 907 | "cell_type": "code", 908 | "execution_count": null, 909 | "metadata": {}, 910 | "outputs": [], 911 | "source": [ 912 | "print_name(\"\")" 913 | ] 914 | }, 915 | { 916 | "cell_type": "markdown", 917 | "metadata": {}, 918 | "source": [ 919 | "### 최솟값과 최댓값을 구하는 함수" 920 | ] 921 | }, 922 | { 923 | "cell_type": "markdown", 924 | "metadata": {}, 925 | "source": [ 926 | "**[7장: 131페이지]**" 927 | ] 928 | }, 929 | { 930 | "cell_type": "code", 931 | "execution_count": null, 932 | "metadata": {}, 933 | "outputs": [], 934 | "source": [ 935 | "myNum = [10, 5, 12, 0, 3.5, 99.5, 42]\n", 936 | "[min(myNum), max(myNum)]" 937 | ] 938 | }, 939 | { 940 | "cell_type": "markdown", 941 | "metadata": {}, 942 | "source": [ 943 | "**[7장: 131페이지]**" 944 | ] 945 | }, 946 | { 947 | "cell_type": "code", 948 | "execution_count": null, 949 | "metadata": {}, 950 | "outputs": [], 951 | "source": [ 952 | "myStr = 'zxyabc'\n", 953 | "[min(myStr), max(myStr)]" 954 | ] 955 | }, 956 | { 957 | "cell_type": "markdown", 958 | "metadata": {}, 959 | "source": [ 960 | "**[7장: 131페이지]**" 961 | ] 962 | }, 963 | { 964 | "cell_type": "code", 965 | "execution_count": null, 966 | "metadata": {}, 967 | "outputs": [], 968 | "source": [ 969 | "myNum = (10, 5, 12, 0, 3.5, 99.5, 42)\n", 970 | "[min(myNum), max(myNum)]" 971 | ] 972 | }, 973 | { 974 | "cell_type": "code", 975 | "execution_count": null, 976 | "metadata": {}, 977 | "outputs": [], 978 | "source": [ 979 | "myNum = {\"Abc\", \"abc\", \"bcd\", \"efg\"}\n", 980 | "[min(myNum), max(myNum)]" 981 | ] 982 | }, 983 | { 984 | "cell_type": "markdown", 985 | "metadata": {}, 986 | "source": [ 987 | "### 절댓값과 전체 합을 구하는 함수" 988 | ] 989 | }, 990 | { 991 | "cell_type": "markdown", 992 | "metadata": {}, 993 | "source": [ 994 | "**[7장: 132페이지]**" 995 | ] 996 | }, 997 | { 998 | "cell_type": "code", 999 | "execution_count": null, 1000 | "metadata": {}, 1001 | "outputs": [], 1002 | "source": [ 1003 | "[abs(10), abs(-10)]" 1004 | ] 1005 | }, 1006 | { 1007 | "cell_type": "code", 1008 | "execution_count": null, 1009 | "metadata": {}, 1010 | "outputs": [], 1011 | "source": [ 1012 | "[abs(2.45), abs(-2.45)]" 1013 | ] 1014 | }, 1015 | { 1016 | "cell_type": "markdown", 1017 | "metadata": {}, 1018 | "source": [ 1019 | "**[7장: 132페이지]**" 1020 | ] 1021 | }, 1022 | { 1023 | "cell_type": "code", 1024 | "execution_count": null, 1025 | "metadata": {}, 1026 | "outputs": [], 1027 | "source": [ 1028 | "sumList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", 1029 | "sum(sumList)" 1030 | ] 1031 | }, 1032 | { 1033 | "cell_type": "markdown", 1034 | "metadata": {}, 1035 | "source": [ 1036 | "### 항목의 개수를 구하는 함수" 1037 | ] 1038 | }, 1039 | { 1040 | "cell_type": "markdown", 1041 | "metadata": {}, 1042 | "source": [ 1043 | "**[7장: 132 ~ 133페이지]**" 1044 | ] 1045 | }, 1046 | { 1047 | "cell_type": "code", 1048 | "execution_count": null, 1049 | "metadata": {}, 1050 | "outputs": [], 1051 | "source": [ 1052 | "len(\"ab cd\") # 문자열" 1053 | ] 1054 | }, 1055 | { 1056 | "cell_type": "code", 1057 | "execution_count": null, 1058 | "metadata": {}, 1059 | "outputs": [], 1060 | "source": [ 1061 | "len([1, 2, 3, 4, 5, 6, 7, 8]) # 리스트" 1062 | ] 1063 | }, 1064 | { 1065 | "cell_type": "code", 1066 | "execution_count": null, 1067 | "metadata": {}, 1068 | "outputs": [], 1069 | "source": [ 1070 | "len((1, 2, 3, 4, 5)) # 튜플" 1071 | ] 1072 | }, 1073 | { 1074 | "cell_type": "code", 1075 | "execution_count": null, 1076 | "metadata": {}, 1077 | "outputs": [], 1078 | "source": [ 1079 | "len({'a', 'b', 'c', 'd'}) # 세트" 1080 | ] 1081 | }, 1082 | { 1083 | "cell_type": "code", 1084 | "execution_count": null, 1085 | "metadata": {}, 1086 | "outputs": [], 1087 | "source": [ 1088 | "len({1:\"Thomas\", 2:\"Edward\", 3:\"Henry\"}) # 딕셔너리" 1089 | ] 1090 | }, 1091 | { 1092 | "cell_type": "markdown", 1093 | "metadata": {}, 1094 | "source": [ 1095 | "### 내장 함수의 활용" 1096 | ] 1097 | }, 1098 | { 1099 | "cell_type": "markdown", 1100 | "metadata": {}, 1101 | "source": [ 1102 | "**[7장: 133페이지]**" 1103 | ] 1104 | }, 1105 | { 1106 | "cell_type": "code", 1107 | "execution_count": null, 1108 | "metadata": {}, 1109 | "outputs": [], 1110 | "source": [ 1111 | "scores = [90, 80, 95, 85] # 과목별 시험 점수\n", 1112 | "\n", 1113 | "score_sum = 0 # 총점 계산을 위한 초깃값 설정\n", 1114 | "subject_num = 0 # 과목수 계산을 위한 초깃값 설정\n", 1115 | "for score in scores:\n", 1116 | " score_sum = score_sum + score # 과목별 점수 모두 더하기\n", 1117 | " subject_num = subject_num + 1 # 과목수 계산\n", 1118 | " \n", 1119 | "average = score_sum / subject_num # 평균(총점 / 과목수) 구하기\n", 1120 | "\n", 1121 | "print(\"총점:{0}, 평균:{1}\".format(score_sum,average))" 1122 | ] 1123 | }, 1124 | { 1125 | "cell_type": "markdown", 1126 | "metadata": {}, 1127 | "source": [ 1128 | "**[7장: 134페이지]**" 1129 | ] 1130 | }, 1131 | { 1132 | "cell_type": "code", 1133 | "execution_count": null, 1134 | "metadata": {}, 1135 | "outputs": [], 1136 | "source": [ 1137 | "scores = [90, 80, 95, 85] # 과목별 시험 점수\n", 1138 | "\n", 1139 | "print(\"총점:{0}, 평균:{1}\".format(sum(scores), sum(scores)/len(scores)))" 1140 | ] 1141 | }, 1142 | { 1143 | "cell_type": "markdown", 1144 | "metadata": {}, 1145 | "source": [ 1146 | "**[7장: 134페이지]**" 1147 | ] 1148 | }, 1149 | { 1150 | "cell_type": "code", 1151 | "execution_count": null, 1152 | "metadata": {}, 1153 | "outputs": [], 1154 | "source": [ 1155 | "print(\"최하 점수:{0}, 최고 점수:{1}\".format(min(scores), max(scores)))" 1156 | ] 1157 | }, 1158 | { 1159 | "cell_type": "markdown", 1160 | "metadata": {}, 1161 | "source": [ 1162 | "# 7.5 정리" 1163 | ] 1164 | } 1165 | ], 1166 | "metadata": { 1167 | "kernelspec": { 1168 | "display_name": "Python 3", 1169 | "language": "python", 1170 | "name": "python3" 1171 | }, 1172 | "language_info": { 1173 | "codemirror_mode": { 1174 | "name": "ipython", 1175 | "version": 3 1176 | }, 1177 | "file_extension": ".py", 1178 | "mimetype": "text/x-python", 1179 | "name": "python", 1180 | "nbconvert_exporter": "python", 1181 | "pygments_lexer": "ipython3", 1182 | "version": "3.6.4" 1183 | }, 1184 | "latex_envs": { 1185 | "LaTeX_envs_menu_present": true, 1186 | "autoclose": false, 1187 | "autocomplete": true, 1188 | "bibliofile": "biblio.bib", 1189 | "cite_by": "apalike", 1190 | "current_citInitial": 1, 1191 | "eqLabelWithNumbers": true, 1192 | "eqNumInitial": 1, 1193 | "hotkeys": { 1194 | "equation": "Ctrl-E", 1195 | "itemize": "Ctrl-I" 1196 | }, 1197 | "labels_anchors": false, 1198 | "latex_user_defs": false, 1199 | "report_style_numbering": false, 1200 | "user_envs_cfg": false 1201 | }, 1202 | "toc": { 1203 | "nav_menu": {}, 1204 | "number_sections": false, 1205 | "sideBar": true, 1206 | "skip_h1_title": false, 1207 | "toc_cell": false, 1208 | "toc_position": { 1209 | "height": "582px", 1210 | "left": "0px", 1211 | "right": "1154px", 1212 | "top": "111px", 1213 | "width": "212px" 1214 | }, 1215 | "toc_section_display": "block", 1216 | "toc_window_display": false 1217 | } 1218 | }, 1219 | "nbformat": 4, 1220 | "nbformat_minor": 2 1221 | } 1222 | -------------------------------------------------------------------------------- /notebook/Chapter_04_Variable_DataType.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 4장 변수와 자료형" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## 4.1 변수" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "**[4장: 42페이지]**" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": null, 27 | "metadata": {}, 28 | "outputs": [], 29 | "source": [ 30 | "12340 * 1/2" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": null, 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [ 39 | "12340 * 1/4" 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": null, 45 | "metadata": {}, 46 | "outputs": [], 47 | "source": [ 48 | "12340 * 1/5" 49 | ] 50 | }, 51 | { 52 | "cell_type": "markdown", 53 | "metadata": {}, 54 | "source": [ 55 | "**[4장: 43페이지]**" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": null, 61 | "metadata": {}, 62 | "outputs": [], 63 | "source": [ 64 | "abc = 12340\n", 65 | "print(abc)" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "**[4장: 44페이지]**" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": null, 78 | "metadata": {}, 79 | "outputs": [], 80 | "source": [ 81 | "abc" 82 | ] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": {}, 87 | "source": [ 88 | "**[4장: 44페이지]**" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": null, 94 | "metadata": {}, 95 | "outputs": [], 96 | "source": [ 97 | "print(abc * 1/2)\n", 98 | "print(abc * 1/4)\n", 99 | "print(abc * 1/5)" 100 | ] 101 | }, 102 | { 103 | "cell_type": "markdown", 104 | "metadata": {}, 105 | "source": [ 106 | "## 4.2 문자열" 107 | ] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": {}, 112 | "source": [ 113 | "### 문자열 만들기" 114 | ] 115 | }, 116 | { 117 | "cell_type": "markdown", 118 | "metadata": {}, 119 | "source": [ 120 | "**[4장: 45 ~ 46페이지]**" 121 | ] 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": 2, 126 | "metadata": {}, 127 | "outputs": [ 128 | { 129 | "name": "stdout", 130 | "output_type": "stream", 131 | "text": [ 132 | "String Test\n" 133 | ] 134 | } 135 | ], 136 | "source": [ 137 | "print(\"String Test\")" 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": null, 143 | "metadata": {}, 144 | "outputs": [], 145 | "source": [ 146 | "print('String Test')" 147 | ] 148 | }, 149 | { 150 | "cell_type": "markdown", 151 | "metadata": {}, 152 | "source": [ 153 | "**[4장: 46페이지]**" 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": null, 159 | "metadata": {}, 160 | "outputs": [], 161 | "source": [ 162 | "string1 = \"String Test 1\"\n", 163 | "string2 = 'String Test 2'\n", 164 | "print(string1)\n", 165 | "print(string2)" 166 | ] 167 | }, 168 | { 169 | "cell_type": "markdown", 170 | "metadata": {}, 171 | "source": [ 172 | "**[4장: 46페이지]**" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": null, 178 | "metadata": {}, 179 | "outputs": [], 180 | "source": [ 181 | "type(string1)" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": null, 187 | "metadata": {}, 188 | "outputs": [], 189 | "source": [ 190 | "type(string2)" 191 | ] 192 | }, 193 | { 194 | "cell_type": "markdown", 195 | "metadata": {}, 196 | "source": [ 197 | "**[4장: 46페이지]**" 198 | ] 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": null, 203 | "metadata": {}, 204 | "outputs": [], 205 | "source": [ 206 | "string3 = 'This is a \"double\" quotation test'\n", 207 | "string4 = \"This is a 'single' quotation test\"\n", 208 | "print(string3)\n", 209 | "print(string4)" 210 | ] 211 | }, 212 | { 213 | "cell_type": "markdown", 214 | "metadata": {}, 215 | "source": [ 216 | "**[4장: 47페이지]**" 217 | ] 218 | }, 219 | { 220 | "cell_type": "code", 221 | "execution_count": null, 222 | "metadata": {}, 223 | "outputs": [], 224 | "source": [ 225 | "long_string1 = '''[삼중 작은따옴표를 사용한 예]\n", 226 | "파이썬에는 삼중 따옴표로 여러 행의 문자열을 입력할 수 있습니다.\n", 227 | "큰따옴표(\")와 작은따옴표(')도 입력할 수 있습니다.''' \n", 228 | "\n", 229 | "long_string2 = \"\"\"[삼중 큰따옴표를 사용한 예]\n", 230 | "파이썬에는 삼중 따옴표로 여러 행의 문자열을 입력할 수 있습니다.\n", 231 | "큰따옴표(\")와 작은따옴표(')도 입력할 수 있습니다.\"\"\" \n", 232 | "\n", 233 | "print(long_string1)\n", 234 | "print(long_string2)" 235 | ] 236 | }, 237 | { 238 | "cell_type": "markdown", 239 | "metadata": {}, 240 | "source": [ 241 | "### 문자열 다루기" 242 | ] 243 | }, 244 | { 245 | "cell_type": "markdown", 246 | "metadata": {}, 247 | "source": [ 248 | "**[4장: 48페이지]**" 249 | ] 250 | }, 251 | { 252 | "cell_type": "code", 253 | "execution_count": null, 254 | "metadata": {}, 255 | "outputs": [], 256 | "source": [ 257 | "a = 'Enjoy '\n", 258 | "b = 'python!'\n", 259 | "c = a + b\n", 260 | "print(c)" 261 | ] 262 | }, 263 | { 264 | "cell_type": "code", 265 | "execution_count": null, 266 | "metadata": {}, 267 | "outputs": [], 268 | "source": [ 269 | "print(a * 3)" 270 | ] 271 | }, 272 | { 273 | "cell_type": "markdown", 274 | "metadata": {}, 275 | "source": [ 276 | "## 4.3 리스트" 277 | ] 278 | }, 279 | { 280 | "cell_type": "markdown", 281 | "metadata": {}, 282 | "source": [ 283 | "### 리스트 만들기" 284 | ] 285 | }, 286 | { 287 | "cell_type": "markdown", 288 | "metadata": {}, 289 | "source": [ 290 | "**[4장: 49페이지]**" 291 | ] 292 | }, 293 | { 294 | "cell_type": "code", 295 | "execution_count": null, 296 | "metadata": {}, 297 | "outputs": [], 298 | "source": [ 299 | "# 1번 학생의 국어, 영어, 수학, 과학 점수가 각각 90,95,85,80\n", 300 | "student1 = [90,95,85,80] \n", 301 | "student1" 302 | ] 303 | }, 304 | { 305 | "cell_type": "markdown", 306 | "metadata": {}, 307 | "source": [ 308 | "**[4장: 49페이지]**" 309 | ] 310 | }, 311 | { 312 | "cell_type": "code", 313 | "execution_count": null, 314 | "metadata": {}, 315 | "outputs": [], 316 | "source": [ 317 | "type(student1)" 318 | ] 319 | }, 320 | { 321 | "cell_type": "markdown", 322 | "metadata": {}, 323 | "source": [ 324 | "**[4장: 50페이지]**" 325 | ] 326 | }, 327 | { 328 | "cell_type": "code", 329 | "execution_count": null, 330 | "metadata": {}, 331 | "outputs": [], 332 | "source": [ 333 | "student1[0]" 334 | ] 335 | }, 336 | { 337 | "cell_type": "code", 338 | "execution_count": null, 339 | "metadata": {}, 340 | "outputs": [], 341 | "source": [ 342 | "student1[1]" 343 | ] 344 | }, 345 | { 346 | "cell_type": "code", 347 | "execution_count": null, 348 | "metadata": {}, 349 | "outputs": [], 350 | "source": [ 351 | "student1[-1]" 352 | ] 353 | }, 354 | { 355 | "cell_type": "markdown", 356 | "metadata": {}, 357 | "source": [ 358 | "**[4장: 50페이지]**" 359 | ] 360 | }, 361 | { 362 | "cell_type": "code", 363 | "execution_count": null, 364 | "metadata": {}, 365 | "outputs": [], 366 | "source": [ 367 | "student1[1] = 100 # 두 번째 항목에 새로운 데이터 할당\n", 368 | "student1" 369 | ] 370 | }, 371 | { 372 | "cell_type": "markdown", 373 | "metadata": {}, 374 | "source": [ 375 | "**[4장: 50페이지]**" 376 | ] 377 | }, 378 | { 379 | "cell_type": "code", 380 | "execution_count": null, 381 | "metadata": {}, 382 | "outputs": [], 383 | "source": [ 384 | "myFriends = ['James', 'Robert', 'Lisa', 'Mary']\n", 385 | "myFriends" 386 | ] 387 | }, 388 | { 389 | "cell_type": "markdown", 390 | "metadata": {}, 391 | "source": [ 392 | "**[4장: 50 ~ 51페이지]**" 393 | ] 394 | }, 395 | { 396 | "cell_type": "code", 397 | "execution_count": null, 398 | "metadata": {}, 399 | "outputs": [], 400 | "source": [ 401 | "myFriends[2]" 402 | ] 403 | }, 404 | { 405 | "cell_type": "code", 406 | "execution_count": null, 407 | "metadata": {}, 408 | "outputs": [], 409 | "source": [ 410 | "myFriends[3]" 411 | ] 412 | }, 413 | { 414 | "cell_type": "code", 415 | "execution_count": null, 416 | "metadata": {}, 417 | "outputs": [], 418 | "source": [ 419 | "myFriends[-1]" 420 | ] 421 | }, 422 | { 423 | "cell_type": "markdown", 424 | "metadata": {}, 425 | "source": [ 426 | "**[4장: 51페이지]**" 427 | ] 428 | }, 429 | { 430 | "cell_type": "code", 431 | "execution_count": null, 432 | "metadata": {}, 433 | "outputs": [], 434 | "source": [ 435 | "mixedList = [0, 2, 3.14, 'python', 'program', True, myFriends]\n", 436 | "mixedList" 437 | ] 438 | }, 439 | { 440 | "cell_type": "markdown", 441 | "metadata": {}, 442 | "source": [ 443 | "### 리스트 다루기" 444 | ] 445 | }, 446 | { 447 | "cell_type": "markdown", 448 | "metadata": {}, 449 | "source": [ 450 | "#### 리스트 더하기와 곱하기" 451 | ] 452 | }, 453 | { 454 | "cell_type": "markdown", 455 | "metadata": {}, 456 | "source": [ 457 | "**[4장: 51페이지]**" 458 | ] 459 | }, 460 | { 461 | "cell_type": "code", 462 | "execution_count": null, 463 | "metadata": {}, 464 | "outputs": [], 465 | "source": [ 466 | "list_con1= [1,2,3,4]\n", 467 | "list_con2 = [5,6,7,8]\n", 468 | "list_con = list_con1 + list_con2 # 리스트 연결\n", 469 | "\n", 470 | "print(list_con)" 471 | ] 472 | }, 473 | { 474 | "cell_type": "markdown", 475 | "metadata": {}, 476 | "source": [ 477 | "**[4장: 51 ~ 52페이지]**" 478 | ] 479 | }, 480 | { 481 | "cell_type": "code", 482 | "execution_count": null, 483 | "metadata": {}, 484 | "outputs": [], 485 | "source": [ 486 | "list_con1= [1,2,3,4]\n", 487 | "list_con = list_con1 * 3 # 리스트 반복\n", 488 | "\n", 489 | "print(list_con)" 490 | ] 491 | }, 492 | { 493 | "cell_type": "markdown", 494 | "metadata": {}, 495 | "source": [ 496 | "#### 리스트 중 일부 항목 가져오기" 497 | ] 498 | }, 499 | { 500 | "cell_type": "markdown", 501 | "metadata": {}, 502 | "source": [ 503 | "**[4장: 52페이지]**" 504 | ] 505 | }, 506 | { 507 | "cell_type": "code", 508 | "execution_count": null, 509 | "metadata": {}, 510 | "outputs": [], 511 | "source": [ 512 | "list_data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", 513 | "print(list_data)\n", 514 | "print(list_data[0:3])\n", 515 | "print(list_data[4:8])\n", 516 | "print(list_data[:3])\n", 517 | "print(list_data[7:])\n", 518 | "print(list_data[::2])" 519 | ] 520 | }, 521 | { 522 | "cell_type": "markdown", 523 | "metadata": {}, 524 | "source": [ 525 | "#### 리스트에서 항목 삭제하기" 526 | ] 527 | }, 528 | { 529 | "cell_type": "markdown", 530 | "metadata": {}, 531 | "source": [ 532 | "**[4장: 53페이지]**" 533 | ] 534 | }, 535 | { 536 | "cell_type": "code", 537 | "execution_count": null, 538 | "metadata": {}, 539 | "outputs": [], 540 | "source": [ 541 | "print(list_data)\n", 542 | "del list_data[6]\n", 543 | "print(list_data)" 544 | ] 545 | }, 546 | { 547 | "cell_type": "markdown", 548 | "metadata": {}, 549 | "source": [ 550 | "#### 리스트에서 항목의 존재 여부 확인하기" 551 | ] 552 | }, 553 | { 554 | "cell_type": "markdown", 555 | "metadata": {}, 556 | "source": [ 557 | "**[4장: 53페이지]**" 558 | ] 559 | }, 560 | { 561 | "cell_type": "code", 562 | "execution_count": null, 563 | "metadata": {}, 564 | "outputs": [], 565 | "source": [ 566 | "list_data1 = [1, 2, 3, 4, 5]\n", 567 | "print(5 in list_data1)\n", 568 | "print(6 in list_data1)" 569 | ] 570 | }, 571 | { 572 | "cell_type": "markdown", 573 | "metadata": {}, 574 | "source": [ 575 | "#### 리스트 메서드 활용하기" 576 | ] 577 | }, 578 | { 579 | "cell_type": "markdown", 580 | "metadata": {}, 581 | "source": [ 582 | "**[4장: 54페이지]**" 583 | ] 584 | }, 585 | { 586 | "cell_type": "code", 587 | "execution_count": null, 588 | "metadata": {}, 589 | "outputs": [], 590 | "source": [ 591 | "myFriends = ['James', 'Robert', 'Lisa', 'Mary']\n", 592 | "print(myFriends)\n", 593 | "myFriends.append('Thomas')\n", 594 | "print(myFriends)" 595 | ] 596 | }, 597 | { 598 | "cell_type": "markdown", 599 | "metadata": {}, 600 | "source": [ 601 | "**[4장: 55페이지]**" 602 | ] 603 | }, 604 | { 605 | "cell_type": "code", 606 | "execution_count": null, 607 | "metadata": {}, 608 | "outputs": [], 609 | "source": [ 610 | "myFriends = ['James', 'Robert', 'Lisa', 'Mary']\n", 611 | "print(myFriends)\n", 612 | "myFriends.insert(1,'Paul')\n", 613 | "print(myFriends)" 614 | ] 615 | }, 616 | { 617 | "cell_type": "markdown", 618 | "metadata": {}, 619 | "source": [ 620 | "**[4장: 55페이지]**" 621 | ] 622 | }, 623 | { 624 | "cell_type": "code", 625 | "execution_count": null, 626 | "metadata": {}, 627 | "outputs": [], 628 | "source": [ 629 | "myFriends = ['James', 'Robert', 'Lisa', 'Mary']\n", 630 | "print(myFriends)\n", 631 | "myFriends.extend(['Laura', 'Betty'])\n", 632 | "print(myFriends)" 633 | ] 634 | }, 635 | { 636 | "cell_type": "markdown", 637 | "metadata": {}, 638 | "source": [ 639 | "## 4.4 튜플" 640 | ] 641 | }, 642 | { 643 | "cell_type": "markdown", 644 | "metadata": {}, 645 | "source": [ 646 | "### 튜플 만들기" 647 | ] 648 | }, 649 | { 650 | "cell_type": "markdown", 651 | "metadata": {}, 652 | "source": [ 653 | "**[4장: 56페이지]**" 654 | ] 655 | }, 656 | { 657 | "cell_type": "code", 658 | "execution_count": null, 659 | "metadata": {}, 660 | "outputs": [], 661 | "source": [ 662 | "tuple1 = (1,2,3,4)\n", 663 | "tuple1" 664 | ] 665 | }, 666 | { 667 | "cell_type": "markdown", 668 | "metadata": {}, 669 | "source": [ 670 | "**[4장: 56페이지]**" 671 | ] 672 | }, 673 | { 674 | "cell_type": "code", 675 | "execution_count": null, 676 | "metadata": {}, 677 | "outputs": [], 678 | "source": [ 679 | "type(tuple1)" 680 | ] 681 | }, 682 | { 683 | "cell_type": "markdown", 684 | "metadata": {}, 685 | "source": [ 686 | "**[4장: 56페이지]**" 687 | ] 688 | }, 689 | { 690 | "cell_type": "code", 691 | "execution_count": null, 692 | "metadata": {}, 693 | "outputs": [], 694 | "source": [ 695 | "tuple1[1]" 696 | ] 697 | }, 698 | { 699 | "cell_type": "markdown", 700 | "metadata": {}, 701 | "source": [ 702 | "**[4장: 56 ~ 57페이지]**" 703 | ] 704 | }, 705 | { 706 | "cell_type": "code", 707 | "execution_count": null, 708 | "metadata": {}, 709 | "outputs": [], 710 | "source": [ 711 | "tuple2 = 5,6,7,8\n", 712 | "print(tuple2)" 713 | ] 714 | }, 715 | { 716 | "cell_type": "code", 717 | "execution_count": null, 718 | "metadata": {}, 719 | "outputs": [], 720 | "source": [ 721 | "type(tuple2)" 722 | ] 723 | }, 724 | { 725 | "cell_type": "markdown", 726 | "metadata": {}, 727 | "source": [ 728 | "**[4장: 57페이지]**" 729 | ] 730 | }, 731 | { 732 | "cell_type": "code", 733 | "execution_count": null, 734 | "metadata": {}, 735 | "outputs": [], 736 | "source": [ 737 | "tuple3 = (9,) # 반드시 쉼표(',') 필요\n", 738 | "tuple4 = 10, # 반드시 쉼표(',') 필요\n", 739 | "print(tuple3)\n", 740 | "print(tuple4)" 741 | ] 742 | }, 743 | { 744 | "cell_type": "markdown", 745 | "metadata": {}, 746 | "source": [ 747 | "### 튜플 다루기" 748 | ] 749 | }, 750 | { 751 | "cell_type": "markdown", 752 | "metadata": {}, 753 | "source": [ 754 | "**[4장: 57페이지]**" 755 | ] 756 | }, 757 | { 758 | "cell_type": "code", 759 | "execution_count": null, 760 | "metadata": {}, 761 | "outputs": [], 762 | "source": [ 763 | "tuple5 = (1,2,3,4)\n", 764 | "tuple5[1] = 5 # 한번 생성된 튜플의 요소는 변경되지 않음" 765 | ] 766 | }, 767 | { 768 | "cell_type": "code", 769 | "execution_count": null, 770 | "metadata": {}, 771 | "outputs": [], 772 | "source": [ 773 | "del tuple5[1] # 한번 생성된 튜플 요소는 삭제되지 않음" 774 | ] 775 | }, 776 | { 777 | "cell_type": "markdown", 778 | "metadata": {}, 779 | "source": [ 780 | "**[4장: 58페이지]**" 781 | ] 782 | }, 783 | { 784 | "cell_type": "code", 785 | "execution_count": null, 786 | "metadata": {}, 787 | "outputs": [], 788 | "source": [ 789 | "tuple6 = ('a', 'b', 'c', 'd', 'e', 'f')\n", 790 | "tuple6.index('c')" 791 | ] 792 | }, 793 | { 794 | "cell_type": "markdown", 795 | "metadata": {}, 796 | "source": [ 797 | "**[4장: 58페이지]**" 798 | ] 799 | }, 800 | { 801 | "cell_type": "code", 802 | "execution_count": null, 803 | "metadata": {}, 804 | "outputs": [], 805 | "source": [ 806 | "tuple7 = ('a', 'a', 'a', 'b', 'b', 'c', 'd')\n", 807 | "tuple7.count('a')" 808 | ] 809 | }, 810 | { 811 | "cell_type": "markdown", 812 | "metadata": {}, 813 | "source": [ 814 | "## 4.5 세트" 815 | ] 816 | }, 817 | { 818 | "cell_type": "markdown", 819 | "metadata": {}, 820 | "source": [ 821 | "### 세트 만들기" 822 | ] 823 | }, 824 | { 825 | "cell_type": "markdown", 826 | "metadata": {}, 827 | "source": [ 828 | "**[4장: 59페이지]**" 829 | ] 830 | }, 831 | { 832 | "cell_type": "code", 833 | "execution_count": null, 834 | "metadata": {}, 835 | "outputs": [], 836 | "source": [ 837 | "set1 = {1, 2, 3}\n", 838 | "set1a = {1, 2, 3, 3}\n", 839 | "print(set1)\n", 840 | "print(set1a)" 841 | ] 842 | }, 843 | { 844 | "cell_type": "markdown", 845 | "metadata": {}, 846 | "source": [ 847 | "**[4장: 59페이지]**" 848 | ] 849 | }, 850 | { 851 | "cell_type": "code", 852 | "execution_count": null, 853 | "metadata": {}, 854 | "outputs": [], 855 | "source": [ 856 | "type(set1)" 857 | ] 858 | }, 859 | { 860 | "cell_type": "markdown", 861 | "metadata": {}, 862 | "source": [ 863 | "### 세트의 교집합, 합집합, 차집합 구하기" 864 | ] 865 | }, 866 | { 867 | "cell_type": "markdown", 868 | "metadata": {}, 869 | "source": [ 870 | "**[4장: 60페이지]**" 871 | ] 872 | }, 873 | { 874 | "cell_type": "code", 875 | "execution_count": null, 876 | "metadata": {}, 877 | "outputs": [], 878 | "source": [ 879 | "A = {1, 2, 3, 4, 5} # Set A\n", 880 | "B = {4, 5, 6, 7, 8, 9, 10} # Set B\n", 881 | "A.intersection(B) # 집합 A에 대한 집합 B의 교집합(A∩B)" 882 | ] 883 | }, 884 | { 885 | "cell_type": "code", 886 | "execution_count": null, 887 | "metadata": {}, 888 | "outputs": [], 889 | "source": [ 890 | "A.union(B) # 집합 A에 대한 집합 B의 합집합(A∪B)" 891 | ] 892 | }, 893 | { 894 | "cell_type": "code", 895 | "execution_count": null, 896 | "metadata": {}, 897 | "outputs": [], 898 | "source": [ 899 | "A.difference(B) # 집합 A에 대한 집합 B의 차집합(A-B)" 900 | ] 901 | }, 902 | { 903 | "cell_type": "markdown", 904 | "metadata": {}, 905 | "source": [ 906 | "**[4장: 60 ~ 61페이지]**" 907 | ] 908 | }, 909 | { 910 | "cell_type": "code", 911 | "execution_count": null, 912 | "metadata": { 913 | "scrolled": true 914 | }, 915 | "outputs": [], 916 | "source": [ 917 | "A = {1, 2, 3, 4, 5} # Set A\n", 918 | "B = {4, 5, 6, 7, 8, 9, 10} # Set B\n", 919 | "A & B # 집합 A에 대한 집합 B의 교집합(A∩B)" 920 | ] 921 | }, 922 | { 923 | "cell_type": "code", 924 | "execution_count": null, 925 | "metadata": {}, 926 | "outputs": [], 927 | "source": [ 928 | "A | B # 집합 A에 대한 집합 B의 합집합(A∪B)" 929 | ] 930 | }, 931 | { 932 | "cell_type": "code", 933 | "execution_count": null, 934 | "metadata": {}, 935 | "outputs": [], 936 | "source": [ 937 | "A - B # 집합 A에 대한 집합 B의 차집합(A-B)" 938 | ] 939 | }, 940 | { 941 | "cell_type": "markdown", 942 | "metadata": {}, 943 | "source": [ 944 | "### 리스트, 튜플, 세트 간 타입 변환" 945 | ] 946 | }, 947 | { 948 | "cell_type": "markdown", 949 | "metadata": {}, 950 | "source": [ 951 | "**[4장: 61페이지]**" 952 | ] 953 | }, 954 | { 955 | "cell_type": "code", 956 | "execution_count": null, 957 | "metadata": {}, 958 | "outputs": [], 959 | "source": [ 960 | "a = [1,2,3,4,5]" 961 | ] 962 | }, 963 | { 964 | "cell_type": "code", 965 | "execution_count": null, 966 | "metadata": {}, 967 | "outputs": [], 968 | "source": [ 969 | "type(a)" 970 | ] 971 | }, 972 | { 973 | "cell_type": "markdown", 974 | "metadata": {}, 975 | "source": [ 976 | "**[4장: 61페이지]**" 977 | ] 978 | }, 979 | { 980 | "cell_type": "code", 981 | "execution_count": null, 982 | "metadata": {}, 983 | "outputs": [], 984 | "source": [ 985 | "b = tuple(a)\n", 986 | "b" 987 | ] 988 | }, 989 | { 990 | "cell_type": "code", 991 | "execution_count": null, 992 | "metadata": {}, 993 | "outputs": [], 994 | "source": [ 995 | "type(b)" 996 | ] 997 | }, 998 | { 999 | "cell_type": "markdown", 1000 | "metadata": {}, 1001 | "source": [ 1002 | "**[4장: 61페이지]**" 1003 | ] 1004 | }, 1005 | { 1006 | "cell_type": "code", 1007 | "execution_count": null, 1008 | "metadata": {}, 1009 | "outputs": [], 1010 | "source": [ 1011 | "c = set(a)\n", 1012 | "c" 1013 | ] 1014 | }, 1015 | { 1016 | "cell_type": "code", 1017 | "execution_count": null, 1018 | "metadata": {}, 1019 | "outputs": [], 1020 | "source": [ 1021 | "type(c)" 1022 | ] 1023 | }, 1024 | { 1025 | "cell_type": "markdown", 1026 | "metadata": {}, 1027 | "source": [ 1028 | "**[4장: 62페이지]**" 1029 | ] 1030 | }, 1031 | { 1032 | "cell_type": "code", 1033 | "execution_count": null, 1034 | "metadata": {}, 1035 | "outputs": [], 1036 | "source": [ 1037 | "list(b)" 1038 | ] 1039 | }, 1040 | { 1041 | "cell_type": "code", 1042 | "execution_count": null, 1043 | "metadata": {}, 1044 | "outputs": [], 1045 | "source": [ 1046 | "list(c)" 1047 | ] 1048 | }, 1049 | { 1050 | "cell_type": "markdown", 1051 | "metadata": {}, 1052 | "source": [ 1053 | "## 4.6 딕셔너리" 1054 | ] 1055 | }, 1056 | { 1057 | "cell_type": "markdown", 1058 | "metadata": { 1059 | "collapsed": true 1060 | }, 1061 | "source": [ 1062 | "### 딕셔너리 만들기" 1063 | ] 1064 | }, 1065 | { 1066 | "cell_type": "markdown", 1067 | "metadata": {}, 1068 | "source": [ 1069 | "**[4장: 63페이지]**" 1070 | ] 1071 | }, 1072 | { 1073 | "cell_type": "code", 1074 | "execution_count": null, 1075 | "metadata": {}, 1076 | "outputs": [], 1077 | "source": [ 1078 | "country_capital = {\"영국\":\"런던\", \"프랑스\":\"파리\", \"스위스\": \"베른\", \"호주\":\"멜버른\", \"덴마크\": \"코펜하겐\"}\n", 1079 | "country_capital" 1080 | ] 1081 | }, 1082 | { 1083 | "cell_type": "markdown", 1084 | "metadata": {}, 1085 | "source": [ 1086 | "**[4장: 63페이지]**" 1087 | ] 1088 | }, 1089 | { 1090 | "cell_type": "code", 1091 | "execution_count": null, 1092 | "metadata": {}, 1093 | "outputs": [], 1094 | "source": [ 1095 | "type(country_capital)" 1096 | ] 1097 | }, 1098 | { 1099 | "cell_type": "markdown", 1100 | "metadata": {}, 1101 | "source": [ 1102 | "**[4장: 63페이지]**" 1103 | ] 1104 | }, 1105 | { 1106 | "cell_type": "code", 1107 | "execution_count": null, 1108 | "metadata": {}, 1109 | "outputs": [], 1110 | "source": [ 1111 | "country_capital[\"영국\"]" 1112 | ] 1113 | }, 1114 | { 1115 | "cell_type": "markdown", 1116 | "metadata": {}, 1117 | "source": [ 1118 | "**[4장: 64페이지]**" 1119 | ] 1120 | }, 1121 | { 1122 | "cell_type": "code", 1123 | "execution_count": null, 1124 | "metadata": {}, 1125 | "outputs": [], 1126 | "source": [ 1127 | "dict_data1 = {1:\"버스\", 3: \"비행기\", 4:\"택시\", 5: \"자전거\"}\n", 1128 | "dict_data1" 1129 | ] 1130 | }, 1131 | { 1132 | "cell_type": "markdown", 1133 | "metadata": {}, 1134 | "source": [ 1135 | "**[4장: 64페이지]**" 1136 | ] 1137 | }, 1138 | { 1139 | "cell_type": "code", 1140 | "execution_count": null, 1141 | "metadata": {}, 1142 | "outputs": [], 1143 | "source": [ 1144 | "dict_data1[3]" 1145 | ] 1146 | }, 1147 | { 1148 | "cell_type": "markdown", 1149 | "metadata": {}, 1150 | "source": [ 1151 | "**[4장: 64페이지]**" 1152 | ] 1153 | }, 1154 | { 1155 | "cell_type": "code", 1156 | "execution_count": null, 1157 | "metadata": {}, 1158 | "outputs": [], 1159 | "source": [ 1160 | "dict_data2 = {1:10, 2: 20, 3:30, 4: 40, 5:50}\n", 1161 | "print(dict_data2)\n", 1162 | "print(dict_data2[4])" 1163 | ] 1164 | }, 1165 | { 1166 | "cell_type": "markdown", 1167 | "metadata": {}, 1168 | "source": [ 1169 | "**[4장: 64페이지]**" 1170 | ] 1171 | }, 1172 | { 1173 | "cell_type": "code", 1174 | "execution_count": null, 1175 | "metadata": {}, 1176 | "outputs": [], 1177 | "source": [ 1178 | "dict_data3 = {\"list_data1\":[11,12,13], \"list_data2\": [21,22,23]}\n", 1179 | "print(dict_data3)\n", 1180 | "print(dict_data3[\"list_data2\"])" 1181 | ] 1182 | }, 1183 | { 1184 | "cell_type": "markdown", 1185 | "metadata": {}, 1186 | "source": [ 1187 | "**[4장: 64페이지]**" 1188 | ] 1189 | }, 1190 | { 1191 | "cell_type": "code", 1192 | "execution_count": null, 1193 | "metadata": {}, 1194 | "outputs": [], 1195 | "source": [ 1196 | "mixed_dict = {1:10, 'dict_num': {1:10, 2:20}, \"dict_list_tuple\": {\"A\":[11,12,13], \"B\":(21,22,23)}, \"dict_string\": \"이것은 책입니다.\"}\n", 1197 | "mixed_dict" 1198 | ] 1199 | }, 1200 | { 1201 | "cell_type": "markdown", 1202 | "metadata": {}, 1203 | "source": [ 1204 | "### 딕셔너리 다루기" 1205 | ] 1206 | }, 1207 | { 1208 | "cell_type": "markdown", 1209 | "metadata": {}, 1210 | "source": [ 1211 | "#### 딕셔너리에 데이터 추가하고 변경하기" 1212 | ] 1213 | }, 1214 | { 1215 | "cell_type": "markdown", 1216 | "metadata": {}, 1217 | "source": [ 1218 | "**[4장: 65페이지]**" 1219 | ] 1220 | }, 1221 | { 1222 | "cell_type": "code", 1223 | "execution_count": null, 1224 | "metadata": {}, 1225 | "outputs": [], 1226 | "source": [ 1227 | "country_capital[\"독일\"]= \"베를린\"\n", 1228 | "country_capital" 1229 | ] 1230 | }, 1231 | { 1232 | "cell_type": "markdown", 1233 | "metadata": {}, 1234 | "source": [ 1235 | "**[4장: 65페이지]**" 1236 | ] 1237 | }, 1238 | { 1239 | "cell_type": "code", 1240 | "execution_count": null, 1241 | "metadata": {}, 1242 | "outputs": [], 1243 | "source": [ 1244 | "country_capital[\"호주\"]= \"캔버라\"\n", 1245 | "country_capital" 1246 | ] 1247 | }, 1248 | { 1249 | "cell_type": "markdown", 1250 | "metadata": {}, 1251 | "source": [ 1252 | "#### 딕셔너리에서 데이터 삭제하기" 1253 | ] 1254 | }, 1255 | { 1256 | "cell_type": "markdown", 1257 | "metadata": {}, 1258 | "source": [ 1259 | "**[4장: 66페이지]**" 1260 | ] 1261 | }, 1262 | { 1263 | "cell_type": "code", 1264 | "execution_count": null, 1265 | "metadata": {}, 1266 | "outputs": [], 1267 | "source": [ 1268 | "del country_capital[\"덴마크\"]\n", 1269 | "country_capital" 1270 | ] 1271 | }, 1272 | { 1273 | "cell_type": "markdown", 1274 | "metadata": {}, 1275 | "source": [ 1276 | "#### 딕셔너리 메서드 활용하기" 1277 | ] 1278 | }, 1279 | { 1280 | "cell_type": "markdown", 1281 | "metadata": {}, 1282 | "source": [ 1283 | "**[4장: 66페이지]**" 1284 | ] 1285 | }, 1286 | { 1287 | "cell_type": "code", 1288 | "execution_count": null, 1289 | "metadata": {}, 1290 | "outputs": [], 1291 | "source": [ 1292 | "fruit_code = {\"사과\":101, \"배\":102, \"딸기\":103, \"포도\":104, \"바나나\":105}" 1293 | ] 1294 | }, 1295 | { 1296 | "cell_type": "markdown", 1297 | "metadata": {}, 1298 | "source": [ 1299 | "**[4장: 66페이지]**" 1300 | ] 1301 | }, 1302 | { 1303 | "cell_type": "code", 1304 | "execution_count": null, 1305 | "metadata": { 1306 | "scrolled": true 1307 | }, 1308 | "outputs": [], 1309 | "source": [ 1310 | "print(fruit_code.keys())" 1311 | ] 1312 | }, 1313 | { 1314 | "cell_type": "markdown", 1315 | "metadata": {}, 1316 | "source": [ 1317 | "**[4장: 66페이지]**" 1318 | ] 1319 | }, 1320 | { 1321 | "cell_type": "code", 1322 | "execution_count": null, 1323 | "metadata": {}, 1324 | "outputs": [], 1325 | "source": [ 1326 | "print(fruit_code.values())" 1327 | ] 1328 | }, 1329 | { 1330 | "cell_type": "markdown", 1331 | "metadata": {}, 1332 | "source": [ 1333 | "**[4장: 67페이지]**" 1334 | ] 1335 | }, 1336 | { 1337 | "cell_type": "code", 1338 | "execution_count": null, 1339 | "metadata": {}, 1340 | "outputs": [], 1341 | "source": [ 1342 | "print(fruit_code.items())" 1343 | ] 1344 | }, 1345 | { 1346 | "cell_type": "markdown", 1347 | "metadata": {}, 1348 | "source": [ 1349 | "**[4장: 67페이지]**" 1350 | ] 1351 | }, 1352 | { 1353 | "cell_type": "code", 1354 | "execution_count": null, 1355 | "metadata": {}, 1356 | "outputs": [], 1357 | "source": [ 1358 | "list(fruit_code.keys())" 1359 | ] 1360 | }, 1361 | { 1362 | "cell_type": "code", 1363 | "execution_count": null, 1364 | "metadata": {}, 1365 | "outputs": [], 1366 | "source": [ 1367 | "list(fruit_code.values())" 1368 | ] 1369 | }, 1370 | { 1371 | "cell_type": "code", 1372 | "execution_count": null, 1373 | "metadata": {}, 1374 | "outputs": [], 1375 | "source": [ 1376 | "list(fruit_code.items())" 1377 | ] 1378 | }, 1379 | { 1380 | "cell_type": "markdown", 1381 | "metadata": {}, 1382 | "source": [ 1383 | "**[4장: 67페이지]**" 1384 | ] 1385 | }, 1386 | { 1387 | "cell_type": "code", 1388 | "execution_count": null, 1389 | "metadata": {}, 1390 | "outputs": [], 1391 | "source": [ 1392 | "fruit_code2 = {\"오렌지\":106, \"수박\":107}" 1393 | ] 1394 | }, 1395 | { 1396 | "cell_type": "markdown", 1397 | "metadata": {}, 1398 | "source": [ 1399 | "**[4장: 67페이지]**" 1400 | ] 1401 | }, 1402 | { 1403 | "cell_type": "code", 1404 | "execution_count": null, 1405 | "metadata": {}, 1406 | "outputs": [], 1407 | "source": [ 1408 | "fruit_code.update(fruit_code2)\n", 1409 | "fruit_code" 1410 | ] 1411 | }, 1412 | { 1413 | "cell_type": "markdown", 1414 | "metadata": {}, 1415 | "source": [ 1416 | "**[4장: 68페이지]**" 1417 | ] 1418 | }, 1419 | { 1420 | "cell_type": "code", 1421 | "execution_count": null, 1422 | "metadata": {}, 1423 | "outputs": [], 1424 | "source": [ 1425 | "fruit_code2.clear()\n", 1426 | "print(fruit_code2)\n", 1427 | "type(fruit_code2)" 1428 | ] 1429 | }, 1430 | { 1431 | "cell_type": "markdown", 1432 | "metadata": {}, 1433 | "source": [ 1434 | "# 4.7 정리" 1435 | ] 1436 | } 1437 | ], 1438 | "metadata": { 1439 | "anaconda-cloud": {}, 1440 | "kernelspec": { 1441 | "display_name": "Python 3", 1442 | "language": "python", 1443 | "name": "python3" 1444 | }, 1445 | "language_info": { 1446 | "codemirror_mode": { 1447 | "name": "ipython", 1448 | "version": 3 1449 | }, 1450 | "file_extension": ".py", 1451 | "mimetype": "text/x-python", 1452 | "name": "python", 1453 | "nbconvert_exporter": "python", 1454 | "pygments_lexer": "ipython3", 1455 | "version": "3.6.4" 1456 | }, 1457 | "latex_envs": { 1458 | "LaTeX_envs_menu_present": true, 1459 | "autoclose": false, 1460 | "autocomplete": true, 1461 | "bibliofile": "biblio.bib", 1462 | "cite_by": "apalike", 1463 | "current_citInitial": 1, 1464 | "eqLabelWithNumbers": true, 1465 | "eqNumInitial": 1, 1466 | "hotkeys": { 1467 | "equation": "Ctrl-E", 1468 | "itemize": "Ctrl-I" 1469 | }, 1470 | "labels_anchors": false, 1471 | "latex_user_defs": false, 1472 | "report_style_numbering": false, 1473 | "user_envs_cfg": false 1474 | }, 1475 | "nav_menu": {}, 1476 | "toc": { 1477 | "nav_menu": { 1478 | "height": "161px", 1479 | "width": "252px" 1480 | }, 1481 | "number_sections": false, 1482 | "sideBar": true, 1483 | "skip_h1_title": false, 1484 | "toc_cell": false, 1485 | "toc_position": { 1486 | "height": "582px", 1487 | "left": "0px", 1488 | "right": "1154px", 1489 | "top": "111px", 1490 | "width": "212px" 1491 | }, 1492 | "toc_section_display": "block", 1493 | "toc_window_display": false 1494 | } 1495 | }, 1496 | "nbformat": 4, 1497 | "nbformat_minor": 1 1498 | } 1499 | -------------------------------------------------------------------------------- /notebook/Chapter_10_Module.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 10장 모듈" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## 10.1 모듈을 사용하는 이유" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "## 모듈 생성 및 호출" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "### 모듈 만들기" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": {}, 34 | "source": [ 35 | "**[10장: 181페이지]**" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": null, 41 | "metadata": {}, 42 | "outputs": [], 43 | "source": [ 44 | "%%writefile C:\\myPyCode\\my_first_module.py\n", 45 | "# File name: my_first_module.py\n", 46 | "\n", 47 | "def my_function():\n", 48 | " print(\"This is my first module.\") " 49 | ] 50 | }, 51 | { 52 | "cell_type": "markdown", 53 | "metadata": {}, 54 | "source": [ 55 | "**[10장: 182페이지]**" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": null, 61 | "metadata": { 62 | "scrolled": true 63 | }, 64 | "outputs": [], 65 | "source": [ 66 | "!type C:\\myPyCode\\my_first_module.py" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "### 모듈 불러오기" 74 | ] 75 | }, 76 | { 77 | "cell_type": "markdown", 78 | "metadata": {}, 79 | "source": [ 80 | "**[10장: 182페이지]**" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": null, 86 | "metadata": {}, 87 | "outputs": [], 88 | "source": [ 89 | "cd C:\\myPyCode" 90 | ] 91 | }, 92 | { 93 | "cell_type": "markdown", 94 | "metadata": {}, 95 | "source": [ 96 | "**[10장: 183페이지]**" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": null, 102 | "metadata": {}, 103 | "outputs": [], 104 | "source": [ 105 | "import my_first_module\n", 106 | "\n", 107 | "my_first_module.my_function()" 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "**[10장: 183페이지]**" 115 | ] 116 | }, 117 | { 118 | "cell_type": "code", 119 | "execution_count": null, 120 | "metadata": {}, 121 | "outputs": [], 122 | "source": [ 123 | "!echo %PYTHONPATH%" 124 | ] 125 | }, 126 | { 127 | "cell_type": "markdown", 128 | "metadata": {}, 129 | "source": [ 130 | "**[10장: 184페이지]**" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": null, 136 | "metadata": { 137 | "scrolled": false 138 | }, 139 | "outputs": [], 140 | "source": [ 141 | "%%writefile C:\\myPyCode\\modules\\my_area.py\n", 142 | "# File name: my_area.py\n", 143 | "\n", 144 | "PI = 3.14\n", 145 | "def square_area(a): # 정사각형의 넓이 반환\n", 146 | " return a ** 2\n", 147 | "\n", 148 | "def circle_area(r): # 원의 넓이 반환\n", 149 | " return PI * r ** 2" 150 | ] 151 | }, 152 | { 153 | "cell_type": "markdown", 154 | "metadata": {}, 155 | "source": [ 156 | "**[10장: 184페이지]**" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": null, 162 | "metadata": {}, 163 | "outputs": [], 164 | "source": [ 165 | "cd C:\\myPyCode" 166 | ] 167 | }, 168 | { 169 | "cell_type": "markdown", 170 | "metadata": {}, 171 | "source": [ 172 | "**[10장: 184페이지]**" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": null, 178 | "metadata": {}, 179 | "outputs": [], 180 | "source": [ 181 | "import my_area # 모듈 불러오기\n", 182 | "\n", 183 | "print('pi =', my_area.PI) # 모듈의 변수 이용\n", 184 | "print('square area =', my_area.square_area(5)) # 모듈의 함수 이용 \n", 185 | "print('circle area =', my_area.circle_area(2))" 186 | ] 187 | }, 188 | { 189 | "cell_type": "markdown", 190 | "metadata": {}, 191 | "source": [ 192 | "**[10장: 185페이지]**" 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": null, 198 | "metadata": {}, 199 | "outputs": [], 200 | "source": [ 201 | "dir(my_area)" 202 | ] 203 | }, 204 | { 205 | "cell_type": "markdown", 206 | "metadata": {}, 207 | "source": [ 208 | "### 모듈을 불러오는 다른 형식" 209 | ] 210 | }, 211 | { 212 | "cell_type": "markdown", 213 | "metadata": {}, 214 | "source": [ 215 | "#### 모듈의 내용 바로 선언" 216 | ] 217 | }, 218 | { 219 | "cell_type": "markdown", 220 | "metadata": {}, 221 | "source": [ 222 | "**[10장: 186페이지]**" 223 | ] 224 | }, 225 | { 226 | "cell_type": "code", 227 | "execution_count": null, 228 | "metadata": { 229 | "scrolled": true 230 | }, 231 | "outputs": [], 232 | "source": [ 233 | "from my_area import PI # 모듈의 변수 바로 불러오기\n", 234 | "\n", 235 | "print('pi =', PI) # 모듈의 변수 이용" 236 | ] 237 | }, 238 | { 239 | "cell_type": "markdown", 240 | "metadata": {}, 241 | "source": [ 242 | "**[10장: 186페이지]**" 243 | ] 244 | }, 245 | { 246 | "cell_type": "code", 247 | "execution_count": null, 248 | "metadata": {}, 249 | "outputs": [], 250 | "source": [ 251 | "from my_area import square_area\n", 252 | "from my_area import circle_area\n", 253 | "\n", 254 | "print('square area =', square_area(5)) # 모듈의 함수 이용 \n", 255 | "print('circle area =', circle_area(2)) " 256 | ] 257 | }, 258 | { 259 | "cell_type": "markdown", 260 | "metadata": {}, 261 | "source": [ 262 | "**[10장: 186페이지]**" 263 | ] 264 | }, 265 | { 266 | "cell_type": "code", 267 | "execution_count": null, 268 | "metadata": {}, 269 | "outputs": [], 270 | "source": [ 271 | "from my_area import PI, square_area, circle_area\n", 272 | "\n", 273 | "print('pi =', PI) # 모듈의 변수 이용\n", 274 | "print('square area =', square_area(5)) # 모듈의 함수 이용 \n", 275 | "print('circle area =', circle_area(2)) " 276 | ] 277 | }, 278 | { 279 | "cell_type": "markdown", 280 | "metadata": {}, 281 | "source": [ 282 | "**[10장: 187페이지]**" 283 | ] 284 | }, 285 | { 286 | "cell_type": "code", 287 | "execution_count": null, 288 | "metadata": {}, 289 | "outputs": [], 290 | "source": [ 291 | "from my_area import *\n", 292 | "\n", 293 | "print('pi =', PI) # 모듈의 변수 이용\n", 294 | "print('square area =', square_area(5)) # 모듈의 함수 이용\n", 295 | "print('circle area =', circle_area(2)) " 296 | ] 297 | }, 298 | { 299 | "cell_type": "markdown", 300 | "metadata": {}, 301 | "source": [ 302 | "**[10장: 187 ~ 188페이지]**" 303 | ] 304 | }, 305 | { 306 | "cell_type": "code", 307 | "execution_count": null, 308 | "metadata": {}, 309 | "outputs": [], 310 | "source": [ 311 | "%%writefile C:\\myPyCode\\modules\\my_module1.py\n", 312 | "# File name: my_module1.py\n", 313 | "\n", 314 | "def func1():\n", 315 | " print(\"func1 in my_module1 \")\n", 316 | "\n", 317 | "def func2():\n", 318 | " print(\"func2 in my_module1 \")" 319 | ] 320 | }, 321 | { 322 | "cell_type": "code", 323 | "execution_count": null, 324 | "metadata": {}, 325 | "outputs": [], 326 | "source": [ 327 | "%%writefile C:\\myPyCode\\modules\\my_module2.py\n", 328 | "# File name: my_module2.py\n", 329 | "\n", 330 | "def func2():\n", 331 | " print(\"func2 in my_module2 \")\n", 332 | "\n", 333 | "def func3():\n", 334 | " print(\"func3 in my_module2 \")" 335 | ] 336 | }, 337 | { 338 | "cell_type": "markdown", 339 | "metadata": {}, 340 | "source": [ 341 | "**[10장: 188페이지]**" 342 | ] 343 | }, 344 | { 345 | "cell_type": "code", 346 | "execution_count": null, 347 | "metadata": {}, 348 | "outputs": [], 349 | "source": [ 350 | "from my_module1 import *\n", 351 | "from my_module2 import *\n", 352 | "\n", 353 | "func1()\n", 354 | "func2()\n", 355 | "func3()" 356 | ] 357 | }, 358 | { 359 | "cell_type": "markdown", 360 | "metadata": {}, 361 | "source": [ 362 | "**[10장: 188페이지]**" 363 | ] 364 | }, 365 | { 366 | "cell_type": "code", 367 | "execution_count": null, 368 | "metadata": {}, 369 | "outputs": [], 370 | "source": [ 371 | "from my_module2 import *\n", 372 | "from my_module1 import *\n", 373 | "\n", 374 | "func1()\n", 375 | "func2()\n", 376 | "func3()" 377 | ] 378 | }, 379 | { 380 | "cell_type": "markdown", 381 | "metadata": {}, 382 | "source": [ 383 | "#### 모듈명을 별명으로 선언" 384 | ] 385 | }, 386 | { 387 | "cell_type": "markdown", 388 | "metadata": {}, 389 | "source": [ 390 | "**[10장: 189페이지]**" 391 | ] 392 | }, 393 | { 394 | "cell_type": "code", 395 | "execution_count": null, 396 | "metadata": {}, 397 | "outputs": [], 398 | "source": [ 399 | "import my_area as area # 모듈명(my_area)에 별명(area)을 붙임 \n", 400 | "\n", 401 | "print('pi =', area.PI) # 모듈명 대신 별명 이용\n", 402 | "print('square area =', area.square_area(5)) \n", 403 | "print('circle area =', area.circle_area(2))" 404 | ] 405 | }, 406 | { 407 | "cell_type": "markdown", 408 | "metadata": {}, 409 | "source": [ 410 | "**[10장: 190페이지]**" 411 | ] 412 | }, 413 | { 414 | "cell_type": "code", 415 | "execution_count": null, 416 | "metadata": {}, 417 | "outputs": [], 418 | "source": [ 419 | "from my_area import PI as pi\n", 420 | "from my_area import square_area as square\n", 421 | "from my_area import circle_area as circle\n", 422 | "\n", 423 | "print('pi =', pi) # 모듈 변수의 별명 이용\n", 424 | "print('square area =', square(5)) # 모듈 함수의 별명 이용\n", 425 | "print('circle area =', circle(2)) " 426 | ] 427 | }, 428 | { 429 | "cell_type": "markdown", 430 | "metadata": {}, 431 | "source": [ 432 | "## 10.3 모듈을 직접 실행하는 경우와 임포트한 후 실행하는 경우 구분하기" 433 | ] 434 | }, 435 | { 436 | "cell_type": "markdown", 437 | "metadata": {}, 438 | "source": [ 439 | "**[10장: 190페이지]**" 440 | ] 441 | }, 442 | { 443 | "cell_type": "code", 444 | "execution_count": null, 445 | "metadata": {}, 446 | "outputs": [], 447 | "source": [ 448 | "%%writefile C:\\myPyCode\\modules\\my_module_test1.py\n", 449 | "# File name: my_module_test1.py\n", 450 | "\n", 451 | "def func(a):\n", 452 | " print(\"입력 숫자:\", a)\n", 453 | " \n", 454 | "func(3)" 455 | ] 456 | }, 457 | { 458 | "cell_type": "markdown", 459 | "metadata": {}, 460 | "source": [ 461 | "**[10장: 191페이지]**" 462 | ] 463 | }, 464 | { 465 | "cell_type": "code", 466 | "execution_count": null, 467 | "metadata": {}, 468 | "outputs": [], 469 | "source": [ 470 | "%run C:\\myPyCode\\modules\\my_module_test1.py" 471 | ] 472 | }, 473 | { 474 | "cell_type": "markdown", 475 | "metadata": {}, 476 | "source": [ 477 | "**[10장: 191페이지]**" 478 | ] 479 | }, 480 | { 481 | "cell_type": "code", 482 | "execution_count": null, 483 | "metadata": {}, 484 | "outputs": [], 485 | "source": [ 486 | "import my_module_test1" 487 | ] 488 | }, 489 | { 490 | "cell_type": "markdown", 491 | "metadata": {}, 492 | "source": [ 493 | "**[10장: 192페이지]**" 494 | ] 495 | }, 496 | { 497 | "cell_type": "code", 498 | "execution_count": null, 499 | "metadata": {}, 500 | "outputs": [], 501 | "source": [ 502 | "%%writefile C:\\myPyCode\\modules\\my_module_test2.py\n", 503 | "# File name: my_module_test2.py\n", 504 | "\n", 505 | "def func(a):\n", 506 | " print(\"입력 숫자:\",a)\n", 507 | "\n", 508 | "if __name__ == \"__main__\":\n", 509 | " print(\"모듈을 직접 실행\")\n", 510 | " func(3)\n", 511 | " func(4)" 512 | ] 513 | }, 514 | { 515 | "cell_type": "markdown", 516 | "metadata": {}, 517 | "source": [ 518 | "**[10장: 192페이지]**" 519 | ] 520 | }, 521 | { 522 | "cell_type": "code", 523 | "execution_count": null, 524 | "metadata": {}, 525 | "outputs": [], 526 | "source": [ 527 | "%run C:\\myPyCode\\modules\\my_module_test2.py" 528 | ] 529 | }, 530 | { 531 | "cell_type": "markdown", 532 | "metadata": {}, 533 | "source": [ 534 | "**[10장: 192페이지]**" 535 | ] 536 | }, 537 | { 538 | "cell_type": "code", 539 | "execution_count": null, 540 | "metadata": {}, 541 | "outputs": [], 542 | "source": [ 543 | "import my_module_test2" 544 | ] 545 | }, 546 | { 547 | "cell_type": "markdown", 548 | "metadata": {}, 549 | "source": [ 550 | "**[10장: 193페이지]**" 551 | ] 552 | }, 553 | { 554 | "cell_type": "code", 555 | "execution_count": null, 556 | "metadata": {}, 557 | "outputs": [], 558 | "source": [ 559 | "%%writefile C:\\myPyCode\\modules\\my_module_test3.py\n", 560 | "# File name: my_module_test3.py\n", 561 | "\n", 562 | "def func(a):\n", 563 | " print(\"입력 숫자:\",a)\n", 564 | "\n", 565 | "if __name__ == \"__main__\":\n", 566 | " print(\"모듈을 직접 실행\")\n", 567 | " func(3)\n", 568 | " func(4)\n", 569 | "else:\n", 570 | " print(\"모듈을 임포트해서 실행\")" 571 | ] 572 | }, 573 | { 574 | "cell_type": "markdown", 575 | "metadata": {}, 576 | "source": [ 577 | "**[10장: 193페이지]**" 578 | ] 579 | }, 580 | { 581 | "cell_type": "code", 582 | "execution_count": null, 583 | "metadata": {}, 584 | "outputs": [], 585 | "source": [ 586 | "%run C:\\myPyCode\\modules\\my_module_test3.py" 587 | ] 588 | }, 589 | { 590 | "cell_type": "markdown", 591 | "metadata": {}, 592 | "source": [ 593 | "**[10장: 194페이지]**" 594 | ] 595 | }, 596 | { 597 | "cell_type": "code", 598 | "execution_count": null, 599 | "metadata": {}, 600 | "outputs": [], 601 | "source": [ 602 | "import my_module_test3" 603 | ] 604 | }, 605 | { 606 | "cell_type": "markdown", 607 | "metadata": {}, 608 | "source": [ 609 | "## 10.4 내장 모듈" 610 | ] 611 | }, 612 | { 613 | "cell_type": "markdown", 614 | "metadata": {}, 615 | "source": [ 616 | "### 난수 발생 모듈" 617 | ] 618 | }, 619 | { 620 | "cell_type": "markdown", 621 | "metadata": {}, 622 | "source": [ 623 | "**[10장: 195페이지]**" 624 | ] 625 | }, 626 | { 627 | "cell_type": "code", 628 | "execution_count": null, 629 | "metadata": {}, 630 | "outputs": [], 631 | "source": [ 632 | "import random\n", 633 | "\n", 634 | "random.random()" 635 | ] 636 | }, 637 | { 638 | "cell_type": "markdown", 639 | "metadata": {}, 640 | "source": [ 641 | "**[10장: 195페이지]**" 642 | ] 643 | }, 644 | { 645 | "cell_type": "code", 646 | "execution_count": null, 647 | "metadata": {}, 648 | "outputs": [], 649 | "source": [ 650 | "import random\n", 651 | "\n", 652 | "dice1 = random.randint(1,6) # 임의의 정수가 생성됨\n", 653 | "dice2 = random.randint(1,6) # 임의의 정수가 생성됨\n", 654 | "print('주사위 두 개의 숫자: {0}, {1}'.format(dice1, dice2))" 655 | ] 656 | }, 657 | { 658 | "cell_type": "markdown", 659 | "metadata": {}, 660 | "source": [ 661 | "**[10장: 196페이지]**" 662 | ] 663 | }, 664 | { 665 | "cell_type": "code", 666 | "execution_count": null, 667 | "metadata": {}, 668 | "outputs": [], 669 | "source": [ 670 | "import random\n", 671 | "\n", 672 | "random.randrange(0,11,2)" 673 | ] 674 | }, 675 | { 676 | "cell_type": "markdown", 677 | "metadata": {}, 678 | "source": [ 679 | "**[10장: 196페이지]**" 680 | ] 681 | }, 682 | { 683 | "cell_type": "code", 684 | "execution_count": null, 685 | "metadata": {}, 686 | "outputs": [], 687 | "source": [ 688 | "import random\n", 689 | "\n", 690 | "num1 = random.randrange(1, 10, 2) # 1 ~ 9(10-1) 중 임의의 홀수 선택\n", 691 | "num2 = random.randrange(0,100,10) # 0 ~ 99(100-1) 중 임의의10의 단위 숫자 선택\n", 692 | "print('num1: {0}, num2: {1}'.format(num1,num2))" 693 | ] 694 | }, 695 | { 696 | "cell_type": "markdown", 697 | "metadata": {}, 698 | "source": [ 699 | "**[10장: 196페이지]**" 700 | ] 701 | }, 702 | { 703 | "cell_type": "code", 704 | "execution_count": null, 705 | "metadata": {}, 706 | "outputs": [], 707 | "source": [ 708 | "import random\n", 709 | "\n", 710 | "menu = ['비빔밥', '된장찌개', '볶음밥', '불고기', '스파게티', '피자', '탕수육']\n", 711 | "random.choice(menu)" 712 | ] 713 | }, 714 | { 715 | "cell_type": "markdown", 716 | "metadata": {}, 717 | "source": [ 718 | "**[10장: 197페이지]**" 719 | ] 720 | }, 721 | { 722 | "cell_type": "code", 723 | "execution_count": null, 724 | "metadata": {}, 725 | "outputs": [], 726 | "source": [ 727 | "import random\n", 728 | "\n", 729 | "random.sample([1, 2, 3, 4, 5], 2) # 모집단에서 두 개의 인자 선택" 730 | ] 731 | }, 732 | { 733 | "cell_type": "markdown", 734 | "metadata": {}, 735 | "source": [ 736 | "### 날짜 및 시간 관련 처리 모듈" 737 | ] 738 | }, 739 | { 740 | "cell_type": "markdown", 741 | "metadata": {}, 742 | "source": [ 743 | "**[10장: 198페이지]**" 744 | ] 745 | }, 746 | { 747 | "cell_type": "code", 748 | "execution_count": null, 749 | "metadata": {}, 750 | "outputs": [], 751 | "source": [ 752 | "import datetime\n", 753 | "\n", 754 | "set_day = datetime.date(2019, 3, 1)\n", 755 | "print(set_day)" 756 | ] 757 | }, 758 | { 759 | "cell_type": "markdown", 760 | "metadata": {}, 761 | "source": [ 762 | "**[10장: 198페이지]**" 763 | ] 764 | }, 765 | { 766 | "cell_type": "code", 767 | "execution_count": null, 768 | "metadata": {}, 769 | "outputs": [], 770 | "source": [ 771 | "print('{0}/{1}/{2}'.format(set_day.year,set_day.month,set_day.day ))" 772 | ] 773 | }, 774 | { 775 | "cell_type": "markdown", 776 | "metadata": {}, 777 | "source": [ 778 | "**[10장: 198 ~ 199페이지]**" 779 | ] 780 | }, 781 | { 782 | "cell_type": "code", 783 | "execution_count": null, 784 | "metadata": {}, 785 | "outputs": [], 786 | "source": [ 787 | "import datetime\n", 788 | "\n", 789 | "day1 = datetime.date(2019, 4, 1)\n", 790 | "day2 = datetime.date(2019, 7, 10)\n", 791 | "diff_day = day2 - day1\n", 792 | "print(diff_day)" 793 | ] 794 | }, 795 | { 796 | "cell_type": "markdown", 797 | "metadata": {}, 798 | "source": [ 799 | "**[10장: 199페이지]**" 800 | ] 801 | }, 802 | { 803 | "cell_type": "code", 804 | "execution_count": null, 805 | "metadata": {}, 806 | "outputs": [], 807 | "source": [ 808 | "type(day1)" 809 | ] 810 | }, 811 | { 812 | "cell_type": "code", 813 | "execution_count": null, 814 | "metadata": {}, 815 | "outputs": [], 816 | "source": [ 817 | "type(diff_day)" 818 | ] 819 | }, 820 | { 821 | "cell_type": "markdown", 822 | "metadata": {}, 823 | "source": [ 824 | "**[10장: 199페이지]**" 825 | ] 826 | }, 827 | { 828 | "cell_type": "code", 829 | "execution_count": null, 830 | "metadata": {}, 831 | "outputs": [], 832 | "source": [ 833 | "print(\"** 지정된 두 날짜의 차이는 {}일입니다. **\".format(diff_day.days))" 834 | ] 835 | }, 836 | { 837 | "cell_type": "markdown", 838 | "metadata": {}, 839 | "source": [ 840 | "**[10장: 199페이지]**" 841 | ] 842 | }, 843 | { 844 | "cell_type": "code", 845 | "execution_count": null, 846 | "metadata": {}, 847 | "outputs": [], 848 | "source": [ 849 | "import datetime\n", 850 | "\n", 851 | "print(datetime.date.today())" 852 | ] 853 | }, 854 | { 855 | "cell_type": "markdown", 856 | "metadata": {}, 857 | "source": [ 858 | "**[10장: 200페이지]**" 859 | ] 860 | }, 861 | { 862 | "cell_type": "code", 863 | "execution_count": null, 864 | "metadata": {}, 865 | "outputs": [], 866 | "source": [ 867 | "import datetime\n", 868 | "\n", 869 | "today = datetime.date.today()\n", 870 | "special_day = datetime.date(2018, 12, 31)\n", 871 | "print(special_day - today)" 872 | ] 873 | }, 874 | { 875 | "cell_type": "markdown", 876 | "metadata": {}, 877 | "source": [ 878 | "**[10장: 200페이지]**" 879 | ] 880 | }, 881 | { 882 | "cell_type": "code", 883 | "execution_count": null, 884 | "metadata": {}, 885 | "outputs": [], 886 | "source": [ 887 | "import datetime\n", 888 | "\n", 889 | "set_time = datetime.time(15, 30, 45)\n", 890 | "print(set_time)" 891 | ] 892 | }, 893 | { 894 | "cell_type": "markdown", 895 | "metadata": {}, 896 | "source": [ 897 | "**[10장: 200페이지]**" 898 | ] 899 | }, 900 | { 901 | "cell_type": "code", 902 | "execution_count": null, 903 | "metadata": {}, 904 | "outputs": [], 905 | "source": [ 906 | "print('{0}:{1}:{2}'.format(set_time.hour,set_time.minute,set_time.second ))" 907 | ] 908 | }, 909 | { 910 | "cell_type": "markdown", 911 | "metadata": {}, 912 | "source": [ 913 | "**[10장: 200페이지]**" 914 | ] 915 | }, 916 | { 917 | "cell_type": "code", 918 | "execution_count": null, 919 | "metadata": {}, 920 | "outputs": [], 921 | "source": [ 922 | "import datetime\n", 923 | "\n", 924 | "set_dt = datetime.datetime(2018, 10, 9, 10, 20, 0)\n", 925 | "print(set_dt)" 926 | ] 927 | }, 928 | { 929 | "cell_type": "markdown", 930 | "metadata": {}, 931 | "source": [ 932 | "**[10장: 200 ~ 201페이지]**" 933 | ] 934 | }, 935 | { 936 | "cell_type": "code", 937 | "execution_count": null, 938 | "metadata": {}, 939 | "outputs": [], 940 | "source": [ 941 | "print('날짜 {0}/{1}/{2}'.format(set_dt.year, set_dt.month, set_dt.day))\n", 942 | "print('시각 {0}:{1}:{2}'.format(set_dt.hour, set_dt.minute, set_dt.second))" 943 | ] 944 | }, 945 | { 946 | "cell_type": "markdown", 947 | "metadata": {}, 948 | "source": [ 949 | "**[10장: 201페이지]**" 950 | ] 951 | }, 952 | { 953 | "cell_type": "code", 954 | "execution_count": null, 955 | "metadata": {}, 956 | "outputs": [], 957 | "source": [ 958 | "import datetime\n", 959 | "\n", 960 | "now = datetime.datetime.now()\n", 961 | "print(now)" 962 | ] 963 | }, 964 | { 965 | "cell_type": "markdown", 966 | "metadata": {}, 967 | "source": [ 968 | "**[10장: 201페이지]**" 969 | ] 970 | }, 971 | { 972 | "cell_type": "code", 973 | "execution_count": null, 974 | "metadata": {}, 975 | "outputs": [], 976 | "source": [ 977 | "print(\"Date & Time: {:%Y-%m-%d, %H:%M:%S}\".format(now))" 978 | ] 979 | }, 980 | { 981 | "cell_type": "markdown", 982 | "metadata": {}, 983 | "source": [ 984 | "**[10장: 201페이지]**" 985 | ] 986 | }, 987 | { 988 | "cell_type": "code", 989 | "execution_count": null, 990 | "metadata": {}, 991 | "outputs": [], 992 | "source": [ 993 | "print(\"Date: {:%Y, %m, %d}\".format(now))\n", 994 | "print(\"Time: {:%H/%M/%S}\".format(now))" 995 | ] 996 | }, 997 | { 998 | "cell_type": "markdown", 999 | "metadata": {}, 1000 | "source": [ 1001 | "**[10장: 201 ~ 202페이지]**" 1002 | ] 1003 | }, 1004 | { 1005 | "cell_type": "code", 1006 | "execution_count": null, 1007 | "metadata": {}, 1008 | "outputs": [], 1009 | "source": [ 1010 | "now = datetime.datetime.now()\n", 1011 | "set_dt = datetime.datetime(2017, 12, 1, 12, 30, 45)\n", 1012 | "\n", 1013 | "print(\"현재 날짜 및 시각:\", now)\n", 1014 | "print(\"차이:\", set_dt - now)" 1015 | ] 1016 | }, 1017 | { 1018 | "cell_type": "markdown", 1019 | "metadata": {}, 1020 | "source": [ 1021 | "**[10장: 202페이지]**" 1022 | ] 1023 | }, 1024 | { 1025 | "cell_type": "code", 1026 | "execution_count": null, 1027 | "metadata": {}, 1028 | "outputs": [], 1029 | "source": [ 1030 | "from datetime import date, time, datetime\n", 1031 | "\n", 1032 | "print(date(2019, 7, 1))" 1033 | ] 1034 | }, 1035 | { 1036 | "cell_type": "code", 1037 | "execution_count": null, 1038 | "metadata": {}, 1039 | "outputs": [], 1040 | "source": [ 1041 | "print(date.today())" 1042 | ] 1043 | }, 1044 | { 1045 | "cell_type": "code", 1046 | "execution_count": null, 1047 | "metadata": {}, 1048 | "outputs": [], 1049 | "source": [ 1050 | "print(time(15, 30, 45))" 1051 | ] 1052 | }, 1053 | { 1054 | "cell_type": "code", 1055 | "execution_count": null, 1056 | "metadata": {}, 1057 | "outputs": [], 1058 | "source": [ 1059 | "print(datetime(2020, 2, 14, 18, 10, 50))" 1060 | ] 1061 | }, 1062 | { 1063 | "cell_type": "code", 1064 | "execution_count": null, 1065 | "metadata": {}, 1066 | "outputs": [], 1067 | "source": [ 1068 | "print(datetime.now())" 1069 | ] 1070 | }, 1071 | { 1072 | "cell_type": "markdown", 1073 | "metadata": {}, 1074 | "source": [ 1075 | "### 달력 생성 및 처리 모듈" 1076 | ] 1077 | }, 1078 | { 1079 | "cell_type": "markdown", 1080 | "metadata": {}, 1081 | "source": [ 1082 | "**[10장: 204페이지]**" 1083 | ] 1084 | }, 1085 | { 1086 | "cell_type": "code", 1087 | "execution_count": null, 1088 | "metadata": {}, 1089 | "outputs": [], 1090 | "source": [ 1091 | "import calendar\n", 1092 | "\n", 1093 | "print(calendar.calendar(2018))" 1094 | ] 1095 | }, 1096 | { 1097 | "cell_type": "markdown", 1098 | "metadata": {}, 1099 | "source": [ 1100 | "**[10장: 205페이지]**" 1101 | ] 1102 | }, 1103 | { 1104 | "cell_type": "code", 1105 | "execution_count": null, 1106 | "metadata": {}, 1107 | "outputs": [], 1108 | "source": [ 1109 | "print(calendar.calendar(2019, m=4))" 1110 | ] 1111 | }, 1112 | { 1113 | "cell_type": "markdown", 1114 | "metadata": {}, 1115 | "source": [ 1116 | "**[10장: 206페이지]**" 1117 | ] 1118 | }, 1119 | { 1120 | "cell_type": "code", 1121 | "execution_count": null, 1122 | "metadata": { 1123 | "scrolled": true 1124 | }, 1125 | "outputs": [], 1126 | "source": [ 1127 | "print(calendar.month(2020,9))" 1128 | ] 1129 | }, 1130 | { 1131 | "cell_type": "markdown", 1132 | "metadata": {}, 1133 | "source": [ 1134 | "**[10장: 206페이지]**" 1135 | ] 1136 | }, 1137 | { 1138 | "cell_type": "code", 1139 | "execution_count": null, 1140 | "metadata": {}, 1141 | "outputs": [], 1142 | "source": [ 1143 | "calendar.monthrange(2020,2)" 1144 | ] 1145 | }, 1146 | { 1147 | "cell_type": "markdown", 1148 | "metadata": {}, 1149 | "source": [ 1150 | "**[10장: 206페이지]**" 1151 | ] 1152 | }, 1153 | { 1154 | "cell_type": "code", 1155 | "execution_count": null, 1156 | "metadata": {}, 1157 | "outputs": [], 1158 | "source": [ 1159 | "calendar.firstweekday()" 1160 | ] 1161 | }, 1162 | { 1163 | "cell_type": "markdown", 1164 | "metadata": {}, 1165 | "source": [ 1166 | "**[10장: 207페이지]**" 1167 | ] 1168 | }, 1169 | { 1170 | "cell_type": "code", 1171 | "execution_count": null, 1172 | "metadata": {}, 1173 | "outputs": [], 1174 | "source": [ 1175 | "calendar.setfirstweekday(calendar.SUNDAY)\n", 1176 | "print(calendar.month(2020,9))" 1177 | ] 1178 | }, 1179 | { 1180 | "cell_type": "markdown", 1181 | "metadata": {}, 1182 | "source": [ 1183 | "**[10장: 208페이지]**" 1184 | ] 1185 | }, 1186 | { 1187 | "cell_type": "code", 1188 | "execution_count": null, 1189 | "metadata": {}, 1190 | "outputs": [], 1191 | "source": [ 1192 | "print(calendar.weekday(2018, 10, 14))" 1193 | ] 1194 | }, 1195 | { 1196 | "cell_type": "markdown", 1197 | "metadata": {}, 1198 | "source": [ 1199 | "**[10장: 208페이지]**" 1200 | ] 1201 | }, 1202 | { 1203 | "cell_type": "code", 1204 | "execution_count": null, 1205 | "metadata": {}, 1206 | "outputs": [], 1207 | "source": [ 1208 | "print(calendar.isleap(2018))\n", 1209 | "print(calendar.isleap(2020))" 1210 | ] 1211 | }, 1212 | { 1213 | "cell_type": "markdown", 1214 | "metadata": {}, 1215 | "source": [ 1216 | "위의 출력 결과에서 2020년은 윤년인 것을 알 수 있습니다." 1217 | ] 1218 | }, 1219 | { 1220 | "cell_type": "markdown", 1221 | "metadata": {}, 1222 | "source": [ 1223 | "## 10.5 패키지" 1224 | ] 1225 | }, 1226 | { 1227 | "cell_type": "markdown", 1228 | "metadata": {}, 1229 | "source": [ 1230 | "### 패키지의 구조" 1231 | ] 1232 | }, 1233 | { 1234 | "cell_type": "markdown", 1235 | "metadata": {}, 1236 | "source": [ 1237 | "### 패키지 만들기" 1238 | ] 1239 | }, 1240 | { 1241 | "cell_type": "markdown", 1242 | "metadata": {}, 1243 | "source": [ 1244 | "**[10장: 210페이지]**" 1245 | ] 1246 | }, 1247 | { 1248 | "cell_type": "code", 1249 | "execution_count": null, 1250 | "metadata": {}, 1251 | "outputs": [], 1252 | "source": [ 1253 | "mkdir C:\\myPyCode\\packages\\image; C:\\myPyCode\\packages\\image\\io_file" 1254 | ] 1255 | }, 1256 | { 1257 | "cell_type": "markdown", 1258 | "metadata": {}, 1259 | "source": [ 1260 | "**[10장: 210페이지]**" 1261 | ] 1262 | }, 1263 | { 1264 | "cell_type": "code", 1265 | "execution_count": null, 1266 | "metadata": {}, 1267 | "outputs": [], 1268 | "source": [ 1269 | "%%writefile C:\\myPyCode\\packages\\image\\__init__.py\n", 1270 | "# File name: __init__.py" 1271 | ] 1272 | }, 1273 | { 1274 | "cell_type": "code", 1275 | "execution_count": null, 1276 | "metadata": {}, 1277 | "outputs": [], 1278 | "source": [ 1279 | "%%writefile C:\\myPyCode\\packages\\image\\io_file\\__init__.py\n", 1280 | "# File name: __init__.py" 1281 | ] 1282 | }, 1283 | { 1284 | "cell_type": "markdown", 1285 | "metadata": {}, 1286 | "source": [ 1287 | "**[10장: 210페이지]**" 1288 | ] 1289 | }, 1290 | { 1291 | "cell_type": "code", 1292 | "execution_count": null, 1293 | "metadata": { 1294 | "scrolled": true 1295 | }, 1296 | "outputs": [], 1297 | "source": [ 1298 | "%%writefile C:\\myPyCode\\packages\\image\\io_file\\imgread.py\n", 1299 | "# File name: imgread.py\n", 1300 | " \n", 1301 | "def pngread():\n", 1302 | " print(\"pngread in imgread module\")\n", 1303 | "\n", 1304 | "def jpgread():\n", 1305 | " print(\"jpgread in imgread module\")\n" 1306 | ] 1307 | }, 1308 | { 1309 | "cell_type": "markdown", 1310 | "metadata": {}, 1311 | "source": [ 1312 | "**[10장: 210페이지]**" 1313 | ] 1314 | }, 1315 | { 1316 | "cell_type": "code", 1317 | "execution_count": null, 1318 | "metadata": {}, 1319 | "outputs": [], 1320 | "source": [ 1321 | "!tree /F c:\\myPyCode\\packages" 1322 | ] 1323 | }, 1324 | { 1325 | "cell_type": "markdown", 1326 | "metadata": {}, 1327 | "source": [ 1328 | "### 패키지 사용하기" 1329 | ] 1330 | }, 1331 | { 1332 | "cell_type": "markdown", 1333 | "metadata": {}, 1334 | "source": [ 1335 | "**[10장: 211페이지]**" 1336 | ] 1337 | }, 1338 | { 1339 | "cell_type": "code", 1340 | "execution_count": null, 1341 | "metadata": {}, 1342 | "outputs": [], 1343 | "source": [ 1344 | "import image.io_file.imgread # image 패키지 io_file 폴더의 imgread 모듈 임포트\n", 1345 | " \n", 1346 | "image.io_file.imgread.pngread() # imgread 모듈 내의 pngread() 함수 호출\n", 1347 | "image.io_file.imgread.jpgread() # imgread 모듈 내의 jpgread() 함수 호출" 1348 | ] 1349 | }, 1350 | { 1351 | "cell_type": "markdown", 1352 | "metadata": {}, 1353 | "source": [ 1354 | "**[10장: 211페이지]**" 1355 | ] 1356 | }, 1357 | { 1358 | "cell_type": "code", 1359 | "execution_count": null, 1360 | "metadata": {}, 1361 | "outputs": [], 1362 | "source": [ 1363 | "from image.io_file import imgread\n", 1364 | "\n", 1365 | "imgread.pngread()\n", 1366 | "imgread.jpgread()" 1367 | ] 1368 | }, 1369 | { 1370 | "cell_type": "markdown", 1371 | "metadata": {}, 1372 | "source": [ 1373 | "**[10장: 212페이지]**" 1374 | ] 1375 | }, 1376 | { 1377 | "cell_type": "code", 1378 | "execution_count": null, 1379 | "metadata": {}, 1380 | "outputs": [], 1381 | "source": [ 1382 | "from image.io_file.imgread import pngread\n", 1383 | "\n", 1384 | "pngread()" 1385 | ] 1386 | }, 1387 | { 1388 | "cell_type": "markdown", 1389 | "metadata": {}, 1390 | "source": [ 1391 | "**[10장: 212페이지]**" 1392 | ] 1393 | }, 1394 | { 1395 | "cell_type": "code", 1396 | "execution_count": null, 1397 | "metadata": {}, 1398 | "outputs": [], 1399 | "source": [ 1400 | "from image.io_file.imgread import *\n", 1401 | "\n", 1402 | "pngread()\n", 1403 | "jpgread()" 1404 | ] 1405 | }, 1406 | { 1407 | "cell_type": "markdown", 1408 | "metadata": {}, 1409 | "source": [ 1410 | "**[10장: 212페이지]**" 1411 | ] 1412 | }, 1413 | { 1414 | "cell_type": "code", 1415 | "execution_count": null, 1416 | "metadata": {}, 1417 | "outputs": [], 1418 | "source": [ 1419 | "from image.io_file.imgread import pngread, jpgread\n", 1420 | "\n", 1421 | "pngread()\n", 1422 | "jpgread()" 1423 | ] 1424 | }, 1425 | { 1426 | "cell_type": "markdown", 1427 | "metadata": {}, 1428 | "source": [ 1429 | "**[10장: 212 ~ 213페이지]**" 1430 | ] 1431 | }, 1432 | { 1433 | "cell_type": "code", 1434 | "execution_count": null, 1435 | "metadata": {}, 1436 | "outputs": [], 1437 | "source": [ 1438 | "from image.io_file import imgread as img\n", 1439 | "\n", 1440 | "img.pngread()\n", 1441 | "img.jpgread()" 1442 | ] 1443 | }, 1444 | { 1445 | "cell_type": "markdown", 1446 | "metadata": {}, 1447 | "source": [ 1448 | "**[10장: 213페이지]**" 1449 | ] 1450 | }, 1451 | { 1452 | "cell_type": "code", 1453 | "execution_count": null, 1454 | "metadata": {}, 1455 | "outputs": [], 1456 | "source": [ 1457 | "from image.io_file.imgread import pngread as pread\n", 1458 | "from image.io_file.imgread import jpgread as jread\n", 1459 | "\n", 1460 | "pread()\n", 1461 | "jread()" 1462 | ] 1463 | }, 1464 | { 1465 | "cell_type": "markdown", 1466 | "metadata": { 1467 | "collapsed": true 1468 | }, 1469 | "source": [ 1470 | "## 10.6 정리" 1471 | ] 1472 | } 1473 | ], 1474 | "metadata": { 1475 | "anaconda-cloud": {}, 1476 | "kernelspec": { 1477 | "display_name": "Python 3", 1478 | "language": "python", 1479 | "name": "python3" 1480 | }, 1481 | "language_info": { 1482 | "codemirror_mode": { 1483 | "name": "ipython", 1484 | "version": 3 1485 | }, 1486 | "file_extension": ".py", 1487 | "mimetype": "text/x-python", 1488 | "name": "python", 1489 | "nbconvert_exporter": "python", 1490 | "pygments_lexer": "ipython3", 1491 | "version": "3.6.4" 1492 | }, 1493 | "latex_envs": { 1494 | "LaTeX_envs_menu_present": true, 1495 | "autoclose": false, 1496 | "autocomplete": true, 1497 | "bibliofile": "biblio.bib", 1498 | "cite_by": "apalike", 1499 | "current_citInitial": 1, 1500 | "eqLabelWithNumbers": true, 1501 | "eqNumInitial": 1, 1502 | "hotkeys": { 1503 | "equation": "Ctrl-E", 1504 | "itemize": "Ctrl-I" 1505 | }, 1506 | "labels_anchors": false, 1507 | "latex_user_defs": false, 1508 | "report_style_numbering": false, 1509 | "user_envs_cfg": false 1510 | }, 1511 | "nav_menu": {}, 1512 | "toc": { 1513 | "nav_menu": { 1514 | "height": "289px", 1515 | "width": "252px" 1516 | }, 1517 | "number_sections": false, 1518 | "sideBar": true, 1519 | "skip_h1_title": false, 1520 | "toc_cell": false, 1521 | "toc_position": { 1522 | "height": "582px", 1523 | "left": "0px", 1524 | "right": "1135px", 1525 | "top": "111px", 1526 | "width": "231px" 1527 | }, 1528 | "toc_section_display": "block", 1529 | "toc_window_display": false 1530 | }, 1531 | "toc_position": { 1532 | "height": "533px", 1533 | "left": "0px", 1534 | "right": "979.167px", 1535 | "top": "107px", 1536 | "width": "273px" 1537 | } 1538 | }, 1539 | "nbformat": 4, 1540 | "nbformat_minor": 1 1541 | } 1542 | --------------------------------------------------------------------------------