Newsgroup: it.comp.programmare
Titolo: [CONFRONTO] C++ vs Python vs Java (benchmarks puri)

==============================================================
Quello che segue è un banale confronto di performances tra i tre linguaggi 
di cui al subject. Le condizioni del benchmark sono le seguenti:
==============================================================
HARDWARE:    PIII 1Ghz, 512 Mb RAM
S.O.:        Linux SuSE 8.2 (kernel 2.4.19)
C++:         g++ 3.2
PYTHON:      Python 2.3 (#1, Aug 19 2003, 12:01:08) [GCC 3.2]
JAVA:        JDK 1.3.1 (09)
==============================================================
Il programma per il benchmark è il seguente:
        P1(N): Riempe un vettore di N elementi interi con N numeri interi casuali.
==============================================================
Le tre implementazioni sono le seguenti:
--- CUT HERE, FILE: P1.py ---
from random import Random
y = [];
for x in range(N) :
        y = y + [ Random( ) ];
--- CUT HERE ---
--- CUT HERE, FILE: P1.java ---
import java.util.Vector;
import java.util.Random;
class P1 {
        public static void main(String[] args) {
                Random r = new Random();
                Vector y = new Vector();
                for( int x = 0; x < N; ++x )
                        y.add( new Integer( r.nextInt( )  ) );
        };
}
--- CUT HERE ---
--- CUT HERE, FILE: P1.cpp ---
#include <iostream>
#include <deque>
using namespace std;
int main( ) {
        deque< int > y;
        for( int x = 0; x < N; ++x )
                y.push_back( rand( ) );
        return 0;
}
--- CUT HERE ---
==============================================================
Ovviamente, nel corso delle misurazioni, il valore di N verrà quantificato 
ed inserito prima della misurazione dei tempi di esecuzione.
Nessun compilatore o interprete compila/interpreta il codice con particolari 
ottimizzazioni (il g++ *NON* viene richiamato con l'opzione "-O3"). 
I tempi di esecuzione sono misurati con l'utilità "time" e corrispondono al 
tempo medio.
==============================================================
P1(1).py: 46.6 ms; P1(1).java: 280.6 ms; P1(1).cpp: 6 ms
P1(10).py: 48.0 ms; P1(10).java: 280.0 ms; P1(10).cpp: 6 ms
P1(100).py: 53.3 ms; P1(100).java: 288.0 ms; P1(100).cpp: 6 ms
P1(1000).py: 130.3 ms; P1(1000).java: 296.0 ms; P1(1000).cpp: 6 ms
P1(10000).py: 7914.0 ms; P1(10000).java: 306.0 ms; P1(10000).cpp: 7 ms
RATIO Python/C++
1    : 7.76
10   : 8
100  : 8.88
1000 : 21.66
10000: 1130.57
RATIO Java/C++
1    : 46.66
10   : 46.66
100  : 48.66
1000 : 49.33
10000: 51
RATIO Python/Java
1    : 0.16
10   : 0.17
100  : 0.18
1000 : 0.44
10000: 25.86
==============================================================
CONCLUSIONI
==============================================================
In base alle rilevazioni, notiamo come la natura altamente dinamica del 
linguaggio Python insieme alla sua implementazione interpretata rappresenti 
un limite notevole per ciò che riguarda le risorse di calcolo necessarie.
Dalle misurazioni si evince anche che il tipo primitivo "collezione" del 
Python è ottimizzato per una cardinalità di circa 100 elementi, superati i 
quali si ha un degrado delle performances (cosa che non avviene di fatto 
con il contenitore generico std::deque del C++ e Vector di Java).
In base al ratio tra i vari linguaggi, è significativo vedere come Java sia 
più conveniente di Python quando il numero di elementi comincia a superare 
il migliaio, in quanto sebbene penalizzato dal caricamento della sua VM, 
risulta alla fine molto più performante.
Su tutti primeggia il C++ che, alla fine, è mediamente poco più di 500 volte 
più veloce del Python (cioè di almeno due ordini di grandezza, quasi tre) e 
50 volte più veloce del Java (cioè di almeno un ordine di grandezza, quasi 
due).
==============================================================
-- 
---
*************** | Have you ever retired a human by mystake?
*** Azathot *** |
*************** | To contact me, ask me gently. Thanks.

 con il contenitore generico std::deque del C++ e Vector di Java).
Mmm direi che fineo a centomila se la cava piuttosto bene. Ad ogni modo
std::deque non è esattamente un tipo "primitivo" no? E di certo Vector non
lo è. Anzi ti consiglio di rifarlo con l'ArrayList. Comunque per tua
informazione...dato che sei un ottimo conoscitore del Python non sto
nemmeno a dirti che esistono altre strutture per fare quel tipo di
operazioni numeriche. Ma questo tu già lo sai.
-- 
Lawrence "Rhymes" Oluyede
http://loluyede.blogspot.com
rhy...@NOSPAMmyself.com

 operazioni numeriche. Ma questo tu già lo sai.
Il punto sta tutto nel rapporto di performances.
Buona documentazione!


 array nativi (anch'essi numerici).
Cosa append? Ma scherzi? Stai dimostrando tutta la tua abissale ignoranza,
č il metodo normale da usare per aggiungere un elemento in fondo ad una
normalissima lista.
Poi dove sei andato a prendere quella definizione dal modulo array? Cosa
c'entra con le liste?
Questa schifezza cos'č?
        y = y + [ Random( ) ];
Sai almeno quello che stai facendo? Ad ogni iterazione crei una nuova lista
con un elemento casuale, la sommi alla lista "y" preesistente e assegni la
*nuova* lista cosě creata alla variabile "y".
Il resto del messaggio non l'ho ancora letto.
-- 
Marco Barisione
http://spazioinwind.libero.it/marcobari/

 Buona documentazione!
La consiglio a te, parti da qui: 
www.python.org


 Il resto del messaggio non l'ho ancora letto.
Ti conviene farlo.
Ciao.


 La consiglio a te, parti da qui: 
www.python.org
Scusa eh, mi fai ridere: prima intervieni per smentire con dati fasulli, e 
poi ti paraventi dietro la documentazione!!!
Sei proprio un *poveraccio*.
Adios.


 No, non scherzo: 
http://www.python.org/doc/current/lib/module-array.html
Solo perché due tipi diversi che fanno cose simili (come ad esempio
potrebbero essere std::list e std::vector) hanno un metodo con lo stesso
nome tu decidi che Lawrence ha usato un array?
Lui ha usato una normalissima lista. Dove vedi che ha usato un array?
"y = []" è una lista, un tipo built-in che si impara ad usare il primo
giorno che si tocca Python. E poi sostieni di conoscere Python?


 E poi sostieni di conoscere Python?
Ciccio, c'è un'impostazione, c'è un filo logico, ci sono le misurazioni. 
Invece di offendere, vogliamo argomentare, sì?


 vediamo di riscriverlo:
Questo tra l'altro cozza con l'affermazione che si fa qui da molto tempo, 
cioé che Python sia "più facile" del C++. :^)


 No, non scherzo: 
http://www.python.org/doc/current/lib/module-array.html
Questo l'hai letto vero?
http://www.python.org/doc/current/lib/typesseq-mutable.html


 Questo l'hai letto vero?
Ovviamente.


 Invece di offendere, vogliamo argomentare, sì?
Secondo me dovevi fare l'avvocato. Ti abbiamo appena dimostrato che non sei
poi cosi esperto di Python, anzi..., eppure sei li nella tua aula di
tribunale a scalciare col pugno alzato gridando obiezione e cercando
di...indovina un pò...arrampicarti sugli specchi :)
Buona fortuna Az. la carriera da giurista non è facilissima ma ce la puoi
fare.


 Buona fortuna Az. 
