Class Rectangle (Width, Height); Real Width, Height;
                           ! Class with two parameters;
 Begin
    Real Area, Perimeter;  ! Attributes;

    Procedure Update;      ! Methods (Can be Virtual);
    Begin
      Area := Width * Height;
      Perimeter := 2*(Width + Height)
    End of Update;

    Boolean Procedure IsSquare;
      IsSquare := Width=Height;

    Update;                ! Life of rectangle started at creation;
    OutText("Rectangle created: "); OutFix(Width,2,6);
    OutFix(Height,2,6); OutImage
 End of Rectangle;

record class person;
    begin   integer date of birth;
            Boolean male;
            reference   father, mother, youngest offspring, elder sbling (person)
    end;

a = 0
# a+3の機能を実現したい

# プロセス指向
sum(a, 3)

# オブジェクト指向
a.sum(3)

class Bird:
    def __init__(self, name):
        self.name = name

    def move(self):
        print("The bird named {} is flying".format(self.name))


class Dog:
    def __init__(self, name):
        self.name = name

    def move(self):
        print("The dog named {} is running".format(self.name))


class Fish:
    def __init__(self, name):
        self.name = name

    def move(self):
        print("The fish named {} is swimming".format(self.name))

bob = Bird("Bob")
john = Bird("John")
david = Dog("David")
fabian = Fish("Fabian")

bob.move()
john.move()
david.move()
fabian.move()

The bird named Bob is flying
The bird named John is flying
The dog named David is running
The fish named Fabian is swimming

def move_bird(name):
    print("The bird named {} is flying".format(name))


def move_dog(name):
    print("The dog named {} is runing".format(name))


def move_fish(name):
    print("The fish named {} is swimming".format(name))


bob = "Bob"
john = "John"
david = "David"
fabian = "Fabian"

move_bird(bob)
move_bird(john)
move_dog(david)
move_fish(fabian)

class Person:
    def __init__(self, name, age, height):
        self.name = name
        self.age = age
        self.height = height

    def describe(self):
        print("name: {}; age: {}; height: {}".format(self.name, self.age, self.height))

    def introduce(self):
        print("My name is {}, and height is {}, and age is {}. ".format(self.name, self.height, self.age))


bob = Person("Bob", 24, 170)
mary = Person("Mary", 10, 160)
bob.describe()
bob.introduce()
mary.describe()
mary.introduce()

name: Bob; age: 24; height: 170
My name is Bob, and height is 170, and age is 24.
name: Mary; age: 10; height: 160
My name is Mary, and height is 160, and age is 10.

def description(name, age, height):
    print("Description: name is {}, age is {}, height is {}".format(name, age, height))


def introduction(name, age, height):
    print("My name is {}, and height is {}, and age is {}. ".format(name, height, age))


description("Bob", 24, 170)
description("Mary", 20, 160)
introduction("Bob", 24, 170)
introduction("Mary", 20, 160)

bob = dict(name='Bob', age=24, height=170)
mary = dict(name='Mary', age=20, height=160)


def introduction(**kwargs):
    print("My name is {name}, and height is {age}, and age is {height}. ".format(**kwargs))


def description(**kwargs):
    print("Description: name is {name}, age is {age}, height is {height}".format(**kwargs))


introduction(**bob)
description(**bob)
introduction(**mary)
description(**mary)

class Individual:
    def __init__(self, energy=10):
        self.energy = energy

    def eat_fruit(self):
        self.energy += 1
        return self

    def eat_meat(self):
        self.energy += 2
        return self

    def run(self):
        self.energy -= 3
        return self


anyone = Individual()
print("energy: {}".format(anyone.energy))
anyone.eat_meat()
print("energy after eat_meat: {}".format(anyone.energy))
anyone.eat_fruit()
print("energy after eat_fruit: {}".format(anyone.energy))
anyone.run()
print("energy after run: {}".format(anyone.energy))
anyone.eat_meat().run()
print("energy after eat_meat and run: {}".format(anyone.energy))

energy: 10
energy after eat_meat: 12
energy after eat_fruit: 13
energy after run: 10
energy after eat_meat and run: 9

class Boy(Individual):
    def daily_activity(self):
        self.eat_meat().eat_meat().run().eat_meat().eat_fruit().run().eat_meat()
        print("boy's daily energy: {}".format(self.energy))


class Girl(Individual):
    def daily_activity(self):
        self.eat_meat().eat_fruit()
        print("girl's daily energy: {}".format(self.energy))


bob = Boy()
bob.daily_activity()
mary = Girl()
mary.daily_activity()

boy's daily energy: 13
girl's daily energy: 13

class oldStyleClass: # inherits from 'type'
    pass

class newStyleClass(object): # explicitly inherits from 'object'
    pass

class Animal:
    def run(self):
        print('Animal is running...')


class Dog(Animal):
    def run(self):
        print('Dog is running...')


class Cat(Animal):
    def run(self):
        print('Cat is running...')


def run_twice(animal):
    animal.run()
    animal.run()

run_twice(Animal())
run_twice(Dog())
run_twice(Cat())

Animal is running...
Animal is running...
Dog is running...
Dog is running...
Cat is running...
Cat is running...

class MyNum:
    def __init__(self,x):
        self.__x = x

    def __lt__(self, other):
        print("__lt__")
        return self.__x < other

    def __le__(self, other):
        print("__le__")
        return self.__x <= other

    def __eq__(self, other):
        print("__eq__")
        return self.__x == other

    def __ne__(self, other):
        print("__ne__")
        return self.__x != other

    def __gt__(self, other):
        print("__gt__")
        return self.__x > other

    def __ge__(self, other):
        print("__ge__")
        return self.__x >= other

x = MyNum(100)
x < 10
x <= 10
x == 10
x != 10
x > 10
x >= 10

__lt__
__le__
__eq__
__ne__
__gt__
__ge__

from types import MethodType


class Animal:
    # ここはクラス変数を定義する場所
    the_name = "animal"  # クラス変数

    def __init__(self, name, age):  # イニシャライザ
        self.name = name  # インスタンス変数
        self.age = age

    # ここはメソッドを定義する場所
    def sleep(self):  # インスタンスメソッド
        print("{} is sleeping".format(self.name))

    def eat(self, food):  # 引数付きのインスタンスメソッド
        print("{} is eating {}".format(self.name, food))

    @classmethod
    def speak(cls, adjective):  # クラスメソッド
        print("I am a {} {}".format(adjective, cls.the_name))

    @staticmethod
    def happening(person, do):  # 静的メソッド
        print("{} is {}ing".format(person, do))


