I want to share with you a nice trick which, even if not fundamental, is still very useful.
You can also use this to impress your girlfriend.

Sometimes profiling is necessary to understand which part of our code are taking so long.
Python offer different alternatives, I advice you to read the official python documentation to get an idea.

Gprof2Dot

Another very nice thing is gprof2dot .
This little program takes into input profiling data in many different formats and converts it to a dot file, keeping all the valuable informations.

As you can see for example here .
You also need to have graphviz to be able to actually generate the final graph.

Scripting and emacs integration

Given that I want to automate it and I want to use it also from emacs I wrote a simple bash script:

#!/bin/bash
FNAME=$1
if [ ! -f $FNAME ]
then
    echo "file $FNAME not found, executing from $PWD"
    exit 1
fi
# discard filename
shift

# change those variables as you prefer
STATS="output.pstats"
TYPE=png
OUT=output.$TYPE
OPEN="open"

# $@ collect all the arguments for the python script
# it doens't contain the file name after the shift
python -m cProfile -o $STATS $FNAME $@
gprof2dot.py -f pstats $STATS | dot -T$TYPE -o $OUT
rm $STATS
$OPEN $OUT

You can find this script also in my emacs configuration .

Now we’re almost done, just put this somewhere in the emacs exec-path and you’re ready to use it!
Just press Meta-! on a python buffer and launch “gprofile.sh python_file.py [extra args..]“

To automate even more this little elisp functions does that for you:

(defun gprof ()
  (interactive)
  (shell-command (concat "gprofile.sh " buffer-file-name)))

But at the moment it doesn’t take arguments for the script (will fix it soon).

As we all know programmers are lazy, repetition is the evil, we want to type as fast as possible.
Using C-like languages you always need to put the comma in the end.

Normally after the comma you also want to go to newline and indent, so why not put together those two things and automate it?

If you also like yasnippet then you’ll find this feature even nicer.
I took from this feature textmate , a wonderful text editor which comes with this setting by default.
As we’ll see we don’t need many lines of elisp code to end up with a much more powerful and flexible version of this nice feature.

Solution

newline-force

We first define a first function newline-force
Here it is:

(defun newline-force()
  "Goes to newline leaving untouched the rest of the line"
  (interactive)
  (progn
    (end-of-line)
    (newline-and-indent)))

This function goes to end of line and calls the predefined function newline-and-indent, which goes to newline and indent according to mode
In more detail:

• interactive: function is available for user
• progn: executes a sequence of disjointed operations

newline-force-close

The newline-force-close function before going to newline adds a closing char at the end.
We have to consider some more cases:

• we are in the beginning of the buffer
• we already have the closing char inserted

