You have an unknown character string c such as '\n' , '\a' , '\7' etc.
How do you echo them using print?
print_str( c ) prints representation '\a' to stdout for c = '\a'
print_str( c ) prints representation '\n' for c = '\n'
...
It is required that not a beep or a linebreak shall be printed.
First of all it has be remarked that it is impossible to a certain
extent. That's because e.g. c = '\a' and c = '\7' do represent the same
string but this ambiguity doesn't occur for many numbers. But lets
weaken the requirement and fix a canonical representation in case of
ambiguity. I'm still getting stuck here.
I don't understand the question. Wouldn't the canonical representation be
repr(c) or repr(c)[1:-1]?
Peter
try "print repr(c)".
Sybren
--
Sybren Stüvel
Stüvel IT - http://www.stuvel.eu/
This yields the hexadecimal representation of the ASCII character and
does not simply echo the keystrokes '\' and 'a' for '\a' ignoring the
escape semantics. One way to achieve this naturally is by prefixing
'\a' with r where r'\a' indicates a "raw" string. But unfortunately
"rawrification" applies only to string literals and not to string
objects ( such as c ). I consider creating a table consisting of pairs
{'\0': r'\0','\1': r'\1',...} i.e. a handcrafted mapping but maybe
I've overlooked some simple function or trick that does the same for
me.
Kay
>> try "print repr(c)".
>
> This yields the hexadecimal representation of the ASCII character and
> does not simply echo the keystrokes '\' and 'a' for '\a' ignoring the
> escape semantics.
But you yourself noted earlier that '\a' and '\x07' are the same string
and said:
> But lets weaken the requirement and fix a canonical representation in
> case of ambiguity.
That's exactly what repr(c) does, it uses a canonical representation
with '\t', '\r', '\n', '\\', (and when it has to "\'", '\"') using the
short escape form (because they are so commonly used), and the all the
other (more obscure) escape sequences using the hexadecimal form.
BTW, c.encode('string_escape') is another way to convert a string to almost
the same escaped form (except for a minor difference in the treatment of
quote characters).
> But unfortunately "rawrification" applies only to string literals and
> not to string objects ( such as c ).
Oh dear, the fact that you could even consider writing that sentence seems
to show a fundamental misunderstanding of what a raw string literal means.
In [30]: c = "\\a"
In [31]: len(c)
Out[31]: 2
In [32]: print c
\a
regards
Steve
--
Steve Holden +44 150 684 7255 +1 800 494 3119
Holden Web LLC/Ltd http://www.holdenweb.com
Skype: holdenweb http://holdenweb.blogspot.com
Recent Ramblings http://del.icio.us/steve.holden
I'm interested in the transition between two literals from which one is
a string literal containing \ as a "meta character" s.t. '\a' has
actually length 1 and is beep when printed to stdout and its "raw" form
without a meta character interpretation of \ that leads to the result
you described. Using the string prefix r to '\a' indicates the raw form
to the compiler. But there seems to be no runtime counterpart. I've
suggested a naive implementation such as
def rawform(c):
return {'\a': r'\a'}[c]
Here the function returns for the single input character '\a' the two
character raw form by means of escaping \ ( and raises a KeyError
exception otherwise ).
>>> c = '\a'
>>> print rawform(c)
\a
This has the same effect as writing:
>>> c = r'\a'
>>> print c
\a
But there is some ambiguity due to the the fact that applying '\7' to
rawform() yields r'\a' and not r'\7'. So one needs more specification
for disambiguation using e.g. an extra parameter.
The two are actually the same thing, so how could a function decide
whether to return '\\a' or '\\7'.
It's like asking the following:
>>> c = 04
>>> print rawform(c)
04
>>> c = 4
>>> print rawform(c)
4
which is obviously not possible, neither of any use imho.
Leonhard
Sorry. It can't possibly know which of two alternative representation
were used to represent a particular character in a literal.
This is perhaps yet another case for SE? I don't really know, because I
don't quite get what you're after. See for yourself:
>>> import SE
>>> Printabilizer = SE.SE ( '''
(1)=\\1 # All 256 octets can be written as parenthesized ascii
(2)=\\2
"\a=\\a" # (7)=\\a"
"\n=\\n" # or (10)=\\n or (10)=LF or whatever
"\r=\\r" # (13)=CR
"\f=\\f"
"\v=\\v"
# Add whatever other ones you like
# and translate them to anything you like.
''')
>>> print Printabilizer ('abd\aefg\r\nhijk\vlmnop\1\2.')
abd\aefg\r\nhijk\vlmno\1\2.
If you think this may help, you'll find SE here:
http://cheeseshop.python.org/pypi/SE/2.2%20beta
Regards
Frederic
This looks quite good. "rawrification" or "printabalization" that's
exactly what I was looking for and I thought this problem would be so
common that someone has done an implementation already. Thanks,
Frederik!
Kay
dumb question - is the backslash as escape character fixed or can one set its
(the escape char's)
value so that backslash is not the escape char?
seems to me that would help - or if you could turn the behaviour off - don't
know how though...
- Hendrik
> This yields the hexadecimal representation of the ASCII character and
> does not simply echo the keystrokes '\' and 'a' for '\a' ignoring the
> escape semantics. One way to achieve this naturally is by prefixing
> '\a' with r where r'\a' indicates a "raw" string. But unfortunately
> "rawrification" applies only to string literals and not to string
> objects ( such as c ). I consider creating a table consisting of pairs
> {'\0': r'\0','\1': r'\1',...} i.e. a handcrafted mapping but maybe
> I've overlooked some simple function or trick that does the same for
> me.
if not else, you've missed that octal escapes consists of three digits,
not one, so translating chr(1) to r"\1" doesn't work in the general case
(e.g. len("\100") == 1, not 3)
</F>
> dumb question - is the backslash as escape character fixed
yes.
> seems to me that would help
help with what?
> or if you could turn the behaviour off - don't know how though...
eh? if you don't want to use repr(), you don't have to.
</F>
> --
> http://mail.python.org/mailman/listinfo/python-list
>
>
>
>
This email is confidential and may be privileged. If you are not the intended recipient please notify the sender immediately and delete the email from your computer.
You should not copy the email, use it for any purpose or disclose its contents to any other person.
Please note that any views or opinions presented in this email may be personal to the author and do not necessarily represent the views or opinions of Digica.
It is the responsibility of the recipient to check this email for the presence of viruses. Digica accepts no liability for any damage caused by any virus transmitted by this email.
UK: Phoenix House, Colliers Way, Nottingham, NG8 6AT UK
Reception Tel: + 44 (0) 115 977 1177
Support Centre: 0845 607 7070
Fax: + 44 (0) 115 977 7000
http://www.digica.com
SOUTH AFRICA: Building 3, Parc du Cap, Mispel Road, Bellville, 7535, South Africa
Tel: + 27 (0) 21 957 4900
Fax: + 27 (0) 21 948 3135
http://www.digica.com
((I have no idea why the following was missing from my first attempt to
post, and since posting the thread has gone over my head, but wasn't the
OP just after a way to print user-inputted strings with '\' in
them?))...
I cant test this where I am, but would the following work
We have our literal user-inputted strings in a list,
l=['\a','\b','\c'] etc..
For s in l:
for c in s:
print c,
print