Python

Tutti i sorgenti in questa sezione sono soggetti a proprietà intellettuale da parte di Gambuzzi Roberto, autore di questo sito, e sono distribuiti secondo la licenza qui sotto indicata (se non specificato diversamente all'interno del file)
L'uso improprio di tali sorgenti non è sotto la responsabilità del suddetto.
Ogni danno arrecato a se stessi o a terzi per l'uso dei sorgenti non è imputabile al suddetto.

Copyright (C) 2012 Roberto Gambuzzi

Those programs are free software: you can redistribute theme and/or modify
theme under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License.

Those programs are distributed in the hope that someone of theme will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with those programs. If not, see <http://www.gnu.org/licenses/>.


NOTA BENE: In questa sezione potete trovare vari programmi di utilità realizzati per bisogno o per diletto in Python. Lo stile parte da qualcosa di molto immaturo per poi raffinarsi e diventare più pitonico, quindi non commentate con un "ma fa cagare" perché ci sono anche i primi esperimenti che ho fatto.

Ninja IDE nel context menu

pubblicato 4 dic 2013, 06:59 da Roberto Gambuzzi

Ultimamente sto usando Ninja IDE sotto Windows (32bit).
Non ho ancora deciso se mi piaccia, comunque per averlo comodo del context menu, ecco una chiave di registro che fa al caso vostro.

Multi-Mechanize

pubblicato 30 mag 2013, 02:47 da Roberto Gambuzzi   [ aggiornato in data 31 mag 2013, 02:30 ]

Installazione

sudo apt-get install python2.7-dev libfreetype6-dev libpng12-dev python-pip

sudo pip install numpy

sudo apt-get install g++

sudo pip install http://sourceforge.net/projects/matplotlib/files/matplotlib/matplotlib-1.1.0/matplotlib-1.1.0.tar.gz

sudo pip install -U multi-mechanize

Quick Sort

pubblicato 9 mag 2012, 08:44 da Roberto Gambuzzi

non è molto performante ma è carino

def qs(x):
    return x if len(x)<2 else qs(filter(lambda y: y<=x[-1],x[:-1]))+[x[-1]]+qs(filter(lambda y: y>x[-1] ,x[:-1]))

Fattoriale

pubblicato 29 apr 2012, 14:04 da Roberto Gambuzzi

Fattoriale minimale!

fattoriale = lambda z: reduce(lambda x,y: x*(y+1), xrange(z), 1)

Decoratore con parametri procedurale

pubblicato 21 apr 2012, 12:03 da Roberto Gambuzzi

Ecco uno stralcio di codice per decorare una funzione. Nello specifico questo decorate si segna in un dizionario tutte le funzioni decorate con lo stesso parametro. E' stato il prototipo per il decoratore di route per un piccolo framework web che sto sviluppando.

from collections import defaultdict
MODELS = defaultdict(list)

def route(_route='.*'):
    def wrap(f):
        def wrapped_f(*argt, **argd):
            return f(*argt, **argd)
        MODELS[_route].append( wrapped_f )
        return wrapped_f
    return wrap

@route('s')
def gallerie():
    return 1

print MODELS, gallerie()

In pratica la funzione route restituisce la funzione decoratrice wrap, la quale a sua volta restituisce una funzione wrappata che non fa nulla se non chiamare la funzione originale. Nel frattempo si segna in un dizionario di liste le funzioni collegate a 's'.
Nella mia idea c'era l'intenzione di decorare tutte le funzioni con una regex da far matchare con l'url richiesta, con tanto di gruppi estratti con un findall e passati come parametro alla funzione decorata.

Game of War

pubblicato 17 ott 2011, 06:15 da Roberto Gambuzzi

Questo è il mio primo esperimento di programma con la libreria PyGame.
Non ha interazione con l'utente, è una simulazione di scontro su un campo aperto.
È un prototipo per una possibile evoluzione futura in un giochino di strategia.

Il sorgente è un po' lungo da commentare.
La cosa che più mi ha interessato sono le due classi Marine Ghost che ereditano dalla classe Pawn, che di per sè non è nulla, ma che gestisce i movimenti ed il fuoco di base.
Il Ghost reimplementa la routine di fuoco, il Marine no.
Quando queste classi chiamano il costruttore della super-classe, passano anche loro stesse come parametro (clazz). Nono ho trovato un modo più elegante di farlo. Funziona ma mi piace poco.

In testa a file dopo gli import ci sono varie costanti, fra qui FPS che può limitare il frame al secondo visualizzati e il numero di squadre e di classi per un tipo e per l'altro.

Divertitevi pure a giocare con questo sorgente e fatemi sapere le Vostre opinioni; tengo particolarmente a questo programma.

Mp3 player

pubblicato 17 ott 2011, 06:12 da Roberto Gambuzzi   [ aggiornato in data 17 ott 2011, 06:33 ]

Creatore di PDF con carte

pubblicato 17 ott 2011, 06:09 da Roberto Gambuzzi   [ aggiornato in data 17 ott 2011, 06:12 ]

Questo progetto nasce per stamparsi le carte di magic per poi ritagliarle.
Trovandosi a giocare fra amici non c'è la necessità di possedere realmente le carte, basta per convenzione avere i mazzi con queste 'copie ed uso personale'.
Altro scopo dei mazzi cosi fatti è non rovinare la propria collezione di carte.

Il programma è molto semplice

Richiede le librerie:
  • CherryPy
  • ReportLab
  • PIL (Python Image Library)
Il file config.py contiene il seguente codice
origine_carte='carte/*.jpg' # percorsi separati da punto e virgola ';'
matrice = (3,3)
spaziatura = (0.05, 0.05)
dimensione = (5.9,8.39)
rotazione = 0.0
carta = (21.0,29.7)
in questo file viene specificato dove prendere le carte (1° riga), quante metterne per pagina, distanziate quanto l'una dall'altra, con quale dimensione, se ruotarle (vedremo poi che era stata prevista questa funzionalità ma non è stata mai implementata) e la dimensione del foglio.
Tutte le dimensioni sono in Centimetri.

Passiamo ora al programma vero e proprio
from reportlab.pdfgen.canvas import Canvas
from reportlab.lib.units import cm
from glob import glob
from PIL import Image
#from math import sin, cos
import cherrypy
from os.path import abspath
import subprocess
#from win32com.client import Dispatch
from sys import argv
import time
from random import randint

from config import *

def crea(fs):
    offset = [(carta[x]-spaziatura[x]*(matrice[x]-1)-matrice[x]*dimensione[x])/2 for x in xrange(2)] #centratura
    pdf = Canvas('mazzo.pdf', pagesize=[x*cm for x in carta])
    x = 0
    y = 0
    for f in fs:
        for i in xrange(int(fs[f])):
            pdf.drawImage(f, (offset[0]+x*(dimensione[0]+spaziatura[0]))*cm , \
                (offset[1]+(matrice[1]-1-y)*(dimensione[1]+spaziatura[1]))*cm , dimensione[0]*cm , dimensione[1]*cm)
            x += 1
            x %= matrice[0]
            if x==0:
                y += 1
                y %= matrice[1]
            if x==0 and y==0:
                pdf.showPage()
    pdf.save()

class MazzoMaker(object):
    def __init__(self):
#        IE = Dispatch("InternetExplorer.Application")
#        IE.Visible = True
#        IE.Navigate("http://localhost:8080/")
#        subprocess.Popen(['CMD.EXE','/c',"ping 127.0.0.1 -n 2 & start http://localhost:8080/"])
        pass
                               
    def redir(self):
        yield "Please Wait..."
        time.sleep(1)
        raise cherrypy.HTTPRedirect('/')
    redir.exposed = True
        
    def index(self):    
        submit = '<p><input type=Submit value="Crea PDF"></p>'
        ret =  ["<html><head><title>Mazzo Maker</title></head><body><h1>Mazzo Maker</h1>"]
        ret.append('<form method=post action="creamazzo">')
        ret.append(submit)
        for f in glob('temp/*.jpg'):
            ret.append('<img src="%s" width=200px>Quantita<input name="%s" type=Text lenght=2 value=0>' \
                        % ( f.replace('\\','/'), f ) )
        ret.append(submit)
        ret.append('</form></body></html>')
        return '\n'.join(ret)
    index.exposed = True
    
    def creamazzo(self, *args, **key):
        crea(key)
        return cherrypy.lib.static.serve_file(abspath('mazzo.pdf'),"application/pdf", "attachment")
    creamazzo.exposed = True

porta = randint(8080,10000)

cfg = """\
[global]
server.socket_port = %i
server.thread_pool = 10
tools.sessions.on = True
tools.staticdir.root = "%s"

[/temp]
tools.staticdir.on = True
tools.staticdir.dir = "temp"
""" % (porta,argv[0][:argv[0].rfind('\\')].replace('\\','/'))

open('config.cfg','w').write(cfg)

for gf in origine_carte.split(';'):
    for f in glob(gf):
        fdest = 'temp\\' + f[f.replace('\\','/').rfind('/')+1:]
        fdest = fdest[:fdest.rfind('.')] + '.jpg'
        Image.open(f).rotate(rotazione, expand=1).save(fdest, quality=100)
        
subprocess.Popen(['CMD.EXE','/c',"start http://localhost:%i/redir" % porta])
cherrypy.quickstart(MazzoMaker(),config='config.cfg')
La funzione crea prende una lista di carte (fs) e crea un file PDF sul disco.
L'inizializzazione del programma è molto grezza si compone di:
  • scelta di una porta a caso del localhost, nessun check, si spera nella fortuna.
  • scrittura del file di configurazione del cherrypy
  • creazione delle immagini temporanee per la pagina html generata dall'index (vedremo dopo)
  • lancia il broswer sul localhost...
  • ...sperando che il cherrypy si avvii in tempo ^_^
La classe del cherrypy si compone fondamentalmente di una pagina index e di un metodo per il FORM HTML che viene POSTato con le quantità delle carte. Per grandi quantità di carte si è rivelato un po scomodo, ma se uno sa già quali carte servono e mette solo quelle va benissimo.

Un programma molto semplice, realizzato molto in fretta (una pausa pranzo) e che svolge la sua funzione egregiamente direi.

Chiunque abbia idee o migliorie è libero di dirmele e prendere questo codice come spunto per qualsiasi sua idea.

1-8 of 8