La compréhension de repr( ) fonction en Python

repr(): evaluatable représentation sous forme de chaîne d'un objet ("eval()"
c'est à dire qu'il est une représentation de chaîne qui donne un Python
objet)

En d'autres termes:

>>> x = 'foo'
>>> repr(x)
"'foo'"

Questions:

Pourquoi dois-je obtenir les guillemets quand je fais repr(x)? (Je n'arrive pas à les obtenir
quand je fais str(x))
Pourquoi puis-je obtenir 'foo' quand je fais eval("'foo'") et pas de x qui est la
objet?

vous offrir un très bel exemple de la réelle/le comportement attendu pour 1, mais vous n'avez pas de 3. qu'est-ce que la façon dont vous serais "comme de le voir?"
S'il vous plaît, des précisions sur la 3d de la question. C'est une bonne idée de donner quelques exemples. Maintenant, il n'est pas clair ce que vous voulez atteindre.
J'ai posté une nouvelle question nouveau sujet. Ne sais pas pourquoi mais je ne pouvais pas éditer ce post pour entrer dans le code. Merci pour m'avoir aidé.
J'ai enlevé la 3ème question et une nouvelle marque qui inclut le code aussi.
Lien?

InformationsquelleAutor 0101amt | 2011-10-16

python repr

154
```
>>> x = 'foo'
>>> x
'foo'
```
De sorte que le nom x est attaché à 'foo' chaîne. Lorsque vous appelez par exemple repr(x) l'interprète met 'foo' au lieu de x et appelle ensuite repr('foo').
```
>>> repr(x)
"'foo'"
>>> x.__repr__()
"'foo'"
```
repr appelle en fait une méthode magique __repr__ de x, ce qui donne à la chaîne contenant la représentation de la valeur 'foo' attribué à x. On en revient donc 'foo' à l'intérieur de la chaîne de "" résultant dans "'foo'". L'idée de repr est de donner une chaîne de caractères qui contient une série de symboles qui nous taper dans l'interprète et obtenir la même valeur qui a été envoyé comme un argument de repr.
```
>>> eval("'foo'")
'foo'
```
Lorsque nous appelons eval("'foo'"), c'est la même chose que nous type 'foo' dans l'interpréteur. C'est comme nous taper directement le contenu de l'extérieur, chaîne de "" dans l'interpréteur.
```
>>> eval('foo')

Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    eval('foo')
  File "<string>", line 1, in <module>
NameError: name 'foo' is not defined
```
Si nous appelons eval('foo'), c'est la même chose que nous type foo dans l'interpréteur. Mais il n'y a pas de foo variable disponible et une exception est levée.
```
>>> str(x)
'foo'
>>> x.__str__()
'foo'
>>> 
```
str est juste la représentation de chaîne de l'objet (rappelez-vous, x variable se réfère à 'foo'), de sorte que cette fonction retourne la chaîne.
```
>>> str(5)
'5'
```
Représentation de chaîne de caractères entier 5 est '5'.
```
>>> str('foo')
'foo'
```
Et représentation de chaîne de caractères chaîne de 'foo' est la même chaîne 'foo'.
- Pouvez-vous aussi laissez-nous connaître certains des cas d'utilisation où l'on doit utiliser des repr de la fonction. Je suis incapable de comprendre que
InformationsquelleAutor ovgolovin
9

La rétroaction que vous obtenez sur le interactives interprète utilise repr trop. Lorsque vous tapez une expression (que ce soit expr), l'interprète ne fait result = expr; if result is not None: print repr(result). La seconde ligne dans votre exemple est le formatage de la chaîne foo dans la représentation que vous voulez ('foo'). Et puis l'interprète crée la representation de que, vous laissant avec des guillemets doubles.

Pourquoi quand je combiner %r avec les guillemets doubles et les guillemets simples évasions et de les imprimer, imprime de la façon que je l'avais écris dans mon .py fichier, mais pas de la façon dont je voudrais le voir?

Je ne suis pas sûr de ce que vous demandez ici. Le texte single ' and double " quotes, lorsqu'il est exécuté par repr, comprend échappe pour une sorte de citation. Bien sûr, il n', sinon cela ne serait pas la validité d'une chaîne littérale par Python règles. C'est précisément ce que vous avez demandé en appelant repr.

Également de noter que la eval(repr(x)) == x analogie n'est pas littérale. C'est une estimation qui est vrai pour la plupart (tous?) types intégrés, mais la chose principale est que vous obtenez une assez bonne idée du type et de la logique de la "valeur" de la recherche à la la repr de sortie.
- A l'origine, il en fait est signifie littéralement: chaque valeur est repr devrait être quelque chose qui peut être transmis à eval (ou de le copier et le coller dans votre code source) pour produire une valeur égale, ou quelque chose qui va soulever une SyntaxError si vous essayez, (généralement le <…> style produit par object.__repr__). Qui a été progressivement atténué au fil des ans, et de 2,7 et 3.x c'est seulement vrai "pour de nombreux types", et il y a des exceptions, même dans la stdlib e.g,, un namedtuple type créé comme un local vous donnera un repr vous ne pouvez pas eval), mais c'était l'idée originale.
InformationsquelleAutor
3

1) Le résultat de repr('foo') est le chaîne 'foo'. Dans votre interface Python, le résultat de l'expression est exprimé comme une représentation trop, de sorte que vous êtes essentiellement de voir repr(repr('foo')).

2) eval calcule le résultat d'une expression. Le résultat est toujours une valeur (comme un nombre, une chaîne ou un objet). Plusieurs variables peuvent se référer à la même valeur, comme dans:
```
x = 'foo'
y = x
```
x et y se réfère maintenant à la même valeur.

3) je n'ai aucune idée de ce que vous voulez dire ici. Pouvez-vous poster un exemple, et ce que vous aimeriez voir?

InformationsquelleAutor phihag
2

Quand vous dites
```
foo = 'bar'
baz(foo)
```
vous n'êtes pas en passant foo à la baz fonction. foo est juste un nom utilisé pour représenter une valeur, dans ce cas 'bar', et que la valeur est passée à la baz fonction.

InformationsquelleAutor SingleNegationElimination
2

str() est utilisé pour la création de la sortie pour l'utilisateur final tout en repr() est utilisée pour debuggin développement.Et c'est de représenter les officiels de l'objet.

Exemple:
```
>>> import datetime
>>> today = datetime.datetime.now()
>>> str(today)
'2018-04-08 18:00:15.178404'
>>> repr(today)
'datetime.datetime(2018, 4, 8, 18, 3, 21, 167886)'
```
De sortie, nous voyons que repr() montre la représentation officielle de l'objet date.

InformationsquelleAutor Tanim_113

Vous devez vous connecter pour publier un commentaire.