Reversing a string

[Scott]

Yeah I know strings == immutable, but question 1 in section 7.14 of "How to
think like a computer Scientist" has me trying to reverse one.

I've come up with two things, one works almost like it should except that
every traversal thru the string I've gotten it to repeat the "list" again.
This is what it looks like:

        
                        
                        
                >>>mylist = []
def rev(x):
 
 
 
 
for char in x:
mylist.append(char)
mylist.reverse()
print mylist
 

And the output that sorta works like it should, but threw a curveball, at me
looks like this:

>>rev("this is just a test")

['t']
['h', 't']
['i', 't', 'h']
['s', 'h', 't', 'i']
[' ', 'i', 't', 'h', 's']
['i', 's', 'h', 't', 'i', ' ']
['s', ' ', 'i', 't', 'h', 's', 'i']
[' ', 'i', 's', 'h', 't', 'i', ' ', 's']
['j', 's', ' ', 'i', 't', 'h', 's', 'i', ' ']
['u', ' ', 'i', 's', 'h', 't', 'i', ' ', 's', 'j']
['s', 'j', 's', ' ', 'i', 't', 'h', 's', 'i', ' ', 'u']
['t', 'u', ' ', 'i', 's', 'h', 't', 'i', ' ', 's', 'j', 's']
[' ', 's', 'j', 's', ' ', 'i', 't', 'h', 's', 'i', ' ', 'u', 't']
['a', 't', 'u', ' ', 'i', 's', 'h', 't', 'i', ' ', 's', 'j', 's', ' ']
[' ', ' ', 's', 'j', 's', ' ', 'i', 't', 'h', 's', 'i', ' ', 'u', 't', 'a']
['t', 'a', 't', 'u', ' ', 'i', 's', 'h', 't', 'i', ' ', 's', 'j', 's', ' ',
' ']
['e', ' ', ' ', 's', 'j', 's', ' ', 'i', 't', 'h', 's', 'i', ' ', 'u', 't',
'a', 't']
['s', 't', 'a', 't', 'u', ' ', 'i', 's', 'h', 't', 'i', ' ', 's', 'j', 's',
' ', ' ', 'e']
['t', 'e', ' ', ' ', 's', 'j', 's', ' ', 'i', 't', 'h', 's', 'i', ' ', 'u',
't', 'a', 't', 's']
So I figured maybe make it a generator (I'm not TO familiar with generators
yet so don't laugh) which changed my code just a slight bit:

        
                        
                        
                >>>mylist = []
def rev(x):
 
 
 
 
for char in x:
mylist.append(char)
mylist.reverse()
yield mylist
 

But even that threw me a curveball:

>>rev("this is just a test")

<generator object at 0x00D52170>

So how on earth would be the best way to: Write a function that takes a
string as an argument and outputs the letters backward, one per line.

It should look like the first char of every list in the top "working" code.

Any help woould be greatly apreciated, and a little bit of explaination as
to why you did it the way you did would be more helpful than just the code.

Thanks in advance

[Stefan Behnel]

Martin Durkin wrote:

Duncan Booth <du**********@i nvalid.invalidw rote in
news:Xn******** *************** **@127.0.0.1:

>Martin Durkin <no****@william sdurkin.co.ukwr ote:

>>>>>>def rev(x):
mylist = []
for char in x:
mylist.append(c har)
mylist.reverse( )
for letter in mylist:
print letter

However, compare the incredible difference in clarity and elegance
between that and:

>>>print "\n".join("spam "[::-1])
OK, maybe I'm missing the point here as I'm new to Python. The first
one seems clearer to me. What am I missing?

I think all you are missing is familarity with Python, but I too don't
like one-liners simply for their own sake.

I guess that's it. The first one reads more like a textbook example which
is about where I am at. Is there any speed benefit from the one liner?

Almost definitely. But you can check yourself by using the timeit module.

Stefan

[Evan Klitzke]

On 1 Jul 2007 11:09:40 GMT, Martin Durkin <no****@william sdurkin.co.ukwr ote:

Duncan Booth <du**********@i nvalid.invalidw rote in
news:Xn******** *************** **@127.0.0.1:

Martin Durkin <no****@william sdurkin.co.ukwr ote:

>>>>def rev(x):
mylist = []
for char in x:
mylist.append(c har)
mylist.reverse( )
for letter in mylist:
print letter

However, compare the incredible difference in clarity and elegance
between that and:

print "\n".join("spam "[::-1])
OK, maybe I'm missing the point here as I'm new to Python. The first
one seems clearer to me. What am I missing?

I think all you are missing is familarity with Python, but I too don't
like one-liners simply for their own sake.

I guess that's it. The first one reads more like a textbook example which
is about where I am at. Is there any speed benefit from the one liner?

The one line is quite a bit faster:

evan@thinkpad ~ $ python -m timeit 's = "onomatopoe ia"; s = s.join(s[::-1])'
100000 loops, best of 3: 6.24 usec per loop

evan@thinkpad ~ $ python -m timeit '

def rev(x):
mylist = []
for char in x:
mylist.append(c har)
mylist.reverse( )
return "".join(myl ist)

s = "onomatopoe ia"
s = rev(s)'

100000 loops, best of 3: 9.73 usec per loop

--
Evan Klitzke <ev**@yelp.co m>

[Alex Martelli]

Jay Loden <py****@jaylode n.comwrote:
...

For what it's worth, with python 2.5 on my Macbook:

Hmmm, doesn't look to me as if it's worth much...:

[jloden@macbook jloden]$ python -m timeit 's = "onomatopoe ia"; s =

s.join(s[::-1])'

since what you're doing is...:

>>s = "onomatopoe ia"
s = s.join(s[::-1])
s

'aonomatopoeiai onomatopoeiaeon omatopoeiaoonom atopoeiaponomat opoeiaoonoma
topoeiatonomato poeiaaonomatopo eiamonomatopoei aoonomatopoeian onomatopoeia
o'

>>>

....which isn't really just reversing the string, but quite a bit more
work!-)
Alex

