[Commits] python.it commit r172 - python/contrib/faq/trunk
commit a svn.python.it
commit a svn.python.it
Mer 31 Maggio 2006 00:15:09 CEST
Author: meo
Date: Wed May 31 00:15:06 2006
New Revision: 172
Modified:
python/contrib/faq/trunk/library.ht
Log:
Prima versione dell'intero documento
Modified: python/contrib/faq/trunk/library.ht
==============================================================================
--- python/contrib/faq/trunk/library.ht (original)
+++ python/contrib/faq/trunk/library.ht Wed May 31 00:15:06 2006
@@ -1,210 +1,233 @@
-Title: Python Library and Extension FAQ
+Title: FAQ librerie ed estensioni Python FAQ
Content-type: text/x-rst
====================================
Python Library and Extension FAQ
====================================
-:Date: $Date: 2005-12-17 03:21:20 +0100 (sab, 17 dic 2005) $
+:Date: $Date: 2005-12-16 19:21:20 -0700 (Fri, 16 Dec 2005) $
:Version: $Revision: 8684 $
:Web site: http://www.python.org/
+:Traduzione: Bartolomeo Bogliolo 25 Maggio 2006
.. contents::
.. sectnum::
-General Library Questions
-===============================
-How do I find a module or application to perform task X?
--------------------------------------------------------------
+**Traduzione Italiana**
+
+Questo documento, di pubblico dominio, e' stato tradotto da
+`Meo Bogliolo <mailto:meo a bogliolo.name?subject=Traduzione Embedding FAQ>`_
+(revisionato da
+`Daniele Tricoli <mailto:eriol a huine.org?subject=Traduzione Embedding FAQ>`_
+): potete contattarli per qualsiasi
+commento o correzione.
-Check `the Library Reference <http://www.python.org/doc/lib/>`_ to see
-if there's a relevant standard library module. (Eventually you'll
-learn what's in the standard library and will able to skip this step.)
-Search the `Python Package Index <http://cheeseshop.python.org/pypi>`_.
-Next, check the `Vaults of Parnassus <http://www.vex.net/parnassus/>`_,
-an older index of packages.
+Domande Generali sulla libreria
+===============================
-Finally, try `Google <http://www.google.com>`_ or other Web search
-engine. Searching for "Python" plus a keyword or two for your topic
-of interest will usually find something helpful.
+Come si trova un modulo o un'applicazione che realizza la funzionalita' X?
+---------------------------------------------------------------------------
+Innanzi tutto deve essere controllata
+`the Library Reference <http://www.python.org/doc/lib/>`_
+per vedere se vi e' un modulo di libreria standard. (Eventualmente
+si possono conoscere i moduli presenti nella libreria standard ed
+saltare questo passo.)
+
+Quindi si puo' cercare nel
+`Python Package Index <http://cheeseshop.python.org/pypi>`_.
+
+Poi controllare nel
+`Vaults of Parnassus <http://www.vex.net/parnassus/>`_,
+un piu' vecchio indice di pacchetti.
+
+Infine su
+`Google <http://www.google.com>`_
+o su altri motori di ricerca. Ricercando per "Python" ed una
+parola chiave o due sull'argomento di interesse generalmente si
+trova qualcosa di utile.
-Where is the math.py (socket.py, regex.py, etc.) source file?
+
+Dove sono i sorgenti di math.py (o di socket.py, regex.py, ...)?
---------------------------------------------------------------------
-If you can't find a source file for a module it may be a builtin
-or dynamically loaded module implemented in C, C++ or other
-compiled language. In this case you may not have the source
-file or it may be something like mathmodule.c, somewhere in
-a C source directory (not on the Python Path).
-
-There are (at least) three kinds of modules in Python:
-
-1) modules written in Python (.py);
-2) modules written in C and dynamically loaded (.dll, .pyd, .so, .sl, etc);
-3) modules written in C and linked with the interpreter; to get a list
- of these, type::
+Se non si trovano i sorgenti si puo' trattare di un builtin o di un
+modulo caricato dinamicamente implementato in C, C++ o in un altro
+linguaggio compilato. Un questo caso potrebbe non essere presente il
+sorgente o essere in qualche directory di sorgenti C (non nel path
+Python).
+
+Vi sono (almeno) tre tipi di moduli in Python:
+
+1) moduli scritti in Python (.py);
+2) moduli scritti in C e caricati dinamicamente (.dll, .pyd, .so, .sl, ecc);
+3) moduli scritti in C e linkati all'interprete; per ottenerne una lista::
import sys
print sys.builtin_module_names
-How do I make a Python script executable on Unix?
+
+Come si rende un script Python eseguibile su Unix?
---------------------------------------------------------
-You need to do two things: the script file's mode must be executable
-and the first line must begin with ``#!`` followed by the path of
-the Python interpreter.
+Sono necessarie due cose: lo script deve essere eseguibile e la prima
+linea deve iniziare con ``#!`` seguito dal path dell'interprete Python.
-The first is done by executing ``chmod +x scriptfile`` or perhaps
+La prima e' ottenuta eseguendo ``chmod +x scriptfile`` o
``chmod 755 scriptfile``.
-The second can be done in a number of ways. The most straightforward
-way is to write ::
+La seconda puo' essere ottenuta in modi differenti. Il piu' diretto
+e' scrivere::
#!/usr/local/bin/python
-as the very first line of your file, using the pathname for where the
-Python interpreter is installed on your platform.
+come prima linea del file utilizzando il pathname per indicare dove
+e' stato installato Python sul sistema.
-If you would like the script to be independent of where the Python
-interpreter lives, you can use the "env" program. Almost all
-Unix variants support the following, assuming the python interpreter
-is in a directory on the user's $PATH::
+Se si vuole rendere lo script indipendente da dove viene installato Python
+e' possibile utilizzare il programma "env". Praticamente tutte le
+varianti Unix supportano l'esempio seguente, purche' Python sia in una
+directory elencata nel $PATH dell'utente::
#! /usr/bin/env python
-*Don't* do this for CGI scripts. The $PATH variable for
-CGI scripts is often very minimal, so you need to use the actual
-absolute pathname of the interpreter.
-
-Occasionally, a user's environment is so full that the /usr/bin/env
-program fails; or there's no env program at all.
-In that case, you can try the following hack (due to Alex Rezinsky)::
+Da *non* fare per gli script CGI. La variabile $PATH di uno script CGI
+e' spesso minimale, e quindi e' necessario utilizzare il pathname
+assoluto dell'interprete.
+
+In qualche caso l'ambiente di un utente e' cosi' pieno che il programma
+/usr/bin/env fallisce; oppure non e' disponibile il programma env.
+In questi casi si puo' provare il trucco seguente (ideato da Alex Rezinsky)::
#! /bin/sh
""":"
exec python $0 ${1+"$@"}
"""
-The minor disadvantage is that this defines the script's __doc__ string.
-However, you can fix that by adding ::
+Un piccolo svantaggio e' che questo definisce la stringa __doc__ dello
+script. Tuttavia questo si puo' cambiare aggiungendo ::
__doc__ = """...Whatever..."""
-
-Is there a curses/termcap package for Python?
+C'e' un package curses/termcap per Python?
----------------------------------------------------
-For Unix variants: The standard Python source distribution comes with
-a curses module in the Modules/ subdirectory, though it's not compiled
-by default (note that this is not available in the Windows
-distribution -- there is no curses module for Windows).
-
-The curses module supports basic curses features as well as many
-additional functions from ncurses and SYSV curses such as colour,
-alternative character set support, pads, and mouse support. This means
-the module isn't compatible with operating systems that only
-have BSD curses, but there don't seem to be any currently maintained
-OSes that fall into this category.
+Per le versioni Unix: la distribuzione standard dei sorgenti Python
+contiene un modulo curses nella sottodirectory Modules/, sebbene
+non sia compilato di default (deve essere notato che questo non
+e' disponibile nella distribuzione Windows-- non vi e' alcun
+modulo curses per Windons).
+
+Il modulo curses supporta le funzioni di base curses ma anche
+molte funzioni aggiuntive di ncurses e di SYSV curses come i colori,
+il supporto a set di caratteri aggiuntivi e la gestione del mouse
+e dei pads.
+Questo significa che il modulo non e' compatibile con i sistemi operativi
+che abbiamo solo i curses BSD, ma non sembra vi sia alcuni sistema
+operativo, attualmente mantenuto, che ricada in questa categoria.
-For Windows: use `the consolelib module <http://effbot.org/zone/console-index.htm>`_.
+Per Windows: utilizzare il modulo
+`consolelib <http://effbot.org/zone/console-index.htm>`_.
-Is there an equivalent to C's onexit() in Python?
+C'e' un equivalente alla onexit() del C in Python?
--------------------------------------------------------
-`The atexit module
-<http://www.python.org/doc/lib/module-atexit.html>`_ provides a
-register function that is similar to C's onexit.
+Il modulo `atexit <http://www.python.org/doc/lib/module-atexit.html>`_
+fornisce una funzione di registrazione che e' simile alla onexit del C.
-Why don't my signal handlers work?
---------------------------------------------
-The most common problem is that the signal handler is declared
-with the wrong argument list. It is called as ::
+
+Perche' i gestori dei segnali non funzionano?
+----------------------------------------------
+
+La causa piu' frequente e' che il gestore dei segnali e' dichiarato
+con una lista di argomenti sbagliata. Viene richiamato come ::
handler(signum, frame)
-so it should be declared with two arguments::
+quindi deve essere dichiarato con due argomenti::
def handler(signum, frame):
...
-
-
-
-
-Common tasks
+Operazioni comuni
=================
-How do I test a Python program or component?
-----------------------------------------------------
-Python comes with two testing frameworks. The `doctest module
-<http://www.python.org/doc/lib/module-doctest.html>`_ finds examples
-in the docstrings for a module and runs them, comparing the output
-with the expected output given in the docstring.
-
-The `unittest module
-<http://www.python.org/doc/lib/module-unittest.html>`_ is a fancier
-testing framework modelled on Java and Smalltalk testing frameworks.
-
-For testing, it helps to write the program so that it may be easily
-tested by using good modular design. Your program should have almost
-all functionality encapsulated in either functions or class methods --
-and this sometimes has the surprising and delightful effect of making
-the program run faster (because local variable accesses are faster
-than global accesses). Furthermore the program should avoid depending
-on mutating global variables, since this makes testing much more
-difficult to do.
+Come si effettua un test di un programma Python o di un componente?
+--------------------------------------------------------------------
-The "global main logic" of your program may be as simple
-as ::
+Python ha due framework di test. Il modulo
+`doctest <http://www.python.org/doc/lib/module-doctest.html>`_
+cerca esempi nella docstrings di un modulo e li esegue, confrontando
+l'output ottenuto con quello riportato nella docstring.
+
+Il modulo `unittest <http://www.python.org/doc/lib/module-unittest.html>`_
+e' un framework di test piu' fantasioso simile a quanto disponibile in
+Java ed in Smalltalk.
+
+Scrivere il programma con un buon disegno modulare
+rende facilmente effettuabile il test.
+
+Il programma deve essere realizzato con praticamente tutte le
+funzionalita' incapsulate in funzioni o metodi -- questo ha anche spesso
+il bell'effetto di rendere il programma piu' veloce
+(perche' l'accesso a variabili locali e' piu' veloce rispetto agli
+accessi globali).
+Inoltre il programma non deve dipendere sulla variazione di
+variabili globali, che rendono piu' difficile l'esecuzione dei test.
+
+La "logica generale" del programma puo' essere semplicemente ::
if __name__=="__main__":
main_logic()
-at the bottom of the main module of your program.
+al termine del modulo principale del programma.
-Once your program is organized as a tractable collection
-of functions and class behaviours you should write test
-functions that exercise the behaviours. A test suite
-can be associated with each module which automates
-a sequence of tests. This sounds like a lot of work, but
-since Python is so terse and flexible it's surprisingly easy.
-You can make coding much more pleasant and fun by
-writing your test functions in parallel with the "production
-code", since this makes it easy to find bugs and even
-design flaws earlier.
+Una volta che il programma e' organizzato come una
+collezione gestibile di funzioni e di classi
+vanno scritte funzioni di test che testino i comportamenti.
+
+Un insieme di test puo' essere associato a ciascun modulo
+che automatizzi la sequenza di test. Sembra un grande lavoro,
+ma in realta' Python e' cosi' spiccio e flessibile
+che risulta sorprendentemente semplice.
+
+La codifica risulta anche piu' piacevole e divertente
+scrivendo le funzioni di test in parallelo al
+"codice di produzione", poiche' risulta piu' facile
+trovare prima errori ed anche difetti di progetto.
-"Support modules" that are not intended to be the main module of a
-program may include a self-test of the module. ::
+"Moduli di supporto" che non siano moduli main possono
+comunque includere un self-test del modulo. ::
if __name__ == "__main__":
self_test()
-Even programs that interact with complex external interfaces may be
-tested when the external interfaces are unavailable by using "fake"
-interfaces implemented in Python.
+Programmi che interagiscano con interfacce esterne complesse
+possono essere testati anche queste non sono presenti utilizzando
+delle interfacce "fittizie" implementate in Python.
+
-How do I create documentation from doc strings?
+Come si genera la documentazione dalle doc strings?
-------------------------------------------------------
-The `pydoc module <http://www.python.org/doc/lib/module-pydoc.html>`_
-can create HTML from the doc strings in your Python source code. An
-alternative is `pythondoc
+Il modulo `pydoc <http://www.python.org/doc/lib/module-pydoc.html>`_
+genera un HTML dalle doc strings del sorgente Python.
+Un'alternativa e' `pythondoc
<http://starship.python.net/crew/danilo/pythondoc/>`_.
-How do I get a single keypress at a time?
------------------------------------------------
+Come si raccoglie una singola pressione di un tasto alla volta?
+---------------------------------------------------------------
-For Unix variants:There are several solutions.
-It's straightforward to do this using curses, but curses is a
-fairly large module to learn. Here's a solution without curses::
+Per le versioni Unix: Ci sono diverse soluzioni.
+E' immediato farlo con curses, anche se curses e' un modulo
+piuttosto ampio da imparare. Ecco un esempio senza curses::
import termios, fcntl, sys, os
fd = sys.stdin.fileno()
@@ -227,40 +250,48 @@
termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm)
fcntl.fcntl(fd, fcntl.F_SETFL, oldflags)
-You need the ``termios`` and the ``fcntl`` module for any of this to work,
-and I've only tried it on Linux, though it should work elsewhere.
-In this code, characters are read and printed one at a time.
+Sono necessari i moduli
+``termios`` e ``fcntl`` per farlo funzionare
+ed e' stato provato solo con Linux, sebbene dovrebbe funzionare
+anche su altri Unix.
+Con questa codifica i caratteri vengono letti e scritti uno alla volta.
+
+``termios.tcsetattr()`` disabilita l'echo dello standard input e il
+canonical mode.
+``fcntl.fnctl()`` e' utilizzato per ottenere il flag del file
+descriptor dello standard input e li setta in modalita' non-blocking.
+Poiche' leggere dallo standard input quando e' vuoto solleva
+un ``IOError``, questo errore e' raccolto ed ignorato.
-``termios.tcsetattr()`` turns off stdin's echoing and disables canonical
-mode. ``fcntl.fnctl()`` is used to obtain stdin's file descriptor flags
-and modify them for non-blocking mode. Since reading stdin when it is
-empty results in an ``IOError``, this error is caught and ignored.
-
-Threads
+Thread
=============
-How do I program using threads?
----------------------------------
-Be sure to use `the threading module
-<http://www.python.org/doc/lib/module-threading.html>`_ and not the
-``thread`` module. The ``threading`` module builds convenient
-abstractions on top of the low-level primitives provided by the
-``thread`` module.
-
-Aahz has a set of slides from his threading tutorial that are helpful;
-see http://starship.python.net/crew/aahz/OSCON2001/.
+Come si programma con i threads?
+---------------------------------
+Si deve utilizzare il modulo `threading
+<http://www.python.org/doc/lib/module-threading.html>`_ e non il modulo
+``thread``. Il modulo ``threading`` fornisce un livello di astrazione
+adatto sulle primitive di basso livello fornite dal modulo
+``thread``.
+
+Aahz ha pubblicato una presentazione su suo
+tutorial sul threading che e' molto utile;
+si veda http://starship.python.net/crew/aahz/OSCON2001/.
-None of my threads seem to run: why?
--------------------------------------------
-As soon as the main thread exits, all threads are killed. Your main
-thread is running too quickly, giving the threads no time to do any work.
+Nessun thread sembra in esecuzione: perche'?
+---------------------------------------------
-A simple fix is to add a sleep to the end of the program
-that's long enough for all the threads to finish::
+Non appena il main thread termina, tutti gli altri thread sono uccisi.
+Se il main thread viene eseguito troppo in fretta non lascia il tempo
+agli altri thread di eseguire alcun lavoro.
+
+Una semplice correzione e' quella di aggiungere una pausa alla fine
+del programma che sia sufficientemente lunga per consentire a tutti gli
+altri thread di terminare::
import threading, time
@@ -273,13 +304,14 @@
time.sleep(10) # <----------------------------!
-But now (on many platforms) the threads don't run in parallel,
-but appear to run sequentially, one at a time! The reason is
-that the OS thread scheduler doesn't start a new thread until
-the previous thread is blocked.
+Adesso pero' (almeno su molte piattaforme) i thread non vengono
+eseguiti in parallelo ma risultano eseguiti in sequenza, uno alla
+volta! La ragione e' che lo schedulatore del sistema operativo
+non attiva un nuovo thread fino a che
+il thread precedente non e' bloccato.
-A simple fix is to add a tiny sleep to the start of the run
-function::
+Una semplice correzione e' quella di aggiungere una breve pausa
+alla partenza di ogni funzione::
def thread_task(name, n):
time.sleep(0.001) # <---------------------!
@@ -291,27 +323,30 @@
time.sleep(10)
-Instead of trying to guess how long a ``time.sleep()`` delay will be
-enough, it's better to use some kind of semaphore mechanism. One idea
-is to use the `Queue module
-<http://www.python.org/doc/lib/module-Queue.html>`_ to create a queue
-object, let each thread append a token to the queue when it finishes,
-and let the main thread read as many tokens from the queue as there
-are threads.
+Anziche' cercare di indovinare quale sia la pausa sufficiente
+di un
+``time.sleep()``, e' meglio utilizzare un qualche tipo di meccanismo
+a semafori. Un'idea e' utilizzare il modulo
+`Queue <http://www.python.org/doc/lib/module-Queue.html>`_
+per creare un oggetto queue, far aggiungere ai thread un token alla coda
+quando terminano e far raccogliere al main thread
+tanti token quanti sono i thread.
-How do I parcel out work among a bunch of worker threads?
+Come si suddivide il lavoro tra un insieme di thread?
----------------------------------------------------------------
-Use the `Queue module
-<http://www.python.org/doc/lib/module-Queue.html>`_ to create a queue
-containing a list of jobs. The ``Queue`` class maintains a list of
-objects with ``.put(obj)`` to add an item to the queue and ``.get()``
-to return an item. The class will take care of the locking necessary
-to ensure that each job is handed out exactly once.
+Utilizzando il modulo `Queue
+<http://www.python.org/doc/lib/module-Queue.html>`_
+per creare una coda che contenga una lista di attivita'.
+La classe ``Queue`` mantiene una lista di oggetti,
+con ``.put(obj)`` per aggiungere un elemento alla coda e con
+``.get()`` per restituire un elemento. La classe gestira' tutti
+i meccanismi di locking necessari perche' ciascuna attivita'
+venga eseguita una sola volta.
-Here's a trivial example::
+Ecco un semplice esempio::
import threading, Queue, time
@@ -349,7 +384,7 @@
print 'Main thread sleeping'
time.sleep(5)
-When run, this will produce the following output:
+Quando eseguito produce il risultato seguente:
Running worker
Running worker
@@ -365,27 +400,32 @@
Worker <Thread(worker 1, started)> running with argument 5
...
-Consult the module's documentation for more details; the ``Queue``
-class provides a featureful interface.
+Si veda la documentazione del modulo per maggiori dettagli;
+la classe ``Queue`` fornisce un'interfaccia ricca di funzionalita'
-What kinds of global value mutation are thread-safe?
+Quali tipi di variazioni di valori globali sono thread-safe?
------------------------------------------------------------
-A global interpreter lock (GIL) is used internally to ensure that only
-one thread runs in the Python VM at a time. In general, Python offers
-to switch among threads only between bytecode instructions; how
-frequently it switches can be set via ``sys.setcheckinterval()``.
-Each bytecode instruction and therefore all the C implementation code
-reached from each instruction is therefore atomic from the point of view of a Python program.
-
-In theory, this means an exact accounting requires an exact
-understanding of the PVM bytecode implementation. In practice, it
-means that operations on shared variables of builtin data types (ints,
-lists, dicts, etc) that "look atomic" really are.
-
-For example, the following operations are all atomic (L, L1, L2 are lists, D, D1, D2 are dicts, x, y
-are objects, i, j are ints)::
+Il lock globale dell'interprete
+(GIL: Global Interpreter Lock) e' utilizzato internamente per
+per assicurarsi che un solo thread alla volta venga eseguito nella
+VM Python. In generale Python consente lo switch tra i thread
+tra le istruzioni in bytecode; la frequenza di switch puo'
+essere impostata con ``sys.setcheckinterval()``.
+Ogni istruzione bytecode e quindi tutta l'implementazione C
+raggiunta da ogni istruzione e' percio' atomica dal punto di vista
+di un programma Python.
+
+Teoricamente questo significa che un'analisi esatta richiede una
+profonda comprensione dell'implementazione del PVM bytecode.
+In pratica questo significa che le operazioni su variabili condivise
+di tipi builtin (ints, lists, dicts, ecc.) che "sembrano atomiche"
+lo sono veramente.
+
+Ad esempio tutte le seguenti operazioni sono atomiche
+(L, L1, L2 sono liste, D, D1, D2 sono dizionari, x, y
+sono oggetti, i, j sono interi)::
L.append(x)
L1.extend(L2)
@@ -399,115 +439,133 @@
D1.update(D2)
D.keys()
-These aren't::
+Mentre le seguenti non lo sono::
i = i+1
L.append(L[-1])
L[i] = L[j]
D[x] = D[x] + 1
-Operations that replace other objects may invoke those other
-objects' ``__del__`` method when their reference count reaches zero, and
-that can affect things. This is especially true for the mass updates
-to dictionaries and lists. When in doubt, use a mutex!
+Operazioni che sostituiscono altri oggetti possono richiamare
+il loro metodo ``__del__`` quanto il contatore dei riferimenti
+raggiunge lo zero, e questo puo' essere importante.
+Questo e' particolarmente vero per le modifiche massive
+di dizionari e liste. Quando si ha qualche dubbio meglio utilizzare un mutex!
-Can't we get rid of the Global Interpreter Lock?
+
+Non si puo' eliminare il GIL?
--------------------------------------------------------
-The Global Interpreter Lock (GIL) is often seen as a hindrance to
-Python's deployment on high-end multiprocessor server machines,
-because a multi-threaded Python program effectively only uses one CPU,
-due to the insistence that (almost) all Python code can only run while
-the GIL is held.
-
-Back in the days of Python 1.5, Greg Stein actually implemented a
-comprehensive patch set (the "free threading" patches) that removed
-the GIL and replaced it with fine-grained locking. Unfortunately, even
-on Windows (where locks are very efficient) this ran ordinary Python
-code about twice as slow as the interpreter using the GIL. On Linux
-the performance loss was even worse because pthread locks aren't as
-efficient.
-
-Since then, the idea of getting rid of the GIL has occasionally come
-up but nobody has found a way to deal with the expected slowdown, and
-users who don't use threads would not be happy if their code ran at
-half at the speed. Greg's free threading patch set has not been kept
-up-to-date for later Python versions.
-
-This doesn't mean that you can't make good use of Python on multi-CPU
-machines! You just have to be creative with dividing the work up
-between multiple *processes* rather than multiple *threads*.
-Judicious use of C extensions will also help; if you use a C extension
-to perform a time-consuming task, the extension can release the GIL
-while the thread of execution is in the C code and allow other threads
-to get some work done.
-
-It has been suggested that the GIL should be a per-interpreter-state
-lock rather than truly global; interpreters then wouldn't be able to
-share objects. Unfortunately, this isn't likely to happen either. It
-would be a tremendous amount of work, because many object
-implementations currently have global state. For example, small
-integers and short strings are cached; these caches would have to be
-moved to the interpreter state. Other object types have their own
-free list; these free lists would have to be moved to the interpreter
-state. And so on.
-
-And I doubt that it can even be done in finite time, because the same
-problem exists for 3rd party extensions. It is likely that 3rd party
-extensions are being written at a faster rate than you can convert
-them to store all their global state in the interpreter state.
-
-And finally, once you have multiple interpreters not sharing any
-state, what have you gained over running each interpreter
-in a separate process?
+Il lock globale dell'interprete
+(GIL: Global Interpreter Lock) e' spesso visto come un'eredita'
+dello sviluppo di Python su sistemi multiprocessori di fascia alta,
+poiche' un programma Python multithread effettivamente utilizza
+una CPU per l fatto che (praticamente) tutto il codice Python
+puo' essere eseguito quando solo quando si detiene il GIL.
+
+Nei lontani giorni della versione 1.5 di Python, Greg Stein implemento'
+un pathc set completo (la patch "free threading" patches) che
+rimpiazzava il GIL con un locking piu' fine.
+Sfortunatamente, anche su Window (dove il locking e' molto efficente)
+questo rendeva il codice Python lento il doppio
+rispetto ad uno eseguito su un interprete con il GIL.
+Su Linux la perdita di prestazioni era ancora maggiore perche' i
+pthread non sono altrettanto efficenti.
+
+Da allora l'idea di eliminare il GIL e' riapparsa in piu' occasioni ma
+nessuno e' riuscito ad evitare il rallentamento e gli utenti che non
+utilizzano i thread non sarebbero molto contenti se il loro codice
+andasse piu' lento del doppio.
+La patch "free threading" di Greg non e' piu' stata mantenuta
+aggiornata per le successive versioni di Python.
+
+Questo non vuol dire che non si possa fare un buon uso di Python
+su sistemi con CPU multiple! Basta essere sufficientemente creativi
+e dividere il lavora tra piu' *processi* piuttosto che tra *thread*.
+Un utilizzo attento delle estensioni C puo' essere d'aiuto;
+se si utilizza un'estensione C per effettuare un task di lunga durata,
+l'estensione puo' rilasciare il GIL mentre il thread dell'esecuzione
+e nel codice C permettendo ad altri thread di svolgere altri compiti.
+
+E' stato suggerito che il GIL debba essere un lock dipendente dallo
+stato dell'interprete piuttosto che globale; gli interpreti non
+sarebbero in grado di condividere oggetti. Sfortunatamente anche
+questo e' molto difficile che avvenga. Sarebbe un gran mole di lavoro,
+perche' molti oggetti hanno attualmente uno stato globale. Ad esempio
+small integer e short strings sono messi in cache;
+questi oggetti dovrebbero essere inseriti nello stato dell'interprete.
+E cosi' via...
+
+E' difficile che tale conversione avvenga in un tempo finito,
+perche' lo stesso problema si ha per le estensioni di terze parti.
+E' probabile che le estensioni siano scritte ad una velocita'
+maggiore della loro conversione da stato globale a quello di interprete.
+
+Ed infine, una volta che si hanno piu' interpreti che non condividono
+alcuno stato, qual'e' il vero guadagno rispetto ad eseguire ogni
+interprete su un processo differente?
-Input and Output
+Input ed Output
=========================
-How do I delete a file? (And other file questions...)
+Come si cancella un file? (ed altre domande sui file)
---------------------------------------------------------
-Use ``os.remove(filename)`` or ``os.unlink(filename)``; for
-documentation, see `the POSIX module
-<http://www.python.org/doc/lib/module-posix.html>`_. The two
-functions are identical; ``unlink()`` is simply the name of the Unix
-system call for this function.
-
-To remove a directory, use ``os.rmdir()``; use ``os.mkdir()`` to
-create one. ``os.makedirs(path)`` will create any intermediate
-directories in ``path`` that don't exist. ``os.removedirs(path)`` will
-remove intermediate directories as long as they're empty; if you want
-to delete an entire directory tree and its contents, use
+Deve essere usato
+``os.remove(filename)`` oppure ``os.unlink(filename)``; come
+documentazione si veda `the POSIX module
+<http://www.python.org/doc/lib/module-posix.html>`_. Le due
+funzioni sono identiche; ``unlink()``
+e' semplicemente il nome della chiamata di sistema Unix
+per questa funzione.
+
+Per cancellare una directory va usato
+``os.rmdir()``; viene invece usato ``os.mkdir()`` per creare una directory.
+``os.makedirs(path)``
+crea le eventuali sottodirectory non esistenti in
+``path``. ``os.removedirs(path)`` cancella tutte le directory
+intermedie purche' siano vuote; se si vuole cancellare un intero
+albero di directory e tutto il suo contento si deve usare
``shutil.rmtree()``.
-To rename a file, use ``os.rename(old_path, new_path)``.
+Per rinominare un file va usato ``os.rename(old_path, new_path)``.
+
+Per troncare un file deve essere aperto con
+``f = open(filename, "r+")``, quindi troncato con
+``f.truncate(offset)``; offset ha come default la posizione corrente.
+E' anche disponibile ```os.ftruncate(fd, offset)`` per i file aperti con
+``os.open()``, dove ``fd`` e' il file descriptor (uno small integer).
-To truncate a file, open it using ``f = open(filename, "r+")``, and use
-``f.truncate(offset)``; offset defaults to the current seek position.
-There's also ```os.ftruncate(fd, offset)`` for files opened with ``os.open()``,
-where ``fd`` is the file descriptor (a small integer).
+Il modulo ``shutil`` contiene anche una serie di funzioni
+per operare sui file tra cui
+``copyfile``, ``copytree``, e ``rmtree``.
-The ``shutil`` module also contains a number of functions to work on files
-including ``copyfile``, ``copytree``, and ``rmtree``.
-How do I copy a file?
+Come si copia un file?
-----------------------------
-The ``shutil`` module contains a ``copyfile()`` function. Note that
+Il modulo ``shutil`` contiene la funzione ``copyfile()``.
+Deve essere notato che su MacOS 9 la funzione non copia
+il resource fork
+*[su MAC OS ogni file e' composto da due parti,
+data fork e resource fork, quest'ultimo contiene informazioni
+sul tipo di file, il creatore, ... N.d.T.]*
+e le informazioni per il Finder.
on MacOS 9 it doesn't copy the resource fork and Finder info.
How do I read (or write) binary data?
+Come si leggono (o scrivono) dati binari?
---------------------------------------------
-or complex data formats, it's best to use `the struct module
-<http://www.python.org/doc/lib/module-struct.html>`_. It allows you
-to take a string containing binary data (usually numbers) and convert
-it to Python objects; and vice versa.
+O anche altri formati dati complessi? E' meglio utilizzare il modulo
+`struct <http://www.python.org/doc/lib/module-struct.html>`_.
+Permette di prendere una stringa che contiene dati binari (tipicamente numeri)
+e li converte in oggetti Python e viceversa.
-For example, the following code reads two 2-byte integers
-and one 4-byte integer in big-endian format from a file::
+Ad esempio il codice di che segue legge da un file
+due interi a 2 byte ed un intero a 4 byte in formato big endian::
import struct
@@ -515,26 +573,33 @@
s = f.read(8)
x, y, z = struct.unpack(">hhl", s)
-The '>' in the format string forces big-endian data; the letter
-'h' reads one "short integer" (2 bytes), and 'l' reads one
-"long integer" (4 bytes) from the string.
-
-For data that is more regular (e.g. a homogeneous list of ints or
-thefloats), you can also use `the array module <http://www.python.org/doc/lib/module-array.html>`_.
-
-I can't seem to use os.read() on a pipe created with os.popen(); why?
-------------------------------------------------------------------------
-
-``os.read()`` is a low-level function which takes a file descriptor, a
-small integer representing the opened file. ``os.popen()`` creates a
-high-level file object, the same type returned by the builtin
-``open()`` function. Thus, to read n bytes from a pipe p created with
-``os.popen()``, you need to use ``p.read(n)``.
+Il '>' nella stringa di formato indica il formato big endian,
+la lettera 'h' legge uno "short integer" (2 byte) e la lettera 'l'
+legge un "long integer" (4 byte) dalla stringa 's'.
+
+Per dati che sono piu' regolari (eg. una lista omogenea di numeri interi
+o float), si puo' utilizzare il modulo
+`array <http://www.python.org/doc/lib/module-array.html>`_.
+
-How do I run a subprocess with pipes connected to both input and output?
+Non si riesce ad utilizzare os.read() su una pipe creata con os.popen(), perche'?
+---------------------------------------------------------------------------------
+
+``os.read()`` e' una funzione di basso livello che
+riceve come parametro un file descriptor, ovvero uno
+small integer che indica il file aperto.
+``os.popen()`` crea un oggetto file di alto livello, lo stesso tipo
+di dato restituito dalla funzione builtin
+``open()``. Percio' per leggere n byte da una pipe "p" creata con
+``os.popen()`` deve essere utilizzato ``p.read(n)``.
+
+
+Come si esegue un sottoprocesso con pipe connesse all'input ed all'output?
--------------------------------------------------------------------------------
-Use `the popen2 module
-<http://www.python.org/doc/lib/module-popen2.html>`_. For example::
+
+Utilizzando il modulo `popen2
+<http://www.python.org/doc/lib/module-popen2.html>`_.
+Ad esempio::
import popen2
fromchild, tochild = popen2.popen2("command")
@@ -542,35 +607,42 @@
tochild.flush()
output = fromchild.readline()
-Warning: in general it is unwise to do this because you can easily
-cause a deadlock where your process is blocked waiting for output from
-the child while the child is blocked waiting for input from you. This
-can be caused because the parent expects the child to output more text
-than it does, or it can be caused by data being stuck in stdio buffers
-due to lack of flushing. The Python parent can of course explicitly
-flush the data it sends to the child before it reads any output, but
-if the child is a naive C program it may have been written to never
-explicitly flush its output, even if it is interactive, since flushing
-is normally automatic.
-
-Note that a deadlock is also possible if you use ``popen3`` to read
-stdout and stderr. If one of the two is too large for the internal
-buffer (increasing the buffer size does not help) and you ``read()``
-the other one first, there is a deadlock, too.
-
-Note on a bug in popen2: unless your program calls ``wait()``
-or ``waitpid()``, finished child processes are never removed,
-and eventually calls to popen2 will fail because of a limit on
-the number of child processes. Calling ``os.waitpid`` with the
-``os.WNOHANG`` option can prevent this; a good place to insert such
-a call would be before calling ``popen2`` again.
-
-In many cases, all you really need is to run some data through a
-command and get the result back. Unless the amount of data is very
-large, the easiest way to do this is to write it to a temporary file
-and run the command with that temporary file as input. The `standard
-module tempfile <http://www.python.org/doc/lib/module-tempfile.html>`_
-exports a ``mktemp()`` function to generate unique temporary file names. ::
+Attenzione: in generale
+non e' corretto programmare in questo modo poiche' si puo'
+generare facilmente un deadlock tra il processo in attesa dell'output
+del figlio mentre questo attende l'input dell'utente.
+Questo avviene poiche' il padre si aspetta piu' output dal figlio
+di quanto questo ne generi oppure per i dati mantenuti sui buffer di
+I/O per l'assenza di operazioni di flush.
+Naturalmente il padre in Python puo'
+effettuare un flush esplicito dei dati prima di leggere ogni input
+ma, se il figlio e' un programma nativo in C, probabilmente andra'
+riscritto poiche' il flush e' generalmente automatico, anche se si tratta
+di un programma interattivo.
+
+Deve essere notato che un deadlock e' possibile anche utilizzando
+``popen3`` per leggere stdout e stderr.
+Se uno dei due e' troppo grande per il buffer interno
+(aumentare il buffer size non serve) ed il programma effettua una ``read()``
+prima dall'altro si entra nuovamente in deadlock.
+
+Deve essere notato un bug in popen2: se il programma non richiama
+``wait()`` o ``waitpid()`` i processi figlio terminati non vengono piu'
+rimossi ed e' possibile che chiamate alla popen2 falliscano poiche'
+si e' raggiunto il limite sul numero dei processi figlio.
+Richiamare ``os.waitpid`` con l'opzione ``os.WNOHANG`` previene il problema;
+il punto corretto e' inserire tale chiamata prima di richiamare
+``popen2``.
+
+In molti casi, quello che realmente serve e' ottenere
+dati da un comando e raccoglierne il risultato. A meno
+che la quantita' di dati sia veramente grande, il modo piu'
+facile di ottenere questo e' di scrivere su un file temporaneo
+ed eseguire il comando con tale file come input.
+Il modulo `standard
+tempfile <http://www.python.org/doc/lib/module-tempfile.html>`_
+esporta la funzione ``mktemp()`` per generare nomi di file temporanei
+univoci. ::
import tempfile
import os
@@ -600,48 +672,49 @@
self.err=open(errfile,"r").read()
os.remove(errfile)
-Note that many interactive programs (e.g. vi) don't work well with
-pipes substituted for standard input and output. You will have to use
-pseudo ttys ("ptys") instead of pipes. Or you can use a Python
-interface to Don Libes' "expect" library. A Python extension that
-interfaces to expect is called "expy" and available from
-http://expectpy.sourceforge.net. A pure Python solution that works
-like expect is ` pexpect <http://pexpect.sourceforge.net>`_.
+Si noti che molti programmi interattivi (eg. vi) non operano correttamente
+con pipe al posto dello standard input e output. Debbono essere utilizzati
+gli pseudo ttys ("ptys") al posto delle pipe. Oppure si puo' utilizzare
+un'interfaccia Python alla libreria "expect" di Don Libes.
+Un'estensione Python che si interfaccia ad expect e' "expy" ed e' disponibile
+su http://expectpy.sourceforge.net. Una soluzione completamente Python che
+lavora come expect e' ` pexpect <http://pexpect.sourceforge.net>`_.
-How do I access the serial (RS232) port?
+Come si accede alla porta seriale (RS232)?
------------------------------------------------
-For Win32, POSIX (Linux, BSD, etc.), Jython:
+Per Win32, POSIX (Linux, BSD, etc.), Jython:
http://pyserial.sourceforge.net
-For Unix, see a Usenet post by Mitch Chapman:
+Per Unix, si veda l'Usenet post di Mitch Chapman:
http://groups.google.com/groups?selm=34A04430.CF9@ohioee.com
-Why doesn't closing sys.stdout (stdin, stderr) really close it?
------------------------------------------------------------------------
+Perche' chiudendo sys.stdout (stdin, stderr) in realta' non si chiude nulla?
+------------------------------------------------------------------------------
-Python file objects are a high-level layer of abstraction on top of C
-streams, which in turn are a medium-level layer of abstraction on top
-of (among other things) low-level C file descriptors.
-
-For most file objects you create in Python via the builtin ``file``
-constructor, ``f.close()`` marks the Python file object as being closed
-from Python's point of view, and also arranges to close the underlying
-C stream. This also happens automatically in f's destructor, when f
-becomes garbage.
-
-But stdin, stdout and stderr are treated specially by Python, because
-of the special status also given to them by C. Running
-``sys.stdout.close()`` marks the Python-level file object as being
-closed, but does *not* close the associated C stream.
-
-To close the underlying C stream for one of these three, you should
-first be sure that's what you really want to do (e.g., you may confuse
-extension modules trying to do I/O). If it is, use
-os.close::
+Gli oggetti file di Python sono astrazioni ad alto livello sugli stream del C,
+che a loro volta sono astrazioni a medio livello dei file descriptor
+a basso livello del C (e di po' di altre cosette).
+
+Per la maggior parte degli oggetti che vengono creati in Python con
+il costruttore builtin ``file``,
+``f.close()`` marca l'oggetto file Python come chiuso dal punto di vista Python
+e fa in modo che venga chiuso lo stream C sottostante.
+Questo avviene automaticamente anche nel distruttore di f quando
+f non e' piu' accedibile.
+
+Ma stdin, stdout and stderr sono trattati in modo speciale da Python, a causa
+dello speciale stato dato loro dal C. Eseguendo
+``sys.stdout.close()`` segna l'oggetto file come chiuso a livello Python
+ma *non* chiude lo stream C associato.
+
+Per chiudere lo stream C sottostante di uno dei tre e' necessario
+innanzi tutto essere ben certi di quello che si sta facendo
+(eg. possono andare in errore moduli d'estensione che cercano di effettuare
+I/O). Se cosi' e' si utilizza os.close::
os.close(0) # close C's stdin stream
os.close(1) # close C's stdout stream
@@ -649,34 +722,35 @@
-Network/Internet Programming
+Programmazione Network/Internet
=======================================
-What WWW tools are there for Python?
+
+Quali tool WWW sono disponibili per Python?
--------------------------------------------
-See the chapters titled `"Internet Protocols and Support"
-<http://www.python.org/doc/lib/internet.html>`_ and `"Internet Data
-Handling" <http://www.python.org/doc/lib/netdata.html>`_ in the
-Library Reference Manual. Python has many modules that will help you
-build server-side and client-side web systems.
+Si vedano i capitoli intitolati `"Internet Protocols and Support"
+<http://www.python.org/doc/lib/internet.html>`_ e `"Internet Data
+Handling" <http://www.python.org/doc/lib/netdata.html>`_ nel
+Library Reference Manual. Python ha diversi moduli che consentono di
+costruire sistemi web server-side e client-side.
-A summary of available frameworks is maintained by Paul Boddie at
+Un indice dei frameworks disponibili e' mantenuto da Paul Boddie su
http://www.python.org/cgi-bin/moinmoin/WebProgramming .
-Cameron Laird maintains a useful set of pages about Python web technologies at
+Cameron Laird mantiene un insieme di page sulle tecnologie web Python su
http://phaseit.net/claird/comp.lang.python/web_python.html.
-The `Web Programming topic guide <http://www.python.org/topics/web/>`_
-also points to many useful resources.
+Il sito `Web Programming topic guide <http://www.python.org/topics/web/>`_
+contiene altre utili risorse.
-How can I mimic CGI form submission (METHOD=POST)?
-----------------------------------------------------------
-I would like to retrieve web pages that are the result of POSTing a
-form. Is there existing code that would let me do this easily?
+Come si realizza una sottomissione di una form CGI (METHOD=POST)?
+------------------------------------------------------------------
+Si vuole raccogliere una pagina web che e' il risultato del POST di
+una form. E' possibile farlo in modo semplice?
-Yes. Here's a simple example that uses httplib::
+Certo. Ecco un esempio che utilizza httplib::
#!/usr/local/bin/python
@@ -700,9 +774,9 @@
if reply != 200:
sys.stdout.write(httpobj.getfile().read())
-Note that in general for URL-encoded POST operations, query
-strings must be quoted by using ``urllib.quote()``. For example to send name="Guy
-Steele, Jr."::
+Si noti che le stringhe utilizzate per la codifica delle operazioni di POST
+debbono essere quotate utilizzando
+``urllib.quote()``. Ad esempio per inviare name="Guy Steele, Jr."::
>>> from urllib import quote
>>> x = quote("Guy Steele, Jr.")
@@ -713,30 +787,30 @@
'name=Guy%20Steele,%20Jr.'
-What module should I use to help with generating HTML?
+Quali moduli possono essere utilizzati per generare HTML?
--------------------------------------------------------------
-There are many different modules available:
+Ci sono diversi moduli disponibili:
-* HTMLgen is a class library of objects corresponding to all the HTML
- 3.2 markup tags. It's used when you are writing in Python and wish
- to synthesize HTML pages for generating a web or for CGI forms, etc.
-* DocumentTemplate and Zope Page Templates are two different systems that are
- part of Zope.
-* Quixote's PTL uses Python syntax to assemble strings of text.
+* HTMLgen e' una libreria di oggetti corrispondenti ai tag HTML 3.2.
+ Utile quando si scrive in Python e si vogliono generare pagine
+ HTML per un web o per form CGI, ecc.
+* DocumentTemplate e Zope Page Templates sono due differenti sistemi che
+ fanno parte di Zope.
+* Quixote's PTL utilizza la sintassi Python per creare stringhe di testo.
-Consult the `Web Programming topic guide
-<http://www.python.org/topics/web/>`_ for more links.
+Si consulti la `Web Programming topic guide
+<http://www.python.org/topics/web/>`_ per altri link.
-How do I send mail from a Python script?
+Come si manda una mail da uno script Python?
------------------------------------------------
-Use `the standard library module smtplib
+Utilizzando `the standard library module smtplib
<http://www.python.org/doc/lib/module-smtplib.html>`_.
-Here's a very simple interactive mail sender that uses it. This
-method will work on any host that supports an SMTP listener. ::
+Ecco un semplice esempio di invio di mail interattivo. Questo
+metodo funziona su qualsiasi server supporti un listener SMTP. ::
import sys, smtplib
@@ -755,10 +829,11 @@
server.sendmail(fromaddr, toaddrs, msg)
server.quit()
-A Unix-only alternative uses sendmail. The location of the
-sendmail program varies between systems; sometimes it is
-``/usr/lib/sendmail``, sometime ``/usr/sbin/sendmail``. The sendmail
-manual page will help you out. Here's some sample code::
+Un'alternativa, valida solo su Unix, e' utilizzare il sendmail.
+Il programma sendmail risiede su directory diverse a seconda dei sistemi;
+a volte e' ``/usr/lib/sendmail``, altre ``/usr/sbin/sendmail``.
+La pagina di manuale del sendmail riporta il path corretto.
+Ecco il codice d'esempio::
SENDMAIL = "/usr/sbin/sendmail" # sendmail location
import os
@@ -773,75 +848,87 @@
print "Sendmail exit status", sts
-How do I avoid blocking in the connect() method of a socket?
+Come si evita il blocco sul metodo connect() di un socket?
--------------------------------------------------------------------------
-The select module is commonly used to help with asynchronous
-I/O on sockets.
+Il modulo di select e' quello da utilizzare per gestire l'I/O
+asincrono sui socket.
-To prevent the TCP connect from blocking, you can set the socket to
-non-blocking mode. Then when you do the ``connect()``, you will
-either connect immediately (unlikely) or get an exception that
-contains the error number as ``.errno``. ``errno.EINPROGRESS``
-indicates that the connection is in progress, but hasn't finished yet.
-Different OSes will return different values, so you're going to have
-to check what's returned on your system.
-
-You can use the ``connect_ex()`` method to avoid creating an
-exception. It will just return the errno value. To poll, you can
-call ``connect_ex()`` again later -- 0 or ``errno.EISCONN`` indicate
-that you're connected -- or you can pass this socket to select to
-check if it's writeable.
+Per evitare che la connect TCP si blocchi deve essere impostato
+il socket in modalita' non-blocking. Quando viene eseguito il
+``connect()``, potra' connettersi immediatamente (improbabile)
+o ricevere un'eccezione che contiene l'errore
+``.errno``. ``errno.EINPROGRESS``
+che indica che la connessione e' in progress ma non e' ancora terminata.
+Sistemi operativi differenti restituiscono valori differenti, percio'
+e' necessario controllare quale valore e' restituito dal sistema interessato.
+
+Per evitare di sollevare un'eccezione
+e' possibile utilizzare il metodo ``connect_ex()``
+che restituisce semplicemente un codice d'errore.
+Per effettuare il polling va richiamato successivamente
+``connect_ex()`` -- 0 o ``errno.EISCONN`` indicano che si e' connessi --
+oppure e' possibile passare il socket alla select e controllare se
+e' scrivibile.
-Databases
+Database
=====================
-Are there any interfaces to database packages in Python?
+Ci sono pacchetti di interfaccia ai database in Python?
----------------------------------------------------------------
-Yes.
-
-Python 2.3 includes the ``bsddb`` package which provides an interface
-to the `BerkeleyDB
-<http://www.python.org/doc/lib/module-bsddb.html>`_ library.
-Interfaces to disk-based hashes such as `DBM
-<http://www.python.org/doc/lib/module-dbm.html>`_ and `GDBM
-<http://www.python.org/doc/lib/module-gdbm.html>`_ are also included
-with standard Python.
+Si.
-Support for most relational databases is available. See the `Database
-Topic Guide <http://www.python.org/topics/database>`_ for details.
+Python 2.3 include il package ``bsddb`` che fornisce un interfaccia alla
+libreria `BerkeleyDB <http://www.python.org/doc/lib/module-bsddb.html>`_.
+Interfacce per accesso a disco ad hash come
+`DBM <http://www.python.org/doc/lib/module-dbm.html>`_ e
+`GDBM <http://www.python.org/doc/lib/module-gdbm.html>`_
+sono incluse nel Python standard.
+
+E' disponibile il supporto per la maggioranza dei database relazionali.
+Si veda la `Database Topic Guide <http://www.python.org/topics/database>`_
+per maggiori dettagli.
+[lo standard delle interfacce verso i database e' definito nella
+PEP-249 di cui e' disponibile la
+`traduzione italiana <http://www.python.it/faq/pep-0249.html>`_
+N.d.T.].
-How do you implement persistent objects in Python?
+Come si implementano oggetti persistenti in Python?
------------------------------------------------------------
-The `pickle library module
-<http://www.python.org/doc/lib/module-pickle.html>`_ solves this in a
-very general way (though you still can't store things like open files,
-sockets or windows), and the `shelve library module
-<http://www.python.org/doc/lib/module-shelve.html>`_ uses pickle and
-(g)dbm to create persistent mappings containing arbitrary Python
-objects. For better performance, you can use
-`the cPickle module <http://www.python.org/doc/lib/module-cPickle.html>`_.
-
-A more awkward way of doing things is to use pickle's little sister,
-marshal. `The marshal module
-<http://www.python.org/doc/lib/module-marshal.html>`_ provides very
-fast ways to store noncircular basic Python types to files and
-strings, and back again. Although marshal does not do fancy things
-like store instances or handle shared references properly, it does run
-extremely fast. For example loading a half megabyte of data may take
-less than a third of a second. This often beats doing something more
-complex and general such as using gdbm with pickle/shelve.
+La libreria del modulo `pickle
+<http://www.python.org/doc/lib/module-pickle.html>`_ risolve la
+cosa in modo molto generale (sebbene non si possano salvare cose come
+file aperti, socket o windows) e la libreria del modulo
+`shelve <http://www.python.org/doc/lib/module-shelve.html>`_
+utilizza pickle e
+(g)dbm per creare collegamenti persistenti che contengono qualsiasi
+oggetto Python.
+Per ottenere migliori prestazioni si puo' utilizzare il modulo
+`cPickle <http://www.python.org/doc/lib/module-cPickle.html>`_.
+
+Un modo piu' complesso di fare questo tipo di cose e' utilizzare il
+fratellino minore del pickle: marshal. Il modulo
+`marshal <http://www.python.org/doc/lib/module-marshal.html>`_
+fornisce una modalita' molto veloce di memorizzare i tipi Python
+non circolari su file e stringhe e viceversa.
+Sebbene marshall non
+sia in grado di fare cose strbilianti, come memorizzare istanze o
+gestire referenze condivise, e' estremamente veloce.
+Ad esempio caricare mezzo megabyte di dati richiede meno di un terzo
+di un secondo. Spesso questo supera il fare qualcosa di piu' complesso
+e generale utilizzando gdbm con pickle/shelve.
-Why is cPickle so slow?
+Perche' cPickle e' cosi' lento?
--------------------------------
-The default format used by the pickle module is a slow one that
-results in readable pickles. Making it the default, but it would
-break backward compatibility::
+Il formato di default utilizzato dal modulo pickle e' lento ma che
+restituisce un risultato leggibile.
+Si puo' cambiare il default, ma non si ha compatibilita'
+all'indietro::
largeString = 'z' * (100 * 1024)
myPickle = cPickle.dumps(largeString, protocol=1)
@@ -849,65 +936,67 @@
-If my program crashes with a bsddb (or anydbm) database open, it gets corrupted. How come?
+Se un programma va in crash con bsddb (o anydbm) aperto, questo si corrompe. Come evitarlo?
--------------------------------------------------------------------------------------------------
-Databases opened for write access with the bsddb module (and often by
-the anydbm module, since it will preferentially use bsddb) must
-explicitly be closed using the ``.close()`` method of the database. The
-underlying library caches database contents which need to be
-converted to on-disk form and written.
-
-If you have initialized a new bsddb database but not written anything to
-it before the program crashes, you will often wind up with a zero-length
-file and encounter an exception the next time the file is opened.
-
-
-I tried to open Berkeley DB file, but bsddb produces bsddb.error: (22, 'Invalid argument'). Help! How can I restore my data?
-------------------------------------------------------------------------------------------------------------------------------------
-
-Don't panic! Your data is probably intact. The most frequent cause
-for the error is that you tried to open an earlier Berkeley DB file
-with a later version of the Berkeley DB library.
-
-Many Linux systems now have all three versions of Berkeley DB
-available. If you are migrating from version 1 to a newer version use
-db_dump185 to dump a plain text version of the database.
-If you are migrating from version 2 to version 3 use db2_dump to create
-a plain text version of the database. In either case, use db_load to
-create a new native database for the latest version installed on your
-computer. If you have version 3 of Berkeley DB installed, you should
-be able to use db2_load to create a native version 2 database.
+I database aperti in scrittura con il modulo bsddb (e spesso con il modulo
+anydbm, visto che di preferenza utilizza il bsddb) debbono essere
+chiusi esplicitamente con il metodo ``.close()`` del database. La
+sottostante libreria mantiene in cache i contenuti che debbono essere
+convertiti nel formato per la memorizzazione e scritti.
+
+Se e' stato inizializzato un nuovo database bsddb e non e' stato scritto
+nulla prima che il programma sia andato in crash, spesso si avra' un file
+con dimensione nulla e si avra' un'eccezione alla prossima apertura del file.
+
+
+Cercando di aprire un file DB Berkeley si ottiene l'errore bsddb.error: (22, 'Invalid argument'). Come e' possibile recuperare i dati?
+----------------------------------------------------------------------------------------------------------------------------------------
+
+Non serve preoccuparsi. Probabilmente i dati sono salvi.
+La causa piu' frequente dell'errore e' che si cerca di aprire un vecchio file
+Berkeley DB con una versione piu' recente delle librerie Berkeley DB.
+
+Molti sistemi Linux hanno tutte le tre versioni dei Berkeley DB.
+Se si migra dalla versione 1 ad una versione successiva si deve utilizzare
+il comando db_dump185 per salvare su un file di testo il contenuto della
+base dati.
+Se si migra dalla versione 2 alla versione 3 si deve utilizzare
+il comando db2_dump per salvare su un file di testo il contenuto della
+base dati.
+In entrambe i casi si utilizzera' il comando db_load per creare un nuovo
+database per la versione piu' recente.
+Se si ha la versione 3 del DB Berkeley dovrebbe essere disponibile
+il comando db2_load per creare una database in versione 2.
+
+Conviene migrare dalla versione 1 del Berkeley DB perche' il codice
+dell'hash contiene bachi noti che possono portare alla perdita
+dei dati.
-You should move away from Berkeley DB version 1 files because
-the hash file code contains known bugs that can corrupt your data.
-
-Mathematics and Numerics
+Matematica e numeri
================================
-How do I generate random numbers in Python?
+Come si generano numeri casuali con Python?
---------------------------------------------------
-The `standard module random <http://www.python.org/doc/lib/module-random.html>`_ implements a random number
-generator. Usage is simple::
+Il modulo standard `random <http://www.python.org/doc/lib/module-random.html>`_
+implementa un generatore di numero casuali. L'utilizzo e' semplice::
import random
random.random()
-This returns a random floating point number in the range [0, 1).
-
-There are also many other specialized generators in this module, such
-as:
+Restituisce un numero random floating point nell'intervallo [0, 1).
-* ``randrange(a, b)`` chooses an integer in the range [a, b).
-* ``uniform(a, b)`` chooses a floating point number in the range [a, b).
-* ``normalvariate(mean, sdev)`` samples the normal (Gaussian) distribution.
+Vi sono altri generatori specializzati nello stesso modulo, come:
-Some higher-level functions operate on sequences directly, such as:
+* ``randrange(a, b)`` sceglie un intero nell'intervallo [a, b).
+* ``uniform(a, b)`` sceglie un floating point nell'intervallo [a, b).
+* ``normalvariate(mean, sdev)`` campiona secondo la distribuzione normale (Gauss).
-* ``choice(S)`` chooses random element from a given sequence
-* ``shuffle(L)`` shuffles a list in-place, i.e. permutes it randomly
+Alcune funzioni di alto livello operano direttamente sulle sequenze, come:
-There's also a ``Random`` class you can instantiate
-to create independent multiple random number generators.
+* ``choice(S)`` sceglie un elemento a caso in una sequenza
+* ``shuffle(L)`` mischia una lista ovvero effettua una permutazione a caso
+E' anche disponibile la classe ``Random`` che puo' essere istanziata per
+creare generatori di numeri random indipendenti.
More information about the Commits
mailing list