def drink_water(self):
    print("{} is drinking water".format(self.name))

adam = Animal(name="Adam", age=2)  # インスタンス化
print('adam.the_name: {}'.format(adam.the_name))  # インスタンスからクラス変数を呼び出す
# 実行結果：adam.the_name: animal
print('Animal.the_name: {}'.format(Animal.the_name))  # クラスからクラス変数を呼び出す
# 実行結果：adam.name: Adam
print('adam.name: {}'.format(adam.name))  # インスタンス変数を呼び出す
# 実行結果：Animal.the_name: animal
adam.sleep()  # インスタンスメソッドを呼び出す
# 実行結果：Adam is sleeping
adam.eat("meat")  # 引数付きのインスタンスメソッドを呼び出す
# 実行結果：Adam is eating meat
adam.speak("happy")  # インスタンスからクラスメソッドを呼び出す
# 実行結果：I am a happy animal
Animal.speak("sad")  # クラスからクラスメソッドを呼び出す
# 実行結果：I am a sad animal
adam.happening("Tim", "play")  # インスタンスから静的メソッドを呼び出す
# 実行結果：Tim is playing
Animal.happening("Mary", "watch")  # クラスから静的メソッドを呼び出す
# 実行結果：Mary is watching
Animal.the_name = "Animal"  # クラス変数を修正
print('adam.the_name: {}'.format(adam.the_name))
# 実行結果：adam.the_name: Animal
adam.the_name = "animal"  # インスタンスから修正
print('Animal.the_name: {}'.format(Animal.the_name))
# 実行結果：Animal.the_name: Animal
adam.age = 3  # インスタンス変数を修正

# メソッドのバンディング（モンキーパッチ）
adam.drink_water = MethodType(drink_water, adam)  # インスタンスにバンディングする
adam.drink_water()
# 実行結果：Adam is drinking water
print(adam.drink_water)
# 実行結果：<bound method drink_water of <__main__.Animal object at 0x7ffd68064310>>
try:
    Animal.drink_water
except AttributeError as e:
    print(e)
# 実行結果：type object 'Animal' has no attribute 'drink_water'
Animal.drink_water = MethodType(drink_water, Animal)  # クラスにバンディングする
adam.drink_water()
# 実行結果：Adam is drinking water
Animal.drink_water = drink_water  # 直接代入でメソッドをバンディングする
adam.drink_water()
# 実行結果：Adam is drinking water

from functools import cached_property


class Dog(Animal):  # クラスの継承
    def eating(self):
        print("{} is eating".format(self.name))

    @property
    def running(self):
        if self.age >= 3 and self.age < 130:
            print("{} is running".format(self.name))
        elif self.age > 0 and self.age < 3:
            print("{} can't run".format(self.name))
        else:
            print("please input true age")

    @property  # プライベートな変数を取得する
    def country(self):
        return self._country

    @country.setter  # メソッド名.setter
    def country(self, value):  # プライベートな変数に値を代入する
        self._country = value

    @country.deleter  # メソッド名.deleter
    def country(self):  # プライベートな変数に値を削除する
        del self._country
        print("The attr country is deleted")

    # property関数で上記のデコレーターと同じ機能を実現
    def get_city(self):
        return self._city

    def set_city(self, value):
        self._city = value

    def del_city(self, value):
        del self._city

    city = property(get_city, set_city, del_city, "I'm the 'city' property.")

    @cached_property  # キャッシュされるproperty
    def official_name(self):
        return 'Mr.{} - the Dog'.format(self.name)

david = Dog("David", 2)
david.eating()
# 実行結果：David is eating
david.running  # ()なしで呼び出す
# 実行結果：David can't run
dean = Dog("Dean", 4)
dean.running
# 実行結果：Dean is running

# デコレーターによる方法
david.country = "America"
print(david.country)
# 実行結果：America
del david.country
# 実行結果：The attr country is deleted

# property関数による方法
david.city = "NewYork"
print(david.city)
# 実行結果：NewYork

# キャッシュされるproperty
print(david.official_name)
# 実行結果：Mr.David - the Dog

class Cat(Animal):
    def __init__(self, weight):  # 親クラスの__init__をオーバーライド
        self.__weight = weight
        self._weight = weight + 1
        self.weight = self._weight + 1

    def get_weight(self):
        print("My _weight is {}kg".format(self._weight))

    def get_real_weight(self):
        print("Actually my __weight is {}kg".format(self.__weight))


class BlackCat(Cat):
    def get_weight(self):  # 親クラスのメソッドをオーバーライド
        print("My weight is {}kg".format(self.weight))

    def get_real_weight(self):
        print("Actually my _weight is {}kg".format(self._weight))

    def get_actual_weight(self):
        print("My __weight is exactly {}kg".format(self.__weight))

cole = Cat(5)
print("Cole's weight: {}kg".format(cole.weight))
# 実行結果：Cole's weight: 7kg

# _xは外部からの利用を推奨しないプライベート変数で、利用すること自体は制限されない
print("Cole's _weight: {}kg".format(cole._weight))
# 実行結果：Cole's _weight: 6kg

# __xは外部からの利用をを禁止するプライベート変数で、利用することは制限され、_<class>__xの形で強制的に呼び出せる
print("Cole's __weight: {}kg".format(cole._Cat__weight))
# 実行結果：Cole's __weight: 5kg
cole.get_real_weight()  # メソッドで内部から__xを利用できる
# 実行結果：Actually my __weight is 5kg

cain = BlackCat(5)
cain.get_weight()
# 実行結果：My weight is 7kg

# _xは制限されないため、子クラスからでも呼び出せる
cain.get_real_weight()
# 実行結果：Actually my _weight is 6kg

# 親クラスのプライベート変数の__xを子クラスの内部から素直な方法では利用できない
try:
    cain.get_actual_weight()
except AttributeError as e:
    print(e)
# 実行結果：'Blackcat' object has no attribute '_Blackcat__weight'

class Tiger(Animal):   
    def speak(self):
        return "I'm a tiger not Lulu's song"

    def eat(self):
        return "{} is eating".format(self.name)


