python format de la chaîne de l'appel d'une fonction

Est-il un moyen de formater avec le nouveau format de la syntaxe d'une chaîne à partir d'un appel de fonction? par exemple:

"my request url was {0.get_full_path()}".format(request)

donc, il appelle la fonction get_full_path fonction à l'intérieur de la chaîne et non pas comme un paramètre dans la fonction format.

EDIT:
Voici un autre exemple qui va probablement montrer ma frustration, c'est ce que je voudrais:

"{0.full_name()} {0.full_last_name()} and my nick name is {0.full_nick_name()}".format(user)

c'est ce que je veux éviter:

"{0} and {1} and my nick name is {2}".format(user.full_name(), user.full_last_name(), user.full_nick_name())
  • Non, vous ne pouvez pas. Quelle différence y a-il si faire "my request url was {0}".format(request.get_full_path())?
  • Par curiosité: pourquoi avez-vous besoin de quelque chose comme ça?
  • ce que je veux éviter, c'est quelque chose comme ceci: "my request url was {0} and my post was {1}".format(request.get_full_path(), request.POST). Je veux utiliser le même objet qu'une seule fois
  • Ce qui est mauvais sur l'utilisation d'un même objet deux fois?
  • En fait, en faisant comme vous le souhaitez, vous utilisez toujours le même objet deux fois.
  • J'ai juste envie de plus d'une syntaxe où je n'ai pas pour ajouter l'objet même plus d'une fois dans le format args
  • C'est juste une référence. Vous pouvez attribuer la même valeur à l'autre, le nom court: r = request, et l'utilisation '...'.format(r.get_full_path(), r.POST)`. Il n'a pas beaucoup d'importance n'est ce pas? Mise en forme de chaîne vous donne quelques raccourcis pratiques, y compris l'indexation et l'attribut de l'accès, mais l'appel de fonction ne fait pas partie du format. Ce ne sont pas complets des expressions Python, ils ne devraient pas être.
  • aucune raison pourquoi ils ne devraient pas l'être? mon sauvage conjecture est que le format de la syntaxe prend les valeurs de l'objet __dict__ et c'est pourquoi ils ne peuvent pas appeler une fonction. mais ce n'est pas qu'il fait moins d'une douleur d'avoir à ajouter le même objet dans le args (au moins pour moi).
  • La chaîne de formatage est l'analyse d'une dédiée format. Il n'est pas régulier python analyseur de parser les références, donc ce ne sont pas des expressions Python. Il n'y a pas d'espace de noms, vous ne pouviez pas passer en arguments, si on peut appeler des fonctions, par exemple. L'attribut et le point d'accès est une commodité pour simplifier de nombreuses exigences de mise en forme, mais ce n'est pas (et ne le sera jamais) une pleine expression Python analyseur.
  • N'étant pas en mesure de dire que quelque chose n'a rien à voir avec accès à la __dict__ ou quoi que ce soit d'autre. Il utilise la norme de méthodes pour accéder à des attributs et des éléments.
  • Je vois, très intéressant. Merci pour ces commentaires 🙂
  • Notez qu'il existe deux réponses que maintenant donner de bonnes approches pour faire ce que tu voulais, et qui ont plus de voix que l'on a accepté la réponse. Vous pourriez voulez leur donner un peu de reconnaissance officielle.
  • merci pour les commentaires, ce que je cherchais ai implémenté en python 3.6 qui est très excitant.

InformationsquelleAutor Hassek | 2013-11-05
  1. 11

    Python 3.6 ajoute chaîne littérale d'interpolation, ce qui est écrit avec un f préfixe. Voir PEP 0498 -- Chaîne Littérale de l'Interpolation.

    Ce qui permet d'écrire 

    >>> x = 'hello'
