Switch earlier solutions to use python3, tidy.

01.py

-#!/usr/bin/python
+#!/usr/bin/python3
 
-from enum import IntEnum
 import math
 import operator
 
+
 def steps(start, delta, count):
     sign = int(math.copysign(1, delta))
     return [start] * count if delta == 0 else range(start + sign, start + delta + sign, sign)
 history = [(0, 0)]
 for move in moves:
     heading = (heading + move[0]) % 4
-    delta = map(operator.mul, direction_lookup[heading], (move[1], move[1]))
+    delta = list(map(operator.mul, direction_lookup[heading], (move[1], move[1])))
     delta_mag = max(abs(delta[0]), abs(delta[1]))
     history += zip(steps(history[-1][0], delta[0], delta_mag),
                    steps(history[-1][1], delta[1], delta_mag))

02.py

-#!/usr/bin/python
+#!/usr/bin/python3
 
 import operator
 
                                        (2, 4): 'D'}}
 
 for part, keys in parts.items():
-    pos = keys.keys()[keys.values().index('5')]
+    pos = list(keys.keys())[list(keys.values()).index('5')]
     ans = ''
     for line in input:
         for move in map(dirs.get, line):

03.py

-#!/usr/bin/python
+#!/usr/bin/python3
 
 from itertools import chain
 

04.py

-#!/usr/bin/python
+#!/usr/bin/python3
 
 import re
 from collections import namedtuple

09.py

 # Version of parse() that recursively parses repeated sections
 rparse = lambda x: parse(x, rparse)
 
+
 def parse(data, rfun=len):
-	# Find the first bracketed part (if one exists)
-	index, bracket = data.find('('), data.find(')')
-	if index == -1: return len(data)
-
-	# Grab the (NxR) values from the brackets
-	num, reps = map(int, data[index+1:bracket].split('x'))
-	
-	# Return the initial, non-repeated data, plus...
-	return (len(data[:index])
-			# the repeated data, potentially parsed recursively, plus...
-	        + reps * rfun(data[bracket+1:bracket+1+num]) 
-	        # the remainder of the string, parsed
-	        + parse(data[bracket+1+num:], rfun))
+    # Find the first bracketed part (if one exists)
+    index, bracket = data.find('('), data.find(')')
+    if index == -1: return len(data)
+
+    # Grab the (NxR) values from the brackets
+    num, reps = map(int, data[index + 1:bracket].split('x'))
+
+    # Return the initial, non-repeated data, plus...
+    return (len(data[:index])
+            # the repeated data, potentially parsed recursively, plus...
+            + reps * rfun(data[bracket + 1:bracket + 1 + num])
+            # the remainder of the string, parsed
+            + parse(data[bracket + 1 + num:], rfun))
+
 
 with open('09.txt', 'r') as file:
     input = re.sub('\s+', '', file.read())

11.py

 my_floor_index = lambda layout: next(i for i, floor in enumerate(layout) if lift in floor)
 
 # Returns just the items on a floor (not the lift)
-items = lambda floor: set(floor) - set([lift])
+items = lambda floor: set(floor) - {lift}
 
 # Returns an enumeration of sets of items that could potentially be picked up (any combo of 1 or 2 items)
 pickups = lambda items: map(set, itertools.chain(itertools.combinations(items, 2), itertools.combinations(items, 1)))
             mappings['%s-compatible microchip' % key] = '%iM' % i
         return '|'.join(''.join(sorted(mappings[item] for item in floor)) for floor in layout)
 
-
     # Evaluates each possible move for the given layout.
     # Moves are checked to ensure they're valid and serialised to ensure they haven't been visited
     # Returns a list of new layouts for the next step, or False if a solution was encountered
     def domoves(layout, steps):
         queued = []
         for items, to in moves(layout):
-            items = set(items).union(set([lift]))
+            items = set(items).union({lift})
             new_layout = [set(floor) - items for floor in layout]
             new_layout[to] |= (items)
             if valid_layout(new_layout):
                         return False
         return queued
 
-
     # Run repeated iterations until we hit a winning result, then immediately returns the step
     # count.
     distances = {serialise(floors): 0}

13.py

 wall = lambda x, y: high(x*x + 3*x + 2*x*y + y + y*y + input) % 2 == 1
 all_moves = lambda x, y: [(x-1, y), (x+1, y), (x, y-1), (x, y+1)]
 moves = lambda x, y: (m for m in all_moves(x, y) if m[0] >= 0 and m[1] >= 0 and not wall(*m))
-queue = set([(1, 1)])
+queue = {(1, 1)}
 visited = set()
 distance = {}
 steps = 0