[Frank Swarbrick]

Alex Martelli wrote:

Martin Durkin <no****@william sdurkin.co.ukwr ote:
...

>>>>>>>>print "\n".join("spam "[::-1])

...

>>>OK, maybe I'm missing the point here as I'm new to Python. The first
one seems clearer to me. What am I missing?

I think all you are missing is familarity with Python, but I too don't
like one-liners simply for their own sake.

I guess that's it. The first one reads more like a textbook example which
is about where I am at. Is there any speed benefit from the one liner?

The first example reads "excruciati ngly low-level" to me: its autor is
thinking in terms of what the machine is doing, mapped into pretty
elementary low-level constructs.

The second example depends first of all on knowledge of extended-slicing
(specifically the fact that x[::-1] is a reversal, because of the
negative -1 "step" aka "stride"). If you don't know about extended
slicing, you're unlikely to just "get it from context", because it uses
a syntax based on punctuation rather than readable words whose meaning
you might guess at. Python has a modest amount of such "punctuatio n
syntax" -- about the same amount as C but definitely more than Cobol
(where one would typically write "ADD a TO b" to avoid shocking totally
clueless readers with "mysterious punctuation" such as "a + b"...!!!-).
Punctuation is often very concise but not "intrinsica lly obvious" unless
you've been exposed to it already;-).

Since you mentioned Cobol I couldn't resist...

move "spam" to spam
Display Function Reverse(spam)

There's also slicing (known in Cobol as "reference modification")
move mystring(5:3) to my-newstring
* moves 3 characters starting with character 5

No "negative" slicing, though it could be simulated with Function
Reverse() and ref.mod.

Frank

[Jay Loden]

Alex Martelli wrote:

since what you're doing is...:

>>>s = "onomatopoe ia"
s = s.join(s[::-1])
s

'aonomatopoeiai onomatopoeiaeon omatopoeiaoonom atopoeiaponomat opoeiaoonoma
topoeiatonomato poeiaaonomatopo eiamonomatopoei aoonomatopoeian onomatopoeia
o'

...which isn't really just reversing the string, but quite a bit more
work!-)

That's what I get for copying and pasting from the post preceding mine and not actually checking it for what it does ;)

[Sion Arrowsmith]

Jan Vorwerk <ja*********@cr etin.frwrote:

[ lots of sensible stuff to discover "reversed" ]

>print reversed.__doc_ _

See also:

>>help(reversed )

--
\S -- si***@chiark.gr eenend.org.uk -- http://www.chaos.org.uk/~sion/
"Frankly I have no feelings towards penguins one way or the other"
-- Arthur C. Clarke
her nu becomeþ se bera eadward ofdun hlæddre heafdes bæce bump bump bump

[Martin Durkin]

al***@mac.com (Alex Martelli) wrote in
news:1i0pz5v.ef trpfbeilzpN%al* **@mac.com:

Aahz <aa**@pythoncra ft.comwrote:

>I would agree with people who claim
that you should memorize most of the built-in functions (which is
precisely why there is a high barrier to adding more built-in
functions).

I think the built-in functions and types a beginner is likely to need
are a "fuzzy subset" (the decision of whether to include or exclude
something being not really obvious:-) roughly including:

abs all any bool chr cmp dict dir enumerate float getattr help hex int
iter len list max min object open ord property raw_input reversed set
sorted str sum tuple unichr unicode xrange zip

Thanks guys, that is helpful.