Update oop-inheritance.ipynb

Author: liganega

oop-inheritance.ipynb

@@ -28,7 +28,7 @@
     "클래스와 객체를 보다 실용적으로 활용하는 두 가지 방법 **상속**과 **구성**을 소개하면서\n",
     "객체 지향 프로그래밍(OOP)의 기본 디자인 원칙을 살펴본다.\n",
     "\n",
-    "이번 장에서는 먼저 `Person` 클래스를 정의하고, 사람의 기본 속성을 물려받는 `Hero` 클래스를 만드는 방식으로\n",
+    "이번 장에서는 먼저 `Human` 클래스를 정의하고, 사람의 기본 속성을 물려받는 `Hero` 클래스를 만드는 방식으로\n",
     "상속의 필요성과 장단점을 살펴본다."
    ]
   },
@@ -48,7 +48,7 @@
     "객체 지향 프로그래밍에서는 필요한 자료형을 클래스로 정의하고,\n",
     "그 클래스로부터 여러 개의 인스턴스를 생성하여 사용할 수 있다.\n",
     "\n",
-    "먼저 사람을 나타내는 가장 단순한 `Person` 클래스를 정의하자.\n",
+    "먼저 사람을 나타내는 가장 단순한 `Human` 클래스를 정의하자.\n",
     "여기서는 설명을 단순하게 하기 위해 사람의 속성을 이름, 나이, 성별로 제한한다."
    ]
   },
@@ -67,7 +67,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "class Person:\n",
+    "class Human:\n",
     "    def __init__(self, name, age, gender):\n",
     "        self.name = name\n",
     "        self.age = age\n",
@@ -94,8 +94,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "kim = Person(\"김민수\", 20, \"남성\")\n",
-    "lee = Person(\"이영희\", 21, \"여성\")"
+    "kim = Human(\"김민수\", 20, \"남성\")\n",
+    "lee = Human(\"이영희\", 21, \"여성\")"
    ]
   },
   {
@@ -149,7 +149,7 @@
    "id": "a77b4e64",
    "metadata": {},
    "source": [
-    "가장 단순한 방법은 `Person` 클래스와 비슷한 코드를 다시 작성하여 `Hero` 클래스를 새로 만드는 것이다.\n",
+    "가장 단순한 방법은 `Human` 클래스와 비슷한 코드를 다시 작성하여 `Hero` 클래스를 새로 만드는 것이다.\n",
     "하지만 이렇게 하면 이름, 나이, 성별을 저장하고 자기소개를 하는 코드가 중복된다."
    ]
   },
@@ -222,7 +222,7 @@
    "metadata": {},
    "source": [
     "하지만 이 방식은 좋은 설계가 아니다.\n",
-    "`Person`과 `Hero`가 공유하는 코드가 중복되며, 사람의 기본 정보 처리 방식이 바뀌면\n",
+    "`Human`과 `Hero`가 공유하는 코드가 중복되며, 사람의 기본 정보 처리 방식이 바뀌면\n",
     "두 클래스를 모두 수정해야 한다.\n",
     "\n",
     "이런 문제를 해결하기 위해 **상속**<font size='2'>inheritance</font>을 사용할 수 있다."
@@ -243,7 +243,7 @@
    "source": [
     "**예제 1**\n",
     "\n",
-    "`Person` 클래스와 상속을 사용하지 않은 `Hero` 클래스에서 중복되는 코드를 찾아 설명하라."
+    "`Human` 클래스와 상속을 사용하지 않은 `Hero` 클래스에서 중복되는 코드를 찾아 설명하라."
    ]
   },
   {
@@ -265,7 +265,7 @@
    "source": [
     "**예제 2**\n",
     "\n",
-    "아래 코드처럼 `Person.introduction()`의 출력 형식을 바꾸고 싶다고 하자.\n",
+    "아래 코드처럼 `Human.introduction()`의 출력 형식을 바꾸고 싶다고 하자.\n",
     "\n",
     "```python\n",
     "def introduction(self):\n",
@@ -282,7 +282,7 @@
    "source": [
     "답:\n",
     "\n",
-    "`Person` 클래스만 수정하면 `Hero` 객체의 자기소개 형식은 바뀌지 않는다.\n",
+    "`Human` 클래스만 수정하면 `Hero` 객체의 자기소개 형식은 바뀌지 않는다.\n",
     "두 클래스가 같은 기능을 각각 구현했기 때문에 `Hero.introduction()`도 별도로 수정해야 한다.\n",
     "클래스가 많아질수록 빠뜨리는 클래스가 생기기 쉽고, 같은 기능의 동작이 서로 달라질 위험도 커진다."
    ]
@@ -307,7 +307,7 @@
     }
    ],
    "source": [
-    "kim = Person(\"김민수\", 20, \"남성\")\n",
+    "kim = Human(\"김민수\", 20, \"남성\")\n",
     "ironman = Hero(\n",
     "    \"아이언맨\", 45, \"남성\",\n",
     "    100, 100, 200,\n",
@@ -429,9 +429,9 @@
     "“영웅은 사람이다”처럼 자식 클래스의 객체를\n",
     "부모 클래스의 객체로 보아도 자연스러운지 신중하게 판단해야 한다.\n",
     "\n",
-    "`Hero`는 특별한 능력을 가진 사람이므로 `Person`의 한 종류로 볼 수 있다.\n",
-    "따라서 `Person`을 상속하는 자식 클래스로 `Hero`를 선언할 수 있다.\n",
-    "`Hero`는 `Person`의 메서드를 물려받고, 부모 클래스의 `__init__()`을 호출하여\n",
+    "`Hero`는 특별한 능력을 가진 사람이므로 `Human`의 한 종류로 볼 수 있다.\n",
+    "따라서 `Human`을 상속하는 자식 클래스로 `Hero`를 선언할 수 있다.\n",
+    "`Hero`는 `Human`의 메서드를 물려받고, 부모 클래스의 `__init__()`을 호출하여\n",
     "사람의 기본 속성을 초기화한 뒤 영웅에게 필요한 속성과 메서드를 추가한다."
    ]
   },
