notebooks/Chapter_03_function_class_module.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3장 함수, 클래스, 모듈"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 함수"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 함수의 정의와 호출"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 85페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 함수의 정의 (이모티콘 출력)\n",
    "def my_emoticon():\n",
    "    print(\"=======\")\n",
    "    print(\" (^o^)\")\n",
    "    print(\"=======\")\n",
    "    \n",
    "# 함수의 호출\n",
    "my_emoticon()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 함수의 정의 (게임 정보 출력)\n",
    "def game_info_display(name, version, genre): # 3 개의 매개변수를 갖는 함수\n",
    "    print(\"--- 게임 정보 ----\")\n",
    "    print(\"이름:\", name)\n",
    "    print(\"버전:\", version)\n",
    "    print(\"장르:\", genre)\n",
    "\n",
    "# 함수의 호출 (매개변수의 개수와 순서가 같게 인수를 입력)\n",
    "game_info_display(\"고독한 방랑자\", \"2.02\", \"MMORPG\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 86페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 함수의 정의 (y = 2*x + 1)\n",
    "def my_func(x):\n",
    "    y = 2*x + 1\n",
    "    return y\n",
    "\n",
    "# 함수의 호출 (함수의 인수는 숫자로 입력)\n",
    "my_func(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = my_func(5)\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 함수의 정의(리스트를 입력 받아서 합계와 평균 반환) \n",
    "def calc_sum_mean(list_data):\n",
    "    e_count = 0  # 요소 개수 (초기화)\n",
    "    e_sum = 0    # 요소 합계 (초기화)\n",
    "    \n",
    "    for element in list_data:\n",
    "        e_count = e_count + 1    # 요소 개수 계산\n",
    "        e_sum = e_sum + element  # 요소 합계 계산\n",
    "    e_mean = e_sum / e_count     # 평균 = 합계/개수\n",
    "    \n",
    "    return e_sum, e_mean        # 계산 합계와 평균을 반환 (자료형은 튜플)\n",
    "\n",
    "# 함수의 호출 (인수는 리스트로 입력)\n",
    "calc_sum_mean([1, 2, 3, 4, 5, 6, 7, 8, 9])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 87페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_sum, list_mean = calc_sum_mean([1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
    "\n",
    "print(list_sum)\n",
    "print(list_mean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_add(a=1, b=2, c=3):\n",
    "    y = a + b + c\n",
    "    print(\"{0} + {1} + {2} = {3}\".format(a, b, c, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 88페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 모든 매개변수가 기본값을 사용\n",
    "my_add()     \n",
    "\n",
    "# 첫 번째 매개변수는 입력한 인수를 사용하고 나머지는 기본값을 사용\n",
    "my_add(11)      \n",
    "\n",
    "# 첫 번째와 두 번째 매개변수는 입력한 인수를 사용하고 나머지는 기본값을 사용\n",
    "my_add(11, 12) \n",
    "\n",
    "# 모든 매개변수가 입력한 인수를 사용\n",
    "my_add(11, 12, 13) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 첫 번째와 세 번째 매개변수는 입력한 인수를 사용하고 두 번째는 기본값을 사용 \n",
    "my_add(11, c=13) # 인수 입력이 매개변수에 의한 입력보다 먼저 와야 됨 \n",
    "\n",
    "# 두 번째와 세 번째 매개변수는 입력한 인수를 사용하고 첫 번째는 기본값 사용 \n",
    "my_add(c=13, b=12) # 매개변수에 의한 입력끼리는 순서가 중요하지 않음"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 89페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_add2(a, b, c=3, d=4):\n",
    "    y = a + b + c + d\n",
    "    print(\"{0} + {1} + {2} + {3} = {4}\".format(a, b, c, d, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "위의 함수를 호출할 때 기본값 없는 매개변수에 대해서는 같은 개수와 순서의 인수가 반드시 필요하며 기본값 있는 매개변수에 대해서는 인수를 사용하지 않을 수 있습니다. 인수를 사용하지 않으면 기본값으로 입력됩니다. 다음은 다양한 방법으로 인수를 사용해 함수를 호출한 예입니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_add2(1, 2)          # 기본값 없는 매개변수는 반드시 인수 필요. c와 d에는 기본값 입력\n",
    "my_add2(1, 2, 13)      # d에는 기본값이 입력됨\n",
    "my_add2(1, 2, 13, 14)  # c와 d에 모두 인수로 지정한 값 입력\n",
    "my_add2(1, 2, d=14)    # c에는 기본값이 입력됨"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 89~90페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10 # 전역 변수. 어디서나 사용\n",
    "\n",
    "def func1():\n",
    "    a = 1 # 지역 변수. 함수 func1 내에서만 사용\n",
    "    print(\"[func1()] 지역 변수 a =\", a)\n",
    "    \n",
    "def func2():\n",
    "    a = 2 # 지역 변수. 함수 func2 내에서만 사용\n",
    "    print(\"[func2()] 지역 변수 a =\", a)    \n",
    "    \n",
    "def func3():\n",
    "    print(\"[func3()] 전역 변수 a =\", a) # 전역 변수를 변경 없이 사용\n",
    "    \n",
    "def func4():\n",
    "    global a # 함수 내에서 전역 변수를 변경하려면 반드시 'global 전역변수명' 선언 필요\n",
    "    a = 20    # 전역 변수의 값 변경\n",
    "    print(\"[func4()] 전역 변수 a =\", a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 90페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func1()\n",
    "func2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"전역 변수 a = \", a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func3() # 함수 내에서 전역 변수 a를 호출\n",
    "func4() # 함수 내에서 전역 변수 a의 값을 변경\n",
    "func3() # 함수 내에서 전역 변수 a를 호출"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 내장 함수"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 91페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"정수로 변환:\", [int(12.34), int(\"1234\"), int(0.56), int(-56.78)])\n",
    "print(\"실수로 변환:\", [float(12), float(\"12.34\"), float(\"56\"), float(-98)])\n",
    "print(\"문자열로 변환:\", [str(12), str(12.34)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 92페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"튜플/세트 -> 리스트로 변환:\", list((1,2,3)), list({1,2,3})) \n",
    "print(\"리스트/세트 -> 튜플로 변환:\", tuple([1,2,3]), tuple({1,2,3}))\n",
    "print(\"리스트/튜플 -> 세트로 변환:\", set([1,2,3]), set((1,2,3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_data = [100, 2, 3, 4, 5, 5, 5] # 리스트 데이터\n",
    "\n",
    "print(list_data)\n",
    "print(set(list_data))               # 리스트 데이터를 세트로 변환"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 93페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_data = [-2, -1, 0, 1, 2, 3, 4, 5] # 리스트 데이터\n",
    "\n",
    "print(\"최소:\", min(list_data))         # 리스트 요소의 최솟값\n",
    "print(\"최대:\", max(list_data))         # 리스트 요소의 최댓값\n",
    "print(\"합계:\", sum(list_data))         # 리스트 요소의 합"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean = sum(list_data) / len(list_data) # 요소의 평균 = 요소의 합 / 요소의 개수\n",
    "\n",
    "print(\"평균:\", mean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "set_data = {-2, -1, 0, 1, 2, 3, 3, 3} # 중복 요소는 제거하고 세트 생성\n",
    "\n",
    "print(\"세트 데이터:\", set_data)\n",
    "print(\"최소: {}, 최대: {}\".format(min(set_data), max(set_data)))\n",
    "print(\"합계: {}, 데이터 개수: {}\".format(sum(set_data), len(set_data)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 클래스"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 클래스와 객체"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 96페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Robot():\n",
    "    def __init__(self, name, position):    # 초기화 함수\n",
    "        self.name = name # 인스턴스 변수(로봇 객체의 이름) 초기화\n",
    "        self.position = position           # 인스턴스 변수(로봇 객체의 초기 위치) 초기화 \n",
    "       \n",
    "    def move(self):     # 앞으로 한 칸 이동을 위한 함수\n",
    "        self.position = self.position + 1  # 이전 위치에서 앞으로 한 칸 이동\n",
    "        print(f\"{self.name}의 현재 위치: {self.position}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 97페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "robot1 = Robot('R1', 0)  # 클래스에서 객체 생성"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 98페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"로봇의 이름: {robot1.name}, 초기 위치: {robot1.position}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "robot1.move() # 객체의 메서드 move 호출"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "robot2 = Robot('R2', 10) # 클래스에서 객체 생성\n",
    "# 객체의 속성에 접근해 로봇의 이름과 초기 위치 출력 \n",
    "print(f\"로봇의 이름: {robot2.name}, 초기 위치: {robot2.position}\") \n",
    "\n",
    "robot2.move() # 객체의 메서드 move 호출(호출할 때마다 한 칸씩 이동)\n",
    "robot2.move() # 객체의 메서드 move 호출(호출할 때마다 한 칸씩 이동)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 클래스의 상속"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 99~100페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PetBot(Robot):\n",
    "    def __init__(self, name, position, color): # PetBot 클래스 초기화 함수\n",
    "        Robot.__init__(self, name, position)   # Robot 클래스 초기화 함수 재사용\n",
    "        # super().__init__(name, position)     # super()도 사용 가능\n",
    "        self.color = color   # 인스턴스 변수(로봇 객체의 초기 위치) 초기화 \n",
    "        print(\"--------------- [객체 속성] -----------------\")\n",
    "        print(f\"이름: {self.name}, 초기 위치: {self.position}, 컬러: {self.color}\")\n",
    "        print(\"---------------------------------------------\")\n",
    "       \n",
    "    def turn(self, direction): # 매개변수(direction)를 받아서 회전하는 함수\n",
    "        print(f\"{self.name}의 회전 방향: {direction}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 100페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "petbot1 = PetBot('루비', 0, '흰색')    # 객체 생성 및 초기화\n",
    "petbot1.move()                         # 부모 클래스에서 상속받은 메서드 호출\n",
    "petbot1.turn('왼쪽')                   # 자식 클래스에서 정의한 메서드 호출\n",
    "\n",
    "petbot2 = PetBot('윙키', 20, '검은색') # 객체 생성 및 초기화\n",
    "petbot2.move()                         # 부모 클래스에서 상속받은 메서드 호출\n",
    "petbot2.turn('오른쪽')                 # 자식 클래스에서 정의한 메서드 호출"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3 모듈"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 모듈 만들고 불러오기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 101페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile C:\\myPyExcel\\modules\\calc_area.py\n",
    "# File name: calc_area.py\n",
    "PI = 3.14\n",
    "def rectangle(l, w): # 직사각형(가로: l, 세로: w)의 넓이를 반환\n",
    "    return l * w\n",
    "\n",
    "def circle(r): # 원(반지름: r)의 넓이를 반환\n",
    "    return PI * r ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 102페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile C:\\myPyExcel\\modules\\car.py\n",
    "# File name: car.py\n",
    "class Car(): # 클래스 선언\n",
    "    def __init__(self, size, color):\n",
    "        self.size = size    # 인스턴스 변수 생성 및 초기화\n",
    "        self.color = color  # 인스턴스 변수 생성 및 초기화\n",
    "        \n",
    "    def move(self):\n",
    "        print(\"자동차({0} & {1})가 움직입니다.\".format(self.size, self.color))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cd C:\\myPyExcel\\modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 103페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import calc_area # 모듈 임포트\n",
    " \n",
    "pi = calc_area.PI # 임포트한 모듈의 변수를 사용\n",
    "rect = calc_area.rectangle(5, 2) # 임포트한 모듈의 함수를 호출\n",
    "circ = calc_area.circle(3)       # 임포트한 모듈의 함수를 호출\n",
    "\n",
    "print(f\"원주율:{pi}, 직사각형 넓이: {rect}, 원의 넓이: {circ}\")    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import car # 모듈 임포트\n",
    "\n",
    "my_car = car.Car(\"중형\", \"검은색\") # 임포트한 모듈의 클래스에서 객체를 생성\n",
    "my_car.move()                      # 객체의 메서드를 호출"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 104페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from calc_area import PI, rectangle, circle # 모듈의 변수, 함수를 임포트\n",
    "\n",
    "pi = PI # 모듈명 없이 바로 변수를 사용\n",
    "rect = rectangle(5, 2) # 모듈명 없이 바로 함수를 호출\n",
    "circ = circle(3)       # 모듈명 없이 바로 함수를 호출\n",
    "\n",
    "print(f\"원주율:{pi}, 직사각형 넓이: {rect}, 원의 넓이: {circ}\")    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import calc_area as area    # 모듈을 불러와서 별명으로 지정\n",
    "\n",
    "pi = area.PI                 # 임포트한 모듈의 별명과 함께 변수를 사용\n",
    "rect = area.rectangle(5, 2)  # 임포트한 모듈의 별명과 함께 함수를 호출\n",
    "circ = area.circle(3)        # 임포트한 모듈의 별명과 함께 함수를 호출\n",
    "\n",
    "print(f\"원주율:{pi}, 직사각형 넓이: {rect}, 원의 넓이: {circ}\")   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 105페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from calc_area import PI as pi          # 모듈의 변수를 별명으로 지정\n",
    "from calc_area import rectangle as rect # 모듈의 함수를 별명으로 지정\n",
    "from calc_area import circle as circ    # 모듈의 함수를 별명으로 지정\n",
    "\n",
    "p = pi          # 모듈의 변수를 별명으로 사용\n",
    "r = rect(5, 2)  # 모듈의 함수를 별명으로 호출\n",
    "c = circ(3)     # 모듈의 함수를 별명으로 호출\n",
    "\n",
    "print(f\"원주율:{p}, 직사각형 넓이: {r}, 원의 넓이: {c}\")   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 내장 모듈"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 107페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "# 파일의 경로 입력해 Path 클래스에서 file_path 객체 생성\n",
    "file_path = Path('C:/myPyExcel/modules/car.py')\n",
    "\n",
    "print(\"- 파일의 전체 경로:\", file_path)          # 파일의 전체 경로 출력\n",
    "print(\"- 파일의 디렉터리:\", file_path.parent)    # 파일의 디렉터리 출력\n",
    "print(\"- 파일명:\", file_path.name)               # 파일의 이름 출력\n",
    "print(\"- 파일의 확장자:\", file_path.suffix)      # 파일의 확장자 출력 \n",
    "print(\"- 확장자 제외한 파일명:\", file_path.stem) # 확장자를 제외한 파일명 출력"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 108페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "dir_path = Path('C:/myPyExcel/modules') # 디렉터리 경로를 입력해 dir_path 객체 생성\n",
    "\n",
    "print(\"- 지정한 경로:\", dir_path)\n",
    "print(\"- 경로 존재 여부 확인:\", dir_path.exists())\n",
    "print(\"- 경로가 디렉터리(폴더)인지 확인:\", dir_path.is_dir())\n",
    "print(\"- 경로가 파일인지 확인:\", dir_path.is_file())\n",
    "print(\"- 홈 디렉터리:\", dir_path.home())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"- 파일의 전체 경로:\", file_path)  \n",
    "print(\"- 경로 존재 여부 확인:\", file_path.exists())\n",
    "print(\"- 경로가 디렉터리(폴더)인지 확인:\", file_path.is_dir())\n",
    "print(\"- 경로가 파일인지 확인:\", file_path.is_file()) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 109페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cd C:\\myPyExcel\\modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "r_dir_path = Path('.')     # 현재 작업 디렉터리를 상대 경로로 입력해 r_dir_path 객체를 생성\n",
    "\n",
    "print(\"- 현재 디렉터리의 상대 경로:\", r_dir_path)\n",
    "print(\"- 상대 경로를 절대 경로로 변경:\", r_dir_path.resolve())\n",
    "print(\"- 현재 작업 디렉터리:\", r_dir_path.cwd())\n",
    "\n",
    "a_dir_path = Path('..')     # 상위 디렉터리를 상대 경로로 입력해 a_dir_path 객체를 생성\n",
    "# a_dir_path = Path('./..') # 현재 디렉터리의 상위 디렉터리로 표시해도 됨\n",
    "print(\"- 상위 디렉터리의 상대 경로:\", a_dir_path)\n",
    "print(\"- 상위 디렉터리의 상대 경로를 절대 경로로 변경:\", a_dir_path.resolve())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 110페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "# 디렉터리 경로를 입력해 path 객체를 생성\n",
    "dir_path = Path('C:/myPyExcel/modules')          \n",
    "\n",
    "# 새로 생성할 디렉터리를 dir_path 객체에 추가. 디렉터리 구분자는 '/'를 사용\n",
    "sub_dir_path = dir_path/'test'  \n",
    "\n",
    "# 새로운 디렉터리 생성\n",
    "sub_dir_path.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "# 생성한 디렉터리의 존재 여부 확인\n",
    "print(\"{0} 존재 여부: {1}\".format(sub_dir_path, sub_dir_path.exists()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 디렉터리 제거\n",
    "sub_dir_path.rmdir()\n",
    "\n",
    "# 생성한 디렉터리의 존재 여부 확인\n",
    "print(\"{0} 존재 여부: {1}\".format(sub_dir_path, sub_dir_path.exists()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 111페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 하위 디렉터리 이름을 리스트로 지정\n",
    "sub_dirs = ['test1', 'test2', 'test3']\n",
    "\n",
    "for sub_dir in sub_dirs:\n",
    "    sub_dir_path = dir_path/sub_dir\n",
    "    sub_dir_path.mkdir(parents = True, exist_ok = True)\n",
    "    print(\"{0} 존재 여부: {1}\".format(sub_dir_path, sub_dir_path.exists()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for sub_dir in sub_dirs:\n",
    "    sub_dir_path = dir_path/sub_dir\n",
    "    sub_dir_path.rmdir()\n",
    "    print(\"{0} 존재 여부: {1}\".format(sub_dir_path, sub_dir_path.exists()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "file_path = Path('C:/myPyExcel/modules/test_file.txt')\n",
    "file_path.touch()   # 빈 파일 생성\n",
    "file_path.exists()  # 파일의 존재 여부 확인"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 112페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if(file_path.exists() == True): # 파일이 있는지 확인\n",
    "    file_path.unlink()           # 파일이 있다면 제거\n",
    "file_path.exists()               # 파일의 존재 여부 다시 확인"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 112~113페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "# C:/myPyExcel/modules 아래에 test 디렉터리 지정\n",
    "test_dir = Path('C:/myPyExcel/modules/test')\n",
    "\n",
    "# 테스트용 디렉터리 생성\n",
    "test_dir.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "# C:/myPyExcel/data/ch03/test 디렉터리에 생성할 다양한 패턴의 파일 이름을 지정\n",
    "data_files = ['file01.txt','file02.txt','file10.txt','file11.txt',\n",
    "              'file01.csv','file02.csv']\n",
    "\n",
    "# C:/myPyExcel/modules/test 디렉터리에 파일 생성\n",
    "for data_file in data_files:\n",
    "    file_path = test_dir/data_file\n",
    "    file_path.touch()\n",
    "    \n",
    "# 하위 디렉터리 이름을 리스트로 지정\n",
    "sub_dirs = ['sub_dir1', 'sub_dir2', 'sub_dir3']\n",
    "\n",
    "# 하위 디렉터리 생성\n",
    "for sub_dir in sub_dirs:\n",
    "    sub_dir_path = test_dir / sub_dir\n",
    "    sub_dir_path.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "# 하위 디렉터리에 생성할 다양한 패턴의 파일 이름을 지정\n",
    "sub_dir_files = ['data_file01.csv', 'data_file02.csv']\n",
    "\n",
    "# 하위 디렉터리 중 하나에 파일 생성    \n",
    "for sub_dir_file in sub_dir_files:\n",
    "    file_path = test_dir / sub_dirs[0] /sub_dir_file    \n",
    "    file_path.touch()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 113페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!tree /F C:\\myPyExcel\\modules\\test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 114페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir_files = test_dir.glob('*') # 모든 디렉터리와 파일을 반환\n",
    "\n",
    "for dir_file in dir_files:\n",
    "    print(dir_file)            # 반환된 결과를 출력"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir_files = test_dir.glob('*.csv') # 확장자가 csv 파일만 반환\n",
    "\n",
    "for dir_file in dir_files:\n",
    "    print(dir_file)                # 반환된 결과를 출력"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 115페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir_files = test_dir.glob('file0?.txt')\n",
    "\n",
    "for dir_file in dir_files:\n",
    "    print(dir_file) # 반환된 결과를 출력"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 하위 디렉터리의 모든 파일과 디렉터리를 가져오도록 패턴을 지정\n",
    "dir_files = test_dir.glob('./sub_dir1/*')  \n",
    "\n",
    "for dir_file in dir_files:\n",
    "    print(dir_file) # 반환된 결과를 출력"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 디렉터리의 모든 내용(하위 디렉터리의 내용 포함)을 가져오기 위한 패턴을 지정\n",
    "dir_files = test_dir.glob('**/*')  \n",
    "\n",
    "for dir_file in dir_files:\n",
    "    print(dir_file) # 반환된 결과를 출력"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 116페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 디렉터리의 모든 내용(하위 디렉터리의 내용 포함)을 가져오기 위한 패턴을 지정\n",
    "dir_files = test_dir.glob('**/*')\n",
    "\n",
    "# 가져온 내용을 리스트로 변환 후 역순으로 변경\n",
    "r_dir_files = reversed(list(dir_files)) \n",
    "\n",
    "for r_dir_file in r_dir_files:\n",
    "    print(r_dir_file) # 반환된 결과를 출력"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 117페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "# 입력한 디렉터리의 파일과 하위 디렉터리를 제거하는 함수\n",
    "def remove_dir_contents(remove_dir):\n",
    "    dir_files = remove_dir.glob('**/*')       # 디렉터리의 모든 내용 가져오기 \n",
    "    r_dir_files = reversed(list(dir_files))   # 리스트로 변환 후 역순으로 변경\n",
    "\n",
    "    # 디렉터리의 내용을 모두 제거\n",
    "    for r_dir_file in r_dir_files:\n",
    "        if(r_dir_file.is_file() == True):    # 파일을 제거\n",
    "            r_dir_file.unlink()\n",
    "            print(\"파일 제거:\", r_dir_file)\n",
    "        elif(r_dir_file.is_dir() == True):   # 디렉터리를 제거\n",
    "            r_dir_file.rmdir()        \n",
    "            print(\"디렉터리 제거:\", r_dir_file)  \n",
    "\n",
    "# 디렉터리를 지정한 후에 함수를 호출            \n",
    "test_dir = Path('C:/myPyExcel/modules/test')  # 디렉터리 지정\n",
    "remove_dir_contents(test_dir) # 함수를 호출"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!tree /F C:\\myPyExcel\\modules\\test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 119페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date, time, datetime, timedelta\n",
    "\n",
    "date_obj = date(2020, 10, 9)\n",
    "time_obj = time(15, 23, 21)\n",
    "datetime_obj = datetime(2021, 8, 15, 20, 19, 45)\n",
    "\n",
    "print(\"[date 클래스로 날짜 지정]\", date_obj)\n",
    "print(\"[date 클래스의 속성 이용] {0}/{1}/{2}\".format(date_obj.year, \n",
    "                                                     date_obj.month, \n",
    "                                                     date_obj.day))\n",
    "\n",
    "print(\"[time 클래스로 시각 지정]\", time_obj)\n",
    "print(\"[time 클래스의 속성 지정] {0}/{1}/{2}\".format(time_obj.hour, \n",
    "                                                     time_obj.minute, \n",
    "                                                     time_obj.second))\n",
    "\n",
    "print(\"[datetime 클래스로 날짜와 시각 지정]\", datetime_obj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "date_obj2 = date(2020, 10, 15)   # 날짜 지정\n",
    "diff_date = date_obj2 - date_obj # date 객체의 날짜 차이를 연산\n",
    "diff_date"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 120페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"두 날짜의 차이: {}일\".format(diff_date.days))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "date_org = date(2022, 5, 15) # 날짜 지정\n",
    "date_result = date_org - timedelta(weeks=1) # 일 주일 전의 날짜 계산\n",
    "print(\"지정 날짜: {0}, 일 주일 전 날짜: {1}\".format(date_org, date_result))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 날짜 및 시간 지정\n",
    "datetime_org = datetime(2021, 11, 14, 23, 0, 0) \n",
    "\n",
    "# 1시간 30분 후 날짜 및 시각 계산\n",
    "datetime_result = datetime_org + timedelta(hours=1, minutes=30) \n",
    "\n",
    "print(datetime_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 120~121페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "today = date.today()\n",
    "now = datetime.now()\n",
    "\n",
    "print(\"- 오늘의 날짜: {0}-{1}-{2}\".format(today.year, today.month, today.day))\n",
    "print(\"- 현재의 날짜 및 시각(전체 표시):\", now)\n",
    "print(\"- 현재의 날짜: {0}-{1}-{2}\".format(now.year, now.month, now.day))\n",
    "print(\"- 현재의 시각: {0}:{1}:{2}\".format(now.hour, now.minute, now.second))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 121페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "special_day = datetime(2021, 4, 8, 13, 30, 0)\n",
    "\n",
    "print(\"- 날짜 표시: {0:%Y}년 {0:%m}월 {0:%d}일\".format(special_day))\n",
    "print(\"- 시각 표시: {0:%H}시 {0:%M}분 {0:%S}초 ({0:%p})\".format(special_day))\n",
    "print(\"- 요일 표시: {0:%A}, {0:%a}, {0:%w}\".format(special_day))\n",
    "print(\"- 월 표시: {0:%B}, {0:%b}\".format(special_day))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 122페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import locale\n",
    "\n",
    "# 한글, 한국, UTF-8 인코딩을 로케일로 지정\n",
    "locale.setlocale(locale.LC_ALL, 'ko_KR.UTF-8')  \n",
    "\n",
    "print(\"* 설정한 로케일: \", locale.getlocale())  # 설정한 로케일 가져오기\n",
    "print(\"- 요일 표시(한글/한국): {0:%A}, {0:%a}\".format(special_day))\n",
    "print(\"- 월 표시(한글/한국): {0:%B}, {0:%b}\".format(special_day))\n",
    "\n",
    "# 영어, 미국, UTF-8 인코딩을 로케일로 지정\n",
    "locale.setlocale(locale.LC_ALL, 'en_US.UTF-8') \n",
    "\n",
    "print(\"* 설정한 로케일: \", locale.getlocale()) # 설정한 로케일 가져오기\n",
    "print(\"- 요일 표시(영어/미국): {0:%A}, {0:%a}\".format(special_day))\n",
    "print(\"- 월 표시(한글/한국): {0:%B}, {0:%b}\".format(special_day))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 한글, 한국, UTF-8 인코딩을 로케일로 지정\n",
    "locale.setlocale(locale.LC_ALL, 'ko_KR.UTF-8')  \n",
    "print(special_day.strftime(\"[날짜] %Y-%m-%d, %A [시간] %H:%M:%S (%p)\"))\n",
    "\n",
    "# 영어, 미국, UTF-8 인코딩을 로케일로 지정\n",
    "locale.setlocale(locale.LC_ALL, 'en_US.UTF-8') \n",
    "print(special_day.strftime(\"[Date] %Y-%m-%d, %A [Time] %H:%M:%S (%p)\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 패키지"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 124페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "# 디렉터리 경로를 입력해 path 객체를 생성\n",
    "dir_path = Path('C:/myPyExcel/modules/image/io_file')          \n",
    "\n",
    "# 디렉터리 생성\n",
    "dir_path.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "# 생성한 디렉터리의 존재 여부 확인\n",
    "print(\"{0} 디렉터리의 존재 여부: {1}\".format(dir_path, dir_path.exists()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile C:\\myPyExcel\\modules\\image\\io_file\\img_read.py\n",
    "# File name: img_read.py\n",
    "\n",
    "default_image = \"=> variable 'default_imag' in img_read module\"\n",
    "\n",
    "def png_read():\n",
    "    print(\"- png_read() in img_read module\")\n",
    "    \n",
    "def jpg_read():\n",
    "    print(\"- jpg_read() in img_read module\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 125페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cd C:\\myPyExcel\\modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# image 패키지 내에 io_file 폴더에 있는 img_read 모듈 임포트\n",
    "import image.io_file.img_read  \n",
    "\n",
    "# '패키지명.하위폴더명.모듈명.함수()' 형식으로 함수 호출\n",
    "image.io_file.img_read.png_read() \n",
    "image.io_file.img_read.jpg_read()\n",
    "\n",
    "# '패키지명.하위폴더명.모듈명.변수' 형식으로 변수를 사용\n",
    "print(image.io_file.img_read.default_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 126페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from image.io_file import img_read\n",
    "\n",
    "# 모듈명.함수() 형식으로 함수를 호출\n",
    "img_read.png_read() \n",
    "img_read.jpg_read()\n",
    "\n",
    "# 모듈명.변수 형식으로 변수를 사용\n",
    "print(img_read.default_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 127페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from image.io_file.img_read import png_read, jpg_read, default_image\n",
    "\n",
    "# 모듈의 함수를 바로 호출\n",
    "png_read() \n",
    "jpg_read()\n",
    "\n",
    "# 모듈의 변수를 바로 사용\n",
    "print(default_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 127~128페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 'import 패키지명[.하위폴더명].모듈명 as 별명'\n",
    "import image.io_file.img_read as i_read\n",
    "\n",
    "# 모듈 별명으로 함수를 호출\n",
    "i_read.png_read() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[3장: 128페이지]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 'from 패키지명[.하위폴더명] import 모듈명 as 별명'\n",
    "from image.io_file import img_read as img_r\n",
    "\n",
    "# 모듈 별명으로 함수를 호출\n",
    "img_r.jpg_read() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 'from 패키지명[.하위폴더명].모듈명 import 변수명/함수명/클래스명 as 별명'\n",
    "from image.io_file.img_read import png_read as p_read\n",
    "from image.io_file.img_read import jpg_read as j_read\n",
    "from image.io_file.img_read import default_image as d_image\n",
    "\n",
    "# 별명으로 모듈의 함수를 바로 호출\n",
    "p_read() \n",
    "j_read()\n",
    "\n",
    "# 별명으로 모듈의 변수를 바로 사용\n",
    "print(d_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4 정리"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  },
  "toc": {
   "base_numbering": "3",
   "nav_menu": {},
   "number_sections": false,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "350.4px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}