Pacchetto DebDato che spesso mi capita di dover programmare in Python e dato che non ho voglia di stare ogni volta che modifico un sorgente a ricrearmi tutto il .deb. Ho deciso di automatizzare la cosa con uno script. E’ uno script grezzo e perfezionabile, ma fa magnificamente il suo lavoro. Lo pubblico sperando che possa essere utile a qualcuno, ovviamente una volta che l’avete modificato per le vostre esigenze.

#! /bin/bash

version="0.2.0-1"

mkdir nomeprogramma_${version}_all
cd nomeprogramma_${version}_all
mkdir DEBIAN
mkdir usr
cd DEBIAN

# GENERATE CONTROL FILE
echo "Package: nomeprogramma" >> control
echo "Version: ${version}" >> control
echo "Section: video" >> control
echo "Priority: optional" >> control
echo "Architecture: all" >> control
echo "Depends: python, python-qt4" >> control
echo "Installed-Size: 309" >> control
echo "Maintainer: Nome Cognome <email@gmail.com&>" >> control
echo "Description: Bla bla bla" >> control

cd ..
cd usr
mkdir bin
mkdir share
cd bin

# GENERATE START FILE
echo "#!/bin/bash" >> nomeprogramma
echo "cd /usr/share/nomeprogramma" >> nomeprogramma
echo "env python -O main.py" >> nomeprogramma

chmod +x nomeprogramma

cd ..
cd share

mkdir applications
mkdir doc
mkdir nomeprogramma

# GENERATE DESKTOP FILE
cd applications
echo "[Desktop Entry]" >> nomeprogramma.desktop
echo "Version=${version}" >> nomeprogramma.desktop
echo "Name=Nome Programma" >> nomeprogramma.desktop
echo "Comment=Bla bla" >> nomeprogramma.desktop
echo "Type=Application" >> nomeprogramma.desktop
echo "Comment[it_IT]=Bla bla" >> nomeprogramma.desktop
echo "Exec=/usr/bin/nomeprogramma" >> nomeprogramma.desktop
echo "Icon=/usr/share/prova/img/nomeprogramma.png" >> nomeprogramma.desktop
echo "Terminal=false" >> nomeprogramma.desktop
echo "Categories=Multimedia;QT;" >> nomeprogramma.desktop
cd ..

cd ..
cd ..
cd ..