Ok, in bocca al lupo anche a te. Hai appena dimostrato di non accettare la 
realtà per quella che è. Buona seduta dallo psicanalista!


>> help([].append)
e vedi cosa ti viene fuori.


 Sei proprio un poveraccio.
Solo una cosa ROTFL.
ps. comunque hai ragione...il mio conto in banca non è ancora a nove zeri :)


 realtà per quella che è.
Ho mai scritto in questo thread che C++ è inferiore a Python in tutto e per
tutto non mi sembra... io mi sono limitato a riscrivere lo script in
_Python_ e non in _Azathot-Python_ e a farti vedere i miei tempi. Poi fai
come vuoi.


 Invece di offendere, vogliamo argomentare, sì?
Ho argomentato che tu fai una cosa completamente diversa da quella che fai
in C++.
Tu ad ogni iterazione copi tutta la lista e poi le sommi invece di
aggiungere un elemento alla fine.
È *completamente* diverso dal push_back del C++. L'analogo del push_back è
il metodo append.


 cioé che Python sia "più facile" del C++. :^)
Probabilmente sei l'unico essere vivente sulla terra che trova Python più
difficile del C++ e a dire la verità anche un bambino saprebbe la
differenza tra 
y = []
y = y + random.random()
piuttosto che 
y = []
y.append(random.random())
Non ci vuole molto basta leggere il tutorial...ah si ma è scritto da Van
Rossum quindi tu non ti degnerai di leggerlo.


 metodo append delle liste.