(defun newline-force-close()
  (interactive)
  (end-of-line)
  (let ((closing-way (assoc major-mode newline-force-close-alist2))
        closing-char)
    ;; Setting the user defined or the constant if not found
    (if (not closing-way)
	(progn
	  (message "closing char not defined for this mode, using default")
	  (setq closing-char default-closing-char))
      (setq closing-char (cdr closing-way)))
    (when (not (bobp))
      ;; if we're at beginning of buffer, the backward-char will beep
      ;; :( This works even in the case of narrowing (e.g. we don't
      ;; look outside of the narrowed area.
      (when (not (looking-at closing-char))
 	(insert closing-char))
      (newline-force))))

Using the variable major mode we do a lookup in the association list newline-force-close-alist.
If nothing is found we use the default closing char.

Here below there are the two variables needed.
When defining some default values which shouldn’t change usign defconst is better than setting the symbol with setq.
Using defconst, defvar, defun or defcustom allows you to add a docstring to your symbols.

This is very useful and that’s why emacs is also called the “self documenting editor”.

Here below is the association list, which is simply it’s a list of conses.

(defconst default-closing-char ";"
  "default closing char, change in newline-force-close-alist if needed")

(setq newline-force-close-alist
  '((python-mode . ":")
   (html-mode . " <br>")))

Now last step, we bind the two defined functions to a pair of key

(global-set-key (kbd "M-RET") 'newline-force)
(global-set-key [M-S-return] 'newline-force-close)

In this way we bind globally the two functions o Meta-Return and Meta-Shift-Return.
If you instead prefer to add it only for certain modes than you need to add hooks to your modes, and use local-set-key.

See also this discussion, which is where this code comes from.

Luckily the github guys give us the access to another server (ssh.github.com) which basically listen on the port 443 and forwards

The informations to set up your environment can be found here:

github over proxy

And here you find:
corkscrew

This for example is my configuration (on Macosx but on linux is the same):

SSH_CONFIG

Host gitproxy
  User git
  HostName ssh.github.com
  Port 443
  ProxyCommand corkscrew <proxy> <port> %h %p
  IdentityFile /Users/andrea/.ssh/github

Now in your git repository you can simply add the new remote

git remote add git@gitproxy:<repository>

Another nice way to bypass the proxy (thanks Christian) is to use the GIT_PROXY_COMMAND variable, in this way

export GIT_PROXY_COMMAND=/usr/local/bin/proxy-cmd.sh

#!/bin/bash
(echo "CONNECT $1:$2 HTTP/1.0"; echo; cat ) | socket proxy.unitn.it 3128 | (read a; read a; cat )

And now git for every push/pull will execute that script and bypass the proxy.

etc etc

Or simply get a shell with all the laboratory software you need automatically.

If you also have on those machines a listening xorg then you could also use X11 programs over the ssh, which works like a charm. (ssh -Yc “hostname” “command” for example)

The only two “problems” are:

Let’s see how to solve them.

First we generate a new key:

ssh-keygen -t dsa -f $HOME/.ssh/unilab

Then we upload the public key to one of the pc’s, as long as the home directory is mounted over the network (of course) it doesn’t matter which one.

 scp $HOME/.ssh/unilab.pub utente@host:.ssh/ 

Last thing you need to add to the authorized keys your public key (on whatever lab pc you’re logged in).

 cat $HOME/.ssh/unilab.pub >> $HOME/.ssh/authorized_keys 

Now we can set a really nice configuration in our $HOME/.ssh/config.

Here it is:

Host a10?pc*
  User <youruser>
  IdentityFile <your private key>
  Port 22
  StrictHostKeyChecking no

And that’s it, if for example you now do

 ssh a105pc08 

But we’re not over, how do we know where sshd is up and running?

We’ll we can do a scan of a list of hosts given in input until we find an ssh up and running

#!/usr/bin/env bash
# usage cluster.sh <command> 
# gives you the first possible shell launching the optional command

NC="/opt/local/bin/nc"
FPING="/opt/local/sbin/fping"

function get_first_shell {
	for host in $(lab5)
	do
    echo "analyzing $host"
    if $FPING -t50 $host > /dev/null
      then 
  		if $NC -z -w 1 $host 22 > /dev/null
  		then
  	    open_shell $host $1 && break
  		fi
		fi
	done
}

function open_shell {
  # -t useful lo launch remote interpreters
	ssh -t $1 $2; return
}

function lab5 {
	for ((i=1; $i < 40; i=$i+1))
	do
		echo "a105pc$(printf '%02d' $i)"
	done
}

get_first_shell $1

This is just an example, it’s enough to substitute the lab5 function with a static list or a generator of your hostnames/ip address you want to scan.
The function get_first_shell first checks that the host is up with fping and then checks that the port 22 is open with netcat , and that’s it!
This is an example of execution:

andreaMb:~ andrea$ get_first_shell 
analyzing a105pc01
analyzing a105pc02
analyzing a105pc03
analyzing a105pc04
analyzing a105pc05
analyzing a105pc06
analyzing a105pc07
analyzing a105pc08
Linux austudNONETWORK 2.6.24-23-generic #1 SMP Thu Nov 27 18:44:42 UTC 2008 i686

The programs included with the Ubuntu system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Ubuntu comes with ABSOLUTELY NO WARRANTY, to the extent permitted by
applicable law.

To access official Ubuntu documentation, please visit:
http://help.ubuntu.com/
Last login: Thu Mar 19 12:22:31 2009 from 172.31.121.180
andrea.crotti@a105pc08:~$

Now we have the automatic access, GREAT!

One easy and “legal” way to always find is using netbios, a protocol that makes a computer shout over the network it’s pairing Name -> IP address.

For windows and macosx this works out of the box, for linux/bsd machines you can just set a minimal smb.conf like this.

[global]
	workgroup = WORKGROUP
	server string = My Samba Server
	netbios name = koala

It’s useful to have the correct pairing right in /etc/hosts for every kind of command line program that doesn’t speak netbios.
So we’ll use nmblookup and sed for the task.
Just substitute the netbios name that you need here:

export koala=$(nmblookup koala | sed -n 2p | cut -d ' ' -f 1)
# Now I can substitute the right ip in /etc/hosts
sed "/koala/ s/.*/$koala\tkoala" < /etc/hosts > /tmp/hosts
sudo mv /etc/hosts /etc/hosts.bak
sudo mv /tmp/hosts /etc/hosts

Maybe you also want to modify sudoers to use it without inserting a password each time.

For example I wanted to add a small but very useful function to textmate, I want to be able to know all the possible informations about a whatever function or data type.

The default info function in the haskell bundle unfortunately is only able to retrieve informations about prelude functions or functions used with the full path.
(eg Data.List.lookup and not simply lookup ).

Using ghci I should load the file (which automatically loads also the needed libraries) and type :info.
This is really easily done using “<<".

I added a command “info about” with the following code in my haskell bundle and now if the file is correct (it compiles) you are sure that you’ll get the informations about the function you’re looking for.

GHCI << EOF
:load $TM_FILEPATH
:info ${TM_SELECTED_TEXT:-$TM_CURRENT_WORD}
EOF

I also think that there should be a better way to communicate with ghci (and using System.Enviroment to get the arguments) but I didn’t find any, this solution even if not really elegant works pretty well.

This “approach” can be used also with many interpreters, sometimes I find it really useful.

With the script you’ll find below we set globally the proxy for ftp, http, rsync and subversion:

# Set your own variables in PROXY, PROXY_PORT and USER
USER="user"
PROXY="myproxy"
PROXY_PORT="proxy_port"
export RSYNC_PROXY=$PROXY:$PROXY_PORT
export ftp_proxy=$PROXY:$PROXY_PORT
export http_proxy="http://$PROXY:$PROXY_PORT"
export ALL_PROXY=$http_proxy

USRHOME="/Users/$USER"
SVN="$USRHOME/.subversion/servers"
# checking if not already set, not totally safe
if ! grep $PROXY $SVN
  then
    cp $SVN "$USRHOME/.subversion/servers.bak"
    chown $USER $SVN.bak
    sed -e "
    /\[global\]/ a\
    http-proxy-host = $PROXY\\
    http-proxy-port = $PROXY_PORT\
    " < $SVN.bak > $SVN
fi

To use it just save it somewhere (I suggest $HOME/.[position]) and whenever you need it for example macports just type

source $HOME/.[position]

For subversion I imagine that you also need to restore the situation when you’re not proxyed.
A simple grep command like:

grep -v '^http-proxy*' .subversion/servers

Another program you may need to run behind a proxy (at least I do) is openvpn .
Openvpn it’s great and breaks through anything, but when proxed it needs a few changes to the default configuration.
In a fairly simple configuration we need to add/modify:

proto tcp-client   # doens't work with udp
port 443           # necessary only if for example only 80 and 443 are available
http-proxy <proxy> <port> <file> <modality>

From the openvpn 2.1 manual

–http-proxy server port [authfile|'auto'] [auth-method]
Connect to remote host through an HTTP proxy at address server and port port. If HTTP Proxy-Authenticate is required, authfile is a file containing a username and password on 2 lines, or “stdin” to prompt from console.
auth-method should be one of “none”, “basic”, or “ntlm”.
The auto flag causes OpenVPN to automatically determine the auth-method and query stdin or the management interface for username/password credentials, if required. This flag exists on OpenVPN 2.1 or higher.

My idea with macosx was to get the global variables and automatic changing global configurations there are a couple of problems that I haven’t solved:

I would also really like to authenticate to the coova login page with mechanize or another automatic system but I still have troubles when I get to https connections.

So if you have any idea to improve automatism you’re welcome to comment, thanks and hope that this script actually helps someone.

The program is divided in a few different parts:

Optionally we can also graph the result using the library pydot and passing the “-d” flag from the command line.

The Floyd Warshall algorithm is the core of the program, instead of calculating the shortest path from each city of the path we just calculate using dynamic programming techniques the shortest distances between all the nodes.

It maybe slower if we just want the shortest path between two cities but it adds no more computational complexity when the path length grows.

def floyd_warshall(cities, dist):
    """returns a dictionary containing the minumum distances between cities"""
    dim = len(cities)
    old = new = {}
    # first cycle to set the initial configuration
    for c1 in cities:
        for c2 in cities:
            old[(c1, c2)] = [dist[(c1, c2)], [c2]]
    # ranging over the distance between nodes
    for k in range(1, dim):
        for c1 in cities:
            for c2 in cities:
                diretto = old[(c1, c2)]
                before = old[(c1, cities[k-1])]
                after = old[(cities[k-1], c2)]
                if diretto[0] <= (before[0] + after[0]):
                    new[(c1, c2)] = diretto
                else:
                    new[(c1, c2)] = [before[0] + after[0], before[1]+after[1]]
        old = new
    return new

We use two dictionaries to calculate at each step what is the shortest distance at k-th step (with k steps between c1 and c2).
We want to save both the distance and the intermediate cities.

The rest of the code is pretty simple to understand, a nice thing (I believe) can be found here:

for t1, t2 in zip(path, path[1:]):

In general using zip over a list and a list without the first element allows get all the pairs in order:

In [76]: k = range(4)

In [77]: for t1, t2 in zip(k, k[1:]):
   ....:     print t1, t2
   ....:     
   ....:     
0 1
1 2
2 3

So we can execute our navigator program for a fairly simple input and get:

./nav.py -d
GRICIGNANO.CANISTRO.BELLINO.FORCE.CONSIGLIO.AFRAGOLA.CASTELPOTO.GRICIGNANO.CASTELPOTO.GORIANO.CASTELPOTO.AFRAGOLA.FORCE
57

In the same folder the program has generated two png files (if it was able to use the pydot module): path.png and pathgraph.png.
The first one shows the full map with distances between cities.

Red node is the starting city, yellow end node and green nodes are intermediate cities (left nodes if we don’t pass trough them).
click on the image to see it larger

In this other png we actually in what order we go trough the map, in form order(distance).

Here there is the full source code:

#!/usr/bin/env python

from copy import deepcopy
from sys import maxint
from sys import argv
from getopt import getopt

def parse_stradario(stradario):
    """parses the file containing the map"""
    toparse = open(stradario).readline().split('.')
    idx = 0
    ncities = int(toparse[idx])
    cities = toparse[1 : ncities + 1]
    idx = ncities + 1
    # main data structure used
    dst = {}
    for jdx in range(0, ncities * ncities, ncities):
        for kdx in range(ncities):
            val = int(toparse[idx + jdx + kdx])
            if val < 0:
                val = maxint
            dst[(cities[jdx / ncities], cities[kdx])] = val
    return ncities, cities, dst

def parse_percorso(percorso):
    &quot;&quot;&quot;parses the path&quot;&quot;&quot;
    return file.readline(open(percorso,'r')).split('.')[:-1]

def floyd_warshall(cities, dist):
    &quot;&quot;&quot;returns a dictionary containing the minumum distances between cities&quot;&quot;&quot;
    dim = len(cities)
    old = new = {}
    # first cycle to set the initial configuration
    for c1 in cities:
        for c2 in cities:
            old[(c1, c2)] = [dist[(c1, c2)], [c2]]
    # ranging over the distance between nodes
    for k in range(1, dim):
        for c1 in cities:
            for c2 in cities:
                diretto = old[(c1, c2)]
                before = old[(c1, cities[k-1])]
                after = old[(cities[k-1], c2)]
                if diretto[0] <= (before[0] + after[0]):
                    new[(c1, c2)] = diretto
                else:
                    new[(c1, c2)] = [before[0] + after[0], before[1]+after[1]]
        old = new
    return new
    
def draw(cities, dist, path):
    &quot;&quot;&quot;draws the graphs&quot;&quot;&quot;
    try:
        import pydot
    except Exception.ImportError:
        print &quot;pydot not present, install it if you want to graph&quot;
        return
    graph = pydot.Dot(graph_type='graph')
    nodes = []
    for c in cities:
        n = pydot.Node(c, label=c, color='black')
        if c == path[0]:
            n.set_color('red')
        elif c == path[-1]:
            n.set_color('yellow')
        elif c in path[1 : len(path)-1]:
            n.set_color('green')
        nodes.append(n)
        graph.add_node(n)
    for i in range(len(cities)):
        for j in range(i + 1, len(cities)):
            d = dist[(cities[i], cities[j])]
            if d < maxint:
                e = pydot.Edge(nodes[i], nodes[j], weight=str(d), label=str(d))
                graph.add_edge(e)
    
    pathGraph = pydot.Dot(graph_type='digraph')
    # very nice way to enumerate couples of a list
    i = 1
    for t1, t2 in zip(path, path[1:]):
        e = graph.get_edge(t1, t2)
        w = 0
        # I could have more than one edge from get_edge
        if isinstance(e, list):
            w = e[0].get_weight()
        else:
            w = e.get_weight()
        e1 = pydot.Edge(pydot.Node(t1, label=t1), pydot.Node(t2, label=t2), label=str(i)+&quot;(&quot; + w + &quot;)&quot;)
        pathGraph.add_edge(e1)
        i += 1
    pathGraph.write_png('pathgraph.png')
    graph.write_png('path.png')

def usage():
    &quot;&quot;&quot;docstring for usage&quot;&quot;&quot;
    print &quot;&quot;&quot;
    ./nav.py [-s stradario] [-p path] [-d]
    nav.py gets as input (optional) a map and a path chosen and outputs the shortest path,
    optionally with option [-d] it also creates two nice graphs with pydot and open them.
    &quot;&quot;&quot;

def main():
    &quot;&quot;&quot;Main function&quot;&quot;&quot;
    strad = &quot;stradario.txt&quot;
    path = &quot;percorso.txt&quot;
    isdraw = False
    
    opts, args = getopt(argv[1:], &quot;s:p:d&quot;)
    for o,a in opts:
        if o in '-s':
            strad = a
        if o in '-p':
            path = a
        if o in '-d':
            isdraw = True

    n, cities, dist = parse_stradario(strad)
    min_dist = floyd_warshall(cities, dist)
    percorso = parse_percorso(path)
    final_dist = 0
    tappe = [percorso[0]]
    for i in range(len(percorso)-1):
        dst = min_dist[(percorso[i],percorso[i+1])]
        final_dist += dst[0]
        tappe += dst[1]
    print '.'.join(tappe)
    print final_dist
    if isdraw:
        draw(cities, dist, tappe)

if __name__ == '__main__':
    main()

I see that there are problems with the comments (every quote is translated into “&quot” even if I put the source code in the tag).
I have this problem only with this python file, if you have an idea of the reason of that behavior please tell me.

As usual if you have any critique or doubt (or you find some bugs, sure they are plenty) you’re welcome to notice it.

This script is used to generate two simple output files in the form:

  rand_c = []
  jump_max = len(cities) / n_cit
  # FIXME: any smarter way to add many cities randomically picked from a list?
  start = randrange(jump_max)
  rand_c.append(cities[start].strip())
  for _ in range(n_cit - 1):
      start += randrange(jump_max)
      rand_c.append(cities[start].strip())
  return rand_c

  for i in range(n_cit):
      # setting to 0 we make sure the diagonal is filled of 0
      res[i] = [0] * n_cit
      for j in range(i):
          res[i][j] = res[j][i] = gen_distance()

  def gen_distance():
      """generates a random distance if threshold reached
      Otherwise no connection => -1"""
      if randrange(0, 11) <= conn_grade:
          return randrange(DST_MIN, DST_MAX)
      else:
          return -1

Output files

#!/usr/bin/env python

# This script generates the input file for the real program navigator,
# given a connection degree, the number of cities and the length
# of the path to calculate

import getopt
from random import randrange, choice
from sys import exit, argv, stdout

MAP_FILE = 'stradario.txt'
PATH_FILE = 'percorso.txt'
BADARGS = 3
DST_MIN = 1
DST_MAX = 10

def gen_cities(n_cit, fname='cities.txt'):
    """Returns n cities picked casually from file fname"""
    cities = open(fname).readlines()
    # check if less cities than possible
    if n_cit > len(cities):
        raise Exception("not enough cities")
    else:
        rand_c = []
        jump_max = len(cities) / n_cit
        # FIXME: any smarter way to add many cities randomically picked from a list?
        start = randrange(jump_max)
        rand_c.append(cities[start].strip())
        for _ in range(n_cit - 1):
            start += randrange(jump_max)
            rand_c.append(cities[start].strip())
        return rand_c


def gen_table(n_cit, conn_grade):
    """Generates the table of distances between cities,
    it basically works on the lower triangular matrix
    automatically setting the upper part
    """
    from operator import add
    def gen_distance():
        """generates a random distance if threshold reached
        Otherwise no connection => -1"""
        if randrange(0, 11) <= conn_grade:
            return randrange(DST_MIN, DST_MAX)
        else:
            return -1
    res = [None] * n_cit
    for i in range(n_cit):
        # setting to 0 we make sure the diagonal is filled of 0
        res[i] = [0] * n_cit
        for j in range(i):
            res[i][j] = res[j][i] = gen_distance()
    # FIXME heavy use of lambdas
    flat = reduce(lambda x, y: add(x, y), res)
    return '.'.join(map(lambda x: str(x), flat)) + '.'


def gen_map(cities, n_cit, conn_grade):
    """creates the random map file"""
    st = '.'.join([str(n_cit), '.'.join(cities), gen_table(n_cit, conn_grade)])
    return st


def random_path(cities, num):
    """creates a random path of length num using the array cities"""
    if len(cities) == 1:
        print "no path possible"
        return cities[0]
    i = 0
    path = []
    while i < num:
        # FIXME if num >> len(cities) very inefficient
        new = choice(cities)
        # we just generate another instance if we get the same value
        if path and new == path[-1]:
            continue
        path.append(new)
        i += 1
    return path

def gen_path(cities, lenpath):
    """writes the path obtained"""
    return '.'.join(random_path(cities, lenpath)) + '.'


def generate(n_cit, lenpath, grade, output):
    """Generations of input and writing on the output files"""
    cities = gen_cities(n_cit)
    mappa, path = gen_map(cities, n_cit, grade), gen_path(cities, lenpath)
    output[0].write(mappa)
    output[1].write(path)
    

def usage():
    """docstring for usage"""
    print """ ./gen_input.py [-n n_cities] [-r lenpath] [-g connection_grade] [stradario] [percorso] -o
        If -o is given it will print output to standard output
        All the parameters have already a default value, which is
        n_cities   => 10
        lenpath     => 10
        grade       => 5
        stradario   => "stradario.txt"
        percorso    => "percorso.txt"""
    exit(BADARGS)

if __name__ == '__main__':
    opts, args = getopt.getopt(argv[1:], 'ohr:n:g:')
    # default value
    n_cities = npath = 10
    grade = 5                   # middle level of connection grade
    for o, a in opts:
        if o in ('-h'):
            usage()
        if o in ('-r'):
            npath = int(a)
        if o == '-n':
            n_cities = int(a)
        if o == '-g':
            grade = int(a)
            if grade < 0 or grade > 10:
                usage()
        if o == '-o':
            args = [stdout, stdout]
    if not args:
        args = [open(MAP_FILE, "w"), open(PATH_FILE, "w")]
    if len(args) == 1:
        usage()
    generate(n_cities, npath, grade, args)

You will also need a cities text file, I just realized that I cannot upload zip or txt files, so for now I will paste some lines of the file I’m using, just paste it everything on a file and call it ‘cities.txt’.

VILLAPUTZU
VILLAR
VILLARBASSE
VILLARBOIT
VILLAREGGIA
VILLARICCA
VILLAROMAGNANO
VILLAROSA
VILLASALTO
VILLASANTA
VILLASIMIUS
VILLASOR
VILLASPECIOSA
VILLASTELLONE
VILLATA
VILLAURBANA
VILLAVALLELONGA
VILLAVERLA
VILLENEUVE
VILLESSE
VILLETTA
VILLETTE
VILLIMPENTA
VILLONGO
VILLORBA
VILMINORE
VIMERCATE
VIMODRONE
VINADIO
VINCHIATURO
VINCHIO
VINCI
VINOVO
VINZAGLIO
VIOLA
VIONE
VIPITENO
VIRGILIO
VIRLE
VISANO
VISCHE
VISCIANO
VISCO
VISONE
VISSO
VISTARINO
VISTRORIO
VITA
VITERBO
VITICUSO
VITO
VITORCHIANO
VITTORIA
VITTORIO
VITTORITO
VITTUONE
VITULANO
VITULAZIO
VIU
VIVARO
VIVERONE
VIZZINI

]]> http://petitesnouvelles.wordpress.com/2009/01/06/multilanguage-and-multiparadigm-navigator-2n/feed/ 0 petitesnouvelles http://petitesnouvelles.wordpress.com/2008/12/29/get-the-k-th-digit-out-of-a-number/ http://petitesnouvelles.wordpress.com/2008/12/29/get-the-k-th-digit-out-of-a-number/#comments Mon, 29 Dec 2008 10:27:19 +0000 petitesnouvelles http://petitesnouvelles.wordpress.com/?p=55 ]]> One really common problem is to get the k-th digit out of a number.
For example given the number

10210

we want to know what it the second digit.

We’ll see how we can solve elegantly this problem in python.

The simplest (and fastest) way is to trasform the number in string and list the chars obtained.

>>> n = 123123
>>> map(int, list(str(n)))
[1, 2, 3, 1, 2, 3]

This is pretty nice but we may want a numerical way to get the digits, thanks to Carlo (on an italian python group) we can just use

>>> n=987654321 
>>> list(reversed([d for n, d in iter(lambda: divmod(n, 10), (0,0))])) 

    [9, 8, 7, 6, 5, 4, 3, 2, 1] 

This is the one-liner version of the classic algorithm used to change a number base.
The most important function is iter which takes a callable and a sentinel, continues to iterate the lambda function until it gets (0,0) .
After we build a list with the list comprehension construct and reverse it.
The first list returns a list object given the iterator constructed by reversed.

It actually works for any bases <= 10, we can redefine as:

>>> f = lambda n, base: list(reversed([d for n, d in iter(lambda: divmod(n, base), (0,0))]))
>>> f(10,2)
[1, 0, 1, 0]

We can also get back our original number in a similar way:

>>> n = 1231231; l = [1,2,3,1,2,3,1]
>>> pows = list(reversed([int(pow(10, x)) for x in range(len(l))]))
>>> sum([pows[i]* l[i] for i in range(len(l))]) == n
True

]]> http://petitesnouvelles.wordpress.com/2008/12/29/get-the-k-th-digit-out-of-a-number/feed/ 2 petitesnouvelles