Use isinstance to check if o is an instance of str or any subclass of str:

if isinstance(o, str):

To check if the type of o is exactly str, excluding subclasses of str:

if type(o) is str:

See Built-in Functions in the Python Library Reference for relevant information.

Checking for strings in Python 2

For Python 2, this is a better way to check if o is a string:

if isinstance(o, basestring):

because this will also catch Unicode strings. unicode is not a subclass of str; both str and unicode are subclasses of basestring. In Python 3, basestring no longer exists since there's a strict separation of strings (str) and binary data (bytes).

Alternatively, isinstance accepts a tuple of classes. This will return True if o is an instance of any subclass of any of (str, unicode):

if isinstance(o, (str, unicode)):

Don't check types, check actions. You don't actually care if it's a function (it might be a class instance with a __call__ method, for example) - you just care if it can be called. So use callable(f).

You probably want a bounded type variable:

import typing
class BaseClass:
    def __init__(self):
        self.name = 'base'


class MainClass(BaseClass):
    def __init__(self):
        self.mc_val = 1
        super().__init__()

T = typing.TypeVar('T', bound=BaseClass)
def base_func(bc: T) -> T:
    bc.name = 'altered'
    return bc


def main_func(mc: MainClass) -> MainClass:
    mc.mc_val = 3
    return mc

mc = MainClass()
mc1 = base_func(mc)
mc2 = main_func(mc1)

Using mypy:

juan$ mypy test_typing.py
Success: no issues found in 1 source file

You don't.

You should never be unsure of the type of a thing in python; it's basically impossible to check accurately. While it is possible to do some naïve surface-level checking, the problem is that python is very flexible. Your function shouldn't care if it's passed a dict or something that behaves exactly like a dict, and the best way to deal with this is to not check at all.

The real question is "why don't I know what the type of something is?"