class WhiteTiger(Tiger):
    def __init__(self, name, age, height):
        super().__init__(name, age)
        self.height = height

    def speak(self):
        return super().speak().replace("tiger", 'white tiger')

    def eat(self):
        return super().eat()

tony = WhiteTiger("Tony", 10, 100)
print(tony.eat())
# 実行結果：Tony is eating
print(tony.speak())
# 実行結果：I'm a white tiger not Lulu's song

def __init__(self, name, age, height):
    self.name = name
    self.age = age
    self.height = height

def __init__(self, name, age, height):
    Tiger.__init__(self, name, age)
    self.height = height

import collections
import copy
import math
import operator
import pickle
import sys
import asyncio


class Dunder:
    def __abs__(self):
        # abs(Dunder()); 絶対値を計算する時に呼び出される
        return self.x

    def __add__(self, other):
        # Dunder() + 123; 加算をする時に呼び出される
        return self.x + other

    async def __aenter__(self):
        # `__aenter__`と`__aexit__`は一緒に実装しなければならない
        # async with Dunder() as coro; 戻り値はawaitable object限定
        await asyncio.sleep(1)

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        # `__aenter__`と`__aexit__`は一緒に実装しなければならない
        # async with Dunder() as coro; 戻り値はawaitable object限定
        await asyncio.sleep(1)

    def __aiter__(self):
        # `__aiter__`は`__anext__`と一緒に実装しなければならない
        # async for _ in Dunder(); 戻り値はasynchronous iterable object限定
        return self

    def __and__(self, other):
        # Dunder() & 123; 論理積演算をする時に呼び出される
        return self.x & other

    async def __anext__(self):
        # `__aiter__`は`__anext__`と一緒に実装しなければならない
        # async for _ in Dunder(); 要素がなくなったら、StopAsyncIterationを引き起こすべき
        val = await self.readline()
        if val == b'':
            raise StopAsyncIteration
        return val

    def __await__(self):
        # await Dunder(); 戻り値はiterator限定
        return self.z  # `__next__`と`__iter__`を実装したクラス

    def __call__(self, *args, **kwargs):
        # Dunder()(); callable(Dunder()) == True; 関数のように呼び出せる
        return self.x

    def __init__(self, **kwargs):
        # Dunder(y=2); イニシャライザ
        self.x = 1
        self.y = kwargs.get('y')
        self.z = [1, 2, 3]

    def __bool__(self):
        # bool(Dunder()) == True; ブール演算する時に呼び出される
        return True

    def __bytes__(self):
        # bytes(Dunder()); バイト列
        return bytes('123', encoding='UTF-8')

    def __ceil__(self):
        # math.ceil(Dunder()); 切り上げ計算する時に呼び出される
        return math.ceil(self.x)

    def __class_getitem__(cls, item):
        # Dunder[int] == "Dunder[int]"; このメソッドは自動的にクラスメソッドになる
        return f"{cls.__name__}[{item.__name__}]"

    def __complex__(self):
        # complex(Dunder()); 複素数
        return complex(self.x)

    def __contains__(self, item):
        # item not in Dunder(); item in Dunder()
        return True if item in self.z else False

    def __copy__(self):
        # copy.copy(Dunder()); 浅いコピーをする時に呼び出される
        return copy.copy(self.z)

    def __deepcopy__(self, memodict={}):
        # copy.deepcopy(Dunder()); 深いコピーをする時に呼び出される
        return copy.deepcopy(self.z)

    def __del__(self):
        # dunder = Dunder(); del dunder;
        # オブジェクトを削除する時に呼び出される。ガベージコレクションにも対応
        del self

    def __delattr__(self, item):
        # del self.params; インスタンス変数を削除する時に呼び出される
        del self.item

    def __delete__(self, instance):
        # class Owner: dunder = Dunder()
        # del Owner().medusa; ディスクリプタメソッド
        # 所有者クラスの属性として削除する時に呼び出される
        del self.x

    def __delitem__(self, key):
        # del Dunder()['some_key']
        self.__dict__.pop(key)

    def __dir__(self):
        # dir(Dunder()); オブジェクトの全ての属性を格納するiterable objectを返す
        return super().__dir__()

    def __divmod__(self, other):
        # divmod(Dunder(), 123); 割り算の商と余りを同時に取得
        return divmod(self.x, other)

    def __enter__(self):
        # with Dunder() as dunder: pass
        return self

    def __eq__(self, other):
        # Dunder() == 123; 等価演算をする時に呼び出される
        return self.x == other

    def __exit__(self, exc_type, exc_val, exc_tb):
        # with Dunder() as dunder: pass; 引数はそれぞれTypeError、ValueError、Traceback
        return True

    def __float__(self):
        # float(Dunder()); 浮動小数にする
        return float(self.x)

    def __floor__(self):
        # math.floor(Dunder()); 小数点を切り捨てる
        return math.floor(self.x)

    def __floordiv__(self, other):
        # Dunder() // 123; 切り捨て除算する時に呼び出される
        return self.x // other

    def __format__(self, format_spec):
        # '{:x}'format(Dunder()); format(Dunder(), 'x')
        if format_spec == 'x':
            return '{}'.format(self.x)
        return '{}'.format(self.y)

    def __fspath__(self):
        # os.fspath(Dunder()) == '/var/www/html/mysite'; ファイルシステムパスを返す
        return '/var/www/html/mysite'

    def __ge__(self, other):
        # Dunder() >= 123
        return self.x >= other

    def __get__(self, instance, owner):
        # class Test: dunder = Dunder(); ディスクリプタメソッド
        # `Test().dunder`または`Test.dunder`をする時にの時に呼び出される
        return self.x

    def __getattr__(self, item):
        # Dunder().a; 未定義のメンバーにアクセスする時に呼び出される
        return f'object has no attribute "{item}"'

    def __getattribute__(self, item):
        # Dunder().a; 未定義・定義済みにかかわらず、全てのメンバーにアクセスする時に呼び出される
        # `return self.x`などすると無限ループになるのでご注意ください
        return super().__getattribute__(item)

    def __getitem__(self, item):
        # Dunder()[item]
        return self.__dict__.get(item)

    def __getnewargs__(self):
        # pickle.loads(pickle.dumps(Dunder())); unPickleする時に、`__new__`メソッドに渡される引数を定義できる
        # Python 3.6以前にpickle protocol 2または3を利用する時に使われる
        # Python 3.6以降にpickle protocol 2または3を利用する時に`__getnewargs_ex__`が使われる
        # 直接呼び出されるわけではなく、`__reduce__`メソッドを構成している
        return (2 * self.x, )

    def __getstate__(self):
        # pickle.dumps(Dunder()); Pickle処理する時に、オブジェクトの状態を取得できる
        # 直接呼び出されるわけではなく、`__reduce__`メソッドを構成している
        return self.__dict__.copy()

    def __gt__(self, other):
        # Dunder() > 123
        return self.x > 123

    def __hash__(self):
        # hash(Dunder()); ハッシュ値を計算する時に呼び出される
        return hash(self.x)

    def __iadd__(self, other):
        # dunder = Dunder(); dunder += 123; in-placeの加算をする時に呼び出される
        self.x += other
        return self

    def __iand__(self, other):
        # dunder = Dunder(); dunder &= 123; in-placeの論理積演算をする時に呼び出される
        self.x &= other
        return self

    def __ifloordiv__(self, other):
        # dunder = Dunder(); dunder //= 123; in-placeの切り捨て除算をする時に呼び出される
        self.x //= other
        return self

    def __ilshift__(self, other):
        # dunder = Dunder(); dunder <<= 123; in-placeのビット左シフトを計算する時に呼び出される
        self.x <<= other
        return self

    def __imatmul__(self, other):
        # dunder = Dunder(); dunder @= 123; in-placeのバイナリ演算をする時に呼び出される
        # numpyではドット積として実装している
        self.x @= other  # 標準ライブラリでは機能未実装
        return self

    def __imod__(self, other):
        # dunder = Dunder(); dunder %= 123; in-placeの剰余演算をする時に呼び出される
        self.x %= other
        return self

    def __imul__(self, other):
        # dunder = Dunder(); dunder *= 123; in-placeの乗算をする時に呼び出される
        self.x *= 123
        return self

    def __index__(self):
        # slice(Dunder(), Dunder() * 2); bin(Dunder()); hex(Dunder()); oct(Dunder())
        # operator.index(Dunder()); 戻り値は整数限定で、`operator.index`関数から呼び出される
        # また、整数を必要とする`slice`、`bin()`、`hex()`、`oct()`はこのメソッドを呼び出す
        return self.x

    def __init_subclass__(cls, **kwargs):
        # class Test(Dunder, **kwargs): ...; 継承される時に呼び出される
        super().__init_subclass__()
        cls.x = kwargs.get('x', 1)

    def __instancecheck__(self, instance):
        # class MetaClass(type):
        #     def __new__(cls, name, bases, namespace):
        #         return super().__new__(cls, name, bases, namespace)
        #
        #     def __instancecheck__(self, other):
        #         return True
        #
        # class Test(metaclass=MetaClass): ...
        # isinstance(int, Test) == True
        # このメソッドはクラスのタイプ（メタクラス）で定義しないと呼び出されない
        # また、`type(other) == self`の場合は直接Trueになり、呼び出されない
        pass

    def __int__(self):
        # int(Dunder()); 整数に変換する時に呼び出される
        return int(self.x)

    def __invert__(self):
        # ~Dunder(); ビット反転を計算する時に呼び出される
        return ~self.x

    def __ior__(self, other):
        # dunder = Dunder(); dunder |= 123; in-placeの論理和演算をする時に呼び出される
        self.x |= other
        return self

    def __ipow__(self, other):
        # dunder = Dunder(); dunder ** 2; in-placeの冪乗を計算する時に呼び出される
        self.x ** other
        return self

    def __irshift__(self, other):
        # dunder = Dunder(); dunder >>= 2; in-placeのビット右シフトを計算する時に呼び出される
        self.x >>= other
        return self

    def __isub__(self, other):
        # dunder = Dunder(); dunder -= 2; in-placeの減算をする時に呼び出される
        return self

    def __iter__(self):
        # dunder = iter(Dunder()); next(dunder); iterable objectを作成するためのメソッド
        # `__next__`と一緒に実装しなければならない
        self._i = 0
        return self.z[self._i]  # self.zはリストとして定義している

    def __itruediv__(self, other):
        # dunder = Dunder(); dunder /= 123; in-placeの除算をする時に呼び出される
        self.x /= other
        return self

    def __ixor__(self, other):
        # dunder = Dunder(); dunder ^= 123; in-placeの排他的論理和演算をする時に呼び出される
        self.x ^= other
        return self

    def __le__(self, other):
        # dunder = Dunder(); dunder <= 123
        return self.x <= other

    def __len__(self):
        # len(Dunder())
        return len(self.z)

    def __lshift__(self, other):
        # Dunder() << 123; ビット左シフトを計算する時に呼び出される
        return self.x << other

    def __lt__(self, other):
        # Dunder() < 123
        return self.x < other

    def __matmul__(self, other):
        # Dunder() @ 123; バイナリ演算をする時に呼び出される
        return self.x @ other  # 標準ライブラリでは機能未実装

    def __missing__(self, key):
        # class Dict(dict):
        #     def __missing__(self, key):
        #         return f'__missing__({key})'
        # dunder = Dict({'key': 1})
        # print(dunder['unk_key'])
        # 辞書内にキーが存在しない時に呼び出されるメソッド
        pass

    def __mod__(self, other):
        # Dunder() % 123; 剰余演算をする時に呼び出される
        return self.x % other

    def __mro_entries__(self, bases):
        # クラス定義の親リストにクラスオブ ジェクトではないものが指定された時に呼ばれる
        # 型アノテーションの実装で、継承関係を正しくするためのメソッド
        # https://www.python.org/dev/peps/pep-0560/#mro-entries
        pass

    def __mul__(self, other):
        # Dunder() * 123; 乗算をする時に呼び出される
        return self.x * ohter

    def __ne__(self, other):
        # Dunder() != 123; 不等価演算をする時に呼び出される
        return self.x != other

    def __neg__(self):
        # -Dunder(); 反数を計算する時に呼び出される
        return -self.x

    def __new__(cls, *args, **kwargs):
        # Dunder(); コンストラクタ
        # __init__や他のインスタンスメソッドで使われるself（インスタンスそのもの）を作成する
        return super().__new__(cls)

    def __next__(self):
        # dunder = iter(Dunder()); next(dunder); iterable objectを作成するためのメソッド
        # `__iter__`と一緒に実装しなければならない
        self._i += 1
        return self.z[self._i]

    def __or__(self, other):
        # Dunder() | 132; 論理和演算をする時に呼び出される
        return self.x | other

    def __pos__(self):
        # +Dunder(); 正数に変換する時に呼び出される
        return +self.x

    def __post_init__(self):
        # データクラス用のメソッドで、`__init__`が定義されている場合のみ、`__init__`の後に呼び出される
        pass

    def __pow__(self, power, modulo=None):
        # Dunder() ** 123; 冪乗を計算する時に呼び出される
        if modulo:
            return self.x ** power % modulo
        else:
            return self.x ** power

    @classmethod
    def __prepare__(metacls, name, bases, **kwargs):
        # class MetaClass(type):
        #     def __new__(cls, name, bases, namespace):
        #         return super().__new__(cls, name, bases, namespace)
        #
        #     @classmethod
        #     def __prepare__(cls, name, bases, **kwargs):
        #         return dict()
        #
        # class Test(metaclass=MetaClass): ...
        # namespace = MetaClass.__prepare__(name, bases, **kwargs)
        # クラス本体を評価する前に呼び出されて、クラスメンバを格納する辞書形オブジェクト（名前空間）を返す
        # 通常`types.prepare_class`と一緒に使用する
        # このメソッドはメタクラスでクラスメソッドとして定義しないと呼び出されない
        return collections.OrderedDict()

    def __radd__(self, other):
        # 123 + Dunder(); 被演算子が反射した加算をする時に呼び出される
        return other + self.x

    def __rand__(self, other):
        # 123 & Dunder(); 被演算子が反射した論理積演算をする時に呼び出される
        return other & self.x

    def __rdiv__(self, other):
        # 123 / Dunder(); 被演算子が反射した除算をする時に呼び出される
        return other / self.x

    def __rdivmod__(self, other):
        # divmod(123, Dunder()); 被演算子が反射した割り算の商と余りを同時に取得
        return divmod(other, self.x)

    def __reduce__(self):
        # pickle.dumps(Dunder())
        # `__getstate__`、`__setstate__`、`__getnewargs__`を利用し、Pickleの挙動をコントロールできる
        # なるべく`__reduce__`を直接定義せず、上記のメソッドを定義するこること
        # 後方互換の`__reduce_ex__`が定義されると優先的に使用される
        return super().__reduce__() # return super().__reduce_ex__(protocol)

    def __repr__(self):
        # repr(Dunder()); オブジェクトの印字可能な表現を含む文字列を返す
        return super().__repr__()

    def __reversed__(self):
        # reversed(Dunder()); 反転したiterator objectを返す
        new_instance = copy.deepcopy(self)
        new_instance.z = new_instance.z[::-1]
        return new_instance

    def __rfloordiv__(self, other):
        # 123 // Dunder(); 被演算子が反射した切り捨て除算をする時に呼び出される
        return other // self.x

    def __rlshift__(self, other):
        # 123 << Dunder(); 被演算子が反射したビット左シフトを計算する時に呼び出される
        return '__rlshift__'

    def __rmatmul__(self, other):
        # 123 @ Dunder(); 被演算子が反射したバイナリ演算をする時に呼び出される
        return other @ self.x  # 標準ライブラリでは機能未実装

    def __rmod__(self, other):
        # 123 % Dunder(); 被演算子が反射した剰余演算をする時に呼び出される
        return other % self.x

    def __rmul__(self, other):
        # 123 * Dunder(); 被演算子が反射した乗算をする時に呼び出される
        return other * self.x

    def __ror__(self, other):
        # 123 | Dunder(); 被演算子が反射した論理和演算をする時に呼び出される
        return other | self.x

    def __round__(self, n=None):
       # round(Dunder()); 四捨五入
        return round(self.x)

    def __rpow__(self, other):
        # 123 ** Dunder(); 被演算子が反射した冪乗を計算する時に呼び出される
        return other ** self.x

    def __rrshift__(self, other):
        # 123 >> Dunder(); 被演算子が反射したビット右シフトを計算する時に呼び出される
        return other >> self.x

    def __rshift__(self, other):
        # Dunder() >> 123; ビット右シフトを計算する時に呼び出される
        return self.x >> other

    def __rsub__(self, other):
        # 123 - Dunder(); 被演算子が反射した減算をする時に呼び出される
        return other - self.x

    def __rtruediv__(self, other):
        # 123 / Dunder(); 被演算子が反射した除算をする時に呼び出される
        return other / self.x

    def __rxor__(self, other):
        # 123 ^ Dunder(); 被演算子が反射した排他的論理和を計算する時に呼び出される
        return other ^ self.x

    def __set__(self, instance, value):
        # class Test: dunder = Dunder(); ディスクリプタメソッド
        # `Test().dunder=123`または`Test.dunder=123`をする時にの時に呼び出される
        instance.x = value

    def __set_name__(self, owner, name):
        # ディスクリプタの変数名のアサイン
        # class Test: pass; オーナークラスが作成される時に自動的に呼び出されるが、
        # dunder = Dunder(); 後でバンディングする時は明示的に呼び出す必要がある
        # Test.dunder = dunder
        # dunder.__set_name__(Test, 'dunder')
        # dunderというディスクリプタをTestクラスの命名空間の'dunder'にアサインする
        owner.__dict__[name] = self

    def __setattr__(self, key, value):
        # dunder = Dunder(); dunder.x = 123; 属性設定する時に呼び出される
        self.__dict__[key] = value

    def __setitem__(self, key, value):
        # dunder = Dunder(); dunder['x'] = 123; ; 添字で属性を設定する時に呼び出される
        self.__dict__[key] = value

    def __setstate__(self, state):
        # pickle.loads(pickle.dumps(Dunder()))
        # unPickleする時に、`__getstate__`で取得しといたオブジェクトの状態を利用できる
        # 直接呼び出されるわけではなく、`__reduce__`メソッドを構成している
        self.__dict__.update(state)

    def __sizeof__(self):
        # sys.getsizeof(Dunder()); オブジェクトのサイズを返す
        return super().__sizeof__()

    def __str__(self):
        # str(Dunder())
        # print(Dunder())
        # オブジェクトの文字列表現を定義する
        return f'{self.x}'

    def __sub__(self, other):
        # Dunder() - 123; 減算をする時に呼び出される
        return self.x - other

    def __subclasscheck__(self, subclass):
        # class MetaClass(type):
        #     def __new__(cls, name, bases, namespace):
        #         return super().__new__(cls, name, bases, namespace)
        #
        #     def __subclasscheck__(self, subclass):
        #         return True
        #
        # class Test(metaclass=MetaClass): ...
        # issubclass(int, Test) == True
        # このメソッドはクラスのタイプ（メタクラス）で定義しないと呼び出されない
        return NotImplemented

    @classmethod
    def __subclasshook__(cls, subclass):
        # class Test: x = 1; # クラス変数を定義
        # issubclass(Test, Dunder) == True
        # このメソッドは仮想基底クラスのクラスメソッドとして定義しなければならない
        if cls is Dunder:
            return hasattr(subclass, 'x')

    def __truediv__(self, other):
        # Dunder() // 123; 切り捨て除算をする時に呼び出される
        return self.x // other

    def __trunc__(self):
        # math.trunc(Dunder()); 端数処理をする時に呼び出される
        return int(self.x)

    def __xor__(self, other):
        # Dunder() ^ 123; 排他的論理和演算をする時に呼び出される
        return self.x ^ other

