Come organizzare un progetto Python?

Question

Sono nuovo di Python e sto iniziando un mini progetto. ma ho qualche dubbio su come organizzare le cartelle in "Python Way".

sto usando PyDev nel mio ambiente di sviluppo, e quando creo un nuovo progetto viene creata una cartella chiamata "src"

+ src 

Ora, nel PyDev posso creare "Pydev Module" e " PyDev pacchetto"

devo organizzare il mio progetto nel seguente modo:

+ Indicators 
    - Moving_averages.py 
    - Stochastics.py 
+ Strategies 
    - Moving_averages_cross.py 
- example.py 

Come posso organizzare questo in termini di moduli e pacchetti? Qual è il significato di moduli e pacchetti?

migliori saluti,

Answer 1

Un pacchetto è fondamentalmente una cartella con __init__.py file con esso e di solito alcuni moduli, in cui il modulo è un file *.py. Ha a che fare principalmente con import. Se si aggiunge __init__.py di indicatori è possibile utilizzare:

from Indicators.Stochastics import * 

o

from Indicators import Stochastics 

A proposito, consiglio di tenere i nomi del modulo/pacchetto minuscolo. Non influisce sulla funzionalità, ma è più "pythonic".

Answer 2

Da un punto di vista del file system, un modulo è un file che termina con .py e un pacchetto è una cartella contenente nuovamente moduli e pacchetti (nidificati). Python riconosce una cartella come un pacchetto se contiene un file __init__.py.

Una struttura di file come quello

some/ 
    __init__.py 
    foofoo.py 
    thing/ 
     __init__.py 
     barbar.py 

definisce il pacchetto some, che ha un modulo foofoo e un package annidato thing, che ha di nuovo un modulo barbar. Tuttavia, quando si utilizza pacchetti e moduli, non realmente distinguere questi due tipi:

import some 

some.dothis() # dothis is defined in 'some/__init__.py' 

import some.foofoo # <- module 
import some.thing # <- package 

segui PEP8 quando si seleziona la denominazione dei pacchetti/moduli (cioè usano nomi minuscole).

Answer 3

Un pacchetto è una directory con un __init__.py in esso. La differenza da una directory è che puoi importarla.

Non c'è un "modo Python" di per sé, ma troverete che è una buona idea mettere tutti i moduli in un unico pacchetto con un nome correlato al progetto.

Inoltre, per seguire la guida di stile Python, PEP8, i nomi dei pacchetti e dei moduli devono essere tutti in minuscolo.Quindi, se assumiamo il progetto si chiama "Botond Statistiche" la struttura potrebbe essere qualcosa di simile:

botondstats/ 
    indicators/ 
     moving_averages.py 
     stochastics.py 
    strategies/ 
     moving_averages_cross.py 
    example.py 

Si potrebbe quindi trovare la classe Stocastico facendo

from botondstats.indicators.stochastics.Stochastics 

(Ci sono vari modi per mantenere la struttura ma rendere le importazioni più brevi, ma questa è un'altra domanda).

È possibile inserire questa struttura sotto src/ se si desidera, ma non è necessario. Non lo faccio mai. Invece ho una directory principale:

BotondStatistics/ 
    docs/ 
    botonstats/ # the above structure 
    setup.py # Distutils/distribute configuration for packaging. 

In questa directory Ho anche in genere hanno un virtualenv così io in realtà sono anche bin/lib/et al. Lo sviluppo è in genere eseguito eseguendo

./bin/python setup.py tests 

Come io uso il corridore di prova Distrubute per eseguire i test.

Ecco come lo faccio. :-)

Answer 4

Si potrebbe voler controllare la moderna liberia modello di pacchetto. Fornisce un modo per configurare un layout di base veramente bello per un progetto che ti guida attraverso alcune domande e cerca di aiutarti a ottenere qualcosa che sia in grado di essere distribuito abbastanza facilmente.

http://pypi.python.org/pypi/modern-package-template

Answer 5

Vedi python-package-template

struttura Directory

