Format inconnu code 'f' pour objet de type 'unicode'

quelqu'un peut me dire quel est le problème avec ce code...

def format_money_value(num):
    return u'{0:.2f}'.format(num)

Il me donne l'erreur suivante:

Unknown format code 'f' for object of type 'unicode'

Je suis en cours d'exécution Django 1.5

Merci

Qu'est-ce que num? Le f format modificateur peut être utilisée que si num est un float. Autant que je sache num est une chaîne unicode. Vous devez le convertir en un flotteur, ou d'éviter d'utiliser f à tous.
@Bakuriu points, le problème est dans num, qui, selon le message d'erreur est une chaîne de unicode type), et non pas d'un flotteur.
ses prises à partir d'une chaîne = 10.00
J'ai remarqué que dans mon formulaire de son montant = formes.CharField(max_length=10)
formataccepte tout numerical type qui peut être représenté comme float. Vous pouvez utiliser int ou Decimal avec format trop.

OriginalL'auteur MarkO | 2013-04-10

django python

17

Dans votre cas num est une chaîne unicode, qui ne prend pas en charge la f format modificateur:
```
>>> '{0:.2f}'.format(u"5.0")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Unknown format code 'f' for object of type 'unicode'
```
Vous pouvez résoudre l'erreur de faire de la conversion à float vous-même:
```
>>> '{0:.2f}'.format(float(u"5.0"))
'5.00'
```
Comme l'a souligné mgilson lorsque vous ne '{0:.2f}'.format(num), le format méthode des chaînes appels num.__format__(".2f"). Il en résulte une erreur pour str ou unicode, car ils ne savent pas comment gérer ce spécificateur de format. À noter que le sens de f est de gauche qu'une implémentation de l'objet. Pour les types numériques il moyen de convertir le nombre à virgule flottante représentation de chaîne, mais d'autres objets peuvent avoir différentes conventions.

Si vous avez utilisé le % opérateur de formatage le comportement est différent, parce que dans ce cas %f appels __float__ directement pour obtenir une représentation à virgule flottante de l'objet.
Ce qui signifie que lors de l'utilisation de %-mise en forme de style f ne ont une signification précise, qui est de convertir à virgule flottante représentation sous forme de chaîne.

En fait, je pense que la magie est fait dans l'objet du __format__ méthode. par exemple, '{0:.2f}'.format(num) appels num.__format__('.2f') et remplace la braketed texte avec la valeur de retour.
Oui, ça doit être ça. Le %-mise en forme de style appels __float__ tout .format appelle simplement __format__. De toute façon, je dois dire que les messages d'erreur que vous obtenez sont assez confus...
Ouais, je suis d'accord. Ce message d'erreur est faux.
Ma seule explication est que hasard drive-by downvoting arrive parfois. Un Débordement de pile a besoin de mettre plus de réglementations strictes sur ce que les utilisateurs qu'ils permettent d'avoir de la souris privilèges. (par exemple, ils doivent le faire les vérifications d'antécédents avant d'autoriser les utilisateurs à cliquer)
Je suis perplexe, parce que 20 minutes avant j'ai eu aussi un downvote dans this réponse, qui je crois ne le mérite pas...

OriginalL'auteur
5

quoi .format() ne

str.format les appels de méthode __format__() méthode de type. Cela signifie que
```
<type>.__format__(<value>, <spec>)
```
méthode ci-dessus, accepte le même type d'argument que la première valeur, et accepte un adapté spec type
en tant que deuxième. Comme,
```
str.__format__('1', 's')
int.__format__(1, 'f')
float.__format__(1.00, 'f')
```
str.__format__ accepte tout type qui est dérivée à partir de str type, comme str ou unicode. Spec valeur doit être valide du formateur qui est utilisable de ce type. Suivant génère une erreur
```
str.__format__('1', 'f')
ValueError: Unknown format code 'f' for object of type 'str'
```
depuis floating point le formatage n'est pas une adapté type de format fot chaîne. De la même manière suivant génère une erreur trop
```
float.__format__(1.00, 's')
ValueError: Unknown format code 's' for object of type 'float'
```
depuis le float est un numeric type et ne peut pas formaté comme un string. Mais les suivantes sont valides:
```
float.__format__(1.00, 'g')
float.__format__(1.00, 'f')
```
de la même façon suivante génère une exception
```
float.__format__(1.00, 'd')
ValueError: Unknown format code 'd' for object of type 'float'
```
depuis le formatage d'un flotteur point décimal de la valeur de la cause de la précision des valeurs perdues. Mais le formatage d'un int à float ne provoquera pas une telle chose, alors c'est valable conversion:
```
int.__format__(1, 'f')
```
Donc .format() est limeted à specs qui est disponible liées à la mise en forme type. Vous devez analyser votre valeur en tant qu' @Bakuriu définis:
```
'{0:.2f}'.format(float(u"5.0"))
```
la vieille mise en forme mini-langue semblent avoir agi différemment. "%s"(anything,) formats anything avec (compatible) __str__ attribut de chaîne, non? pouvez-vous faire avec le 2.6+ format de syntaxe?

OriginalL'auteur
1

Le scénario où vous êtes re-formatage d'une chaîne de caractères (unicode ou autre) en float string n'est pas très sûr. Vous devez d'abord convertir la chaîne de caractères à une représentation numérique et uniquement si cela réussit si vous format en tant que chaîne de nouveau. Vous n'êtes pas dans le contrôle des données qui vient dans votre programme de sorte que vous devriez être sûr de les valider à venir.

Si vous choisissez de laisser comme une chaîne de caractères, vous pouvez utiliser ceci:
```
return u"{:.2f}".format(num) if num.isnumeric() else u"{}".format(num)
```
Si vous avez déjà converti la chaîne dans un format numérique, vous pouvez ajuster votre formateur comme ceci:
```
return u"{:.2f}".format(num) if isinstance(num, NumberTypes) else u"{}".format(num)
```
OriginalL'auteur
0

J'ai été confronté à un problème similaire, comme l'OP, quand num était une réponse chiffrée retournée par une de mes bibliothèques, dont la mise en œuvre detais ai oublié:
```
>>> num
-4132.56528214700
>>> u'{0:.4g}'.format(num)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Unknown format code 'g' for object of type 'unicode'
```
J'ai été vraiment étonné, car num comportés comme un float, mais après des tests @Bakuriu 's solution, j'ai découvert qu'il n'était pas un float:
```
>>> type(num)
<class 'sympy.core.numbers.Float'>
```
Donc @Bakuriu 's solution a droite sur la cible pour mon cas:
```
>>> u'{0:.4g}'.format(float(num))
u'-4133'
```
Par conséquent, l'erreur peut être due à des types d'affichage/de calculer le souhaitez, mais ne sont pas vraiment des flotteurs.

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.

quoi .format() ne