print(object)
# 実行結果：<class 'object'>
print(type)
# 実行結果：<class 'type'>

print(object.__class__)
# 実行結果：<class 'type'>
print(object.__bases__)  # 継承関係の頂点なので、それ以上は存在しない
# 実行結果：()
print(type.__class__)  # type自身もtypeのインスタンス
# 実行結果：<class 'type'>
print(type.__bases__)
# 実行結果：(<class 'object'>,)

print(list.__bases__)
# 実行結果：(<class 'object'>,)
print(list.__class__)
# 実行結果：<class 'type'>
print(dict.__bases__)
# 実行結果：(<class 'object'>,)
print(dict.__class__)
# 実行結果：<class 'type'>
print(tuple.__bases__)
# 実行結果：(<class 'object'>,)
print(tuple.__class__)
# 実行結果：<class 'type'>

mylist = [1, 2, 3]
print(mylist.__class__)
# 実行結果：<class 'list'>
print(mylist.__bases__)
# 実行結果：
# ---------------------------------------------------------------------------
# AttributeError                            Traceback (most recent call last)
# <ipython-input-21-0b850541e51b> in <module>
# ----> 1 print(mylist.__bases__)
#
# AttributeError: 'list' object has no attribute '__bases__'

class C:  # Python3ではクラスはデフォルトでobjectを継承する
    pass
