Determining whether a loop iterated at least one element in generator function

This is very strange to read:

try:
    variable
except UnboundLocalError:

I'm familiar with NameErrors but didn't realise UnboundLocalError was a separate exception. It's generally confusing to have a variable sitting by itself doing nothing, though I know why you're doing it in this case. I think your yielded boolean makes far more sense because if not yielded makes perfect sense to read.

To make it extra explicit, your docstring should contain the note that even if no value from RealEstatesCustomization is yielded the generator will at least fall back on self.customer.

@property
def source_customers(self):
    """Yields source customers

    Yield self.customer if database query returned no results."""

    yielded = False
    for config in RealEstatesCustomization.select().where(
            RealEstatesCustomization.customer == self.cid):
        yield config.source_customer
        yielded = True

    if not yielded:
        yield self.customer

I'm coming back to this question as I'm not entirely satisfied with either answer or your original code. And I think the main part that is bothering me is the simple fact that you hide away an error situation.

I think that both ways of detecting that the loop hasn't executed seems sensible, although the UnboundLocalError is a bit of a hack, but to me the main issue that you void the separation of concern by returning something when you don't find anything.

This should be done in the outer code, in my meaning, and as such it would be proper to raise an exception instead of returning/yielding self.customer. So the last part of your code I think I would use something like:

raise NoCustomizationFound(self.customer)

Which would allow for the outer level to take proper action when no customization is found, and you could (as suggested but not tested) include the self.customer as a parameter to the exception and thusly allow the outer code to continue using that as the value.

If not moving this check to the outer level, where it seems natural to have it, you could opt for doing it the way Barry suggests since you then indicate at the outer level that this error situation is handled by the iter_or_default() part. But this does still hide the functionality somewhat, as when you use the property you don't really know if you got the customization you are looking for, or the default value.

Here is a cleaner version of yield_or_default created by @Barry and updated by @RichardNeumann

def yield_or_default(iterable, defaults):
    """Yields from the iterable or yields
    from the defaults iff iterable is empty
    """
    iterator = iter(iterable)
    try:
        yield next(iterator)
    except StopIteration:
        # Iterable is empty
        yield from defaults
    else:
        yield from iterator

Why I believe it is Cleaner:

In comparison to:

def yield_or_default(iterable, defaults):
    """Yields from the iterable or yields
    from the defaults iff iterable is empty
    """
    iterator = iter(iterable)
    try:
        first = next(iterator)
    except StopIteration:
        # Iterable is empty
        yield from defaults
    else:
        yield first
        yield from iterator

The 1st solution is 1 less statement, why save to first variable when you can simply attempt to yield, catch exception, and either yield from defaults or yield from iterator (to get the rest of items in iterator).

Yet another variation, no 'tee', no 'else'.

def iter_or_default(iterable, dflt):
   it = iter(iterable) 
   try:
      yield next(it)
      # here iterable wasn't empty,
      # we yield remaining items
      yield from it
   except StopIteration:
      yield dflt