login_manager.login_view = "users.login"

dougdrums fucked around with this message at 19:39 on Mar 9, 2017

dougdrums fucked around with this message at 18:37 on Apr 25, 2017

dougdrums fucked around with this message at 20:49 on Sep 7, 2017

for i in range(100):
    print(i)

def take_screenshot(x, y, *args):
    pyautogui.click(x, y)
    return screenshot.grab(*args)

for index, image in zip(count, partial(take_screenshot, x, y)):
    image.save(f'filename{index}.png')

dougdrums fucked around with this message at 17:34 on Jun 10, 2018

import operator as op
map(op.and, zip(a, b, c))

map(all, zip(a, b, c))

dougdrums fucked around with this message at 09:59 on Aug 3, 2018

list(map(all, zip(a, b, c)))

dougdrums fucked around with this message at 11:50 on Aug 3, 2018

dougdrums fucked around with this message at 14:02 on Aug 23, 2018

dougdrums fucked around with this message at 21:57 on Feb 5, 2019

dougdrums fucked around with this message at 03:09 on Mar 13, 2019

dougdrums fucked around with this message at 16:42 on Mar 30, 2019

def unfuck_table(filename, header_size=2):
    import re
    from itertools import chain, tee, groupby
    from operator import itemgetter
    regex = re.compile(r'\b\w+\b')
    with open(filename) as file:
        def scan(line):
            match = regex.search(line)
            while match:
                yield match.group(0), match.span()
                match = regex.search(line, pos=match.end())
        parts, other_parts = tee(map(list, map(scan, file)))
        spans = map(itemgetter(1), chain(*other_parts))
        def overlaps(a, b):
            return max(a[0], b[0]) <= min(a[1], b[1])
        def union(a, b):
            return min(a[0], b[0]), max(a[1], b[1])
        guides = []
        for span in spans:
            def search():
                for i, guide in enumerate(guides):
                    if overlaps(span, guide):
                        guides[i] = union(span, guide)
                        return
                guides.append(span)
            search()
        guides = sorted(guides, key=itemgetter(0))
        def within(a, b):
            return a[0] >= b[0] and a[1] <= b[1]
        def range_to_column(r):
            return next( i 
                for i, guide in enumerate(guides) 
                if within(r, guide))
        columnized = [
            [ (data, range_to_column(r)) for data, r in part ]
            for part in parts ]
        data = columnized[header_size:]
        header = sorted(chain(*columnized[:header_size]), key=itemgetter(1))
        header = ([ ' '.join(map(itemgetter(0), groups))
            for _, groups in groupby(header, key=itemgetter(1)) ])
        assert len(header) == len(guides)
        data = [ list(map(itemgetter(0), row)) for row in data ]
        return [ header ] + data

dougdrums fucked around with this message at 18:21 on Apr 2, 2019

dougdrums fucked around with this message at 02:03 on Apr 4, 2019

dougdrums fucked around with this message at 02:54 on Apr 4, 2019

dougdrums fucked around with this message at 07:05 on Apr 9, 2019

def paint_color(color : Color):
  return paint({
    Color.RED: '#ff0000',
    Color.GREEN: '#00ff00',
    Color.BLUE: '#0000ff'
  }.get(color, '#000000'))

def route(page : str, *args):
  return {
    'index': index_view,
    'about': about_view,
    'contact': contact_view,
  }.get(page, not_found_view)(*args)

dougdrums fucked around with this message at 02:41 on May 10, 2019

def f(x):
  if x < 2:
    return x*x
  if x == 2:
    return 6
  if x <= 6:
    return 10 - x
  raise ValueError('x is only defined in (-inf, 6]')
y = f(z)

• You're forced to give it a name, possibly obliviating the need for a comment anyways.
  
• You can be certain of the state of the rest of the function, outside of the scope of your branches.
  
• It's not possible to return from the outer function within your branches, complicating control flow.
  
• It can be typed and the type can be validated, if thats your thing.