print(C.__bases__)
# 実行結果：(<class 'object'>,)
c = C()
print(c.__class__)
# 実行結果：<class '__main__.C'>
print(c.__bases__)
# 実行結果：
# ---------------------------------------------------------------------------
# AttributeError                            Traceback (most recent call last)
# <ipython-input-30-bf9b854689d5> in <module>
# ----> 1 print(c.__bases__)
#
# AttributeError: 'C' object has no attribute '__bases__'

class M(type):
    pass
print(M.__class__)
# 実行結果：<class 'type'>
print(M.__bases__)
# 実行結果：(<class 'type'>,)

class TM(metaclass=M):
    pass
print(TM.__class__)
# 実行結果：<class '__main__.M'>
print(TM.__bases__)
# 実行結果：(<class 'object'>,)

class ObjectCreater:
    pass
my_object = ObjectCreater()
print(my_object)
# 実行結果：<__main__.ObjectCreater object at 0x7fbc76f9a970>

class ObjectCreator:
    pass


def echo(obj):
    print(obj)


echo(ObjectCreator)  # 引数として渡す

ObjectCreator.new_attr = 'foo'  # 属性を増やす
assert hasattr(ObjectCreator, 'new_attr') == True

ObjectCreatorMirror = ObjectCreator  # 他の変数に代入する