# COPY COMPILED FILE
cp -r -v ./src/* ./nomeprogramma_${version}_all/usr/share/nomeprogramma/ #Questa parte copia tutti i sorgenti del vostro programma python.
cd ./nomeprogramma_${version}_all/usr/share/nomeprogramma/

# CLEAN NOT USEFUL FILES
#Cancella i file non necessari all'esecuzione.
find -name '*.ui' -exec rm -v {} \;
find -name '*.*~' -exec rm -v {} \;
rm Makefile

cd ..
cd ..
cd ..
cd ..

#  MAKE DEB
dpkg -b ./nomeprogramma_${version}_all

# REMOVE TEMP DIRECTORY
rm -r ./nomeprogramma_${version}_all

Ovviamente in nomeprogramma dovete inserire il nome del vostro programma. Ancora meglio sarebbe metterlo in una variabile e usare una variabile, così potete riutilizzarlo per più programmi. A me non andava di farlo e ve lo beccate così com’è :D

Inoltre la copia dei file dovete rivederla perché io assumo che nella cartella in cui c’è questo script esista una cartella src che contiene i sorgenti (in pratica assumo che usiate una convenzione che uso io xD). Ma è solo una riga, si cambia facilmente.

Spero vi sia utile. :)

 

Dato che ho ripreso un po il pallino degli scacchi riporto di seguito uno script python di 60 righe non troppo elaborato (mancano infatti tutte le gestioni delle eccezioni) per il calcolo e aggiornamento del punteggio ELO.

L’uso è semplice e si riduce a:

python elo.py <elo_attuale> <score> <elo_avversario1> ….. <elo_avversarioN>

Per i sistemi Unix come al solito su può tralasciare il “python” iniziale.

#! /usr/bin/env python
# Calcolatore per ELO

import sys

#Costanti per estrarre i dati dal risultato di Start.
OLD_ELO = 0
EXPECTED_SCORES = 1
EFFECTIVE_SCORE = 2
NEW_ELO = 3

#Impostazioni.
SEP = 60

def punteggioAtteso(diff) :
    return 1.0 / ( 1.0 + (10.0 ** ( float(diff) / 400.0 ) ) )

def newElo(elo, patteso, peffettivo, K) :
    return elo + int (K * (peffettivo - patteso) )

def start(arg) :
    lista_attesi = []
    myElo = int(arg[0])
    if myElo < 2100 :
        K = 32
    elif 2100<=myElo<=2400 :
        K = 24
    else :
        K = 16
    peffettivo = float(arg[1])
    avversari = arg[2:]
    patteso = 0
    for i in avversari :
        current_atteso = punteggioAtteso( int(i) - myElo )
        lista_attesi.append(current_atteso)
        patteso += current_atteso
    return (myElo, lista_attesi , peffettivo, newElo(myElo,patteso,peffettivo,K) )

def printResult(result) :
    myElo = result[0]
    lista_attesi = result[1]
    peffettivo = result[2]
    nelo = result[3]
    print "Your current ELO is: %i" % myElo
    print '-'*SEP
    somma = 0.0
    for i in lista_attesi :
        print "\tExpected score #%2i: %f" % (lista_attesi.index(i) + 1 , i)
        somma += i
    print '-'*SEP
    print "\tExpected total score :  %f" % somma
    print "\tEffective total score:  %f" % peffettivo
    print '-'*SEP
    print "Your new ELO is: %i" % nelo
    print "Change: %i%%" % int( ((nelo - myElo) * 100.0) / myElo)
    print '-'*SEP

if __name__ == "__main__" :
    arg = sys.argv[1:]
    result = start(arg)
    printResult(result)

Allegherò in seguito un file commentato.

 

Questo problema recita:

A palindromic number reads the same both ways.
The largest palindrome made from the product of two
2-digit numbers is 9009 = 91×99.

Find the largest palindrome made from the product of
two 3-digit numbers.

Risolviamo questo problema prima concettualmente e poi passiamo alla sua implementazione in Python.

Continue reading »

 

Con il terzo problema ci troviamo davanti la prima difficoltà, questa volta infatti il metodo più intuitivo risulta inapplicabile computazionalmente. Ma leggiamo la richiesta del problema:

The prime factors of 13195 are 5, 7, 13 and 29.

What is the largest prime factor of the number 600851475143 ?

Dobbiamo trovare quindi il più grande fattore primo di un numero dato.

Continue reading »

 

Dopo aver affrontato con non troppa difficoltà il primo problema, ci prepariamo ad affrontare il secondo. Il testo recita più o meno in questo modo.

Each new term in the Fibonacci sequence is generated by adding
the previous two terms.
By starting with 1 and 2, the first 10 terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, …

Find the sum of all the even-valued terms in the sequence which
do not exceed four million.

Il nostro compito consiste quindi nel trovare tutti i numeri di Fibonacci minori di 4 milioni, scartare i dispari e sommare i pari. Matematicamente l’algoritmo consiste in:

  1. Trovare l’n-esimo numero della successione partendo dal n-1esimo e n-2esimo.
  2. Verificare se è pari. Ovvero vedere se il resto della divisione per due è zero.
  3. Se è pari, sommarlo alla somma parziale che teniamo da parte.

Continue reading »

 

In questi articoli cercherò di illustrarvi gli algoritmi risolutivi del Progetto Eulero a scopo didattico e di guida nel caso di problemi particolarmente ostici.

Il problema 1 del Progetto Eulero recita più o meno cosi:

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.

Find the sum of all the multiples of 3 or 5 below 1000.

Bene. Il primo problema, in quanto primo è molto semplice. Dobbiamo trovare tutti i numeri minori di mille tali che siano divisibili interamente da 3 o da 5 e sommarli insieme. In Python l’algoritmo risolutivo ha più o meno questa forma. Continue reading »

© 2008-2012 SlashCode Suffusion theme by Sayontan Sinha