Polymorfism och duck typing

class Cat:
    def speak(self): return 'Meow'
class Dog:
    def speak(self): return 'Woof'
for animal in [Cat(), Dog()]:
    print(animal.speak())

class Duck:
    def quack(self): return 'Quack'
class Person:
    def quack(self): return 'I am quacking like a duck'
def make_it_quack(duck):
    print(duck.quack())
make_it_quack(Duck())
make_it_quack(Person())

for obj in ['hello', [1,2,3], {'a':1}]:
    print(type(obj).__name__, len(obj))

print(1 + 2)        # int addition
print('a' + 'b')    # string concat
print([1] + [2])    # list concat

class Squares:
    def __init__(self, n): self.n,self.i=n,0
    def __iter__(self): return self
    def __next__(self):
        if self.i>=self.n: raise StopIteration
        x=self.i**2; self.i+=1; return x
print(list(Squares(5)))

# LBYL:
if hasattr(obj, 'quack'):
    obj.quack()
# EAFP (Pythonic):
try:
    'hello'.quack()
except AttributeError:
    print('no quack')

def process(data):
    if isinstance(data, str):
        return data.upper()
    elif isinstance(data, list):
        return [x*2 for x in data]
print(process('hi'))
print(process([1,2,3]))

from abc import ABC, abstractmethod
class Drawable(ABC):
    @abstractmethod
    def draw(self): pass
class Circle(Drawable):
    def draw(self): print('O')
Circle().draw()

from typing import Protocol
class Quackable(Protocol):
    def quack(self) -> str: ...
def make_quack(x: Quackable) -> str:
    return x.quack()
print('protocol demo')

class JSONSerializer:
    def serialize(self, obj): import json; return json.dumps(obj)
class XMLSerializer:
    def serialize(self, obj): return f'<data>{obj}</data>'
def export(data, serializer):
    return serializer.serialize(data)
print(export({'x': 1}, JSONSerializer()))