@@ -442,7 +442,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "class Hero(Person):\n",
+    "class Hero(Human):\n",
     "    def __init__(self, name, age, gender, power, health, damage, inventory):\n",
     "        super().__init__(name, age, gender)\n",
     "        self.power = power\n",
@@ -461,7 +461,7 @@
    "id": "a8133a2f",
    "metadata": {},
    "source": [
-    "`Hero` 클래스는 `Person` 클래스를 상속한다.\n",
+    "`Hero` 클래스는 `Human` 클래스를 상속한다.\n",
     "따라서 `Hero`의 인스턴스는 영웅 객체이면서 동시에 사람 객체이기도 하다."
    ]
   },
@@ -485,15 +485,15 @@
    "source": [
     "ironman = Hero(\"아이언맨\", 45, \"남성\", 100, 100, 200, {\"suit\": 500, \"weapon\": \"레이저\"})\n",
     "\n",
-    "isinstance(ironman, Hero), isinstance(ironman, Person)"
+    "isinstance(ironman, Hero), isinstance(ironman, Human)"
    ]
   },
   {
    "cell_type": "markdown",
    "id": "f9e02f21",
    "metadata": {},
    "source": [
-    "`Hero`는 `Person`의 메서드를 물려받으므로 `introduction()` 메서드를 바로 사용할 수 있다."
+    "`Hero`는 `Human`의 메서드를 물려받으므로 `introduction()` 메서드를 바로 사용할 수 있다."
    ]
   },
   {
@@ -540,7 +540,7 @@
     }
    ],
    "source": [
-    "park = Person(\"박지민\", 19, \"여성\")\n",
+    "park = Human(\"박지민\", 19, \"여성\")\n",
     "\n",
     "try:\n",
     "    park.attack(ironman)\n",
@@ -552,7 +552,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "`park`은 `Person` 클래스의 객체이기는 하지만 `Hero` 클래스의 객체는 아니다."
+    "`park`은 `Human` 클래스의 객체이기는 하지만 `Hero` 클래스의 객체는 아니다."
    ]
   },
   {
@@ -572,7 +572,7 @@
     }
    ],
    "source": [
-    "isinstance(park, Person), isinstance(park, Hero)"
+    "isinstance(park, Human), isinstance(park, Hero)"
    ]
   },
   {
@@ -591,14 +591,14 @@
     "**`__init__()` 메서드 재정의와 `super()`**\n",
     "\n",
     "`Hero` 클래스는 상속받은 `__init__()` 메서드를 재정의한다.\n",
-    "재정의된 메서드에서는 `super()`를 사용하여 부모 클래스인 `Person`의\n",
+    "재정의된 메서드에서는 `super()`를 사용하여 부모 클래스인 `Human`의\n",
     "`__init__()` 메서드를 호출한다.\n",
     "\n",
     "```python\n",
     "super().__init__(name, age, gender)\n",
     "```\n",
     "\n",
-    "이를 통해 `Person`이 담당하는 `name`, `age`, `gender` 속성을\n",
+    "이를 통해 `Human`이 담당하는 `name`, `age`, `gender` 속성을\n",
     "`Hero` 인스턴스에 초기화할 수 있다.\n",
     "이때 현재 인스턴스가 자동으로 전달되므로 `self`를 직접 전달하지 않는다.\n",
     "\n",
@@ -610,7 +610,7 @@
     "부모 클래스에서 상속받은 메서드를 자식 클래스에서 같은 이름으로 다시 정의하는 것을\n",
     "**메서드 오버라이딩**<font size='2'>method overriding</font>이라고 한다.\n",
     "\n",
-    "아래 `Hero` 클래스는 부모 클래스인 `Person` 클래스로부터 상속받은 `introduction()` 메서드도 재정의하여\n",
+    "아래 `Hero` 클래스는 부모 클래스인 `Human` 클래스로부터 상속받은 `introduction()` 메서드도 재정의하여\n",
     "일반적인 자기소개와 함께 파워와 무기 정보도 제공한다."
    ]
   },
