Understanding repr( ) function in Python

 

repr() : evaluatable string representation of an object (can "eval()" it, meaning it is a string representation that evaluates to a Python object)

In other words: 

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

Questions:

  • Why do I get the double quotes when I do repr(x) ? (I don't get them when I do str(x) )
  • Why do I get 'foo' when I do eval("'foo'") and not x which is the object? 
    • >>> x = 'foo'
>>> x
'foo'

    So the name x is attached to 'foo' string. When you call for example repr(x) the interpreter puts 'foo' instead of x and then calls repr('foo') . 

    >>> repr(x)
"'foo'"
>>> x.__repr__()
"'foo'"

    repr actually calls a magic method __repr__ of x , which gives the string containing the representation of the value 'foo' assigned to x . So it returns 'foo' inside the string "" resulting in "'foo'" . The idea of repr is to give a string which contains a series of symbols which we can type in the interpreter and get the same value which was sent as an argument to repr . 

    >>> eval("'foo'")
'foo'

    When we call eval("'foo'") , it's the same as we type 'foo' in the interpreter. It's as we directly type the contents of the outer string "" in the interpreter. 

    >>> 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

    If we call eval('foo') , it's the same as we type foo in the interpreter. But there is no foo variable available and an exception is raised. 

    >>> str(x)
'foo'
>>> x.__str__()
'foo'
>>>

    str is just the string representation of the object (remember, x variable refers to 'foo' ), so this function returns string. 

    >>> str(5)
'5'

    String representation of integer 5 is '5' . 

    >>> str('foo')
'foo'

    And string representation of string 'foo' is the same string 'foo' .

    The feedback you get on the interactive interpreter uses repr too. When you type in an expression (let it be expr ), the interpreter basically does result = expr; if result is not None: print repr(result) result = expr; if result is not None: print repr(result) . So the second line in your example is formatting the string foo into the representation you want ( 'foo' ). And then the interpreter creates the repr esentation of that, leaving you with double quotes.

    Why when I combine %r with double-quote and single quote escapes and print them out, it prints it the way I'd write it in my .py file but not the way I'd like to see it?

    I'm not sure what you're asking here. The text single ' and double " quotes , when run through repr , includes escapes for one kind of quote. Of course it does, otherwise it wouldn't be a valid string literal by Python rules. That's precisely what you asked for by calling repr .

    Also note that the eval(repr(x)) == x analogy isn't meant literal. It's an approximation and holds true for most (all?) built-in types, but the main thing is that you get a fairly good idea of the type and logical "value" from looking the the repr output.

    1) The result of repr('foo') is the string 'foo' . In your Python shell, the result of the expression is expressed as a representation too, so you're essentially seeing repr(repr('foo')) .

    2) eval calculates the result of an expression. The result is always a value (such as a number, a string, or an object). Multiple variables can refer to the same value, as in: 

    x = 'foo'
y = x

    x and y now refer to the same value.

    3) I have no idea what you meant here. Can you post an example, and what you'd like to see?

    链接地址: http://www.djcxy.com/p/63438.html

    上一篇: SqlAlchemy：可以在关系中使用混合表达式吗？

    下一篇: 了解Python中的repr（）函数