Beh, comunque sarebbe interessante rifare i test, ma già vedo che con 1000 
inserimenti i tempi si restringono solo di poco...


 Scusa ma dove sta scritto che deve fare tutta la copia? :-?
Č quello che fa il tuo programma in Python!
Il + crea un nuovo oggetto, non avendo senso modificare gli operandi.
Quando tu sommi due liste stai creando una nuova lista che contiene gli
elementi della prima piů quelli della seconda, in questo caso la copia č
inutile, quindi si deve usare append che č l'analogo di push_back.


 Scusa ma dove sta scritto che deve fare tutta la copia? :-?
perchè è il comportamento dll'operatore + sulle liste


         y = y + [ Random( ) ];
buona fortuna:) sei proprio furbo, ma questo espediente è inutile,
il codice C++ sarebbe comunque più veloce del Python, non
cerchiamo di scoprire l'acqua calda...se dovessi scegliere un linguaggio
solo in base alle sue prestazioni...
ciaociao

Azazel ha scritto:


Su questo nessuno ha dubbi.
La questione è: ne vale la pena? Le "superiori prestazioni" del c++
valgono la sua complessità in OGNI caso? O ci sono certi ambiti nei quali
le performances non sono indispensabili, ma lo sono piuttosto la rapidita
di sviluppo e la facilità di manutenzione?
Bisognerebbe però fare diversi test, di diverso tipo, comprendendo accessi
a DB, ordinamenti, i/o sul disco, etc etc, includendo di volta in volta
una stima dei tempi di scrittura dei codici, ed eseguendo i test usando
diverse versioni dello stesso programma nello stesso linguaggio scritti da
persone diverse...
Raffaele
-- 
Raffaele Castagno
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 solo in base alle sue prestazioni...
È questo il punto, Python non è fatto per fare certe cose, ma può essere
usato in settori molto ampli. Siamo sicuri che la differenza di prestazioni
non molto grande in questo caso faccia davvero la differenza?
Penso che con psyco il pezzo di codice corretto che fa quello che vuole
Azimuth possa avere prestazioni molto vicine a quello C++ (ma ottimizzare
tutto con psyco sarebbe stupido oltre che controproducente).


         y = y + [ Random( ) ];