def choose_class(name):
    if name == 'foo':
        class Foo:
            pass
        return Foo
    else:
        class Bar:
            pass
        return Bar


MyClass = choose_class('foo')
print(MyClass)
print(MyClass())

<class '__main__.choose_class.<locals>.Foo'>
<__main__.choose_class.<locals>.Foo object at 0x7fad2abc8340>

print(type(1))
# 実行結果：<class 'int'>
print(type('1'))
# 実行結果：<class 'str'>
print(type(ObjectCreatorMirror))
# 実行結果：<class 'type'>

MyShinyClass = type("MyShinyClass", (), {})
print(MyShinyClass)
print(MyShinyClass())

<class '__main__.MyShinyClass'>
<__main__.MyShinyClass object at 0x7f9cd02bddc0>

class Foo:
    bar = True

    def echo_bar(self):
        print(self.bar)

def echo_bar(self):
    print(self.bar)


Foo = type('Foo', (), {'bar': True, 'echo_bar': echo_bar})

class FooChild(Foo):
    pass

FooChild = type('FooChild', (Foo, ), {})

x = 30
print(x.__class__)
# 実行結果：<class 'int'>
print(x.__class__.__class__)
# 実行結果：<class 'type'>

class Meta(type):
    pass


class Foo(metaclass=Meta):
    pass

import types


class A(type):
    expected_ns = {}

    def __new__(cls, name, bases, namespace):
        return type.__new__(cls, name, bases, namespace)

    @classmethod
    def __prepare__(cls, name, bases, **kwargs):
        expected_ns.update(kwargs)
        return expected_ns


B = types.new_class("B", (object,))
C = types.new_class("C", (object,), {"metaclass": A})

# メタクラスの継承チェーンで1番近いのはtypeではなく、Aになる
meta, ns, kwds = types.prepare_class("D", (B, C), {"metaclass": type, 'x': 1})

assert meta is A  # 継承チェーンの1番下にあるメタクラスAが選択されたのが確認できる
assert ns is expected_ns  # Aの__prepare__が使用されているのが確認できる
print(kwds)  # metaclassキーワード引数が削除されたのが確認できる（適切なメタクラスは戻り値として返したため）
# 実行結果：{'x': 1}