@@ -621,7 +621,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "class Hero(Person):\n",
+    "class Hero(Human):\n",
     "    def __init__(self, name, age, gender, power, health, damage, inventory):\n",
     "        super().__init__(name, age, gender)\n",
     "        self.power = power\n",
@@ -684,11 +684,11 @@
    "source": [
     "**예제 1**\n",
     "\n",
-    "아래 코드의 실행 결과를 예측하고, `Hero` 객체가 `Person`의 인스턴스로도 판정되는 이유를 설명하라.\n",
+    "아래 코드의 실행 결과를 예측하고, `Hero` 객체가 `Human`의 인스턴스로도 판정되는 이유를 설명하라.\n",
     "\n",
     "```python\n",
     "print(isinstance(ironman, Hero))\n",
-    "print(isinstance(ironman, Person))\n",
+    "print(isinstance(ironman, Human))\n",
     "print(isinstance(park, Hero))\n",
     "```"
    ]
@@ -701,9 +701,9 @@
     "답:\n",
     "\n",
     "차례대로 `True`, `True`, `False`가 출력된다.\n",
-    "`Hero`는 `Person`을 상속하므로 `Hero`의 인스턴스는 자식 클래스인 `Hero`의 인스턴스이면서\n",
-    "부모 클래스인 `Person`의 인스턴스이기도 하다.\n",
-    "반대로 `Person`의 인스턴스가 자동으로 `Hero`의 인스턴스가 되지는 않는다."
+    "`Hero`는 `Human`을 상속하므로 `Hero`의 인스턴스는 자식 클래스인 `Hero`의 인스턴스이면서\n",
+    "부모 클래스인 `Human`의 인스턴스이기도 하다.\n",
+    "반대로 `Human`의 인스턴스가 자동으로 `Hero`의 인스턴스가 되지는 않는다."
    ]
   },
   {
@@ -724,7 +724,7 @@
    ],
    "source": [
     "print(isinstance(ironman, Hero))\n",
-    "print(isinstance(ironman, Person))\n",
+    "print(isinstance(ironman, Human))\n",
     "print(isinstance(park, Hero))"
    ]
   },
@@ -769,7 +769,7 @@
     }
    ],
    "source": [
-    "class IncompleteHero(Person):\n",
+    "class IncompleteHero(Human):\n",
     "    def __init__(self, name, age, gender, power):\n",
     "        self.power = power\n",
     "\n",
@@ -826,7 +826,7 @@
    "source": [
     "**문제 1**\n",
     "\n",
-    "`Person`을 상속하는 `Student` 클래스를 정의하라.\n",
+    "`Human`을 상속하는 `Student` 클래스를 정의하라.\n",
     "`Student` 클래스는 `school` 속성을 추가로 가지며,\n",
     "생성자에서 `super()`를 사용하여 이름, 나이, 성별을 초기화해야 한다."
    ]
@@ -849,7 +849,7 @@
    "source": [
     "**문제 3**\n",
     "\n",
-    "다음 객체를 생성한 후 `isinstance()`를 이용하여 `student`가 `Student`와 `Person`의 인스턴스인지 각각 확인하라.\n",
+    "다음 객체를 생성한 후 `isinstance()`를 이용하여 `student`가 `Student`와 `Human`의 인스턴스인지 각각 확인하라.\n",
     "\n",
     "```python\n",
     "student = Student(\"김하나\", 18, \"여성\", \"파이썬고\")\n",
@@ -1335,7 +1335,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "class Hero(Person):\n",
+    "class Hero(Human):\n",
     "    def __init__(self, name, age, gender, power, health, damage, inventory, flying=None):\n",
     "        super().__init__(name, age, gender)\n",
     "        self.power = power\n",
@@ -1636,7 +1636,7 @@
     "**디자인 원칙 2: 상속과 구성을 함께 활용하라.**\n",
     "\n",
     "상속과 구성은 서로 대체하는 기법이라기보다 서로 다른 관계를 표현하는 도구이다.\n",
-    "`Hero`는 `Person`의 한 종류이므로 두 클래스는 **~이다**<font size='2'>is-a</font> 관계에 있고,\n",
+    "`Hero`는 `Human`의 한 종류이므로 두 클래스는 **~이다**<font size='2'>is-a</font> 관계에 있고,\n",
     "사람의 공통 속성과 기능을 상속하는 것이 자연스럽다.\n",
     "반면 영웅은 비행 방식의 한 종류가 아니라 비행 기능을 **가지므로**\n",
     "`Hero`와 `Flying`은 **~을 가진다**<font size='2'>has-a</font> 관계로 표현하는 편이 자연스럽다.\n",
@@ -1745,7 +1745,7 @@
    "source": [
     "**문제 1**\n",
     "\n",
-    "현재 예제에서 `Person`, `Hero`, `Flying` 클래스가 각각 담당하는 책임을 한 문장씩 정리하라."
+    "현재 예제에서 `Human`, `Hero`, `Flying` 클래스가 각각 담당하는 책임을 한 문장씩 정리하라."
    ]
   },
   {