1180 lines
29 KiB
Plaintext
1180 lines
29 KiB
Plaintext
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "44ca09f7",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Inheritance\n",
|
|
"\n",
|
|
"### Motivations\n",
|
|
"\n",
|
|
"Let's say we're building an application that tracks students."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 1,
|
|
"id": "feaa69a2",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"class Student:\n",
|
|
"\n",
|
|
" # this is a class-level variable\n",
|
|
" # instead of each instance having its own copy\n",
|
|
" # the variable is shared among all `Student`\n",
|
|
" next_id_counter = 1\n",
|
|
" \n",
|
|
" def __init__(self, name):\n",
|
|
" # assign each student a unique id\n",
|
|
" # note use of Student. not self.\n",
|
|
" self.id = Student.next_id_counter\n",
|
|
" Student.next_id_counter += 1\n",
|
|
" \n",
|
|
" self.name = name\n",
|
|
" self.year = 1\n",
|
|
" self.major = \"Undeclared\"\n",
|
|
" self.course_grades = {}\n",
|
|
" self.extracurriculars = []\n",
|
|
" \n",
|
|
" def add_grade(self, course_name, grade):\n",
|
|
" self.course_grades[course_name] = grade\n",
|
|
" \n",
|
|
" @property\n",
|
|
" def gpa(self):\n",
|
|
" grade_pts = {\"A\":4.0, \"A-\":3.7, \"B+\":3.3, \"B\":3.0, \"B-\":2.7, \"C+\":2.3, \"C\":2.0, \"C-\":1.7, \"D+\":1.3, \"D\":1.0, \"F\":0.0} \n",
|
|
" if len(self.course_grades) == 0:\n",
|
|
" return 0\n",
|
|
" return sum(grade_pts[g] for g in self.course_grades.values()) / len(self.course_grades)\n",
|
|
" \n",
|
|
" def __repr__(self):\n",
|
|
" return f\"Student(name={self.name}, id={self.id}, gpa={self.gpa})\""
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 45,
|
|
"id": "c410fb1d",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"s1 = Student(\"Adam\")\n",
|
|
"s2 = Student(\"Beth\")\n",
|
|
"s2.add_grade(\"Programming Python\", \"A\")\n",
|
|
"s2.add_grade(\"Discrete Math\", \"B+\")"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 46,
|
|
"id": "f9deab26",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Student(name=Adam, id=8, gpa=0)\n",
|
|
"Student(name=Beth, id=9, gpa=3.65)\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"print(s1)\n",
|
|
"print(s2)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "6aa3358d",
|
|
"metadata": {},
|
|
"source": [
|
|
"Perhaps we want to add `Alumni` to our application.\n",
|
|
"\n",
|
|
"An alum will have some things in common with students:\n",
|
|
"\n",
|
|
"- They still have a name.\n",
|
|
"- We want to remember their major.\n",
|
|
"- We'll still want to keep track of their grades/GPA.\n",
|
|
"\n",
|
|
"We now also:\n",
|
|
"\n",
|
|
"- Want to record their year of graduation.\n",
|
|
"- No longer want to allow grades to be recorded.\n",
|
|
"- Want to be able to calculate how long ago they graduated.\n",
|
|
"- When displaying them, we want to display their graduation year.\n",
|
|
"\n",
|
|
"**How to implement?**\n",
|
|
"\n",
|
|
"We *could* copy `student.py` and rename to `alum.py` and rename the class as needed.\n",
|
|
"\n",
|
|
"**But copying & pasting is generally a bad idea!**\n",
|
|
"\n",
|
|
"We'd need to fix bugs & add features in both classes separately.\n",
|
|
"\n",
|
|
"A new feature in `Student` would need to be copied over to `Alum`, this will quickly get messy.\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "d0d61727",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Implementation\n",
|
|
"\n",
|
|
"Instead we will use **inheritance**, which allows us to create a new class from an existing one. The new class inherits the attributes and methods from the parent.\n",
|
|
"\n",
|
|
"- **superclass**, **parent**, or **base** class: The pre-existing class.\n",
|
|
"- **subclass**, **child**, or **derived** class: The new class that inherits the code (attributes & methods) of another class.\n",
|
|
"\n",
|
|
"Subclasses can extend/modify the functionality of superclasses.\n",
|
|
"\n",
|
|
"Syntax:\n",
|
|
"\n",
|
|
"```python\n",
|
|
"class Subclass(Superclass):\n",
|
|
" pass\n",
|
|
"```\n",
|
|
"\n",
|
|
"For example:\n",
|
|
"\n",
|
|
"```python\n",
|
|
"class Alum(Student):\n",
|
|
" pass\n",
|
|
"```\n",
|
|
"\n",
|
|
"At this point, `Alum` is a new class with the exact same implementation as `Student`.\n",
|
|
"\n",
|
|
"Typically we'll want to add new instance & class variables, methods, etc.\n",
|
|
"\n",
|
|
"Newly defined features will only apply to instances of `Alum`\n",
|
|
"\n",
|
|
"It is possible to override parent class behavior, or rely on parent behavior, whichever is needed."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "e4d45c9f",
|
|
"metadata": {},
|
|
"source": [
|
|
"### Adding & Overriding Behavior"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 49,
|
|
"id": "47f7dfc9",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"class Alum(Student):\n",
|
|
" def __init__(self, name, grad_year):\n",
|
|
" # call Student's constructor, which contains id logic\n",
|
|
" super().__init__(name)\n",
|
|
" self.graduation_year = grad_year\n",
|
|
" \n",
|
|
" # new behavior\n",
|
|
" def years_since_graduation(self, now):\n",
|
|
" return now - self.graduation_year\n",
|
|
" \n",
|
|
" # overrides parent's add_grade\n",
|
|
" def add_grade(self, course_name, grade):\n",
|
|
" raise NotImplementedError(\"cannot add grades to Alum\")\n",
|
|
" #print(\"Sorry, you cannot add grades to Alums\")\n",
|
|
" # we choose not call super().add_grade here\n",
|
|
" \n",
|
|
" # overrides parent's __repr__\n",
|
|
" def __repr__(self):\n",
|
|
" #return f\"Alum(name={self.name}, id={self.id}, gpa={self.gpa}, graduated={self.graduation_year})\"\n",
|
|
" string = super().__repr__()\n",
|
|
" string += \" is an alum\"\n",
|
|
" return string"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 51,
|
|
"id": "4811b0fd",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Student(name=Charlie, id=13, gpa=0) is an alum\n",
|
|
"6 years since graduation\n"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"0"
|
|
]
|
|
},
|
|
"execution_count": 51,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"alum1 = Alum(\"Charlie\", 2016)\n",
|
|
"print(alum1)\n",
|
|
"print(alum1.years_since_graduation(2022), \"years since graduation\")\n",
|
|
"#alum1.add_grade(\"Python\", \"B\")\n",
|
|
"alum1.gpa"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 54,
|
|
"id": "18a75666-9986-4e2b-9d55-ec0e0b9e930d",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"alum2 = Alum(\"Charlie\", 2016)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 56,
|
|
"id": "b6719a36-b827-4373-87e0-23714438b83f",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [
|
|
{
|
|
"ename": "TypeError",
|
|
"evalue": "unsupported operand type(s) for +: 'Alum' and 'Alum'",
|
|
"output_type": "error",
|
|
"traceback": [
|
|
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
|
|
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
|
|
"Cell \u001b[0;32mIn[56], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43malum1\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43malum2\u001b[49m\n",
|
|
"\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'Alum' and 'Alum'"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"alum1 + alum2"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "3cd672f1",
|
|
"metadata": {},
|
|
"source": [
|
|
"### super()\n",
|
|
"\n",
|
|
"Allows direct access to parent class(es).\n",
|
|
"\n",
|
|
"Many different ways to be called, but for our purposes we will stick to `super().method_name()` to access parent implementation of `method_name()`"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "f6d2c035",
|
|
"metadata": {},
|
|
"source": [
|
|
"### issubclass & isinstance"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 8,
|
|
"id": "a46d5b02",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"True"
|
|
]
|
|
},
|
|
"execution_count": 8,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"isinstance(7, int)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 9,
|
|
"id": "d3596a45-2c00-4541-910d-08251d3f9c5f",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"True"
|
|
]
|
|
},
|
|
"execution_count": 9,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"# same as?\n",
|
|
"type(7) == int"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 10,
|
|
"id": "eaa8b6db-e7df-4137-b4c8-67dfa0be06d5",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"False"
|
|
]
|
|
},
|
|
"execution_count": 10,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"type(7) == object"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 57,
|
|
"id": "9cfc8480-ecca-4f80-9dfe-70a655bc5b3c",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"True"
|
|
]
|
|
},
|
|
"execution_count": 57,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"isinstance(7, object)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 62,
|
|
"id": "0e50f7bc-541e-4fec-9cd6-ad708f312831",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"True"
|
|
]
|
|
},
|
|
"execution_count": 62,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"# isinstance checks the inheritance hierarchy \n",
|
|
"isinstance(alum2, object)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 64,
|
|
"id": "34e491d5-ac5c-4dc9-b059-491e0f0f73b0",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"False"
|
|
]
|
|
},
|
|
"execution_count": 64,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"type(alum2) == Student"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 65,
|
|
"id": "cd55fd8d",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"True"
|
|
]
|
|
},
|
|
"execution_count": 65,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"isinstance([1, 2, 3], list)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 17,
|
|
"id": "feb9f2ac",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"True"
|
|
]
|
|
},
|
|
"execution_count": 17,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"s1 = Student(\"Sarah\")\n",
|
|
"isinstance(s1, Student)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 18,
|
|
"id": "e6a2f3b1",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"True"
|
|
]
|
|
},
|
|
"execution_count": 18,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"# child classes are instances of parent types\n",
|
|
"alum1 = Alum(\"Charlie\", 2016)\n",
|
|
"isinstance(alum1, Student)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 19,
|
|
"id": "8f759efb",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"False"
|
|
]
|
|
},
|
|
"execution_count": 19,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"# but not vice-versa\n",
|
|
"isinstance(s1, Alum)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 20,
|
|
"id": "1d52b927",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [
|
|
{
|
|
"ename": "TypeError",
|
|
"evalue": "issubclass() arg 1 must be a class",
|
|
"output_type": "error",
|
|
"traceback": [
|
|
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
|
|
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
|
|
"Cell \u001b[0;32mIn[20], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# takes class names\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;43missubclass\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43malum1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mStudent\u001b[49m\u001b[43m)\u001b[49m\n",
|
|
"\u001b[0;31mTypeError\u001b[0m: issubclass() arg 1 must be a class"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"# takes class names\n",
|
|
"issubclass(alum1, Student)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 22,
|
|
"id": "a71ee1cb",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"True"
|
|
]
|
|
},
|
|
"execution_count": 22,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"issubclass(Alum, Student)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "32e11764",
|
|
"metadata": {},
|
|
"source": [
|
|
"### `object`\n",
|
|
"\n",
|
|
"Every object derives from a base class named `object`.\n",
|
|
"\n",
|
|
"```python\n",
|
|
"class Point:\n",
|
|
" def __init__(self, x, y):\n",
|
|
" self.x = y\n",
|
|
"\n",
|
|
"# Same as: \n",
|
|
"\n",
|
|
"class Point(object):\n",
|
|
" def __init__(self, x, y):\n",
|
|
" self.x = y\n",
|
|
" self.y = y\n",
|
|
"```\n",
|
|
"\n",
|
|
"### MRO\n",
|
|
"\n",
|
|
"When we call a function, Python walks up the chain of parent classes to determine the first one that has the method defined.\n",
|
|
"\n",
|
|
"This is called the **method resolution order**.\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 66,
|
|
"id": "1d4e00ca",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Help on class Alum in module __main__:\n",
|
|
"\n",
|
|
"class Alum(Student)\n",
|
|
" | Alum(name, grad_year)\n",
|
|
" | \n",
|
|
" | Method resolution order:\n",
|
|
" | Alum\n",
|
|
" | Student\n",
|
|
" | builtins.object\n",
|
|
" | \n",
|
|
" | Methods defined here:\n",
|
|
" | \n",
|
|
" | __init__(self, name, grad_year)\n",
|
|
" | Initialize self. See help(type(self)) for accurate signature.\n",
|
|
" | \n",
|
|
" | __repr__(self)\n",
|
|
" | Return repr(self).\n",
|
|
" | \n",
|
|
" | add_grade(self, course_name, grade)\n",
|
|
" | # overrides parent's add_grade\n",
|
|
" | \n",
|
|
" | years_since_graduation(self, now)\n",
|
|
" | # new behavior\n",
|
|
" | \n",
|
|
" | ----------------------------------------------------------------------\n",
|
|
" | Readonly properties inherited from Student:\n",
|
|
" | \n",
|
|
" | gpa\n",
|
|
" | \n",
|
|
" | ----------------------------------------------------------------------\n",
|
|
" | Data descriptors inherited from Student:\n",
|
|
" | \n",
|
|
" | __dict__\n",
|
|
" | dictionary for instance variables (if defined)\n",
|
|
" | \n",
|
|
" | __weakref__\n",
|
|
" | list of weak references to the object (if defined)\n",
|
|
" | \n",
|
|
" | ----------------------------------------------------------------------\n",
|
|
" | Data and other attributes inherited from Student:\n",
|
|
" | \n",
|
|
" | next_id_counter = 16\n",
|
|
"\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"help(Alum)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 67,
|
|
"id": "45f732f0-2036-416e-a44c-70b99b18a960",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"(__main__.Alum, __main__.Student, object)"
|
|
]
|
|
},
|
|
"execution_count": 67,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"Alum.__mro__"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 23,
|
|
"id": "592f6930-cf36-4ec1-a4f3-ea1947fa7173",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"Help on class super in module builtins:\n",
|
|
"\n",
|
|
"class super(object)\n",
|
|
" | super() -> same as super(__class__, <first argument>)\n",
|
|
" | super(type) -> unbound super object\n",
|
|
" | super(type, obj) -> bound super object; requires isinstance(obj, type)\n",
|
|
" | super(type, type2) -> bound super object; requires issubclass(type2, type)\n",
|
|
" | Typical use to call a cooperative superclass method:\n",
|
|
" | class C(B):\n",
|
|
" | def meth(self, arg):\n",
|
|
" | super().meth(arg)\n",
|
|
" | This works for class methods too:\n",
|
|
" | class C(B):\n",
|
|
" | @classmethod\n",
|
|
" | def cmeth(cls, arg):\n",
|
|
" | super().cmeth(arg)\n",
|
|
" | \n",
|
|
" | Methods defined here:\n",
|
|
" | \n",
|
|
" | __get__(self, instance, owner=None, /)\n",
|
|
" | Return an attribute of instance, which is of type owner.\n",
|
|
" | \n",
|
|
" | __getattribute__(self, name, /)\n",
|
|
" | Return getattr(self, name).\n",
|
|
" | \n",
|
|
" | __init__(self, /, *args, **kwargs)\n",
|
|
" | Initialize self. See help(type(self)) for accurate signature.\n",
|
|
" | \n",
|
|
" | __repr__(self, /)\n",
|
|
" | Return repr(self).\n",
|
|
" | \n",
|
|
" | ----------------------------------------------------------------------\n",
|
|
" | Static methods defined here:\n",
|
|
" | \n",
|
|
" | __new__(*args, **kwargs) from builtins.type\n",
|
|
" | Create and return a new object. See help(type) for accurate signature.\n",
|
|
" | \n",
|
|
" | ----------------------------------------------------------------------\n",
|
|
" | Data descriptors defined here:\n",
|
|
" | \n",
|
|
" | __self__\n",
|
|
" | the instance invoking super(); may be None\n",
|
|
" | \n",
|
|
" | __self_class__\n",
|
|
" | the type of the instance invoking super(); may be None\n",
|
|
" | \n",
|
|
" | __thisclass__\n",
|
|
" | the class invoking super()\n",
|
|
"\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"help(super)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "d2519b22",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Abstract Base Classes\n",
|
|
"\n",
|
|
"Sometimes we want to define a class that can't be instantiated directly, but is intended to be inherited from.\n",
|
|
"\n",
|
|
"These are known as **abstract classes**. This helps us define an interface, which contains a collection of methods that the **concrete class** must implement.\n",
|
|
"\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 29,
|
|
"id": "9f705ba6",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"def print_dot_prod(v1, v2):\n",
|
|
" \"\"\" prints dot product between two vectors \"\"\"\n",
|
|
" print(v1.dot_product(v2))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "ec8087af",
|
|
"metadata": {},
|
|
"source": [
|
|
"If we want this method to be polymorphic for vectors of multiple dimensions, such as:"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 38,
|
|
"id": "4b20d7b3",
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"class Vec2:\n",
|
|
" def __init__(self,x,y):\n",
|
|
" self.x = x\n",
|
|
" self.y = y \n",
|
|
"\n",
|
|
" def dot_product(self, other):\n",
|
|
" ...\n",
|
|
" \n",
|
|
"class Vec3:\n",
|
|
" def __init__(self,x,y,z):\n",
|
|
" self.x = x\n",
|
|
" self.y = y \n",
|
|
" self.z = z \n",
|
|
"\n",
|
|
" def dot(self, other):\n",
|
|
" ..."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "86d216a7",
|
|
"metadata": {},
|
|
"source": [
|
|
"We can force that these types implement an interface (i.e., an abstract base class) such that we can guarantee that objects we pass to ``print_dot_prod`` will always work by forcing them to implement a ``dot_product`` method. \n",
|
|
"\n",
|
|
"We will define an abstract class called ``Vector`` that has only the required method: \n",
|
|
"\n",
|
|
"`` def dot_product(self, other) `` "
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 72,
|
|
"id": "a2cddb6d",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"from abc import ABC, abstractmethod\n",
|
|
"\n",
|
|
"class Vector(ABC): \n",
|
|
" def print_x(self):\n",
|
|
" print(self.x)\n",
|
|
" \n",
|
|
" @abstractmethod\n",
|
|
" def dot_product(self, other):\n",
|
|
" pass"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 71,
|
|
"id": "a32d26a8",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [
|
|
{
|
|
"ename": "TypeError",
|
|
"evalue": "Can't instantiate abstract class Vector with abstract methods __repr__, dot_product",
|
|
"output_type": "error",
|
|
"traceback": [
|
|
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
|
|
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
|
|
"Cell \u001b[0;32mIn[71], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# we can't instantiate abstract classes\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m v \u001b[38;5;241m=\u001b[39m \u001b[43mVector\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
|
|
"\u001b[0;31mTypeError\u001b[0m: Can't instantiate abstract class Vector with abstract methods __repr__, dot_product"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"# we can't instantiate abstract classes\n",
|
|
"v = Vector()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 75,
|
|
"id": "5a9ae047",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"class Vec2(Vector):\n",
|
|
" def __init__(self, x, y):\n",
|
|
" self.x = x\n",
|
|
" self.y = y \n",
|
|
" \n",
|
|
" def dot_product(self, other): \n",
|
|
" return self.x * other.x + self.y * other.y\n",
|
|
" \n",
|
|
"class Vec3(Vector):\n",
|
|
" def __init__(self, x, y, z):\n",
|
|
" self.x = x\n",
|
|
" self.y = y \n",
|
|
" self.z = z \n",
|
|
" \n",
|
|
" def dot_product(self, other): \n",
|
|
" return self.x * other.x + self.y * other.y + self.z * other.z"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 76,
|
|
"id": "e25536d1",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"True\n",
|
|
"True\n",
|
|
"----\n",
|
|
"True\n",
|
|
"True\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"# now print_dot_prod works\n",
|
|
"\n",
|
|
"# Vec2 and Vec3 objects are instances of Vector since their classes \n",
|
|
"# inherit from the Vector ABC.\n",
|
|
"v2a = Vec2(1,2)\n",
|
|
"v2b = Vec2(3,4)\n",
|
|
"v3a = Vec3(6,7,3)\n",
|
|
"v3b = Vec3(1,2,3)\n",
|
|
"\n",
|
|
"print(isinstance(v2a, Vec2)) \n",
|
|
"print(isinstance(v2a, Vector)) \n",
|
|
"print(\"----\")\n",
|
|
"print(isinstance(v3a, Vec3)) \n",
|
|
"print(isinstance(v3a, Vector))"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 78,
|
|
"id": "69ac4241-b251-4485-9ba9-3b0348d82c34",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"1\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"v2a.print_x()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 47,
|
|
"id": "96d41011",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"11\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"print_dot_prod(v2a, v2b)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 48,
|
|
"id": "7cf62b14",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"29\n"
|
|
]
|
|
}
|
|
],
|
|
"source": [
|
|
"print_dot_prod(v3a, v3b)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "ebbd1b47-601b-4a65-b493-213ccbedf373",
|
|
"metadata": {},
|
|
"source": [
|
|
"## Dataclasses\n",
|
|
"\n",
|
|
"Python 3.7 added `dataclasses` as a handy way to create classes that are mostly responsible for representing data. These classes often have few or no methods defined."
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 79,
|
|
"id": "4f98cf62-52da-4072-bf5a-da7de3ad9a98",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"from dataclasses import dataclass\n",
|
|
"\n",
|
|
"@dataclass\n",
|
|
"class InventoryItem:\n",
|
|
" \"\"\"Class for keeping track of an item in inventory.\"\"\"\n",
|
|
" name: str\n",
|
|
" unit_price: float\n",
|
|
" quantity_on_hand: int = 0\n",
|
|
"\n",
|
|
" def total_cost(self) -> float:\n",
|
|
" return self.unit_price * self.quantity_on_hand\n",
|
|
"#InventoryItem = dataclass(InventoryItem)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"id": "af1f9445-29c7-4fd8-8648-596fa3a12006",
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 43,
|
|
"id": "8faf9c31-33e4-42f1-a8e8-8b72a7f1f96f",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [],
|
|
"source": [
|
|
"wrench = InventoryItem(\"Wrench\", 12.95, 10)\n",
|
|
"hammer = InventoryItem(\"Hammer\", 16, 8)\n",
|
|
"nails = InventoryItem(\"Nails\", 0.03, 1000)\n",
|
|
"saw = InventoryItem(\"Saw\", 99)\n",
|
|
"saw2 = InventoryItem(\"Saw\", 99)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 44,
|
|
"id": "94f14911-335c-4097-8658-b9a30a70d53b",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"True"
|
|
]
|
|
},
|
|
"execution_count": 44,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"saw == saw2"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "4a088329-2f4d-4548-a750-b0f02df5dc9b",
|
|
"metadata": {},
|
|
"source": [
|
|
"Dataclasses get an automatic `__init__`, `__repr__`, `__eq__`, and several other helpful options. (Even more is possible via the decorator: https://docs.python.org/3/library/dataclasses.html)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 55,
|
|
"id": "e3a8dd5f-55bc-49d2-af83-79c977393b0d",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"outputs": [
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"30.0"
|
|
]
|
|
},
|
|
"execution_count": 55,
|
|
"metadata": {},
|
|
"output_type": "execute_result"
|
|
}
|
|
],
|
|
"source": [
|
|
"nails.total_cost()"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"id": "d8f9a214-3277-40a9-b50c-2aabf5794079",
|
|
"metadata": {
|
|
"tags": []
|
|
},
|
|
"source": [
|
|
"Beyond this, additional methods/staticmethods/etc. can be defined in the usual way.\n",
|
|
"\n",
|
|
"This syntax uses Python's type-hinting, and if you're looking to use it you'll want to get familiar with the rules\n",
|
|
"around complex types: https://docs.python.org/3/library/typing.html\n",
|
|
"\n",
|
|
"**Note: This syntax has been evolving rapidly from Python 3.6->now. This is one are where making sure you have a current (>=3.10) version of Python will matter.**"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 57,
|
|
"id": "3c1a8baa-3840-437d-b6ad-d880a4676423",
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"# instead of returning tuples and \n",
|
|
"# remembering the positional order, can instead\n",
|
|
"@dataclass\n",
|
|
"class RetType:\n",
|
|
" data: list[int]\n",
|
|
" counter: int\n",
|
|
"\n",
|
|
"def fn():\n",
|
|
" return RetType([], counter)\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"id": "7097097d-b7a6-437a-8f60-f12d38df6a1b",
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": []
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"id": "73195ac4-c0cc-4f8b-8852-2b63168e1713",
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"functools."
|
|
]
|
|
}
|
|
],
|
|
"metadata": {
|
|
"kernelspec": {
|
|
"display_name": "Python 3 (ipykernel)",
|
|
"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.10.15"
|
|
},
|
|
"toc": {
|
|
"base_numbering": 1,
|
|
"nav_menu": {},
|
|
"number_sections": false,
|
|
"sideBar": true,
|
|
"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": "256.933px"
|
|
},
|
|
"toc_section_display": true,
|
|
"toc_window_display": false
|
|
}
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 5
|
|
}
|