Bonjour voilà, j'ai créé une fonction :

def A(a, carre = True):
    if carre:
        return a*a
    else:
        return a*a*a

Et enfaite je me suis un peu senti obligé de mettre carre par défaut, pour précisé que c'est un booléan...
Même si je suis conscient que Python trouve tout seul si c'est un nombre, un bool, etc. mais là les conditions ne sont pas les même, comment aurait-il pu savoir que c'est un bool ?
Et de la même manière, j'aurais très bien pu appeler ma fonction A comme ca :

A(True, False)

Il n'y pas de différence à faire puisqu'on peut appeler n'importe quelle fonction avec des paramètres de n'importe quel type.
Ou sinon j'ai mal compris ta question.

Bon
Peut être, je n'ai pas compris ta réponse en tout cas ^^'

Si j'aurais appeler ma fonction comme ca :

A(True, "blabla")

Que se serait-il passé ?

Je ne sais pas si j'ai bien compris, car je trouve ton code très bien comme ça, mais bon...

On peut dire que :

True==1
False==0

Dans la PEP285, partie spécification, on te donne l'exemple typique de ce qui doit être représenté, est c'est l'identique de ton programme.

def __new__(cls, val=0):
                # This constructor always returns an existing instance
                if val:
                    return True
                else:
                    return False

Maintenant si j'ai pas compris je m'en excuse

Bon je crois que je me suis mal exprimé

Voici un code en python :

def A(a, carre = True):
    if carre:
        return a*a
    else:
        return a*a*a

Voici la même en C++ :

int A(int a, bool carre)
{
if(carre)
return a*a
else
return a*a*a
}

La différence est là, en C++, le compilateur sait qu'on veut un nombre et un bool, si on mets :

A("caca boudin", 5.478569), ca va planter en disant que les arguments sont mauvais.

Mais python lui ne réclame aucun type, alors si on mets :

A(4.5872, "Ouistiti")

Comment va-t-il réagir ?

Je pense qu'il veut assurer qu'on utilise le bon type.
Si on pouvait faire cela, puisque python est interprété, il y aurait une erreur à l'execution si on donne la mauvaise variable.
Si on laisse faire python, il y aurait aussi une erreur à l'execution (si Python ne peut pas utiliser la variable comme il faut mais "" correspond à False donc même avec une chaine ça fonctionne).

Donc il n'y aurait pas de différence.
Pour vérifier que le programme ne plante pas, tu peux utiliser les exceptions.

isinstance(objet, type ou classe ou tuple de types ou classes)

Exemple d'utilisation:

def test(obj):
    if isinstance(obj, bool):
        print("l'objet est bien un booléen, BRAVO !!")
    else:
        print("PERDU !! l'objet est de type : ", type(obj))

Mais je suis pas sùr d'avoir compris la question non plus...

la fonction bool existe aussi sous python

>>> bool(2)
True
>>> bool('C')
True
>>> bool(0)
False
>>> bool("Ouistiti")
True

Il suffit d'essayer, ce qui est une bonne habitude à prendre:

>>> def A(a, carre = True):
... 	if carre:
... 		return a*a
... 	else:
... 		return a*a*a
... 
>>> A(4.5872, "Ouistiti")
21.042403840000002

L'expression "Ouistiti" est considéré comme vrai dans le if et le résultat retourné est donc 4.5872 * 4.587.
Les paramètres ne sont pas attaché à un type; le Python n'est pas le C++ (avec son typage statique et explicite assez rigide) et ne vérifie les types que pendant l'exécution. Il en résulte que ta fonction peut être appelée avec n'importe quelle valeur.

Oui, voilà c'était ca ma question, comment réagirai Python.
Je sais bien que Python n'est pas le C++ mais, c'était pour comparer et qu'on comprenne plus facilement ma question.

Enfaite oui, pour revenir à ce que disait Eponix, je voulais savoir si on pouvait régler la confusion entre les classes par des exception.

EMC1, en effet si on appele A(4.58, "Ouistiti") il peut convertir Ouistiti en booléan comme vrai.
Mais si j'aurais mis Ouistiti à la place de 4.58 ?
Aurait-il pu convertir Ouistiti comme un nombre pour le mettre au carré ?

Python ne fait jamais de conversion implicite entre les types en vertu de son typage fort. "Ouistiti" est considéré comme vrai dans une condition, et "Ouistiti" * "Ouistiti" renvoie une erreur.

Okay, et dans ce cas j'aimerai savoir s'il est possible d'arranger ca avec une exception ?

Oui. Tu connais bien la construction try: ... except: ?

En tout cas mieux qu'hier
Enfaite j'avais une idée, dites moi, si je suis bien partie :

def A(a, carre = True):
    try:
        if carre:
            return a*a
        else:
            return a*a*a
    except:
        print("Une erreur est survenu")

Oui tu pourrai très bien régler ça en tentant une convertion de type:

try:
    bool(carre)
except ValueError:
    # gérer l'erreur de valeur (mm si devrai po y'en avoir dans ce cas là ^^)

Ou alors tu fais comme j'ai dit plus haut.

Tout dépend de ce que tu cherches à faire mais ton code est parfaitement valide.

LeYan'tibus: c'est parfaitement inutile de faire ça.

Faut lire tous les posts et te faire une idée hein.
J'pense que ça peut marcher ça :

def A(a, carre):
  if isinstance(carre, bool) and carre:
    return a*a
  else:
    return a*a*a

c'est une bonne idée aussi
En effet, je pense qu'on peut conclure en disant qu'il existe beaucoup de façon de résoudre le problème ?
Merci

Citation : EMC1

LeYan'tibus: c'est parfaitement inutile de faire ça.

De quoi ?! La conversion de type ou l'utilisation de isinstance() ??

Si on veut s'assurer que l'argument carre est bien un bool, isinstance() est très utile je pense. Après pour ce qui est de la convertion, dans ce cas précis c'est inutile mais dans d'autres...

def saisirUnEntier():
    while True:
        s = 'Entrez un entier : '
        try:
            nb = int(input(s))
        except ValueError:
            print('Vous êtes bouché ou quoi !!?')
            s = s.upper()
            continue
        break
    return nb

True: C'est tout nombre différent de 0 pour les chiffres, et pour une chaine de caractères c'est tout différent de ""

Colb-Seton> isinstance() considered harmful.

En court, avec isinstance on réduit le domaine de la fonction et c'est mal. De toute façon, Python est dynamiquement typé, et il ne procédera à la vérification de type qu'à l'exécution, alors il est inutile (dans le cas présent) de la faire. Travaillez avec des exceptions : si l'utilisateur de votre fonction a envie de travailler avec un type à lui qui peut bien se comporter mais qui n'est pas une sous-classe de bool, ça ne sert à rien de l'en empêcher.