Iterative “post order” tree traversal I wanted to get feedback on the correctness and efficiency of this post order traversal routine that my wife and I find really easy to grasp.

def postOrderTraversal(root: TreeNode):
  curr = root
  stack = []

  while stack or curr:
    if curr is None:
      if stack[-1].right is None or popped == stack[-1].right:
        popped = stack.pop()
        print(popped.val)
      else:
        curr = stack[-1].right
    else:
      stack.append(curr)
      curr = curr.left
Congratulations on finding code you enjoy!

This appears to be walking through a binary tree you have defined (or possibly from toytree?).  Walking through this with an explicit stack is one way of thinking of the problem, and the code can be a good learning experience.

An alternate method would be to use the Python's recursion system, where you make code vaguely like:

   def walk(tree):
        if tree is not None:   # ignore walking into an empty node
            walk(tree.left)
            walk(tree.right)
            print(tree.val)


It takes a a little brain stretching to see these as equivalent.  As an exercise you should explore making the function a generator.  That is, would call it as:

  for value in tree.walk():
      print(value)


To do this, you need to replace a print with a yield, and a recursive call with a yield from.   Try it: it does a different stretch on the brain.

As far as efficiency, you need to use the the timeit module to see what does run fast.   In general, tree structures with a single value do poorly for really large numbers because memory access is a bit slow.  However, profiling is necessary for optimizing by less than factors of n (the size of the tree).  Orders of magnitude can be judged by eye and logic while unexpected internals might double the speed of some code. 

You might notice that your code will currently fail on being passed an empty tree (root=None), as popped will be checked before it is assigned.  I am not sure why you are checking if popped equals the right node.

Keep hacking!  Keep notes.