Che e` sta roba qua? Con quel punto e virgola alla fine poi...  Qua fai il
triplo delle cose che fai con gli altri linguaggi, e 2/3 delle cose che
fai sono inutili... Le liste hanno un metodo chiamato append() che
permette di aggiungere elementi ad una lista senza pero` ricrearla ogni
volta (come fai tu li` sopra, e ne ricrei per ben 2 volte ogni ciclo).
Se tutti programmassero come te usando python... Meno male che tu non lo
conosci, non e` bene che ne parli ma finche` scrivi sta robaccia... Altro
che codice ottimizzato.
-- 
Valentino Volonghi, Regia SpA, Milan
Linux User #310274, Debian Sid Proud User

 essere un pochino più a tuo favore. Tu che ne pensi?
==========================
import random
y = []
for x in xrange(N):
    y.append(random.random())
==========================
#include <iostream>
#include <deque>
using namespace std;
int main( ) {
        deque< int > y;
        for( int x = 0; x < N; ++x )
                y.push_back( rand( ) );
        return 0;
}
=========================
import java.util.Vector;
import java.util.Random;
class P1 {
        public static void main(String[] args) {
                Random r = new Random();
                Vector y = new Vector();
                for( int x = 0; x < N; ++x )
                        y.add( new Integer( r.nextInt( )  ) );
        };
}
=========================
Python2.3, Gcc3.3, Jre 1.4.1 Blackdown (gcc3.2)
P1(100): C++: 2ms, Python: 13ms, java: 24ms
P1(1000):     3ms,         17ms,       23ms
P1(10000):    3ms,         17ms,       23ms
P1(100000):   4ms,         20ms,       23ms 
P1(1000000):  4ms,        200ms,       25ms
Con questo cosa abbiamo dimostrato? Che se ti serve potenza enormemente
elevata allora python non e` il caso in quanto oltre una certa soglia
comincia a fare fatica (o perche` manca memoria visto che ne fa un uso
particolarmente massiccio, o perche` proprio non e` adatto). Abbiamo
inoltre dimostrato che tu sei un banfone contaballe che scrive codice
python come lo scrive la mia cuginetta che ha 3 anni.
Tutto e` andato su un Athlon 2000+ con 256Mb di SdRam su Via Km133 (e` un
laptop). Io vedo ch fino a 1 M di elementi python se la cava benissimo con
metodi built-in della lista, l'array e` un altro tipo di dato. Poi puoi
dire quello che vuoi ma tanto sono comunque boiate... Tra l'altro decidere
se e` utile o no un linguaggio da questa robetta e` risibile...


 Altro che codice ottimizzato.
Lavati la bocca prima di parlare con me, poppante. :*


 di sviluppo e la facilità di manutenzione?
Ma certo... facciamo merda, tanto a noi che ci frega? Siamo rapidi a 
sviluppare, noi! Siamo commercialmente aggressivi! :^)


 Rossum quindi tu non ti degnerai di leggerlo.
Infatti... Quindi il Python ha perso persino il diritto di chiamarsi 
"linguaggio intuitivo". :^)


 se e` utile o no un linguaggio da questa robetta e` risibile...
Sei tu ad essere risibile, ciccio.


 Mi dai l'URL dove recuperare questa versione?
www.google.com


 passare... :^)
Scusa ammetto il typo ad ogni modo il punto non cambia.


 
Sei tu quello che non è riuscito ad impararlo...ma è meglio cosi :)


 Lavati la bocca prima di parlare con me, poppante. :*
Accendi il cervello scimmia arrampicavetri


 Sei tu ad essere risibile, ciccio.
Ovviamente i dati di fatto li hai tralasciati alla grande. Ottima
obbiettivita`.


 writes:
import random
ran = random.random
y = []
for x in xrange(N):
    y.append(ran())
P1(100): C++: 2ms, Python: 13ms, java: 24ms, AGG:  11ms
P1(1000):     3ms,         17ms,       23ms,       11ms
P1(10000):    3ms,         17ms,       23ms,       13ms
P1(100000):   4ms,         20ms,       23ms,       19ms
P1(1000000):  4ms,        200ms,       25ms,      189ms


                        y.add( new Integer( r.nextInt( )  ) );
				^^^^^^^^^^^^
Questo mi sembra abbastanza scorretto, perlomeno per un benchmark :-)
Non mi pare che in C++ tu crei un'oggetto nello heap prima di inserirlo nella collezione,
o mi sbaglio? 
Le cose non mi sembrano paragonabili, mi sembrerebbe corretto in tutti i casi
creare/passare sempre un oggetto oppure usare una collezione in grado di mantenere tipi
primitivi.
Ciao,
    Bruno.
-- 
| Bruno Bossola 
| A Java Software Engineer :-)
| 
http://digilander.iol.it/bbossola
| Membro del JUG Torino - 
http://www.jugtorino.it

 P1(1000000):  4ms,        200ms,       25ms,      189ms
Che roba è AGG?


 Che roba è AGG?
Python con il binding locale del metodo che viene richiamato "solo" 1
milione di volte... Facendo il rebinding con ran = random.random evito di
andare a ricercare il metodo random all'interno del modulo random ogni
volta che mi serve. Nel caso di molte chiamate alla stessa funzione e` una
cosa che aiuta parecchio.
Ad ogni modo mi sembrava chiaro, ho modificato solo il codice di P1.py e
quindi l'aggiornamento riguardava solo lui.


 cosa che aiuta parecchio.
