code/22-meta-classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "📝 **Author:** Amirhossein Heydari - 📧 **Email:** <amirhosseinheydari78@gmail.com> - 📍 **Origin:** [mr-pylin/python-workshop](https://github.com/mr-pylin/python-workshop)\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Table of contents**<a id='toc0_'></a>    \n",
    "- [Meta Classes](#toc1_)    \n",
    "  - [General Syntax](#toc1_1_)    \n",
    "  - [Custom Metaclasses](#toc1_2_)    \n",
    "\n",
    "<!-- vscode-jupyter-toc-config\n",
    "\tnumbering=false\n",
    "\tanchor=true\n",
    "\tflat=false\n",
    "\tminLevel=1\n",
    "\tmaxLevel=6\n",
    "\t/vscode-jupyter-toc-config -->\n",
    "<!-- THIS CELL WILL BE REPLACED ON TOC UPDATE. DO NOT WRITE YOUR TEXT IN THIS CELL -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc1_'></a>[Meta Classes](#toc0_)\n",
    "\n",
    "- Meta classes in Python allow you to define the behavior of **classes themselves**, not just the instances created from those classes.\n",
    "- Essentially, a **class** is an instance of a **metaclass**, just as objects are instances of classes.\n",
    "\n",
    "✍️ **Key Concepts**:\n",
    "\n",
    "- **Classes as Objects**:\n",
    "  - In Python, when you define a class, Python internally creates a **class object**.\n",
    "  - This class object is an instance of a **metaclass**, typically `type`.\n",
    "- **Default Metaclass (`type`)**:\n",
    "  - By default, Python uses the built-in `type` metaclass to create classes.\n",
    "  - When you create a class, Python executes its code and uses `type` to construct the class.\n",
    "- **Custom Metaclasses**:\n",
    "  - You can define your own metaclass by inheriting from `type`.\n",
    "  - A metaclass allows you to customize the **creation** and **structure** of classes.\n",
    "\n",
    "🆚 **Inheritance vs. Metaclass**\n",
    "\n",
    "- Inheritance:\n",
    "  - Every **class instance** in Python inherits from the `object` class.\n",
    "  - This is **instance-level** inheritance, where the chain of inheritance is followed when calling methods or accessing attributes.\n",
    "- Metaclass (type):\n",
    "  - Every **class itself** is an instance of the `type` metaclass.\n",
    "  - The metaclass determines how the *class* is created, not how *instances* of the class behave.\n",
    "  - By default, `type` is the metaclass, but you can define your own metaclass to modify class creation behavior.\n",
    "\n",
    "📝 **Docs**:\n",
    "\n",
    "- Metaclasses: [docs.python.org/3/reference/datamodel.html#metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)\n",
    "- Customizing class creation: [docs.python.org/3/reference/datamodel.html#customizing-class-creation](https://docs.python.org/3/reference/datamodel.html#customizing-class-creation)\n",
    "- `class type(object)`: [docs.python.org/3/library/functions.html#type](https://docs.python.org/3/library/functions.html#type)\n",
    "\n",
    "🐍 **PEP**:\n",
    "\n",
    "- Metaclasses in Python 3000 [[PEP 3115](https://peps.python.org/pep-3115/)]\n",
    "- Simpler customisation of class creation [[PEP 487](https://peps.python.org/pep-0487/)]\n",
    "- Simpler customisation of class creation [[PEP 422](https://peps.python.org/pep-0422/)]\n",
    "- Subtyping Built-in Types [[PEP 253](https://peps.python.org/pep-0253/)]\n",
    "- Introducing Abstract Base Classes [[PEP 3119](https://peps.python.org/pep-3119/)]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a class\n",
    "class Foo:  # equivalent to <class Foo(metaclass=type)>\n",
    "    pass\n",
    "\n",
    "\n",
    "# initialization\n",
    "f = Foo()\n",
    "\n",
    "# log\n",
    "print(f\"type(f)   : {type(f)}\")  # the type of <f> is \"class Foo\"\n",
    "print(f\"type(Foo) : {type(Foo)}\")  # the type of <Foo> (the class itself) is type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# types of familiar built-in classes\n",
    "for cls in (int, float, list, tuple, dict, set):\n",
    "    print(f\"type({cls.__name__:5}) : {type(cls)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_1_'></a>[General Syntax](#toc0_)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# syntax of defining a metaclass (always inherits from <type>)\n",
    "class Meta(type):\n",
    "    def __new__(cls, name, bases, dct):\n",
    "        print(f\"Creating class: {name}\")\n",
    "        return super().__new__(cls, name, bases, dct)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# syntax of using a metaclass\n",
    "class MyClass(metaclass=Meta):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# log\n",
    "cls = MyClass()\n",
    "print(f\"type(cls)     : {type(cls)}\")\n",
    "print(f\"type(MyClass) : {type(MyClass)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_2_'></a>[Custom Metaclasses](#toc0_)\n",
    "\n",
    "- When the Python interpreter encounters an expression like `Foo()`, it follows a specific process under the hood, invoking methods from the **metaclass** (usually `type`) that controls how `Foo` instances are created.\n",
    "\n",
    "🔄 **Class Instantiation Process**:\n",
    "\n",
    "   1. The `__call__()` method of `Foo`'s metaclass (typically `type`) is invoked.\n",
    "      - This happens whenever `Foo()` is called to create a new instance.\n",
    "   1. The metaclass's `__call__()` method is responsible for invoking the following:\n",
    "      - **`__new__()`**: This method is responsible for **allocating memory** and creating a new instance.\n",
    "      - **`__init__()`**: Once the instance is created, this method **initializes** the instance (i.e., sets up attributes).\n",
    "\n",
    "📝 **Key Notes**:\n",
    "\n",
    "- If `Foo` defines its own `__new__()` or `__init__()` methods, they will override the methods from the parent classes or metaclass.\n",
    "- Customizing `__new__()` or `__init__()` can allow fine-grained control over instance creation and initialization.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyMeta(type):\n",
    "    def __call__(cls, *args, **kwargs):\n",
    "        print(f\"Creating instance of {cls.__name__}\")\n",
    "        instance = super().__call__(*args, **kwargs)  # call __new__ and __init__ from the parent which is <type>\n",
    "        return instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Foo(metaclass=MyMeta):\n",
    "    def __new__(cls):\n",
    "        print(\"In __new__ method\")\n",
    "        return super().__new__(cls)\n",
    "\n",
    "    def __init__(self):\n",
    "        print(\"In __init__ method\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating an instance of Foo\n",
    "f = Foo()"
   ]
  }
 ],
 "metadata": {
  "author_email": "AmirhosseinHeydari78@gmail.com",
  "author_github": "https://github.com/mr-pylin",
  "author_name": "Amirhossein Heydari",
  "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.12.3"
  },
  "origin_repo": "https://github.com/mr-pylin/python-workshop"
 },
 "nbformat": 4,
 "nbformat_minor": 2
}