From 30127b35533ecb0b32b5b85e1690e34708b93cc2 Mon Sep 17 00:00:00 2001 From: Alexander Hess Date: Wed, 28 Oct 2020 22:42:08 +0100 Subject: [PATCH] Add initial version of chapter 11's summary --- 11_classes/05_summary.ipynb | 100 ++++++++++++++++++++++++++++++++++++ CONTENTS.md | 1 + 2 files changed, 101 insertions(+) create mode 100644 11_classes/05_summary.ipynb diff --git a/11_classes/05_summary.ipynb b/11_classes/05_summary.ipynb new file mode 100644 index 0000000..47baf9f --- /dev/null +++ b/11_classes/05_summary.ipynb @@ -0,0 +1,100 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Chapter 11: Classes & Instances (TL;DR)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ + "With the `class` statement, we can create a *user-defined* data type that we also call a **class**.\n", + "\n", + "Then, to create new **instances** of the data type, we simply call the class, just as we do with the built-in constructors.\n", + "\n", + "Conceptually, a class is the **blueprint** defining the **behavior** each instance exhibits.\n", + "\n", + "In the example used throughout the chapter, the `Vector` and `Matrix` classes implement the linear algebra rules all `Vector` and `Matrix` instances follow *in general*. On the contrary, the instances **encapsulate** the **state** of *concrete* vectors and matrices.\n", + "\n", + "The `class` statement acts as a *namespace* that consists of simple *variable assignments* and *function definitions*:\n", + "1. Variables become the **class attributes** that are shared among all instances.\n", + "2. Functions may take a different role:\n", + " - By default, they become **instance methods** by going through a **binding process** where a reference to the instance on which the method is *invoked* is passed in as the first argument. By convention, the corresponding parameter is called `self`; it embodies an instance's state: That means that instance methods set and get **instance attributes** on and from `self`.\n", + " - They may be declared as **class methods**. Then, the binding process is adjusted such that the first argument passed in is a reference to the class itself and, by convention, named `cls`. A common use case is to design **alternative constructors**.\n", + " - They may also be declared as **properties**. A use case for that are *derived* attributes that follow semantically from an instance's state.\n", + " \n", + "The **Python Data Model** concerns what special methods (i.e., the ones with the dunder names) exists and how they work together.\n", + "\n", + "The instantiation process is controlled by the `.__init__()` method.\n", + "\n", + "The `__repr__()` and `__str__()` methods implement the **text representation** of an instance, which can be regarded as a Unicode encoded representation of all the state encapsulated in an instance.\n", + "\n", + "**Sequence emulation** means that a user-defined data type exhibits the same four properties as the built-in sequences, which are regarded as finite and iterable containers with a predictable order. The `.__len__()`, `.__iter__()`, `__reversed__()`, `__getitem__()`, and some others are used to implement the corresponding behaviors.\n", + "\n", + "Similarly, **number emulation** means that an instance of a user-defined data type behaves like a built-in number. For example, by implementing the `.__abs__()` method, an instance may be passed to the built-in [abs() ](https://docs.python.org/3/library/functions.html#abs) function.\n", + "\n", + "If different data types, built-in or user-defined, share a well-defined set of behaviors, a single function may be written to work with objects of all the data types. We describe such functions as **polymorphic**.\n", + "\n", + "Classes may specify how *operators* are **overloaded**. Examples for that are the `.__add__()`, `.__sub__()`, or `.__eq__()` methods.\n", + "\n", + "**Packages** are folders containing **modules** (i.e., \\*.py files) and a \"*\\_\\_init\\_\\_.py*\" file. We use them to design coherent libraries with reusable code." + ] + } + ], + "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.6" + }, + "livereveal": { + "auto_select": "code", + "auto_select_fragment": true, + "scroll": true, + "theme": "serif" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": true, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "384px" + }, + "toc_section_display": false, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/CONTENTS.md b/CONTENTS.md index be3d163..b545cb4 100644 --- a/CONTENTS.md +++ b/CONTENTS.md @@ -289,3 +289,4 @@ If this is not possible, (Writing one's own Packages; The final `Vector` & `Matrix` Classes; Comparison with `numpy`) + - [summary ](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/develop/11_classes/05_summary.ipynb)