What is the best practice of conditions style in Python?

Question

We have a function that processes the user request if it is not None, how best to style it? I did not find a better choice in PEP8

Style 1

def user_handler(user):
   if db.getUser(user) is not None:
      """
      Here we have a big body of function
      """
      return {'message': 'Successful handled'}
   else:
      return {'message': 'User not found'}

Style 2

def user_handler(user):
   if db.getUser(user) is None:
      return {'message': 'User not found'}
   """
   Here we have a big body of function
   """
   return {'message': 'Successful handled'}

---

UPD 1: Since there were a lot of questions in the comments regarding the content of the code, I remade the question into a more real one.

Answer 1

I encourage using style no. 2.
The reason is, that an else after a short, concise early return statement is redundant noise. It adds no clarity to the code, since it is already obvious that a certain condintional branch was not taken due to the fact that the function is still running at this point, i.e. has not returned.
Especially in Python, a redundant else block also adds an unneccessary level of indentation which is also noise and reduces the usable line length without any reason.

Another possible issue with your function may be the big body you hinted to with the placeholder. Depending on the size of that block of code, the function might be doing too much and it may be a better idea to split the several processing steps into multiple functions dealing with part of the problem.

Answer 2

There is no "best practice" answer to a question like this.*

My personal preference would be

def handler(request):
   if request is None:
      return False
   else:
      """
      Here we have a big body of function
      """
      return True

I like this better than your first option because the failure condition is at the top, which encourages reading the code in order. You're not getting to the end and then scrolling up to remember what the trailing else return False was for.

I like it better than your second option because when you get to the return True, you're still indented, which cues the reader that this isn't the only exit from the function. Equivalently, I like for every if to have an else that fills the same space in the program flow.

This is not a consensus opinion. Some people would prefer your second option because it doesn't "waste" a level of indentation. In other words, "quit early as needed, and then proceed confident of whatever assumptions you've ensured". My impression is that this the majority perspective among people who like python.

_{* certianly not in python; shout-out to haskell, where we could just lift to the Maybe monad.}