4Scaricare

4Scaricare

PYCHARM SCARICARE

Posted on Author Akinris Posted in Multimedia


    PyCharm IDE è un ambiente di sviluppo per Python realizzato da sito di JetBrains e scaricare il pacchetto di installazione, a questo indirizzo. PyCharm è un ambiente di programmazione per linguaggio Python e i framework Django. Scarica PyCharm e potrai scoprire un modo di. Se la tua distribuzione non supporta i pacchetti ppa o semplicemente vuoi scaricare PyCharm direttamente sul sito web JetBrains, segui questa procedura. Leggi la recensione e scarica gratuitamente PyCharm Community Edition, scopri tutte le funzioni che offre e le valutazioni degli utenti.

    Nome: pycharm
    Formato:Fichier D’archive
    Sistemi operativi: Android. iOS. MacOS. Windows XP/7/10.
    Licenza:Solo per uso personale
    Dimensione del file: 31.37 MB

    Sviluppato da JetBrains prima conosciuto come IntelliJ , è disponibile sia in licenza Apache che in edizione proprietaria commerciale. Possono essere usati per scopi commerciali. La sola Ultimate Edition supporta: [7]. Altri progetti. Da Wikipedia, l'enciclopedia libera. URL consultato il 19 dicembre Altri progetti Wikimedia Commons.

    Dopo aver capito come si creano i venv, è il momento di usarli per lo scopo per cui sono nati: mantenere "ambienti" separati e isolati in cui installare tutte le "dependencies" necessarie al progetto a cui state lavorando. Per prima cosa, dovete sapere che cosa è PyPI Python Package Index : si tratta della più grande e "ufficiale" repository di software scritto in Python.

    È ufficiale nel senso che è mantenuta dalla stessa Python Software Foundation che gestisce lo sviluppo di Python, ed è sicuramente il punto di riferimento per tutti gli sviluppatori Python. PyPI ha un'interfaccia web che offre varie possibilità di ricerca e, volendo, di scaricamento diretto dei pacchetti. Pip è un package manager per pacchetti Python: è "ufficiale" perché è entrato a far parte della libreria standard, e quindi dovrebbe essere a disposizione con la vostra installazione di Python dalla versione 3.

    Se avete una versione più vecchia, Pip va installato separatamente. Pip è un modulo della libreria standard, ma esiste anche un eseguibile pip. Per esempio, potete usare direttamente pip install invocando l'eseguibile, invece di py -m pip install invocando l'interprete Python e chiedendogli di eseguire il modulo pip. Abbiamo già usato Pip per installare il pacchetto virtualenv nel Python 2 di sistema.

    Come abbiamo detto, è bene tuttavia installare i pacchetti sempre in un venv. Come primo esempio, proviamo a installare Arrow : si tratta di un pacchetto per la gestione delle date.

    Se non lo avete già fatto, create un venv di Python 3 chiamiamolo test e usiamo pip install :. Come vedete la sintassi è elementare: invochiamo pip. Pip si occupa di tutto per noi: cerca il pacchetto su PyPI, sceglie la versione più aggiornata, la scarica e la installa. Se c'è bisogno come in questo caso di installare degli altri pacchetti mancanti per il funzionamento di Arrow, allora Pip cerca, scarica e installa anche questi. Se adesso aprite una shell nel venv e provate a importare e usare Arrow, scoprirete che Niente di difficile.

    Se adesso uscite dal venv deactivate , e provate di nuovo ad aprire una shell Python py -3 e importare Arrow, otterrete invece un ModuleNotFoundError. Come promesso, Arrow è stato installato solo nel venv, e non nel Python di sistema. La stessa cosa, ovviamente, vale per i vostri script. Modificate ancora una volta il vostro test. La documentazione completa di Pip spiega nel dettaglio tutte le opzioni possibili.

    È importante la possibilità di specificare la versione del pacchetto da installare, in modo più o meno preciso. Per esempio,. Una nota ancora: nei rari casi in cui effettivamente serve installare un pacchetto "globalmente", e non all'interno di un venv, state attenti a usare pip install quando avete molteplici versioni di Python installate. La semplice invocazione a pip utilizza il primo pip. Ma fuori da un venv, pip potrebbe non riferirsi al pip.

    Per fortuna oltre a pip. Quindi, se siete fuori da un venv, dovete invocare le versioni numerate per essere sicuri di usare il Pip giusto: invece di pip install , usate pip2 install , pip3. Tutto questo, ripetiamo, non è necessario all'interno di un venv ovvero, nella quasi totalità dei casi : all'interno di un venv, pip install fa sempre la cosa giusta.

    In questo caso, naturalmente, l'installazione di pacchetti "globali" con pip3 install fallirà con un PermissionError: [WinError 5] : dovete installare da una shell "privilegiata" ovvero con privilegi da amministratore.

    Ancora una volta, precisiamo: è molto raro incontrare questo problema, perché in genere installerete pacchetti solo nei venv, e i venv naturalmente risiedono in una directory per la quale avete i necessari permessi di scrittura. Pip mantiene un registro dei pacchetti. Potete verificare quali pacchetti avete installato con pip freeze :. Di solito, dopo aver installato i pacchetti necessari in un venv, si "salva" la configurazione raggiunta in un file di testo:.

    Un file requirements. Infatti pip install ha anche l'opzione di installare in un colpo solo tutti i pacchetti che trova elencati in un file di testo. Potete fare la prova. Supponiamo che abbiate messo il vostro requirements. Alla fine della procedura, vi ritroverete un venv completo di tutti i pacchetti dichiarati nel requirements. La lista di requirements che ottenete da pip freeze è molto specifica: per ciascun pacchetto è indicata la versione esatta che avete installato.

    Questo è utile se si desidera ri-creare ogni volta lo stesso preciso venv. Per questo vi basterà correggere manualmente il vostro requirements. In questo modo pip install -r requirements.

    Il formato di un requirements. Questo torna utile in molti scenari. Per esempio: un progetto richiede un elenco di pacchetti comuni, e inoltre alcuni pacchetti aggiuntivi che si usano solo in fase di sviluppo, o di test, ma che non sono necessari per la versione "pubblica" del progetto. In questo caso, potete indicare i pacchetti comuni in un requirements.

    Notate l'opzione iniziale -r che rimanda a requirements. Una strategia comune, al momento di iniziare un nuovo progetto, è di creare un venv apposito. Man mano che si installano dei nuovi pacchetti necessari al progetto, si rigenera il requirements.

    A questo punto, è importante sottolineare che non bisognerebbe mai manipolare direttamente la directory del venv aggiungere, togliere, spostare dei file al suo interno.

    Il motivo è appunto questo: tutto il contenuto del venv deve dipendere esclusivamente da un requirements. Il nostro progetto i moduli Python che scriviamo, la documentazione, i file di configurazione e accessori Anche il file dei requirement risiede nella directory del progetto. Vedremo in seguito come strutturare un progetto Python in modo razionale. Molto raramente potrebbe capitarvi di installare un pacchetto che non è stato caricato su PyPI, ma che trovate solo per esempio su sito dell'autore.

    Oppure potreste volervi fare una piccola collezione di pacchetti che installate frequentemente, in modo da non doverli scaricare tutte le volte da PyPI. Una terza possibilità è che dobbiate installare dei pacchetti pre-compilati non ufficiali, che non trovate quindi su PyPI: approfondiremo tra poco questo caso.

    Potete scaricare direttamente dal sito di PyPI, ma potete anche lasciare che sia Pip a fare il lavoro per voi: Pip ha infatti un'opzione per scaricare senza installare. Lavoriamo sempre all'interno del nostro venv di Python 3: anche se Pip non installerà subito il pacchetto, è importante che sappia per quale versione di Python deve scaricarlo. L'opzione -d specifica una directory di destinazione; se non la indicate, Pip scaricherà il pacchetto nella directory corrente.

    Si tratta di una Wheel riconoscibile dall'estensione. Per il momento, una raccomandazione: non dovete cambiare il nome del file scaricato. In una Wheel il nome del file è significativo, e Pip non potrà installarlo correttamente se lo modificate. Una volta scaricato il pacchetto, potete installarlo con Pip senza più bisogno della connessione internet:. Come vedete, basta specificare la path del pacchetto non è necessario che sia una path assoluta: basta la path relativa alla directory corrente.

    Potete anche scrivere le path dei pacchetti locali che desiderate in un requirements. La procedura che abbiamo descritto fin qui funziona per installare pacchetti che sono scritti completamente in Python. Ma occasionalmente per fortuna sempre più di rado pip install fallisce con una serie di messaggi di errore piuttosto complicati, ma che in sostanza ci avvertono che non è possibile "compilare" i pacchetti necessari.

    Che cosa è successo? Fino a qualche anno fa, il formato di distribuzione dei pacchetti Python le "egg", che si trovano ancora occasionalmente non prevedeva un modo per distribuire pacchetti con estensioni già compilate. Quindi, le estensioni in C dovevano essere compilate da voi al momento dell'installazione. Questo non è un problema sui sistemi Linux, che tradizionalmente hanno un compilatore di default pronto all'uso: in questo caso, Pip si rivolge al compilatore, compila le estensioni C, e installa il pacchetto senza problemi.

    Windows invece non ha un compilatore di default, e quindi Pip scarica correttamente il pacchetto giusto, ma al momento di compilare le estensioni non sa più come procedere.

    Da qualche anno Python ha introdotto un nuovo formato per distribuire i pacchetti, che ormai ha quasi del tutto sostituito il precedente: le Wheel , che consentono tra l'altro di pre-compilare le estensioni C. Tuttavia occasionalmente pip install potrebbe ancora trovare su PyPI solo vecchi pacchetti non pre-compilati. O magari Pip trova una wheel, ma non quella pre-compilata per la vostra particolare versione di Python.

    In casi del genere, possiamo rimediare seguendo una delle due strade:. Vedremo subito come percorrere la seconda strada - ma prima, una legittima domanda: perché gli sviluppatori non distribuiscono su PyPI direttamente i pacchetti con le estensioni già compilate? In primo luogo, questa possibilità è arrivata solo di recente, con le wheel. Ma soprattutto, è possibile e scusabile che gli sviluppatori non abbiano voglia di supportare diverse versioni dello stesso pacchetto, pre-compilate per ciascuna diversa piattaforma.

    Spesso è possibile trovare le wheel compilate solo per le piattaforme che gli sviluppatori ritengono più interessanti o accessibili per loro.

    Talvolta esistono wheel compilate solo per certe versioni di Python, e non per altre. In particolare, potrebbe essere leggermente più complicato trovare wheel compilate per Python 3. Infatti ricordate che queste versioni di Python sono compilate con Visual Studio Uno scenario frequente è che il pacchetto, per quanto riguarda il solo codice Python, sia perfettamente compatibile tra Python 3.

    Tuttavia, se il pacchetto contiene delle estensioni C, lo sviluppatore deve ugualmente compilarlo due volte con un compilatore diverso per supportare la 3.

    Molti sviluppatori, comprensibilmente, potrebbero non aver voglia di tenere entrambi i compilatori installati e fare due volte il lavoro. Va detto comunque che, man mano che Python 3. Se cercate delle wheel in rete da scaricare manualmente, fate attenzione a scegliere il pacchetto giusto: i nomi dei file delle wheel sono significativi e riportano la versione del pacchetto e con quali versioni di Python è compatibile.

    Una volta scaricato il pacchetto, potete installarlo con Pip dal file locale, come visto sopra. Se adesso chiedete un pip freeze , noterete che il pacchetto che avete installato a mano è regolarmente elencato insieme agli altri. Tuttavia, se in futuro volete usare il file di requirements per re-installare l'ambiente del venv pip install -r requirements.

    L'unica soluzione è correggere il file requirements. Quando installate dei pacchetti in un venv, questi sono ovviamente disponibili solo nel venv in cui li avete installati. È possibile tuttavia creare un venv con l'opzione --system-site-packages , che permette al venv di utilizzare anche i pacchetti installati nel Python di sistema da cui è stato creato. Ma non abbiamo detto e ripetuto che non bisognerebbe mai installare pacchetti nel Python di sistema?

    Infatti: quindi, anche --system-site-packages non andrebbe usata affatto, o con estrema cautela. Vi troverete spesso a dover installare una serie di pacchetti ausiliari che non sono necessari per eseguire il codice del vostro progetto, ma che comunque vorrete installare per aiutarvi nello sviluppo.

    Per esempio, un linter come Pep8 o PyLint ; pacchetti che vi aiutano con i test, come Pytest , Nose o Fixtures ; oppure ancora Sphinx per generare la documentazione; e altri ancora parleremo di questi aspetti e di questi pacchetti nelle sezioni successive. Ci sono due strategie per gestire questi pacchetti ausiliari.

    La prima, più semplice, è di installarli con Pip in ciascun venv che create. Tutt'al più, potete risparmiare il tempo di download scaricando una volta per tutte le wheel necessarie, e chiedendo a Pip di installare dal file locale.

    Dovete solo fare attenzione a un dettaglio: siccome non sono pacchetti necessari a eseguire il vostro codice, non dovreste includerli nel requirements. La seconda strategia è quella di installare questi pacchetti ausiliari di uso comune nel Python di sistema, e poi creare i vostri venv con l'opzione --system-site-packages : in questo modo i venv possono attingere anche ai pacchetti ausiliari che vi servono per lo sviluppo.

    In questo modo vi risparmiate la piccola noia di installare gli stessi pacchetti in tutti i venv. Una cautela: come vedremo, molti di questi pacchetti potrebbero essere utilizzati e integrati nel vostro editor preferito: in genere gli editor evoluti possono essere istruiti sul venv di cui ha bisogno il codice su cui state lavorando. È importante in ogni caso ribadire un concetto: usate eventualmente questa strategia esclusivamente per i pacchetti ausiliari che non servono per far funzionare il codice dei vostri progetti, ma che servono solo a voi per lo sviluppo.

    Tutte le "dependencies" necessarie al vostro progetto devono essere installate nel venv ed elencate nel requirements. Prima di abbandonare l'argomento venv, è forse opportuno inserire alcune note di carattere più avanzato, che un principiante potrebbe tenere a mente per il futuro.

    Occorre tener presente che i venv Python non sono e non vogliono essere una soluzione completa di virtualizzazione: si tratta solo di un meccanismo, anche abbastanza poroso, per tenere separati i pacchetti Python occorrenti in un progetto.

    Il resto dell'ambiente di lavoro in cui il progetto è immerso non è controllabile con i venv. Un requirements. Se tutto questo per il vostro progetto è indifferente, allora nessun problema. Ma se avete bisogno di un controllo maggiore, dovreste rivolgervi a una soluzione di virtualizzazione più completa, come per esempio un container Docker.

    Un altro aspetto importante da ricordare è che Pip e i venv fanno molto poco per aiutarvi ad affrontare la variegata classe di problemi nota informalmente come "dependency hell". In sostanza, con Pip avete solo due alternative.

    Potete specificare nel requirements. In linea di principio, far girare il vostro codice produce risultati diversi in tempi diversi. Oppure potete elencare tutti i pacchetti con le loro versioni esatte, come risultano da un pip freeze. In questo caso vi garantite una build deterministica, ma lo svantaggio è che dovete gestire manualmente il requirements. I moduli pip e venv della libreria standard sono sicuramente sufficienti per i principianti e anche per i più esperti, almeno nella maggioranza dei casi.

    Esistono comunque soluzioni più avanzate che prima o poi potreste voler prendere in considerazione: in questo periodo lo strumento di packaging più valido e popolare nel mondo Python è diventato Pipenv di Kenneth Reitz, ormai adottato come raccomandazione ufficiale della Python Packaging Authority.

    Uno script Python è un file di testo che contiene il vostro codice, nulla di più. Tuttavia esistono alcune convenzioni che potete, e in qualche caso dovete, rispettare. Come minimo dovreste conoscerle, in modo da capire che cosa significano certe annotazioni che trovate nei programmi altrui.

    Le shebang sono una convenzione molto comune nel mondo Linux per gli script in genere, e non solo quelli in Python. Fino a poco tempo fa, non avevano nessuna importanza per Python su Windows: era utile comunque inserirle per venire incontro agli sviluppatori Linux che eventualmente avrebbero usato i nostri script. Tuttavia, nelle versioni più recenti anche il launcher py ha imparato a tenere conto delle shebang in certe situazioni: a maggior ragione quindi bisogna sapere che cosa sono e come usarle.

    L'idea della shebang è di fornire all'ambiente circostante la shell del sistema operativo, tipicamente informazioni su come deve essere interpretato lo script: specificare che si tratta di uno script Python non Perl, per esempio ; e dichiarare almeno entro certi limiti da quale interprete Python dovrebbe essere eseguito, nel caso che più di uno sia disponibile.

    Ne consegue che le shebang hanno senso, e dovrebbero essere usate, solo per gli script che vanno effettivamente eseguiti dall'interprete script stand-alone, o script che costituiscono l'entry point della vostra applicazione. Se uno script è fatto esclusivamente per essere importato da altri script Python, allora non ha senso mettere la shebang. Una shebang, se esiste, deve essere rigorosamente la prima riga del file, e deve iniziare con i caratteri!

    In genere si preferisce indicare una path "virtuale", o comunque più generica. Il launcher py riconosce i seguenti tipi di shebang che naturalmente sono validi anche nel mondo Linux :.

    Inoltre, è anche possibile usare queste shebang con un numero di versione: per esempio potete indicare! Tuttavia la shebang! Come si comporta il launcher py quando gli chiedete di eseguire uno script che inizia con una di queste shebang? Tutto questo è un po' disorientante. Potete fare delle prove, comunque: aggiungete al vostro script test. In primo luogo, dovreste avere almeno una discreta conoscenza di cos'è Unicode e cosa sono gli encoding: in caso contrario vi conviene informarvi subito sull'argomento.

    Una dichiarazione di encoding deve stare nella prima riga dello script, se manca la shebang. Altrimenti, deve stare nella seconda riga dello script, immediatamente dopo la shebang. La dichiarazione di encoding ha la forma:. Molti encoding hanno degli alias che Python non ha problemi a riconoscere: utf-8 , utf8 , UTF-8 etc.

    Prima di chiedervi quando è necessario inserire una dichiarazione di encoding, dovete tenere a mente la regola d'oro: nei vostri script Python, limitatevi a usare il set di caratteri ASCII. Ma soprattutto, questa è ancora la convenzione più comune tra i programmatori.

    Anche se è certamente possibile scrivere codice Python con caratteri "strani" non-ASCII, per dirlo in modo più tecnico , i programmatori tendono a evitarlo il più possibile. Questo ci porta a una importante questione di stile. Ma ecco il punto: il codice dovrebbe sempre essere scritto in Inglese, la lingua franca nel mondo della programmazione. Usate l'Italiano solo ed esclusivamente per le note e le docstring. Questo almeno vi consentirà in futuro di tradurre in Inglese i vostri script senza dover cambiare il codice vero e proprio.

    Se usate l'Italiano per note e documentazione, allora limitatevi comunque al set ASCII, con il vecchio trucco di sostituire gli accenti con gli apostrofi perche' invece di perché , etc.

    L'ultima cosa che volete è introdurre ulteriori complicazioni solo per il piccolo gusto estetico di vedere gli accenti nei commenti al codice. Detto questo, occasionalmente potreste avere davvero bisogno di introdurre nel codice qualche carattere non-ASCII.

    Per esempio, delle stringhe di testo che devono essere mostrate all'utente, e quindi devono essere "giuste" con gli accenti e tutto il resto. A dire il vero, i programmatori bravi evitano anche in questi casi di uscire dal set ASCII, per esempio mettendo tutte queste stringhe in qualche tipo di risorsa esterna un file di testo, un database Se volete o dovete uscire dalla zona sicura di ASCII, è importante sapere in primo luogo che Python ha il concetto di "encoding di default" per gli script.

    Se il vostro script non usa l'encoding di default per la versione di Python per cui è concepito , allora è necessario inserire una dichiarazione di encoding all'inizio dello script.

    La dichiarazione di encoding non è necessaria se lo script rispetta l'encoding di default. Anzi, in questo caso la dichiarazione di encoding non dovrebbe essere indicata, secondo la guida di stile ufficiale di Python. Che cosa vuol dire che uno script "usa" un encoding? Che il vostro editor salva fisicamente il file utilizzando quel particolare encoding. Oggi, praticamente tutti gli editor "da programmatori" salvano i file in UTF-8 di default.

    In ogni caso, è fondamentale imparare subito a capire come si impostano le preferenze dell'editor, imparare come si fa a vedere se l'editor sta usando per qualche motivo un encoding differente, come si cambia l'encoding, etc. Per esempio, il Blocco Note che avete usato fino a questo momento salva i file con l'encoding cp, e quindi non in UTF Naturalmente non è l'unica ragione per cui non bisogna mai usare il Blocco Note per programmare, ma è già una ragione sufficiente.

    Vediamo come si applica tutto questo al caso di Python 3. Se il vostro script è per Python 3, usate sempre UTF-8 come encoding che del resto dovrebbe essere quello predefinito del vostro editor. Non c'è ragione, ormai, per usare un encoding diverso. Usando UTF-8, non dovete inserire dichiarazioni di encoding all'inizio del file. Vediamo invece il caso di Python 2. Da quanto detto finora, dovrebbe essere chiaro che una dichiarazione di encoding non è, di per sé, una garanzia che il file sia effettivamente salvato con quell'encoding.

    Sta a voi assicurarvi che il vostro editor faccia la cosa giusta. La dichiarazione di encoding, in ogni caso, vale solo per lo script a cui si riferisce. Se lo script accede a dati esterni un database, un file di testo, l'input della shell Dovreste conoscere l'encoding di tutti i dati esterni a cui volete accedere: informatevi sulle specifiche del provider di questi dati per esempio, quasi tutti gli engine di database moderni restituiscono i dati in UTF-8; lo standard input della shell cmd.

    Python ha degli strumenti per convertire gli encoding, naturalmente: per saperne di più potete partire dall' Unicode How-To nella documentazione ufficiale. Abbiamo concluso la nostra rassegna delle cose essenziali da sapere per installare e usare Python su Windows.

    Ci occupiamo adesso di alcuni aspetti più secondari, opzionali e anche soggetti ai gusti personali di ciascuno. Cominciamo con alcuni consigli su come strutturare un progetto Python. Come è possibile intuire dagli esempi che abbiamo fatto finora, l'istruzione import serve per "importare" e quindi rendere utilizzabile un modulo ossia uno script, un file.

    Quando gli chiedete di importare "qualcosa", Python compie una ricerca per trovare "qualcosa" che corrisponde al nome che gli avete chiesto: se non trova nulla, alla fine restituisce un errore ModuleNotFoundError: No module named La strategia di ricerca dei nomi da importare è piuttosto complessa e non è questa la sede per spiegarla nel dettaglio: la documentazione ufficiale è molto chiara in merito.

    Tra i posti dove Python cerca i moduli o i package da importare, c'è naturalmente la libreria standard la directory Infine, Python cerca anche in.

    In altre parole, se avete due moduli a. Allo stesso modo, se vi portate con la shell nella directory in cui stanno a. Ci sono diversi modi in cui potete modificare e personalizzare il meccanismo degli import di Python.

    Anche se è possibile modificare in questo modo il meccanismo di import di Python, in genere non bisognerebbe farlo. Capito almeno in parte come funziona import , possiamo adesso rispondere alla domanda che spesso si pone chi inizia a programmare in Python: dove dovrei mettere il codice che scrivo?

    In primo luogo, sicuramente non bisogna mettere i propri script nella installazione di Python in In particolare, come abbiamo visto un venv dovrebbe essere ri-creabile solo a partire da un requirements. Potete mettere i vostri script Questo vale per gli script stand-alone composti da un solo modulo.

    Vedremo tra poco come conviene strutturare un progetto Python. E come fate, se volete usare e quindi importare uno dei vostri script, magari uno dei vostri progetti, dentro un altro script o un altro progetto? Ecco, questo a rigore non si dovrebbe mai fare.

    Se due o più moduli appartengono allo stesso progetto, allora vivono nella stessa directory e sono quindi liberamente importabili tra loro. Ma non si dovrebbe mai importare un modulo "estraneo" al progetto, collocato in un posto "qualsiasi".

    La guida ufficiale spiega nel dettaglio come si fa. Beninteso, se poi distribuite ad altri il vostro progetto "B" senza mai aver pubblicato su PyPI o altrove anche il progetto "A", allora chi usa il vostro progetto avrà qualche prevedibile problema.

    Ma questo è un altro discorso. In generale, non è la cosa giusta da fare. Ci soffermiamo ora brevemente su come bisognerebbe organizzare un progetto Python ovvero, fisicamente, la directory che contiene tutti i file relativi al progetto. Ci sono molte guide, template, coding styles, suggerimenti di vario tipo in merito, e molti dettagli dipendono dalle abitudini di ciascuno, dai tool di sviluppo utilizzati, etc.

    Inoltre, i framework complessi come Django hanno le loro peculiariarità e le loro raccomandazioni specifiche. In primo luogo, come già detto ogni progetto dovrebbe avere una sua directory, che avrà il nome del progetto: deve essere un nome corto ma significativo quindi non project , naturalmente! Dentro la directory-base c'è un'altra directory con lo stesso nome , dentro cui mettete i moduli Python che effettivamente compongono il progetto. Gli "unit test" e altri tipi di test in Python sono praticamente un obbligo per ogni progetto serio: se non sapete nulla sull'argomento, potete iniziare dalla documentazione standard relativa.

    Documentare bene il codice è un punto d'onore di ogni sviluppatore Python: nessuno vorrà avere a che fare con il vostro codice, se non è documentato. In teoria, siete liberi di decidere il formato, le strategie e gli strumenti per la vostra documentazione. Sphinx è un tool che genera diversi tipi di output html, latex, etc. Un file conf. Naturalmente non siete obbligati a usare Sphinx per la documentazione.

    La directory-base project contiene inoltre un numero variabile di file di meta-informazioni sul progetto. Il README contiene le informazioni essenziali, e dovrebbe essere scritto in Inglese o come minimo avere una introduzione corta in Inglese all'inizio, se proprio non potete rinunciare all'Italiano.

    Ci potrebbe poi essere un numero variabile di file eventualmente auto-generati necessari ai diversi tool di sviluppo che utilizzate. Per esempio, se usate Git per il controllo di versione, allora avrete una directory nascosta. Anche il vostro editor potrebbe appoggiarsi ad alcuni file nascosti nella directory-base per leggere delle impostazioni di configurazione.

    Abbiamo già imparato a conoscere requirements. Infine setup. Per saperne di più su setup. Assegnare un numero di versione a un progetto Python è importante, e occorre saperlo fare bene.

    Se distribuite il vostro progetto su PyPI, ogni volta che caricate degli aggiornamenti il numero di versione deve cambiare. Tuttavia, deve essere ben chiaro a quali commit corrisponde un nuovo numero di versione di solito, questo si ottiene taggando i commit in modo che sia possibile clonare una versione ben precisa.

    Il mondo Python ha adottato da tempo uno standard preciso per i numeri di versione, descritto nel dettaglio nella PEP Detto in breve, si tratta del popolare schema "a tre numeri": un numero di "major version", uno di "minor version" e uno di "micro version" o "bugfix release".

    Per convenzione, dovreste sempre incrementare il primo numero "major version" quando introducete delle modifiche non retrocompatibili con il codice precedente. La PEP regola anche l'utilizzo di codici per indicare versioni alfa, beta, candidate, pre- e post- release, etc.

    È utile pubblicare l'elenco di tutti i cambiamenti apportati tra una versione e la successiva. Il manuale di stile ufficiale di Python è la PEP 8 che bisogna leggere e conoscere a fondo. I programmatori Python sono molto sensibili sull'argomento, e se volete far vedere il vostro codice è meglio seguire sempre la PEP 8.

    Molti grandi progetti hanno inoltre un loro manuale di stile interno: se decidete di collaborare con questi, è ovviamente necessario conformarsi.

    Il processo di rilevazione automatica dei potenziali errori nel vostro codice e dei potenziali difetti di stile si chiama linting. Esistono diversi linter che fanno un ottimo lavoro nel segnalarvi dove il vostro codice non è conforme alla PEP 8. Il più semplice è Pep8 , ma ci sono opzioni più evolute come PyLint. Sono pacchetti che si installano normalmente con Pip, e si possono usare dalla riga di comando della shell. Parleremo più diffusamente degli editor e della loro configurazione tra poco.

    Come abbiamo già detto, il vostro linter appartiene a quella categoria di pacchetti "ausiliari" che non è sbagliato installare globalmente, e rendere eventualmente accessibili ai venv dei progetti con l'opzione --system-site-packages al momento di creare il venv. Dopo aver capito, almeno a grandi linee, come funzionano gli import in Python, dobbiamo tornare sull'argomento "doppio clic".

    Abbiamo già detto che gli script Python si invocano dalla shell e non facendo doppio clic sull'icona del file corrispondente - e lo confermiamo qui ancora una volta. Tuttavia, il desiderio di trattare uno script Python come di solito si "avvia un programma" è comprensibile: ripetiamo ancora!

    Ci sono strumenti che vi consentono di generare degli eseguibili veri e propri, pronti per la distribuzione, che naturalmente si possono avviare con il doppio clic. Ne accenniamo più in là. Se volete il doppio clic, allora pacchettizzate il vostro script. E tuttavia In questo caso, tuttavia, potreste incontrare due famiglie di problemi: quelli legati alla directory di lavoro e alle path relative, se il vostro script deve accedere a risorse esterne come file o database; e quelli legati alle differenti versioni di Python e ai venv necessari.

    Anche se non avete ancora cominciato a studiare Python, il significato del codice dovrebbe essere chiaro: proviamo a importare un modulo foo. Notate che identifichiamo la risorsa usando una path relativa foo. Adesso facciamo qualche esperimento. Come vedete, la directory corrente della shell al momento di invocare lo script viene passata a Python.

    Non ci sono problemi per l' import di foo. Non ci sono problemi neppure per l'apertura di foo. In questo caso l' import va ancora a buon fine come prima, ma l'apertura del file è invece compromessa. In effetti, occorre sempre ricordarsi che gli import sono relativi alla posizione dello script eseguito, ma le path delle risorse esterne sono relative alla directory corrente passata a Python al momento dell'invocazione.

    Infine, possiamo verificare che anche il doppio clic su un collegamento soft link allo script funziona come cliccare sul file originale: ovvero, la directory corrente resta quella del file originale, non quella del link. Talvota capita di voler invocare uno script Python attraverso un batch file un file con estensione. Se adesso mettete questo file in una directory qualsiasi per esempio il desktop e ci fate doppio clic sopra, vedrete che l'apertura del file fallisce, perché la directory corrente non è quella giusta.

    In generale, lo script Python invocato nel modo "giusto" dovrebbe passare a Python la directory corrente del file dello script. Di conseguenza, ogni volta che volete accedere a una risorsa esterna un file, un database Una soluzione sarebbe identificare le risorse esterne solo per mezzo di path assolute , ma chiaramente questo non va bene, perché sacrifica completamente la portabilità del vostro codice. Modificate main. Qui, os. Se adesso riprovate tutti gli esperimenti fatti fin qui, noterete che la directory corrente resta sempre quella del file, anche se cercate di passare qualcos'altro dalla shell, o da un file batch, o con le impostazioni di un collegamento.

    Se volete usare questa tecnica, vi conviene impostare la directory corrente molto presto nel vostro script: sicuramente, prima di accedere a qualsiasi risorsa esterna. Un altro ordine di problemi capita quando avete due o più versioni di Python installate, o magari quando il vostro script deve essere eseguito in un venv.

    IDE Python

    In questi casi, naturalmente fare doppio clic lascia a Windows la scelta dell'eseguibile Python da invocare, e non sempre le cose andranno lisce. Se avete conservato quel venv e in caso contrario, basta ricrerlo , potete verificare subito il problema. Modificate il nostro script main. Se adesso eseguite lo script con il doppio clic, vedrete che Arrow non viene importato. Il motivo è semplice: Windows esegue lo script con il Python "di sistema", che non ha Arrow installato.

    Per fare in modo che Windows selezioni l'interprete Python corretto ovvero quello del venv quando fate doppio clic sullo script, avete diverse opzioni. In primo luogo, potete senz'altro attivare il venv da una shell prima di fare doppio clic.

    Ma si capisce che questo non avrebbe molto senso, visto che state appunto cercando di evitare di usare la shell. In secondo luogo, potete impostare la shebang dello script indirizzandola verso l'interprete corretto:. Questo funziona, ma non è una buona idea: legate il vostro codice a dettagli della configurazione specifica del vostro computer, e sacrificate la portabilità.

    Terzo, potete usare un collegamento. Create un collegamento al vostro script main. Accertatevi anche che la casella "Da:" contenga la path della directory corrente che volete passare a Python. Adesso, se fate doppio clic sul collegamento, Windows eseguirà lo script con l'interprete giusto.

    Questa soluzione è buona: non dovete toccare il vostro codice, e i dettagli di configurazione restano specificati in un collegamento che potete modificare separatamente. Usare un file batch è un'altra buona soluzione, che vi consente di separare dal codice Python i dettagli della vostra configurazione specifica.

    Il vantaggio di un file batch rispetto a un semplice collegamento "preparato", è che vi permette all'occorrenza di fare molte cose in più prima di avviare lo script Python. Per esempio potete impostare delle variabili d'ambiente, creare file e directory di lavoro, e in generale preparare l'esecuzione dello script senza inquinare il codice Python con dettagli specifici per la vostra configurazione. Talvolta il vostro script produce un output che desiderate vedere nella shell: per esempio, in seguito a un print.

    Se invocate lo script dalla shell, questa resta aperta durante l'esecuzione. Ma se fate doppio clic, tipicamente la shell la "finestrella nera", per capirci si apre, esegue lo script, mostra l'output e poi si chiude: tutto questo avviene troppo rapidamente per permettervi di capirci qualcosa.

    La soluzione standard è quella che abbiamo già adottato negli esempi precedenti: fare in modo che lo script termini con una richiesta di input per l'utente. In questo modo lo script si blocca e la shell non si chiude!

    In questo caso, Python si arresta inaspettatamente dopo aver pubblicato sullo stream dello "standard error" il traceback dell'eccezione incontrata: naturalmente, lo "standard error" è diretto verso la shell, di solito. Questo significa che avete lo stesso problema di prima. Se avviate lo script dalla shell, tutto va bene: Python si arresta, ma la shell resta aperta e voi potete esaminare il traceback dell'errore incontrato e capire il problema.

    Ma se fate doppio clic, la shell si chiude immediatamente e voi restate senza informazioni. Qui Python pubblicherà il risultato della prima istruzione 4 nello "standard output" la shell. Infine terminerà l'esecuzione dello script prematuramente, prima di arrivare all' input finale.

    Certo, la verità è che, almeno in un software destinato all'utente finale, tutte le eccezioni dovrebbero essere previste e gestite. Un'eccezione non gestita è un baco. Ma appunto, anche i bachi succedono, e ci serve lo stacktrace dell'eccezione per poterli correggere. In fase di sviluppo di solito questo non è un problema perché voi avviate sempre lo script dalla shell. La cosa peggiore è che un errore di questo tipo potrebbe capitare non solo all'interno del codice Python vero e proprio, ma anche a causa di una gestione sbagliata dell'ambiente di esecuzione.

    Per esempio, se facendo doppio clic avviate lo script con l'interprete sbagliato, Python potrebbe incontrare immediatamente degli ImportError se magari non siete nel venv giusto , o addirittura dei SyntaxError se state eseguendo lo script con una versione sbagliata di Python.

    La frustrazione cresce perché talvolta invece, eseguendo lo script dalla shell, tutto funziona perché la shell è nel venv giusto, o seleziona la versione giusta di Python. Ci sono diverse possibilità per risolvere questi problemi. Una idea valida, anche se un po' rozza, è re-direzionare lo stream dello "standard error" verso un file di log, invece che nella shell. In caso di errore, in seguito potete aprire il file e ispezionare lo stacktrace:. Questo non è del tutto a prova di bomba, ma basta e avanza per i casi più comuni.

    In particolare, vi salva dalle eccezioni non gestite come lo ZeroDivisionError qui sopra e anche dagli ImportError iniziali dovuti all'interprete sbagliato. Naturalmente dovreste re-direzionare lo "standard error" molto presto nel vostro codice, e senz'altro prima del primo import che potrebbe fallire. Possono esserci situazioni particolari in cui Python si interrompe prima di essere riuscito a completare la scrittura dello stracktrace nel file, e situazioni in cui il file stesso risulta mancante, corrotto, etc.

    Una possibilità analoga, ma più raffinata, è ricorrere a sys. Potete sovrascriverla e fare quello che desiderate in questa fase: in questo esempio noi scriviamo lo stacktrace nella shell e, invece di uscire immediatamente, blocchiamo lo script con il trucco che già conosciamo:. Notate che, per la stessa ragione di prima, questo meccanismo non vi difende dai SyntaxError né dagli "hard crash" dell'interprete Python, e comunque andrebbe inserito molto in alto nel vostro codice.

    Usare sys. Nella vostra funzione potete usare un sistema di logging per conservare lo stacktrace dell'eccezione, emettere un messaggio di avviso per l'utente, prendervi il tempo chiudere le risorse rimaste aperte connessioni al database Fate solo attenzione, naturalmente, che queste operazioni non inneschino a loro volta altre eccezioni.

    Infine, ricordate che tutti questi rimedi valgono solo a partire dal momento in cui il controllo passa all'interprete Python. Se fate qualche errore prima , per esempio nel file batch che avvia lo script, oppure se sbagliate a scrivere la path dell'interprete nelle impostazioni del collegamento Gli strumenti di lavoro del programmatore sono infiniti, e ciascuno nel tempo sviluppa le sue preferenze e le sue antipatie.

    In questa sezione elenchiamo solo alcuni strumenti indispensabili, o quasi. Arrivati a questo punto, avrete ormai notato che la shell è uno strumento indispensabile e onnipresente per programmare e non solo in Python. Avrete anche notato che la shell di Windows cmd. Non potete fare a meno di un "console emulator", e ConEmu è il migliore in circolazione per Windows. ConEmu è un software complesso ma a voi basterà conoscere le basi.

    ConEmu è un manager in grado di gestire diverse shell contemporaneamente cmd. L'installer di Cmder, volendo, comprende anche Git for Windows: è tuttavia preferibile installare Git separatamente, come vediamo qui di seguito. Da qualche anno GitHub è diventato un modo molto popolare di pubblicare il proprio codice, condividerlo, cercare collaborazioni, farsi conoscere. Anche se non avete intenzione di aprire un account su GitHub, probabilmente vi conviene comunque usare un sistema di controllo di versione VCS per i vostri progetti, e Git è ormai di gran lunga il più popolare.

    Non è questa la sede per descrivere che cosa è e a cosa serve un VCS: la documentazione di Git fa un buon lavoro anche a spiegare la filosofia e le strategie d'uso più comuni. Per installare Git su Windows, avete due possibilità. È un software molto piacevole e intuitivo da usare, ma non è la nostra prima scelta.

    Dopo tutto, Git è nato come uno strumento di lavoro snello, che si governa con la shell: i comandi più comuni, poi, sono davvero semplici da usare.

    Inoltre molti editor ormai offrono qualche tipo di integrazione con Git, e quindi userete Git quasi sempre dal vostro editor. Il nostro consiglio è invece di installare Git per Windows uno strumento più snello che comprende, oltre a Git, la shell Git Bash un porting della nota shell Unix Bash , l'interfaccia grafica GitGui abbastanza comoda da usare, se proprio volete restare lontani dalla shell e il "commit viewer" GitK utile per avere una rappresentazione grafica dell'albero dei commit, per esempio.

    Al momento di installare Git per Windows, potete scegliere tra le numerose opzioni quelle che vi sembrano più opportune. Vi consigliamo in particolare di selezionare "Use Git from Git Bash only", dal momento che Git Bash è una shell molto più completa del solito cmd. Quando poi si arriva alla scelta della console, è indifferente selezionare "Use Windows' default console window", oppure scegliere MinTTY: la verità è che comunque useremo Git Bash all'interno di ConEmu che abbiamo già installato, senza ricorrere né a cmd.

    Infine, ricordatevi di selezionare "Enable Git Credential Manager" specialmente se avete intenzione di usare Git per collegarvi a un server come GitHub. Completata l'installazione, potete usare GitGui per le operazioni sulle vostre repository Git, se preferite. Ma probabilmente la cosa più rapida è lavorare con Git Bash, con qualche occasionale sguardo a GitK.

    Vi conviene usare Git Bash all'interno di ConEmu, chiaramente. Notate che è importante selezionare il corretto eseguibile Il prompt master vi indicherà a questo punto che siete nel branch di default master. Giocare con Git dalla shell a questo punto è facile. Provate per esempio:. Se invocate gitk mentre siete in una repository, aprite l'interfaccia grafica di GitK e potete vedere i vostri commit naturalmente potete usare anche git log per questo.

    Non c'è niente di male nell'invocare l'interprete Python direttamente nella vostra shell, come abbiamo fatto finora: è il modo più rapido, e spesso è più che sufficiente. Tuttavia per le sessioni più lunghe e impegnative desiderate avere un'interfaccia migliore.

    Ma forse a questo punto preferite usare la shell:. In questo modo potete avviare le diverse IDLE "globali" con py -2 -m idlelib , py -3 -m idlelib etc. Un'altra opzione è costituita dal vostro editor. Molti editor evoluti offrono la possibilità di integrare una REPL per vari linguaggi di programmazione, tra cui naturalmente anche la shell di Python. In genere potete configurare la shell integrata per lavorare globalmente, oppure all'interno di un venv.

    Tuttavia in questi anni si è progressivamente affermata una shell molto evoluta e ricca di opzioni: gli Jupyter Notebook in precedenza noti come IPython Notebook sono lo stato dell'arte, al punto che è riduttivo considerli solo delle shell.

    Jupyter è piuttosto un ambiente di sviluppo IDE interattivo, rivolto soprattutto alla comunità scientifica e alle applicazioni di data visualisation.

    Il sito è ricco di esempi e la documentazione è molto completa. Potete provare i notebook nel vostro browser senza installare nulla, se volete farvi un'idea. Il sito ufficiale raccomanda di usare i notebook Jupyter installando Anaconda , una distribuzione di Python dedicata soprattutto all'ambito scientifico che comprende moltissimi pacchetti pre-installati tra cui, appunto, anche Jupyter.

    Ma non è assolutamente necessario installare Anaconda per usare i notebook Jupyter. Siccome Jupyter ha bisogno di moltissimi altri pacchetti, è consigliabile installarlo in un venv appositamente creato, per poterlo valutare senza impegno. Se vi piace, potete successivamente installarlo nel Python di sistema. Una volta installato Jupyter, avete due opzioni principali per avviarlo. Potete invocare dalla shell jupyter console per aprire un notebook con l'interfaccia testuale direttamente nella shell.

    Oppure potete invocare jupyter notebook per aprire un notebook nel vostro browser, e sfruttare tutte le opzioni che vi offre l'interfaccia grafica. Le possibilità dei notebook Jupyter sono impressionanti: leggete la documentazione online per farvi un'idea. Dovete imparare a usare un editor "intelligente" di file di testo.

    La scelta di un editor dipende da mille fattori, è sempre molto personale, e la rete è piena di discussioni interminabili su qual è il "miglior editor". Ci limitiamo qui ad alcune considerazioni e suggerimenti molto generici. In primo luogo, è sempre più difficile distinguere tra un " IDE " e un " editor ".

    In teoria un IDE è un ambiente integrato che comprende, oltre all'editor vero e proprio, molti altri strumenti debugger, compiler, code completion, integrazione con vari framework, version control system, e altro ancora ; un editor d'altra parte è "solo" specializzato nella scrittura del codice, e offre funzionalità più mirate al codice in senso stretto, e non allo sviluppo di applicazioni in senso più ampio.

    Di contro, è possibile disattivare molte funzionalità non necessarie di un IDE, fino a usarlo quasi come un editor. È vero comunque che un IDE tende a "imporsi di più" sul lavoro che fate: per sfruttarlo al meglio dovete accettare un po' di sovrastruttura necessaria.

    Un editor, per contro, di solito è più snello e non impone nessun particolare modo di lavorare. Ma tutte le differenze sono opinabili, e per ogni generalizzazione ci sono sempre dieci contro-esempi. Scegliete con calma l'editor o l'IDE che si adatta di più al vostro modo di lavorare e al vostro gusto.

    In primo luogo, il già menzionato IDLE comprende oltre alla shell interattiva anche un editor. In genere non sono molti quelli che continuano a usare IDLE dopo i primi esercizi. IDLE è inteso come ambiente di lavoro provvisorio e spartano per chi, dopo aver installato Python, desidera mettersi subito al lavoro. Anche se all'inizio potrebbe piacervi proprio per la sua semplicità, probabilmente è meglio investire fin da subito in un editor più completo, in grado di supportarvi mentre progredite nella vostra conoscenza di Python.

    A parte IDLE, il primo editor che dovreste prendere in considerazione è Vim : è un editor concepito per girare direttamente nella shell, senza interfaccia grafica. È estremamente potente e flessibile, ed è l'editor preferito da molte "star" della programmazione.

    Ha una vasta e vocale "fan base" pronta a sostenere che sia il miglior editor possibile. La verità è che è anche un editor difficile da imparare e difficile da configurare.

    Vim è fatto per essere usato nella shell, senza il mouse, i menu a tendina e le altre piacevolezze grafiche a cui siamo abituati. Se il vostro lavoro si svolge tutto o quasi nel terminale, allora probabilmente Vim è davvero il vostro editor ma potreste voler dare un'occhiata anche a Emacs prima di fare una scelta definitiva. Tuttavia, anche se Vim non è il vostro editor preferito, è comunque obbligatorio imparare e memorizzare almeno i pochi comandi fondamentali che vi permettono di aprire un file, apportare delle modifiche, salvare e uscire.

    Oppure, quando vi collegate a un server remoto con una connessione ssh, Vim è praticamente l'unica cosa che siete sicuri di trovare, e che funziona in una shell, se volete anche solo aprire e leggere un file.

    Infine va detto che Vim, con tutte le sue peculiarità, è comunque lo strumento più comodo quando dovete modificare al volo un file, senza bisogno di abbandonare la shell e aprire un editor separato.

    Portatevi in una directory in cui c'è un file di testo, e apritelo con Vim:. Ecco perché occorre imparare almeno le basi di Vim! Se preferite un editor grafico o un IDE, allora la scelta non manca.

    Come Installare PyCharm su Windows 10

    Si tratta della "esperienza IDE" per definizione, completa e totalizzante, che integra e supporta ogni aspetto della vostra attività di programmatore.

    Il vantaggio è che non resta nulla o quasi che dovete cercare altrove. Lo svantaggio, probabilmente, è che vi sentirete un po' costretti a fare le cose solo in un certo modo. È davvero una questione di gusti, alla fine. Un'alternativa ulteriore potrebbe essere WingIde la cui versione free è tuttavia piuttosto limitata. La corazzata di casa Microsoft ha fatto negli ultimi anni due passi importanti che l'hanno resa competitiva anche al di fuori del mondo.

    Net e per la programmazione Python nello specifico: Visual Studio Community , una versione free dedicata espressamente al mondo dell'open source, e i Python Tools per Visual Studio , sviluppati dal Python Team di Microsoft guidato da Steve Dower, che è anche l'esperto Windows tra i core developer di Python, e il responsabile delle Windows release di CPython. Net, allora Visual Studio dovrebbe essere lo strumento che fa per voi.

    Se gli IDE vi sembrano troppo ingombranti e preferite un editor grafico più snello, allora davvero avete l'imbarazzo della scelta. Ma il primo della classe nel campo degli editor grafici è probabilmente Sublime Text : vanta una larga e attiva comunità di utenti, e una repository sterminata di add-on che coprono praticamente qualsiasi necessità. Sublime Text ha introdotto o reso popolari molti concetti innovativi come l'editing multi-cursore, che poi sono stati emulati dagli editor grafici più giovani.

    In effetti, editor come Atom o Brackets hanno un'aria Un pregio ulteriore di Sublime Text è la sua notevole velocità e robustezza: è difficile vedere un crash o un rallentamento anche con file di notevoli dimensioni. In generale, Sublime Text è forse l'unico editor grafico che non fa storcere il naso neppure alla "vecchia scuola" degli hacker che usano Vim o Emacs.

    Il lato negativo è che è un po' difficile da configurare, e la sovrabbondanza di add-on rende complicato scegliere. Se volete usare Sublime Text per la programmazione Python, vi conviene prendere spunto da una guida come questa. Prendiamo infine in considerazione Visual Studio Code , un editor di Microsoft ancora giovane, ma che è già cresciuto rapidamente e si è conquistato una sempre crescente quota di successo.

    Nonostante il nome, non ha niente a che vedere con Visual Studio. È basato sul motore Node.

    I Video di HTML.it

    È tuttavia più veloce e stabile di Atom, e rispetto a Sublime Text sembra un po' meglio organizzato, più facile da usare. Se siete programmatori esperti e avete già delle esigenze particolari, Sublime Text è ancora imbattibile e forse lo resterà per molto tempo.

    Se state iniziando, Code potrebbe essere uno strumento interessante: relativamente stabile, veloce, facile da usare, in rapida crescita e con un buon supporto da parte di Microsoft. E in definitiva, una volta imparato Code è comunque molto facile passare poi a Sublime Text. Aggiungiamo qualche indicazione su come usare Code per la programmazione Python. Con questo non intendiamo suggerire che Code sia l'editor migliore: è solo facile da impostare, e quindi adatto a una breve guida come questa, per dare l'idea di cosa più o meno occorre fare anche con gli altri editor.

    Prima di tutto, bisogna scaricare e installare Code. Fatto questo, occorre procurarsi l'estensione ufficiale per Python. Il manuale completo si trova qui. Code ha la nozione di "spazio di lavoro" workspace , che corrisponde a una directory: usate quindi "Open folder Le impostazioni dello spazio di lavoro sovrascrivono le impostazioni generali: Code genera una directory nascosta.

    Potete semplicemente copiare questo file da un progetto all'altro, se volete mantenere le stesse impostazioni in diversi progetti. Se non trova un settings. Nell'elenco dei setting, un'attenzione particolare meritano le varie path. La path predefinita per l'interprete Python è "python. Impostate poi "python.

    In questo modo Code mantiene un elenco di tutti i venv che avete creato, oltre a quelli che trova installati globalmente. Code vi mostra sempre quale interprete sta usando attualmente, nella barra di stato: se non è quello giusto, basta cliccarci sopra per sceglierne un altro.

    Una volta che Code lavora nel venv giusto per il vostro progetto, anche l'autocompletion funzionerà meglio, mostrandovi i suggerimenti dai pacchetti che avete installato nel venv. Eccovi pronta una shell Python interattiva, che usa lo stesso interprete del vostro codice, e "vede" quindi gli stessi pacchetti installati.

    Il linter predefinito è PyLint, ma potete configurarne altri e anche più di uno. Chiaramente PyLint va installato, prima di poterlo usare: se Code non lo trova, si offre di istallarlo per voi. I messaggi di PyLint sono riassunti nella barra di stato: cliccate per avere un report più dettagliato.

    Code rispetta le impostazioni di PyLint per il filtraggio dei messaggi, se usate un file. Se avete installato Git, allora Code vi offre una discreta integrazione: il pulsante "Git" nella barra di sinistra vi consente di fare le operazioni più comuni commit, push, pull La barra di stato mostra la branch attiva e vi permette di fare un checkout. Per altri comandi anche piuttosto comuni tag, log Nei progetti dove non volete usare Git, vi conviene impostare "git.

    Code e Python for Visual Studio Code vi offrono molte altre opzioni relative a fattorizzazione, formattazione, unit test, debugging, integrazione con Jupyter. La guida spiega tutto nel dettaglio. Una delle prime cose che in genere si fanno dopo aver installato un editor, è configurare l'aspetto estetico. Per esempio, molti programmatori preferiscono una combinazione di colori scura come l'onnipresente Monokai o una delle sue varianti perché la trovano più riposante per gli occhi.

    La scelta più importante, tuttavia, è quella di un font con cui visualizzare il codice. Un altro fattore determinante per la scelta del font è la resa a diverse dimensioni, a seconda della geometria del vostro schermo. Qui occorre tener conto che, per regola, la riga non dovrebbe essere più lunga di 79 caratteri. Mantenendo la finestra dell'editor a tutto schermo, la dimensione "giusta" del font è quella che vi consente di avere tutta la riga visibile, lasciando spazio a destra e a sinistra per gli ulteriori elementi grafici previsti dall'editor barre laterali, gutter, numeri di riga Siccome molti editor hanno elementi laterali ingombranti, un fattore di pregio per un font è la sua "compattezza" una buona crenatura : la riga deve essere densa, ma restare ugualmente ben leggibile.

    In ogni caso, se il font non rende bene quando è regolato alla dimensione giusta per il vostro editor e il vostro schermo, è meglio cambiare font piuttosto che adattare il layout dell'editor.

    Un aspetto decisamente meno importante è la resa del font con diverse formattazioni. Qui il fatto è che il codice è sempre "puro testo" non formattato: tuttavia molti editor applicano una formattazione automatica a seconda del contesto per esempio, i commenti sono resi in corsivo, etc. Ovviamente è possibile personalizzare ed eventualmente abolire queste scelte di formattazione, ma conviene comunque scegliere un font che sia leggibile anche in corsivo e in neretto. Windows è già dotato di uno dei migliori font "da programmatore" in circolazione, ovvero Consolas che è uno dei font selezionabili nella shell cmd.

    Molti preferiscono comunque la sua variante open source Inconsolata. Ma le scelte sono veramente molte, e nuovi font interessanti nascono ogni giorno. Per finire, una rapida rassegna di alcune librerie "Windows-oriented" che occasionalmente potrebbero tornare utili. Esistono alcune distribuzioni alternative di Python, curate da terze parti, che installano non solo Python e la sua libreria standard, ma anche una selezione curata di pacchetti e framework esterni.

    Fino a non molto tempo fa, come abbiamo visto, in Windows era difficile installare molti pacchetti con estensioni non pre-compilate: le distribuzioni alternative erano un modo facile per poter usare questi pacchetti, dal momento che i curatori della distribuzione li fornivano già pre-compilati.

    Con l'introduzione di Pip e del nuovo formato Wheel, è diventato molto più facile trovare pacchetti pre-compilati per Windows, e ormai non c'è quasi più bisogno di ricorrere a distribuzioni alternative solo come escamotage per usare certi pacchetti. Ha senso invece ricorrere a una distribuzione alternativa se offre un reale vantaggio rispetto al tipo di lavoro che vogliamo fare per esempio, Anaconda per certi ambiti scientifici, tecnologici, accademici.

    L'implementazione ufficiale di Python, l'unica sviluppata e supportata dalla Python Software Foundation, è CPython, scritta in C, che è quella che abbiamo preso fin qui in considerazione. Ma esistono altre implementazioni curate da terze parti: le più note sono Jython il cui bytecode viene eseguito dalla Java Virtual Machine, e PyPy , un'implementazione di Python scritta in CPython che offre un JIT compiler e stackless mode per aumentarne velocità e capacità in concurrency.

    Un'implementazione dedicata al mondo Windows è IronPython , scritta in C e integrata in. Net allo stesso modo delle consuete librerie Python. Purtroppo IronPython implementa solo Python 2, ma di recente lo sviluppo è ripreso e ci sono piani per implementare anche Python 3. Dedichiamo questa sezione all'esame di alcuni problemi legati all'uso di Unicode in Windows. Ricordiamo che questa non è una guida introduttiva a Unicode. Le note che seguono presuppongono una certa conoscenza operativa su Unicode, gli encoding Unicode e gli encoding regionali, gli strumenti Unicode di Python e il loro uso.

    Se usate Python per costruire programmi a interfaccia grafica GUI , in genere non dovete preoccuparvi troppo di Unicode. I moderni GUI framework supportano Unicode in maniera trasparente, e in pratica per usarli basta sapere come funziona una stringa in Python.

    In genere il principiante non si preoccupa se ogni tanto nei suoi esercizi qualche carattere "strano" viene fuori "sbagliato". Tuttavia esistono anche programmi professionali a interfaccia testuale CLI , e se intendete percorrere questa strada dovete considerare attentamente Unicode. Per cominciare, tenente presente che il problema spesso non riguarda Python. I font disponibili in cmd.

    Potete cambiare font facendo clic col pulsante destro nella barra del titolo della shell e selezionando "Proprietà". Copiateli da questa pagina del vostro browser e provate a incollarli nella shell clic col destro, e "incolla". A seconda del font impostato, vedrete correttamente i glifi oppure solo dei "segnaposto".

    Potete controllare esattamente quali caratteri sono supportati da un font usando tool come BabelMap. Aggiungere un font a quelli disponibili in cmd. Il problema di fondo è che cmd. Stai commentando usando il tuo account Twitter. Stai commentando usando il tuo account Facebook. Notificami nuovi commenti via e-mail. Notificami nuovi post via e-mail. Questo sito utilizza Akismet per ridurre lo spam.

    Scopri come vengono elaborati i dati derivati dai commenti. RSS - Articoli. RSS - Commenti. Ok, panico Insalate di cibernetica. Mi piace: Mi piace Caricamento By juhan , on 27 novembre at , under Linguaggi , Python , Windows. Posta un commento o usa questo indirizzo per il trackback. Rispondi Annulla risposta Scrivi qui il tuo commento Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:. E-mail obbligatorio L'indirizzo non verrà pubblicato.

    Nome obbligatorio. Sito web. Notificami nuovi commenti via e-mail Notificami nuovi post via e-mail.


    Articoli popolari: