Use generator to do inorder traversal I am not used to generators and wonder how to make code cleaner/Pythonic in the generator part. 

The function is about validating a binary search tree. The inorder_gen function yield one element a time. The main function compares the value yielded and previous yielded value to determine whether BST's invariant is violated.

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):

    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        last_val = None
        for idx, v in enumerate(self.inorder_gen(root)):
            if idx != 0 and v &lt;= last_val:
                return False
            last_val = v
        return True

    def inorder_gen(self, node):
        if node is None:
            return 
        if node.left != None:
            for v in self.inorder_gen(node.left):
                yield v
        yield node.val
        if node.right != None:
            for v in self.inorder_gen(node.right):
                yield v
Your structure seems adequate, but there are a couple of mistakes, and some new language syntax in 3.3 that will make things even clearer:


That name!

def inorder_gen(self, node):


The name does make it obvious what order you're using. And it also explains that you're writing a generator - which is putting implementation details in the public interface. Don't do that. You could go with inorder(), but even better would be to make your class iterable using the standard Python approach. See this SO answer for an example of how.
You were off to a good start ...

if node is None:
    return 
if node.left != None:


... but then you tried to use != None. Use is None or is not None instead. (Like you did on the first line!)
Use Python's yield from expression to connect a nested generator to your caller. This code:

if node.left != None:
    for v in self.inorder_gen(node.left):
        yield v
yield node.val
if node.right != None:
    for v in self.inorder_gen(node.right):
        yield v


Becomes this:

yield from self.inorder_gen(node.left) if node.left is not None else ()
yield node.val
yield from self.inorder_gen(node.right) if node.right is not None else ()


And if your nodes default to truthy (which most objects do), you can replace if node.left is not None with if node.left, for more readability!

yield from self.inorder_gen(node.left) if node.left else ()
yield node.val
yield from self.inorder_gen(node.right) if node.right else ()

Bonus: If you make your TreeNode class iterable, as mentioned in #1, and you use yield from as mentioned in #3, you can make your code even smaller! Since the nodes are iterable, and since yield from will accept an iterable, you can yield from the nodes directly, like this:

# NOTE: This has to be on the node class, so if you can't change 
# that, it won't work. (But maybe you could subclass the TreeNode?)

def __iter__(self):
    if self.left: yield from self.left
    yield self.val
    if self.right: yield from self.right


(In fairness, this last example came from the PEP proposing the yield from syntax: http://www.cosc.canterbury.ac.nz/greg.ewing/python/yield-from/yf_current/Examples/binary_tree.py, and see overview page here: http://www.cosc.canterbury.ac.nz/greg.ewing/python/yield-from/yield_from.html)