python-beginner/notebooks/classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [Classes](https://docs.python.org/3/tutorial/classes.html#a-first-look-at-classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyFirstClass:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def greet(self):\n",
    "        print('Hello {}!'.format(self.name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_instance = MyFirstClass('John Doe')\n",
    "print('my_instance: {}'.format(my_instance))\n",
    "print('type: {}'.format(type(my_instance)))\n",
    "print('my_instance.name: {}'.format(my_instance.name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods\n",
    "The functions inside classes are called methods. They are used similarly as functions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alice = MyFirstClass(name='Alice')\n",
    "alice.greet()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `__init__()`\n",
    "`__init__()` is a special method that is used for initialising instances of the class. It's called when you create an instance of the class. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Example:\n",
    "    def __init__(self):\n",
    "        print('Now we are inside __init__')\n",
    "        \n",
    "print('creating instance of Example')\n",
    "example = Example()\n",
    "print('instance created')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`__init__()` is typically used for initialising instance variables of your class. These can be listed as arguments after `self`. To be able to access these instance variables later during your instance's lifetime, you have to save them into `self`. `self` is the first argument of the methods of your class and it's your access to the instance variables and other methods. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Example:\n",
    "    def __init__(self, var1, var2):\n",
    "        self.first_var = var1\n",
    "        self.second_var = var2\n",
    "        \n",
    "    def print_variables(self):\n",
    "        print('{} {}'.format(self.first_var, self.second_var))\n",
    "        \n",
    "e = Example('abc', 123)\n",
    "e.print_variables()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `__str__()`\n",
    "`__str__()` is a special method which is called when an instance of the class is converted to string (e.g. when you want to print the instance). In other words, by defining `__str__` method for your class, you can decide what's the printable version of the instances of your class. The method should return a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        \n",
    "    def __str__(self):\n",
    "        return 'Person: {}'.format(self.name)\n",
    "    \n",
    "jack = Person('Jack', 82)\n",
    "print('This is the string presentation of jack: {}'.format(jack))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class variables vs instance variables\n",
    "Class variables are shared between all the instances of that class whereas instance variables can hold different values between different instances of that class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Example:\n",
    "    # These are class variables\n",
    "    name = 'Example class'\n",
    "    description = 'Just an example of a simple class'\n",
    "\n",
    "    def __init__(self, var1):\n",
    "        # This is an instance variable\n",
    "        self.instance_variable = var1\n",
    "\n",
    "    def show_info(self):\n",
    "        info = 'instance_variable: {}, name: {}, description: {}'.format(\n",
    "            self.instance_variable, Example.name, Example.description)\n",
    "        print(info)\n",
    "\n",
    "\n",
    "inst1 = Example('foo')\n",
    "inst2 = Example('bar')\n",
    "\n",
    "# name and description have identical values between instances\n",
    "assert inst1.name == inst2.name == Example.name\n",
    "assert inst1.description == inst2.description == Example.description\n",
    "\n",
    "# If you change the value of a class variable, it's changed across all instances\n",
    "Example.name = 'Modified name'\n",
    "inst1.show_info()\n",
    "inst2.show_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Public vs private\n",
    "In python there's now strict separation for private/public methods or instance variables. The convention is to start the name of the method or instance variable with underscore if it should be treated as private. Private means that it should not be accessed from outside of the class.\n",
    "\n",
    "For example, let's consider that we have a `Person` class which has `age` as an instance variable. We want that `age` is not directly accessed (e.g. changed) after the instance is created. In Python, this would be:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, age):\n",
    "        self._age = age\n",
    "        \n",
    "example_person = Person(age=15)\n",
    "# You can't do this:\n",
    "# print(example_person.age)\n",
    "# Nor this:\n",
    "# example_person.age = 16"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want the `age` to be readable but not writable, you can use `property`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, age):\n",
    "        self._age = age\n",
    "        \n",
    "    @property\n",
    "    def age(self):\n",
    "        return self._age\n",
    "        \n",
    "example_person = Person(age=15)\n",
    "# Now you can do this:\n",
    "print(example_person.age)\n",
    "# But not this:\n",
    "#example_person.age = 16"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This way you can have a controlled access to the instance variables of your class: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, age):\n",
    "        self._age = age\n",
    "        \n",
    "    @property\n",
    "    def age(self):\n",
    "        return self._age\n",
    "    \n",
    "    def celebrate_birthday(self):\n",
    "        self._age += 1\n",
    "        print('Happy bday for {} years old!'.format(self._age))\n",
    "        \n",
    "example_person = Person(age=15)\n",
    "example_person.celebrate_birthday()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction to inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animal:\n",
    "    def greet(self):\n",
    "        print('Hello, I am an animal')\n",
    "\n",
    "    @property\n",
    "    def favorite_food(self):\n",
    "        return 'beef'\n",
    "\n",
    "\n",
    "class Dog(Animal):\n",
    "    def greet(self):\n",
    "        print('wof wof')\n",
    "\n",
    "\n",
    "class Cat(Animal):\n",
    "    @property\n",
    "    def favorite_food(self):\n",
    "        return 'fish'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dog = Dog()\n",
    "dog.greet()\n",
    "print(\"Dog's favorite food is {}\".format(dog.favorite_food))\n",
    "\n",
    "cat = Cat()\n",
    "cat.greet()\n",
    "print(\"Cat's favorite food is {}\".format(cat.favorite_food))"
   ]
  }
 ],
 "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}