>>> s = f'{x}'
>>> print(s)
hello

    Il convient de noter que ce ne sont pas réels des chaînes, mais représentent code qui renvoie une chaîne de caractères à chaque fois. Dans l'exemple ci-dessus, s sera de type str, avec la valeur 'hello'. Vous ne pouvez pas passer une f-corde autour de, car il sera évalué à la suite str avant d'être utilisé (contrairement à str.format, mais, comme tous les autres littéral de chaîne de modificateur, tels que r'hello', b'hello', '''hello'''). (PEP 501 -- à des fins Générales de la chaîne d'interpolation (actuellement différé) suggère un littéral de chaîne qui permettra d'évaluer à un objet qui peut prendre des substitutions plus tard.)

    InformationsquelleAutor leewz
  2. 18

    Vous ne savez pas si vous pouvez modifier l'objet, mais vous pourrez modifier ou de les emballer l'objet pour faire les fonctions de propriétés. Ensuite, ils ressemblent à des attributs, et vous pourriez le faire comme

    class WrapperClass(originalRequest):
    @property
    def full_name(self):
        return super(WrapperClass, self).full_name()

"{0.full_name} {0.full_last_name} and my nick name is {0.full_nick_name}".format(user)

    qui EST légal.

    • Il fonctionne également avec les dicts. '{0[hello]}'.format({'hello':'world'}) résultats dans 'world'.
    • Oui, ce dict de récupération fonctionne out-of-the-box sans avoir cette WrapperClass, pour info
    • bon à savoir (je pense qui a été ajouté plus tard), mais la question était à propos de l'appel de fonctions, pas vraiment regardant des éléments dans le dictionnaire. chaîne littérale de l'interpolation peut le faire bien..
    InformationsquelleAutor Corley Brigman
  3. 6

    Python n'est pas directement en charge interpolation de variable. Cela signifie qu'il manque de certaines fonctionnalités (à savoir, la fonction d'appel en chaînes de caractères) que pour les autres langues de soutien.

    Donc, il n'y a pas vraiment grand-chose à dire ici, d'autres que non, vous ne pouvez pas le faire. C'est juste pas comment Python mise en forme de la syntaxe œuvres.

    Le meilleur que vous avez est ce:

    "my request url was {0}".format(request.get_full_path())
    • Juste fait une modification, n'est pas à propos de l'objet de demande vraiment. Je suis presque certain que vous avez raison sur ce, j'aimerais juste une autre syntaxe option qui, je pense, n'existe pas 🙁
    InformationsquelleAutor iCodez
  4. 1

    Ce à propos de cette chose très étrange?

    "my request url was %s and my post was %s"\
    % (lambda r: (r.get_full_path(), r.POST))(request)

    Explication:

    1. Façon classique de mise en forme
    2. Fonction Lambda qui prend une requête et retourne un tuple avec ce que vous voulez
    3. Appeler le lambda en ligne, comme des arguments pour votre chaîne.

    Je préfère encore la façon dont vous le faites.

    Si vous voulez des raisons de lisibilité, vous pouvez le faire:

    path, post = request.get_full_path(), request.POST
"my request url was {} and my post was {}".format(path, post)
    • Oui je pense que c'est juste pas la peine heh. Je suis à la recherche de plus pour une syntaxe qui est permis il y a, par exemple, pour un format datetime vous pouvez faire {:%Y} et il fonctionne.
    • Je suis désolé c'est tout ce que j'ai 🙂 je ne pense pas que Python va jusqu'à présent. En particulier, il n'est pas célèbre pour sa chaîne d'interpolation/mise en forme de toute façon :/
    • Je vais laisser la question ouverte pendant un certain temps, mais mes espoirs sont en bas sur celui-ci 🙁
    InformationsquelleAutor Paulo Bu
  5. 0

    Donc résumé des méthodes serait

    (base) [1]~ $ cat r.py
# user is dict:
user = {'full_name': 'dict joe'}
print('{0[full_name]}'.format(user))

# user is obj:
class user:
    @property
    def full_name(self):
        return 'attr joe'


print('{0.full_name}'.format(user()))


# Wrapper for arbitray values - as dict or by attr
class Getter:
    def __init__(self, src):
        self.src = src

    def __getitem__(self, k):
        return getattr(self.src, k, 'not found: %s' % k)

    __getattr__ = __getitem__


print('{0[foo]} - {0.full_name}'.format(Getter(user())))
(base) [1]~ $ python r.py
dict joe
attr joe
not found: foo - attr joe
    InformationsquelleAutor Red Pill