/s/metodo/funzione


 Che roba è AGG?
AGGiornamento, penso. Ha postato una versione del codice
leggermente diversa.
-- 
 Francesco Romani - Ikitt  | Describe your vision, the meaning is missing |
*** mailserver: 
freemail.it
| Won't anybody listen?                        |

 volta che mi serve
Giusto...non avevo pensato a questo tipo di ottimizzazione. Io avevo
intenzione di fare qualche prova con psyco ma ho altro da fare :)


 leggermente diversa.
Si si poi ho notato


 intenzione di fare qualche prova con psyco ma ho altro da fare :)
Oltretutto, cui prodest? La situazione e` chiara da tempo... 


 di mantenere tipi primitivi.
Hai un esempio? Perché sarei interessato a migliorare il rendimento del 
programma Java... già tanto penalizzato dal caricamento della VM! :)
Ciao!


 Scusa ammetto il typo ad ogni modo il punto non cambia.
Accetto la tua onestà intellettuale ma il punto appunto non cambia. :)


 obbiettivita`.
Quali dati di fatto? Che tu sia risibile è appena diventato un FATTO.


 
www.google.com
Spiritoso.


 sotto Java (cioè VERAMENTE generici).
Come ben sai non esistono i template in Java fino alla 1.4.x quindi è
inutile cercarli :)


 Quali dati di fatto? Che tu sia risibile è appena diventato un FATTO.
tsk... Non meriti neanche impegno...


 sviluppare, noi! Siamo commercialmente aggressivi! :^)
E tu come ti permetti di dare giudizi su cose che neppure conosci? Non sai
qual'è la mia ditta, nè di cosa si occupa, nè come lavora.
Se dai i tuoi giudizi unicamente in base al linguaggio usato, allora sei
un fanfarone.
Raffaele
-- 
Raffaele Castagno
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 Spiritoso.
Python 2.3c2 - [ Traduci questa pagina ]
Python 2.3c2. We are pleased to announce the release of Python 2.3c2 on
July
24, 2003. This is the second and final release candidate for Python 2.3.
..
www.python.org/2.3/
 - 9k - Copia cache - Pagine simili
il primo risultato che ho ottenuto con "python 2.3"
fai un po tu...


 un fanfarone.
Già a quanto pare per lui solo le ditte che usano C++ fanno linguaggi
seri...come se tutti i programmatori C++ fossero bravi...


 un fanfarone.
Do i miei giudizi in base a chi ne fa parte. Se ci lavori tu è un buon 
indizio... :^)


 seri...
s/linguaggi/applicazioni
Ciao!


 il primo risultato che ho ottenuto con "python 2.3"
Usa un carattere non proporzionale e vedrai cosa andavo VERAMENTE cercando. 
Visto che sul sito *ufficiale* l'ultima versione scaricabile è la 1.3.1 
(04).
Ciao ciccio!



Su un programma reale (ad esempio Eclipse o una web application qualsiasi) il "tempo di
caricamento della VM" e' largamente ininfluente.



Correggere con:
        for( int x = 0; x < N; ++x )
            y[x]=r.nextInt();


 indizio... :^)
Beh, sei molto superficiale se ti basi sull'ultimo arrivato per giudicare
un'intera azienda.


 un'intera azienda.
Se ancora ti tengono, qualcosa vorrà pur dire. :^)


 
http://java.sun.com/j2se/1.4.1/download.html
Strano che la mia ricerca su Google abbia dato altri risultati (?!?!)... che 
dici, sarà un problema del materiale prodotto dal Python? <g> :-)))))


 dici, sarà un problema del materiale prodotto dal Python? <g> :-)))))
Dipende da cosa hai cercato.
Spesso la ricerca più semplice è la più efficace:
"jre 1.4.1":
Java 2 SDK, Standard Edition, v 1.4.1_04 (J2SE) - [ Traduci questa pagina ]
.. Solaris 64-bit requires users to first install 32-bit. Download J2SE
Itanium
Developer Release v 1.4.1, JRE, SDK. Windows 64-bit (Itanium), N/A, ...
java.sun.com/j2se/1.4.1/download.html
 - 57k - Copia cache - Pagine simili
