DESCRIPTION.

Retourne True si l'objet passé en argument est appelable, sinon False.

SYNTAXE.

Variable = callable ( objet )

Variable = ⇨ variable qui la recevra la valeur [ optionnel ]

callable ( ) ⇨ appel de la méthode [ OBLIGATOIRE ]

objet ⇨ objet valide pour Python [ OBLIGATOIRE ]

REMARQUES.

objet peut être l'identifiant de l'objet, un nom de variable désignant l'objet, ou toute autre forme de lien se référant à l'objet.

Pour Python, un objet est appelable s'il est suivi d'un paire de parenthèses (( )) quand il est invoqué, et qu'il est susceptible de retourner une valeur. objet peut donc être une instance de classe (class), représenté par sa variable, une méthode, une fonction (def), une fonction anonyme (lambda), ...

Lors de l'utilisation de la méthode callable ( ), les parenthèses ne doivent pas être présentes à la suite de l'objet à tester.

Si callable ( objet ) retourne True, cela  ne signifie pas que l'appel de objet sera toujours possible sans lever d'exception. Mais si False est retourné, l'appel de objet échouera à chaque fois. 

EXEMPLES.

print ( callable ( max ) ) retourne True

print ( callable ( len ) ) retourne True

Les méthodes natives de Python max ( ) et len ( ), retourneront des valeurs si elles sont appelées de façon valide. En effet, 

TPL_Test = ( 12 , 90 , 876, 3 , 54 )

print ( max ( TPL_Test ) ) retourne 876

print ( len ( TPL_Test ) ) retourne 5

print ( callable ( import ) ) retourne Invalid Syntaxe

print ( callable ( lambda ) ) retourne Invalid Syntaxe

Les instructions natives de Python import et lambda, ne sont pas appelables, car leur utilisation ne nécessite pas de parenthèses. Ce ne sont pas des objets valides pour la méthode callable ( ).

Par contre, si une instruction produit un objet retournant une valeur quand il est invoqué, cet objet est tout à fait valide pour la méthode callable ( ). En effet, il faut utiliser une paire de parenthèses, avec ou sans  argument, lors de l'appel.

print ( callable ( lambda : True ) ) retourne True

print ( ( lambda : True ) ( ) ) retourne True

print ( callable ( lambda : False ) ) retourne True

print ( ( lambda : False ) ( ) ) retourne False

print ( callable ( lambda : None ) ) retourne True

print ( ( lambda : None ) ( ) ) retourne None

print ( callable ( lambda kbase : kbase ** 3 ) ) retourne True

print ( ( lambda kbase : kbase ** 3 ) ( 4 ) ) retourne 64

LMD_Racine = lambda kcarre : kcarre ** .5 

print ( callable ( LMD_Racine ) ) retourne True

print ( LMD_Racine ( 21 ) ) retourne 4.58257569495584

def FNC_Test ( Qa , Qb ) : return  ( Qa + Qb ) * ( Qa - Qb )

print ( callable ( FNC_Test ) ) retourne True

print ( FNC_Test ( 7 , -4 ) ) retourne 33

class CLS_Test ( ) : pass

print ( callable ( CLS_Test ) ) retourne True

print ( CLS_Test ( ) ) retourne <__main__.CLS_Test object at 0xb50c1330>

Mais l'appel doit être valide, car même s'il l'objet est appelable, cela ne garanti pas que son appel ne lèvera pas d'exception.

print ( LMD_Racine ( "21" ) ) retourne TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'float'

Un objet peut ne pas être appelable, alors qu'une de ses méthodes le sera.

TPL_Mots = ( "Mon" , "Python" , "à" , "moi" )

Lien = " ... "

print ( callable ( Lien ) ) retourne False

print ( callable ( Lien.join  ) ) retourne True

print ( Lien ) retourne  ... 

print ( Lien.join ( TPL_Mots ) ) retourne Mon ... Python ... à ... moi

Un str ( ) ne retourne rien, sauf lui même, alors que la méthode .join ( ) d'un l'objet str ( ) retourne une certaine valeur : un nouveau str ( ).