Reverse list, slicing: (0.58000000000000007, 0.64144396781921387)
Reverse list, method: (0.20000000000000018, 0.19551301002502441)
Reverse string, slicing: (0.45000000000000001, 0.49545693397521973)
Reverse string, list: (3.71, 3.7981550693511963)

I’m using a quick Timer class that I implemented to report the running time for a chunk of code using both of time.clock() (the first item) and time.time() (the second item). Here is the code used to produce these results:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

import time
from collections import namedtuple
from copy import deepcopy
 
class Timer(object):
   Times=namedtuple('times','clock time')
 
   def __init__(self):
      self.running=False
 
   def _set_times(self,field_name):
      times=Timer.Times(time.clock(),time.time())
      setattr(self,field_name,times)
 
   def start(self):
      if self.running: raise ValueError('Timer is already running!')
      self.running=True
      self._set_times('tstart')
   def stop(self):
      if not self.running: raise ValueError('Timer is not running!')
      self.running=False
      self._set_times('tstop')
 
   def time(self):
      return (self.tstop.clock-self.tstart.clock,self.tstop.time-self.tstart.time)
 
timer=Timer()
test_string='Time flies like an arrow.  Fruit flies like a banana.'
test_list=list(test_string)
iterations=1000000
 
timer.start()
for i in xrange(iterations):
   new_string=test_string[::-1]
timer.stop()
print 'Reverse string, slicing:',timer.time()
 
timer.start()
for i in xrange(iterations):
   l=list(test_string)
   l.reverse()
   new_string=''.join(l)
timer.stop()
print 'Reverse string, list:',timer.time()
 
timer.start()
for i in xrange(iterations):
   test_list=test_list[::-1]
timer.stop()
print 'Reverse list, slicing:',timer.time()
 
timer.start()
for i in xrange(iterations):
   test_list.reverse()
timer.stop()
print 'Reverse list, method:',timer.time()

Feel free to use any of this code yourself, consider it under a BSD license. Particularly the Timer class has been useful for me in multiple cases.

Based on the timing results, I’d say it looks best to use the slicing idiom on strings and the reverse method on lists.

I’m currently running the currently unreleased Ubuntu Jaunty on virtually all of my machines.  At times, such as when resuming my notebook, I find that my X session has died.  This is not that much of an inconvenience for me—I do most of my work within a screen session that exists as long as the machine stays running, regardless of what X decides to do.  However, services such as ssh-agent must be restarted when creating a new X session and along with this restart comes a new set values for SSH_AGENT_PID and SSH_AUTH_SOCK.  In addition, it is possible that DISPLAY may change as well.

While these variables have changed, the screen sessions values have not been updated.  So when I re-attach to the running screen session and attempt to use ssh, I find that rather than using the running ssh-agent process to cache my passphrase, I am prompted in my terminal to enter the passphrase.  If I were able to use the updated environment variables I could use the ssh-agent process and all would be fine.

As I normally do, I googled for this issue and ran across this solution to the problem.  Rather than reiterate the details presented in this post, I simply show the two zsh functions I’ve written, as they differ sightly from the afore mentioned post:

grabvars()
{
VARS="SSH_AGENT_PID SSH_AUTH_SOCK DISPLAY"
 
#For each variable in $VARS
for x in $(echo $VARS) ; do
eval echo $x=\$$x | sed  's/=/="/
s/$/"/
s/^/export /'
done 1>$VARSLOC
}
 
sourcevars()
{
if [[ -f $VARSLOC ]]; then
source $VARSLOC
fi
}

Note that VARSLOC names the file that the export statements should be written to.

How do I use these two functions?  sourcevars is called every time a new shell is created (I’ve simply added a call to this function in ~/.zshrc).  grabvars is only called when I create or attach to a screen session, so I’ve aliased ‘screen’ to be ‘grabvars; screen’.  So now when I first login and create a new terminal, this terminal has the updated environment vars.  I do a ‘screen -DR session_name’ to attach, which then calls grabvars, the correct values are written to VARSLOC, and my screen session is attached.  If I create a new window in my screen session, the correct variables are now set.  If I want the updated variables in an exsiting window, I simply call ‘sourcevars’.