Se poi non sai neppure usare Google...


 
Figurati lui è bravo è colpa di Google che non è professionale perchè usa
anche Python :)


 Se ancora ti tengono, qualcosa vorrą pur dire. :^)
Gia, ma non mecessaiamente quello che pensi tu.


Se puo' essere utile ecco una classe che gestice una collezione di interi, simile a Vector
ma in grado di mantenere tipi primitivi: usando questa il confronto senza oggetti dovrebbe
essere un po' piu' equo.
Non ho implementato tutti i servizi ma solo quelli necessari a fare girare il benckmark:
facci sapere.
Ciao,
    Bruno.
------------------------- IntVector.java -------------------------
public class IntVector
{
    private int capacityIncrement = 100;
    private int capacityInitial   = 100;
 
    private int[] data;
    private int   next;
 
    public IntVector()
    {
        clear();
    }
    public IntVector(int capacity, int increment)
    {
        capacityInitial = capacity;
        capacityIncrement = increment;
        clear();
    }
 
    public void clear()
    {
        data = new int[capacityInitial];
        next = 0;
    }
 
 
    public void add(int value)
    {
        ensureCapacity(next+1);
        data[next++] = value;
    }
 
    public int valueAt(int index)
    {
        if (index >= next)
            throw new IndexOutOfBoundsException("size: "+size()+" - index: "+index);
 
        return data[index];
    }
 
 
    public int size()
    {
        return next;
    }
 
    public void setSize(int newSize)
    {
        ensureCapacity(newSize);
        next=newSize;
    }
 
 
    public int capacity()
    {
        return data.length;
    }
    public void ensureCapacity(int size)
    {
        if (size > data.length)
        {
            int newSize = size+capacityIncrement;
            newSize -= (newSize%capacityIncrement);
 
            int newData[] = new int[newSize];
            System.arraycopy(data, 0, newData, 0, data.length);
            data = newData;
        }
    }
 
 
    public int getCapacityIncrement()
    {
        return capacityIncrement;
    }
    public void setCapacityIncrement(int newCapacityIncrement)
    {
        capacityIncrement = newCapacityIncrement;
    }
 
    public int getCapacityInitial()
    {
        return capacityInitial;
    }
    public void setCapacityInitial(int newCapacityInitial)
    {
        capacityInitial = newCapacityInitial;
    }
    /*
     * main() dummy per prova
     */
    public static void main(String args[])
    {
        IntVector v = new IntVector();
 
        for (int i=0; i<1000; i++)
            v.add(i);
        for (int i=0; i<v.size(); i++)
            System.out.println(i+": "+v.valueAt(i));


 tra loro omogenee. Qui non si fanno i benchmarks "alla Martelli"
ROTFL. Quindi "non vale" ottenere performance migliori con un algoritmo 
migliore o con una migliore conoscenza del linguaggio?
-- 
  < 
http://www.reactos.com/
 >  Open source clone of Windows NT. Current
      Don't stand, REACT!      version 0.1.2. C, C++ and ASM developers
                               and beta testers are welcome!

 E poi sostieni di conoscere Python? 
no, non mi sembra che l'abbia mai sostenuto


 Lavati la bocca prima di parlare con me, poppante. :*
pervertito pedofilo infetto! gių le papille da Dialtone!


 no, non mi sembra che l'abbia mai sostenuto
Quando gli si faceva notare che non si può criticare Python senza
conoscerlo lui rispondeva che lo conosceva a sufficienza.
-- 
Marco Barisione
http://spazioinwind.libero.it/marcobari/

 pervertito pedofilo infetto! giù le papille da Dialtone!
? Quali papille? >:>. Sei una ragazza misteriosa Juliet, non si capisce
mai da che parte stai ;P


 mai da che parte stai ;P
Se ho capito bene lei sta da una sola parte (giustamente): la sua


 migliore o con una migliore conoscenza del linguaggio?
No, non vale scrivere algoritmi migliori o equivalenti agli analoghi
scritti in c++. In poche parole, il c++ è migliore per volontà divina, ed
è eresia affermare il contrario.
A quando le crocifissioni di programmatori python, inquisizioni varie e
roghi di programmatori java?
Con i programmatori che sotto tortura urleranno "SIIII, lo ammetto! Ho
scritto uno script in python per ridimensionare le immagini! Pietaaaaaa"
Poi ovviamente ci sarà l'Indice. Primo della lista: "Python in a
nutshell"...
Vedrò di procurarmi un gatto nero per allora! :)
Raffaele, che dopo tutte le critiche di Azathot si è messo a dare
un'occhiata al py, tiè!