class UpperAttrMetaClass(type):
    # __new__はインスタンスselfを作成するコンストラクタ
    # __init__は作成されたインスタンスselfを初期化するイニシャライザ
    def __new__(cls, new_class_name,
                new_class_parents, new_class_attr):
        uppercase_attr = {}
        for name, val in new_class_attr.items():
            # 特殊メソッドを除く
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val
        return type.__new__(cls, new_class_name, new_class_parents, new_class_attr)
        # 下の書き方と同様
        # return super().__new__(cls, new_class_name, new_class_parents, new_class_attr)

from django.db import models


class Person(models.Model):
    name = models.CharField(max_length=30)
    age = models.IntegerField()


guy = Person.objects.get(name='bob')
print(guy.age)  # output is 35

class Student:
    def __init__(self, name, score):
        self.name = name
        self._score = score

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            print('Please input an int')
            return
        self._score = value

import os


class DirectorySize:
    def __get__(self, instance, owner):
        return len(os.listdir(instance.dirname))


class Directory:
    size = DirectorySize()  # ディスクリプタ

    def __init__(self, dirname):
        self.dirname = dirname


debug = Directory('debug')
print(debug.size)

print(vars(debug))
# 実行結果：{'dirname': 'debug'}

import logging


logging.basicConfig(level=logging.INFO)


class LoggedAgeAccess:
    def __get__(self, instance, owner):
        value = instance._age
        logging.info('Accessing %r giving %r', 'age', value)
        return value

    def __set__(self, instance, value):
        logging.info('Updating %r to %r', 'age', value)
        instance._age = value


class Person:
    age = LoggedAgeAccess()  # ディスクリプタ

    def __init__(self, name, age):
        self.name = name  # 普通のインスタンス変数
        self.age = age  # ディスクリプタを呼び出す

    def birthday(self):
        self.age += 1  # __get__と__set__両方が呼び出される


mary = Person('Mary M', 30)
mary.age
mary.birthday()

INFO:root:Updating 'age' to 30
INFO:root:Accessing 'age' giving 30
INFO:root:Accessing 'age' giving 30
INFO:root:Updating 'age' to 31

print(vars(mary))
# 実行結果：{'name': 'Mary M', '_age': 31}

import sqlite3


conn = sqlite3.connect('entertainment.db')


class BaseModel(type):
    def __new__(cls, clsname, bases, attrs):
        table = attrs.get('table')
        if table:
            columns = [k for k in attrs.keys() if k != 'table' and not k.startswith('__')]
            # ダミーのデータ型を付与
            columns_with_type = [c + ' TEXT PRIMARY KEY' if attrs[c].is_primary_key
                                 else c + ' TEXT'
                                 for c in columns]
            # テーブルの作成
            create_table = f"CREATE TABLE IF NOT EXISTS {table} ({', '.join(columns_with_type)});"
            conn.execute(create_table)
            conn.commit()
            attrs['_columns_'] = columns  # 各モデルのカラム名を格納

        return super().__new__(cls, clsname, bases, attrs)


class Model(metaclass=BaseModel):
    def __init__(self, *args):
        self.args = args  # レコードの各カラムの値を格納
        columns = self._columns_
        table = self.table
        primary_key = self.primary_key
        self.primary_key_value = args[columns.index(primary_key)]
        c = conn.execute(f'SELECT * FROM {table} WHERE {primary_key}=?;',
                         (self.primary_key_value,)).fetchone()
        if not c:
            params = [':' + c for c in type(self).__dict__.get('_columns')]
            conn.execute(f"INSERT INTO {table} VALUES ({' ,'.join(params)});", args)
            conn.commit()


class Field:
    def __init__(self, primary_key=False):
        self.is_primary_key = primary_key

    def __set_name__(self, owner, name):
        if self.is_primary_key:
            owner.primary_key = name
        self.fetch = f'SELECT {name} FROM {owner.table} WHERE {owner.primary_key}=?;'
        self.store = f'UPDATE {owner.table} SET {name}=? WHERE {owner.primary_key}=?;'

    def __get__(self, instance, owner):
        return conn.execute(self.fetch, [instance.primary_key_value]).fetchone()[0]

    def __set__(self, instance, value):
        conn.execute(self.store, [value, instance.primary_key_value])
        conn.commit()
        if self.is_primary_key:
            instance.primary_key_value = value


class MovieModel(Model):
    table = 'Movie'
    title = Field(primary_key=True)
    director = Field()
    year = Field()


class MusicModel(Model):
    table = 'Music'
    title = Field(primary_key=True)
    artist = Field()
    year = Field()
    genre = Field()


star_wars = MovieModel('Star Wars', 'George Lucas', '1977')
print(f'{star_wars.title} released in {star_wars.year} by {star_wars.director}')
star_wars.director = 'J.J. Abrams'
print(star_wars.director)
country_roads = MusicModel('Country Roads', 'John Denver', '1973', 'country')
print(f'{country_roads.title} is a {country_roads.genre} song of {country_roads.artist}')

Star Wars released in 1977 by George Lucas
J.J. Abrams
Country Roads is a country song of John Denver

class Descriptor:
    def __get__(self, instance, owner):
        return self._x

    def __set__(self, instance, value):
        self._x = value


class B:
    x = Descriptor()

    def __init__(self, x):
        self.x = x

    def __getattribute__(self, key):
        attr = type(self).__dict__[key]
        if hasattr(attr, '__get__'):
            return attr.__get__(self, type(self))
        else:
            return attr

class Property:
    def __init__(self, fget=None, fset=None, fdel=None, doc=None):
        self.fget = fget
        self.fset = fset
        self.fdel = fdel
        if doc is None and fget is not None:
            doc = fget.__doc__
        self.__doc__ = doc

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        if self.fget is None:
            raise AttributeError("unreadable attribute")
        return self.fget(obj)

    def __set__(self, obj, value):
        if self.fset is None:
            raise AttributeError("can't set attribute")
        self.fset(obj, value)

    def __delete__(self, obj):
        if self.fdel is None:
            raise AttributeError("can't delete attribute")
        self.fdel(obj)

    def getter(self, fget):
        return type(self)(fget, self.fset, self.fdel, self.__doc__)

    def setter(self, fset):
        return type(self)(self.fget, fset, self.fdel, self.__doc__)

    def deleter(self, fdel):
        return type(self)(self.fget, self.fset, fdel, self.__doc__)

