Stop Writing Classes (Jack Diederich, PyCon US 2012)

01_greeting_class.py

class Greeting:
    def __init__(self, greeting='hello'):
        self.greeting = greeting

    def greet(self, name):
        return f'{self.greeting}! {name}'

greeting = Greeting('hola')
print(greeting.greet('bob'))

02_greeting_function.py

def greet(name):
    ob = Greeting('hola')
    print(ob.greet('bob))
    return

def greet(greeting, target):
    return f'{greeting}! {target}'

03_functools_partial.py

import functools
greet = functools.partial(greet, 'hola')
greet('bob')

04_muffinhash.py

# MuffinHash.py is a module containing two lines.
class MuffinHash(dict):
    pass

# Everywhere in the code has
d = MuffinMail.MuffinHash.MuffinHash(foo=3)  # d = {'foo': 3}

05_api_v2.py

class API:
    def __init__(self, key):
        self.header = dict(apikey=key)
    
    def call(self, method, params):
        request = urllib2.Request(
            self.url + method[0] + '/' + method[1],
            urllib.urlencode(params),
            self.header
        )
        try:
            response = json.loads(urllib2.urlopen(request).read())
            return response
        except urllib2.HTTPError as error:
            return dict(Error=str(error))

06_api_v3.py

MUFFIN_API_URL = 'https://api.wbsrvc.com/%s/%s'
MUFFIN_API_KEY = 'SECRET-API-KEY'

def request(noun, verb, **params):
    headers = {'apikey': MUFFIN_API_KEY}
    request = urllib2.Request(
        MUFFIN_API_URL % (noun, verb),
        urllib.urlencode(params), headers)
    return json.loads(urllib2.urlopen(request).read())

07_custom_exception.py

try:
    get_article()
    raise LookupError() # this raises an exception
except ArticleNotFound:  # this catches an exception
    pass

08_flow_class.py

class Flow:
    """Base class for all Flow objects."""
    pass

class Storage:
    def put(self, data): _abstract()
    def get(self): _abstract()

def _abstract(): raise NotImplementedError

09_conways_game_of_life_class.py

class Cell:
    def __init__(self, x, y, alive=True):
        self.x = x
        self.y = y
        self.alive = alive
        self.next = None

    def neighbors(self):
        yield (self.x + 1, self.y)
        yield (self.x + 1, self.y + 1)
        # ...
        yield (self.x + 1, self.y)

class Board:
    def __init__(self):
        self.cells = {}  # { (x, y) : Cell() }
    
    def advance(self):
        for (x, y), cell in self.cells.items():
            if len(cell.neighbors) > 3:
                cell.next = False

10_conways_game_of_life_functions.py

def neighbors(point):
    x, y = point
    yield x + 1, y
    yield x - 1, y
    yield x, y + 1
    yield x, y - 1
    yield x + 1, y + 1
    yield x + 1, y - 1
    yield x - 1, y + 1
    yield x - 1, y - 1

def advance(board):
    newstate = set()
    recalc = board | set(itertools.chain(*map(neighbors, board)))
    for point in recalc:
        count = sum((neigh in board)
                    for neigh in neighbors(point))
        if count == 3 or (count == 2 and point in board):
            newstate.add(point)
    return newstate

glider = set([(0, 0), (1, 0), (2, 0), (0, 1), (1, 2)])

for i in range(1000):
    glider = advance(glider)
print(glider)