 un'occhiata al py, tiè!
Al contrario di quanto pensa Az. non può farti che bene :)


 Al contrario di quanto pensa Az. non puň farti che bene :)
Ne sono convinto. L'unica cosa scomoda č forse questa faccenda
dell'indentazione per separare i blocchi, ma sembra piů un espediente per
mantenere i blocchi corti e chiari. Credo basti farci un pň l'occhio.
Bye!
Raffaele


 mantenere i blocchi corti e chiari. Credo basti farci un pò l'occhio.
E' solo questione di abitudine, vedrai che dopo non vorrai mai scrivere una
graffa in vita tua :)


 graffa in vita tua :)
Non credo, per ora, che ci starò sopra granchè. Sto solo seguendo dei
tutorial su Linux&Coe LinuxMagazine. Se ho poi voglia faccio anche un pò
di c++......


P1(1000000):  4ms,        200ms,       25ms,      189ms
i miei due eurocent..
un cent:
non si dovrebbe usare NumPy per roba come questa?
due cent:
tanto per dirlo.. in ruby dovrebbe essere così per la versione 1.6
--1
y=[] # oppure Array.new
1.upto(N) do 
 y.push( rand())
end
--
o, leggermente meno efficiente, ma più classico
--2
y=[] # opppure Array.new
for i in (1..N) do
 y.push(i)
--
Nella v1.8 esiste un modo per inizializzare i valori di un array, che
sembra essere la più efficiente:
--3
a=Array.new(N) do
 rand()
end
--
test sbrigativi mostrano ruby1.8 (in efetti una preview e non la
final) un po più veloce di python2.3 ma solo fino a un milione di
elementi.
Oltre python prosegue degnamente e ruby degenera, boh sarà il GC.
[1](le versioni precedenti di entrambi gli interpreti, mi pare di
ricordare, usano un algoritmo di randomizzazione più lento)

 writes:
Python ha una cosa bellissima che io non ho usato ovvero le List
Comprehension che avrebbero reso il codice stupendamente bello e elegante:
import random
ran = random.random
[ran() for x in xrange(N)]
BTW: e` vero che bisognava usare numpy pero` si era detto di non usare
librerie esterne e via dicendo.


 per nomi importanti quali Carrefour e Aermacchi.
Sono contento per voi, ma questo non significa nulla... 
Ciao.
-- 
BSD is for UNIX lovers -- linux is for Windows haters.


tanto per discutere, ennesima possibile versione in python,
leggermente piů veloce:
==============================================================
HARDWARE:    Pentium 133Mhz, 32 Mb RAM
S.O.:        Red Hat Linux 7.2 2.96-102 (kernel 2.4.17-0.13)
PYTHON:      Python 2.2.1 
==============================================================
(per favore non chidetemi perchč questa macchina, con questa
configurazione, esista..)
[loser@irc lsr]$ cat p.py
import random
import sys
ran = random.random
y = []
for x in xrange(int(sys.argv[1])):
    y.append(ran())
[loser@irc lsr]$ cat p2.py
from random import random
import sys
def f(x):
 return random()
a=map(f,xrange(int(sys.argv[1])))
(č impossibile passare a map() una funzione che non accetti
argomenti?)
$ time -p python p.py 10000; time -p python p2.py 10000
real 1.41
user 1.37
sys 0.05
real 1.19
user 1.13
sys 0.06
$ time -p python p.py 100000; time -p python p2.py 100000
real 12.28
user 11.81
sys 0.48
real 10.00
user 9.96
sys 0.04
$ time -p python p.py 1000000; time -p python p2.py 1000000
real 136.31
user 116.56
sys 5.56
real 106.80
user 98.63
sys 0.74