class MethodType:
    def __init__(self, func, obj):
        self.__func__ = func
        self.__self__ = obj

    def __call__(self, *args, **kwargs):
        func = self.__func__
        obj = self.__self__
        return func(obj, *args, **kwargs)

class Function:
    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return MethodType(self, obj)

class ClassMethod:
    def __init__(self, f):
        self.f = f

    def __get__(self, obj, cls=None):
        if cls is None:
            cls = type(obj)
        if hasattr(obj, '__get__'):
            return self.f.__get__(cls)
        return MethodType(self.f, cls)

class StaticMethod:
    def __init__(self, f):
        self.f = f

    def __get__(self, obj, objtype=None):
        return self.f

from types import DynamicClassAttribute


class EnumMeta(type):
    def __new__(cls, name, bases, namespace):
        reserved_names = ('name', 'value', 'values')
        enum_namespace = namespace.copy()
        enum_namespace['_member_map_'] = {}
        enum_namespace['_member_map_']['values'] = []
        for k, v in namespace.items():
            if not (k in reserved_names or k.startswith('_')):
                member_namespace = namespace.copy()
                member_namespace.update({"_name_": k, "_value_": v})
                member_cls = super().__new__(cls, name, bases, member_namespace)
                enum_namespace['_member_map_']['values'].append(v)
                enum_namespace['_member_map_'][k] = member_cls()
                enum_namespace[k] = enum_namespace['_member_map_'][k]

        return super().__new__(cls, name, bases, enum_namespace)

    def __getattr__(self, item):
        return self._member_map_[item]


class Enum(metaclass=EnumMeta):
    @DynamicClassAttribute
    def name(self):
        return self._name_

    @DynamicClassAttribute
    def value(self):
        return self._value_

    @DynamicClassAttribute
    def values(self):
        return self._values_


class Color(Enum):
    red = 1
    blue = 2
    green = 3


print(Color.red.value)
# 実行結果：1
Color.red._values_ = [1]
print(Color.red.values)  # インスタンスのvalues
# 実行結果：[1]
print(Color.values)  # クラスのvalues
# 実行結果：[1, 2, 3]

class Student:
    __slots__ = ('name', 'age')


student = Student()

student.name = 'Mike'
student.age = 20

student.grade = 'A'
# 実行結果：
# Traceback (most recent call last):
#   File "oop.py", line 10, in <module>
#     student.grade = 'A'
# AttributeError: 'Student' object has no attribute 'grade'

class RESTAPIMeta(type):
    def __instancecheck__(cls, instance):
        return cls.__subclasscheck__(type(instance))

    def __subclasscheck__(cls, subclass):
        return (hasattr(subclass, 'get') and
                callable(subclass.get) and
                hasattr(subclass, 'post') and
                callable(subclass.post))


class RESTAPIInterface(metaclass=RESTAPIMeta):
    ...


class ItemList:
    def get(self, id):
        pass

    def post(self, id):
        pass


class UserList:
    def get(self, id):
        pass


print(issubclass(ItemList, RestAPIInterface))
# 実行結果：True
print(ItemList.__mro__)
# 実行結果：(<class '__main__.ItemList'>, <class 'object'>)
print(issubclass(UserList, RestAPIInterface))
# 実行結果：False

import abc


class RestAPIInterface(metaclass=abc.ABCMeta):
    @classmethod
    def __subclasshook__(cls, subclass):
        return (hasattr(subclass, 'get') and
                callable(subclass.get) and
                hasattr(subclass, 'post') and
                callable(subclass.post))


class ItemList:
    def get(self, id):
        pass

    def post(self, id):
        pass


class UserList:
    def get(self, id):
        pass


print(issubclass(ItemList, RestAPIInterface))
# 実行結果：True
print(ItemList.__mro__)
# 実行結果：(<class '__main__.ItemList'>, <class 'object'>)
print(issubclass(UserList, RestAPIInterface))
# 実行結果：False

import abc


class RestAPIInterface(metaclass=abc.ABCMeta):
    ...


class UserList:
    def get(self, id):
        pass


RestAPIInterface.register(UserList)
print(issubclass(UserList, RestAPIInterface))
# 実行結果：True

import abc


class RestAPIInterface(metaclass=abc.ABCMeta):
    ...


@RestAPIInterface.register
class UserList:
    def get(self, id):
        pass


print(issubclass(UserList, RestAPIInterface))

import abc


class RestAPIInterface(metaclass=abc.ABCMeta):
    ...


class UserList:
    def get(self, id):
        pass


token_old = abc.get_cache_token()
RestAPIInterface.register(UserList)
token_new = abc.get_cache_token()

print(f'{token_old} >>> {token_new}')
# 実行結果：36 >>> 37

import abc


class RestAPIInterface(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def get(self, id):
        raise NotImplementedError

    @abc.abstractmethod
    def post(self, id):
        raise NotImplementedError


class ItemList(RestAPIInterface):
    def get(self, id):
        pass

    def post(self, id):
        pass


class UserList(RestAPIInterface):
    def get(self, id):
        pass


item_list = ItemList()
user_list = UserList()

Traceback (most recent call last):
  File "resource.py", line 29, in <module>
    user_list = UserList()
TypeError: Can't instantiate abstract class UserList with abstract methods post

import abc


class Model(abc.ABC):
    @classmethod
    @abc.abstractmethod
    def select_all(cls):
        ...

    @staticmethod
    @abc.abstractmethod
    def show_db_name(age):
        ...

    @property
    @abc.abstractmethod
    def row_id(self):
        ...

import abc


class StaticMethod:
    def __init__(self, f):
        self.f = f

    def __get__(self, obj, objtype=None):
        return self.f

    @property
    def __isabstractmethod__(self):
        return getattr(self.f, '__isabstractmethod__', False)


class Model(abc.ABC):
    @StaticMethod
    @abc.abstractmethod
    def show_db_name():
        ...


class ItemModel(Model):
    pass


item_model = ItemModel()
# 実行結果：
Traceback (most recent call last):
  File "oop.py", line 27, in <module>
    item_model = ItemModel()
TypeError: Can't instantiate abstract class ItemModel with abstract methods show_db_name