. 
    |-- bin 
    | `-- my_program 
    |-- docs 
    | `-- doc.txt 
    |-- my_program 
    | |-- data 
    | | `-- some_data.html 
    | |-- __init__.py 
    | |-- submodule 
    | | `-- __init__.py 
    | |-- helpers.py 
    |-- tests 
    | |-- __init__.py 
    | |-- test_helpers.py 
    |-- Makefile 
    |-- CHANGES.txt 
    |-- LICENSE.txt 
    |-- README.md 
    |-- requirements-dev.txt 
    |-- requirements.txt 
    `-- setup.py 

gatto Makefile

PYTHON=`which python` 
    NAME=`python setup.py --name` 


    all: check test source deb 

    init: 
     pip install -r requirements.txt --use-mirrors 

    dist: source deb 

    source: 
     $(PYTHON) setup.py sdist 

    deb: 
     $(PYTHON) setup.py --command-packages=stdeb.command bdist_deb 

    rpm: 
     $(PYTHON) setup.py bdist_rpm --post-install=rpm/postinstall --pre-uninstall=rpm/preuninstall 

    test: 
     unit2 discover -s tests -t . 
     python -mpytest weasyprint 

    check: 
     find . -name \*.py | grep -v "^test_" | xargs pylint --errors-only --reports=n 
     # pep8 
     # pyntch 
     # pyflakes 
     # pychecker 
     # pymetrics 

    clean: 
     $(PYTHON) setup.py clean 
     rm -rf build/ MANIFEST dist build my_program.egg-info deb_dist 
     find . -name '*.pyc' -delete 

Answer 6

Prova python_boilerplate_template:

https://pypi.python.org/pypi/python_boilerplate_template

Answer 7

Prima di decidere su una struttura di progetto, è bene chiedersi quale sia lo scopo del progetto sta per essere. Sarà un'analisi singola? Un concetto di giocattolo che vuoi investigare? Un progetto in piena regola che intendi distribuire? La quantità di sforzi che vuoi mettere nella strutturazione del tuo progetto sarà diversa.

• Se si tratta di un'analisi singola, mi piace usare ipython notebooks. Il notebook catturerà il flusso dei tuoi pensieri e potrai aggiungere note in markup al tuo codice per riferimenti futuri.
• Se si tratta di un concetto di giocattolo che si vuole indagare, trovo un approccio semplice e veloce per lavorare al meglio. Vuoi essere in grado di implementare rapidamente il tuo concetto per scoprire se è anche fattibile e quindi vale la pena dedicare più tempo a questo. Parte della filosofia di Python è 'Non cercare la perfezione perché "abbastanza buono" è spesso solo questo.' Puoi sempre tornare più tardi e strutturare il tuo progetto in modo da seguire le migliori pratiche di ingegneria del software.

• Se si vuole strutturare il progetto in modo da poter in seguito distribuirlo, e in modo che scalare fino a molti moduli vi consiglio la seguente struttura:

  projectname 
  ├── MANIFEST.in 
  ├── setup.py 
  ├── README 
  ├── .gitignore 
  ├── .git 
  ├── projectname_env 
  └── projectname 
      ├── __init__.py 
      ├── subpackageone 
      │ ├── __init__.py 
      │ ├── second_module.py 
      │ ├── tests 
      │ │ └── test_second_module.py 
      │ └── models 
      │  └── model1 
      ├── first_module.py 
      └── tests 
       └── test_second_module.py 
  

I motivi dettagliati per cui mi piace questa struttura are in my blog post, ma l'essenziale è che la directory gerarchicamente inferiore del livello projectname contiene il tuo progetto attuale. Accanto a esso ci sono tutti gli strumenti che aiutano a gestire (git) e il pacchetto (setup.py, MANIFEST.in).

Answer 8

Il progetto cookiecutter da audreyr include diversi modelli di progetto Python:

• https://github.com/audreyr/cookiecutter#python

Il pacchetto utilizza un singolo file ~/.cookiecutterrc per creare modelli di progetti personalizzati in Python, Java, JS, e altre lingue .

Per esempio, un modello compatibile con Python PyPI:

• https://github.com/audreyr/cookiecutter-pypackage