Comme tout langage à typage dynamique, il n'est pas possible d'effectuer une surchage de fonctions. On peut toutefois contourner le problème de plusieurs façons dépendant du paramétrage des fonctions que vous souhaitez écrire.
par exemple, pour une fonction proposant un paramètre nécessitant un traitement spécial suivant son type, on peut simplement tout d'abord tester le type du paramètre avant d'appeler une autre fonction privée adéquate.

def _testint(data): print "traitement d'un entier ", data
def _teststr(data): print "traitement d'un string ", data
def _testlist(data): print "traitement d'une liste ", data

def fonctiontest(data):
    if type(data) == int: _testint(data)
    elif type(data) == str: _teststr(data)
    elif type(data) == list: _testlist(data)
    else: raise AttributeError, "aucun traitement pour le type "+str(type(data))
    

>>> fonctiontest(1)
traitement d'un entier 1
>>> fonctiontest("1")
traitement d'un string 1
>>> fonctiontest({})
AttributeError: aucun traitement pour le type <type 'dict'>

S'il s'agit d'une surcharge de fonctions dont le nombre de paramètres peut varier, on peut utiliser la syntaxe *args qui permet de passer autant de paramètres supplémentaires par position que l'on veut

def somme(*args):
    return sum(args)

>>> print somme(5,3,2)
10
>>> print somme(1,2,3,4)
10

S'il s'agit d'une surcharge de fonctions dont le nombre de paramètres peut varier ainsi que leur type (ou leur sens), on peut dans ce cas utiliser soit un paramètre dictionnaire soit un paramètre de la forme **keys qui permet de passer des paramètres par la syntaxe nomparametre = valeurparametre

def calcul(**keys):
    score = keys['value']
    if 'somme' in keys: score += keys['somme']
    if 'produit' in keys: score *= keys['produit']
    return score


>>> print calcul(value = 5, somme = 2, produit = 7)
49
>>> print calcul(value = 4, produit = 9)
36

On peut bien évidemment mélanger les différentes syntaxe. La syntaxe général étant def mafonction(param1, param2, ..., *args, **keys): ...

Si vous avez besoin d'utiliser une fonction et que vous ne connaissez pas les paramètres qu'elle prend, vous pouvez tout de même récupérer le prototype complet de la fonction. Pour cela, il vous faudra passer par le module inspect. Ce module propose la fonction inspect.getargspec( func) qui renvoie le nom et les valeurs par défaut des arguments de la fonction func. Un tuple de 4 valeurs est retourné de la forme (args, varargs, varkw, defaults). args est la liste des noms des paramètres spécifiés. varargs et varkx correspondent aux noms des arguments * et ** ou bien à None si ceux-ci ne sont pas présents. Enfin defaults est un tuple des valeurs par défaut des arguments ou bien None si il n'y a aucune valeur par défaut de spécifier. Si ce tuple a n éléments, ils correspondent aux n derniers éléments listés dans args

import inspect

def TestInspectFonction(p1, p2, **kwarg): pass

class TestInspect:
    def MaFonction(self, p1, p2 = 'PPP2', p3 = 'PPP3', *arg , **kwarg ): pass

inspect.getargspec(TestInspectFonction)   ## (['p1', 'p2'], None, kwarg, None)
inspect.getargspec(TestInspect.MaFonction)  ## (['self', 'p1', 'p2', 'p3'], 'arg', 'kwarg', ('PPP2', 'PPP3'))