Python e Vim: differenze tra le versioni

Da Guide@Debianizzati.Org.
Vai alla navigazione Vai alla ricerca
m (piccole aggiunte)
(guida estesa e verificata)
 
(43 versioni intermedie di 5 utenti non mostrate)
Riga 1: Riga 1:
{{Versioni compatibili}}
== Introduzione ==
== Introduzione ==
Questa pagina raccoglie piccoli suggerimenti per sfruttare al meglio [http://www.vim.org/ Vim] e gVim con il linguaggio di programmazione [http://www.python.org/ Python].


Questo how-to spiegher� come installare i driver proprietari forniti da ATI per generare il modulo <tt>fglrx</tt> necessario al funzionamento del motore 3d delle schede grafiche.
== Syntax Higlight ==
La prima funzione che generalmente si abilita quando si usa un editor per programmazione è il ''syntax highlight''.


Come � noto i driver ATI soffrono di una difficile installazione e configurazione. Sfortunatamente (o forse no) esistono molteplici configurazioni hardware che ostacolano l'installazione dei driver. Spesso, anche seguendo un guida perfetta, non si riesce ad attivare l'accelerazione 3D al primo colpo (molto raramente si hanno anche problemi di visualizzazione nel desktop). Solamente con i successivi tentativi (variando anche il metodo, o la guida) solitamente si raggiunge lo scopo prefisso. Il modesto consiglio � di non disperarsi, magari tirare cazzotti pesanti al case, ma provare finch� non si riesce.
Per abilitarlo in Vim per i vari linguaggi (incluso Python) è sufficiente decommentare in <code>/etc/vim/vimrc</code> la riga:


== Software richiesto ==
<pre>syntax on</pre>


Sebbene i pacchetti per la generazione del modulo <tt>fglrx</tt> siano disponibili nel repository di Debian, il consiglio � quello di utilizzare l'installer fornito da ATI in quanto pi� aggiornato.
Se invece si volesse abilitare questa funzionalità unicamente per il proprio utente, o se non si disponesse dei privilegi di superutente, si può creare un file <code>~/.vimrc</code> contenente quella riga che dunque andrà a sovrascrivere il comportamento di default.
Oltre a questo, nel caso in cui si voglia compilare il modulo senza sfruttare l'installer, sar� necessario disporre dei sorgenti del kernel (o gli header), quindi del pacchetto linux-source e di tutti i pacchetti correlati a questo e necessari per la compilazione (<tt>build-essential</tt>).


{{ Warningbox | Prima di far partire l'installazione di nuovi driver:
== Gestire l'indentazione: TAB, spazi e ''autoindent'' ==
In Python è di vitale importanza gestire correttamente l'indentazione dato che (a differenza dei linguaggi ''free-form'' come il C) questa è parte integrante della sintassi.


* Salvate una copia di <tt>/etc/X11/xorg.conf</tt> , che in caso di problemi andra' sostituita a quella nuova (creata dal configurer).
Il Python di per sé riconosce ogni tipo di indentazione (TAB, spazi, o un mix dei due). Nei moderni sistemi il TAB ha tuttavia una larghezza variabile ed impostabile a piacere. Per evitare dunque problemi di interoperabilità tra persone che usano convezioni diverse è universalmente consigliato di usare nei file di codice Python solamente spazi oppure solamente TAB. Anche l'uso esclusivo di TAB può talvolta creare dei problemi di visualizzazione (e quindi difficoltà di lettura) a causa di una diversa larghezza usata. Per tagliare la testa al toro, dunque, il modo più robusto e portabile di programmare in Python è quello di usare soltanto spazi. È possibile impostare qualsiasi editor per programmazione in modo da sostituire automaticamente al TAB un numero di spazi pari alla larghezza dell'indentazione, e ovviamente anche Vim non è da meno. La larghezza per una unità di indentazione usata quasi universalmente in Python, come raccomandato nella [https://www.python.org/dev/peps/pep-0008/#indentation PEP 8], è pari ad una larghezza di 4 spazi. Per ricapitolare il nostro scopo è ottenere:
* Verificate che non sia presente la cartella <tt>/usr/share/fglrx/</tt>. Se � presente, significa che sono installati dei vecchi driver fglrx. Per rimuoverli:
<pre># cd /usr/share/fglrx/
# sh ./fglrx-uninstall.sh</pre>
e seguite le istruzioni.
* Fate un '''<tt>aptitude purge</tt>''' di vecchi pacchetti di vecchi driver, se sono installati. Per esempio (i nomi dei pacchetti potrebbero essere diversi):
<pre># aptitude purge fglrx-driver fglrx-kernel-src fglrx-control fglrx-kernel-2.6.17-2-686</pre>
}}


== Metodologie di installazione ==
* sostituzione alla pressione del tasto TAB con un numero equivalente di spazi;
* larghezza indentazione pari a 4 spazi.


Per quanto riguarda l'intallazione di quelli nuovi, esistono essenzialmente <u>3 metodi alternativi</u>:
Per ottenere questo comportamento in Vim/gVim si possono decommentare le seguenti righe nel file di configurazione <code>/etc/vim/vimrc</code>:
# usare l'eseguibile Ati
<pre>  if has("autocmd")
# creare i pacchetti ''.deb'' partendo dall'eseguibile Ati
    filetype plugin indent on
# installare i driver dai repository
  endif</pre>


=== Intallazione attraverso l'installer ATI ===
ed inserire il seguente codice nello stesso file:
<pre>  autocmd FileType python setlocal et sw=4 sts=4 sta tw=79</pre>


Da un terminale spostatevi nella cartella dove avete scaricato il file e date i permessi di esecuzione:
Il primo abilita l'indentazione automatica per i vari linguaggi di programmazione. In particolare per il Python, se ad esempio dichiariamo una funzione su una riga, andando a capo avremo già il cursore indentato per poter scrivere il corpo della funzione con la giusta indentazione. Stessa cosa vale per i vari <code>'''if'''</code>, <code>'''for'''</code>, ecc... Questa funzione è utile anche per accorgersi di errori sintattici come la mancanza dei :, poiché la loro assenza fa si che il cursore non venga indentato.
<pre>$ chmod +x ati-driver-installer-8.26.18-x86.run</pre> quindi, da root:
<pre># sh ./ati-driver-installer-8.26.18.x86.run</pre>
e seguite le istruzioni.
Poi, sempre con i permessi di root, aggiornate il file di configurazione <tt>xorg.conf</tt>:
<pre># cd /etc/X11/
# aticonfig --initial
# aticonfig --overlay-type=Xv</pre>
e se volete settare meglio la configurazione:
<pre># aticonfig</pre>
il quale ci dar� un lungo output con la descrizione di tutte le opzioni che possiamo usare con <tt>aticonfig</tt>.


Riavviamo '''X'''.
La riga aggiunta associa ai tipi di file Python le seguenti impostazioni:


Tutto dovrebbe essere a posto.
;<code>tabstop</code> oppure <code>ts</code>: larghezza del carattere TAB, quando incontrato nel file. Noi non useremo caratteri TAB, quindi questa impostazione può essere ignorata (e infatti non è riportata nell'esempio precedente). Viene elencata qui solo per chiarezza e completezza.


===Installazione manuale con generazione pacchetti specifici per Debian===
;<code>expandtab</code> oppure <code>et</code>: riempe con spazi le indentazioni generate dalla pressione del tasto TAB.


Con i privilegi di root, rimuoviamo i vecchi pacchetti del modulo <tt>fglrx</tt>, se presenti:
;<code>shiftwidth</code> oppure <code>sw</code>: larghezza di un rientro dell'indentazione automatica. È usato anche per definire la larghezza del rientro che si aggiunge o toglie ad un blocco di testo quando si seleziona (con '''V''') e poi si indenta/deindenta con '''>''' o con '''<'''.
<pre># rm /usr/src/fglrx-kernel*.deb</pre>
E' necessario installare i seguenti pacchetti:
<pre># apt-get install module-assistant build-essential fakeroot dh-make debconf libstdc++5 gcc-3.4-base</pre>
Spostiamoci nella cartella dove abbiamo scaricato l'eseguibile Ati e diamogli i permessi di esecuzione:
<pre>$ chmod +x ati-driver-installer-8.26.18-x86.run</pre>
Poi, per creare i 5 pacchetti .deb:
<pre>$ sh ./ati-driver-installer-8.26.18-x86.run --buildpkg Debian/[release]</pre>
Ad esempio:
<pre>$ sh ./ati-driver-installer-8.26.18-x86.run --buildpkg Debian/testing</pre>
Per installarli (installiamo solo quelli fondamentali):
<pre>$ su
Password:
# dpkg -i fglrx-driver_8.26.18-1_i386.deb
# dpkg -i fglrx-kernel-src_8.26.18-1_i386.deb
# dpkg -i fglrx-control_8.26.18-1_i386.deb</pre>


====Compilazione del modulo <tt>fglrx</tt>====
;<code>softtabstop</code> oppure <code>sts</code>: larghezza di un rientro causato dalla pressione di un TAB. Il rientro è creato inserendo spazi se <code>'''et'''</code> è settato, altrimenti viene usata una combinazione di spazi e caratteri TAB (questi ultimi hanno larghezza <code>'''ts'''</code>).


Adesso va compilato il modulo <tt>fglrx</tt>, con <tt>module-assistant</tt> (m-a):
;<code>smarttab</code> oppure <code>sta</code>: in combinazione con le opzioni precedenti questa impostazione permette di cancellare un rientro (4 spazi ''reali ''nel nostro caso) con una sola pressione del tasto '''BS''' (o '''BackSpace''').
<pre># m-a prepare
# m-a update
# m-a build fglrx
# m-a install fglrx
# depmod -a</pre>
Quindi muoviamoci in <tt>/etc/X11/</tt>:
<pre># cd /etc/X11/</pre>
e aggiorniamo il file di configurazione di X:
<pre># aticonfig --initial
# aticonfig --overlay-type=Xv</pre>
Naturalmemte � possibile modificare <tt>etc/X11/xorg.conf</tt> anche a manina (per fare questo consultate...uhm, forse c'� qualche cosa in <tt>man xorg.conf</tt>) oppure consultando e usando <tt>aticonfig</tt>.


Riavviamo '''X'''.
;<code>textwidth</code> oppure <code>tw</code>: lunghezza massima del testo inserito. Una riga più lunga viene spezzata dopo uno spazio bianco per stare in questi limiti.


{{ Warningbox | Ad ogni aggiornamento del kernel bisogna ricompilare il modulo <tt>fglrx</tt>. }}
== Folding: le piegature nel codice ==
Una funzione comoda durante la programmazione è la possibilità di ripiegare del codice (ad esempio una funzione o una classe) in modo di avere una visione più compatta del file e facilitare la navigazione.


===Installazione dei driver dai repository===
Questo è possibile in Vim tramite il ''folding'' (''piegature''). Esistono dei plugin per Vim che riconoscono le strutture sintattiche del Python e creano automaticamente le piegature. Tuttavia il metodo illustrato di seguito è ancora più semplice: piegature automatiche in base all'indentazione. Nel caso del Python questo semplice metodo è particolarmente efficace.


Innanzi tutto installiamo i pacchetti necessari:
Per abilitarlo basta inserire in <code>/etc/vim/vimrc</code>:
<pre># apt-get install fglrx-control fglrx-driver fglrx-driver-dev fglrx-kernel-src</pre>
Siccome il modulo di cui abbiamo bisogno (<tt>fglrx</tt>) � sotto forma di sorgenti (<tt>fglrx-kernel-src</tt>), lo compiliamo e lo installiamo utilizzando <tt>module-assistant</tt>, come descritto [[#Compilazione del modulo fglrx|qui]].


In teoria abbiamo finito, bisogna solamente configurare [[#Struttura del file xorg.conf|<tt>/etc/X11/xorg.conf</tt>]] e riavviare '''X'''.
<pre>set foldmethod=indent</pre>


'''Nota:''' Consultate anche il manuale di <tt>fglrx</tt> . ( <tt>man fglrx</tt> ).
Di seguito sono elencati i principali comandi per gestire le piegature:


== Struttura del file xorg.conf ==
;<code>zo</code> oppure Spazio: apre la piegature sotto il cursore (un solo livello)
;<code>zO</code>: apre la piegature sotto il cursore e ricorsivamente tutte le piegature in essa contenute
;<code>zc</code>: chiude la piegatura alla quale appartiene il blocco di codice indicato dal cursore (un solo livello)
;<code>zC</code>: chiude la piegatura alla quale appartiene il blocco di codice indicato dal cursore e ricorsivamente tutte le piegature che la contengono
;<code>zr</code>: apre tutte le piegature del file corrente di un livello
;<code>zR</code>: apre completamente le piegature contenute nel file corrente (tutti i livelli)
;<code>zm</code>: chiude tutte le piegature del file corrente di un livello
;<code>zM</code>: chiude completamente le piegature contenute nel file corrente (tutti i livelli)


Un esempio di <tt>/etc/X11/xorg.conf</tt>
== Eseguire Python da Vim ==
Vim possiede caratteristiche avanzate che permettono di impostare i compilatori da usare per ogni linguaggio e il metodo di esecuzione del <code>make</code>.


<pre>
Nel caso del Python propongo una soluzione ''quick and dirty'' che associa ad un tasto l'esecuzione dello script.


### /etc/X11/xorg.conf ###
Aggiungendo nell'ormai famoso <code>/etc/vim/vimrc</code>


Section "ServerLayout"
<pre>
Identifier    "Default Layout"
" Running Python by pushing F5
Screen      0  "aticonfig-Screen[0]" 0 0
map <f5> :w<CR>:!python %<CR>
InputDevice    "Keyboard"
</pre>
InputDevice    "Mouse"
InputDevice    "Touchpad"
EndSection


Section "Files"
oppure, nel caso in cui si usi Python 3,
# path to defoma fonts
FontPath    "/usr/share/fonts/X11/misc"
FontPath    "/usr/share/fonts/X11/100dpi/:unscaled"
FontPath    "/usr/share/fonts/X11/75dpi/:unscaled"
FontPath    "/usr/share/fonts/X11/Type1"
FontPath    "/usr/share/fonts/X11/100dpi"
FontPath    "/usr/share/fonts/X11/75dpi"
FontPath    "/var/lib/defoma/x-ttcidfont-conf.d/dirs/TrueType"
EndSection


Section "Module"
<pre>
Load  "synaptics"
" Running Python 3 by pushing F5
Load  "bitmap"
map <f5> :w<CR>:!python3 %<CR>
Load  "ddc"
</pre>
Load  "dri"
Load  "extmod"
Load  "freetype"
Load  "glx"
Load  "int10"
Load  "type1"
Load  "vbe"
#      Load  "GLcore"
EndSection


Section "InputDevice"
alla pressione del tasto F5 verrà eseguito <code>python</code> (o <code>python3</code>) passando come parametro il file corrente (indicato da <code>'''%'''</code>).
Identifier  "Keyboard"
Driver      "kbd"
Option     "CoreKeyboard"
Option     "XkbRules" "xorg"
Option     "XkbModel" "pc105"
Option     "XkbLayout" "it"
EndSection


Section "InputDevice"
Se si è soliti usare entrambe le versioni di Python si può pensare di associare l'avvio di ciascun compilatore/interprete a tasti funzione diversi.
Identifier  "Mouse"
Driver      "mouse"
Option     "CorePointer"
Option     "Device" "/dev/input/mice"
Option     "Protocol" "ExplorerPS/2"
Option     "Emulate3Buttons" "true"
EndSection


Section "InputDevice"
== Autocompletamento e documentazione integrata ==
Identifier  "Touchpad"
{{Box|Attenzione|I pacchetti <code>vim-tiny</code> e <code>vim</code> non includono questa funzionalità. Occorre dunque installare uno tra i pacchetti seguenti: <code>vim-nox</code>, <code>vim-gtk</code>, <code>vim-gnome</code> o <code>vim-athena</code>.}}
Driver      "synaptics"
Dalla versione 7 in Vim è stata inserita una funzione di autocompletamento intelligente (conosciuto anche come ''omnicompletion'')  per i vari linguaggi simile a quella presente in alcuni degli IDE più avanzati.
Option     "Device" "/dev/psaux"
Option     "Protocol" "auto-dev"
Option     "LeftEdge" "1700"
Option     "RightEdge" "5300"
Option     "TopEdge" "1700"
Option     "BottomEdge" "4200"
Option     "FingerLow" "25"
Option     "FingerHigh" "30"
Option     "MaxTapTime" "180"
Option     "MaxTapMove" "220"
Option     "VertScrollDelta" "100"
Option     "MinSpeed" "0.10"
Option     "MaxSpeed" "0.30"
Option     "AccelFactor" "0.0150"
Option     "SHMConfig" "on"
        Option      "AlwaysCore" "true"
EndSection


Section "Monitor"
[[image: Python-gvim-7-omnicompletion.png|thumb|Screenshot della funzione di omnicompletion di Vim 7 con linguaggio di programmazione Python.]]
Identifier  "aticonfig-Monitor[0]"
HorizSync    30.0 - 70.0
VertRefresh  50.0 - 100.0
Option     "VendorName" "ATI Proprietary Driver"
Option     "ModelName" "Generic Autodetecting Monitor"
Option     "DPMS" "true"
EndSection


Section "Monitor"
Per il Python questa funzione permette di completare i nomi delle classi, dei metodi e degli attributi tramite un comodo menu contestuale. Inoltre viene anche visualizzata contemporaneamente la docstring del metodo o della classe che si sta completando.
Identifier  "aticonfig-Monitor[1]"
Option     "DPMS" "true"
EndSection


Section "Device"
Una immagine vale più di mille parole. Potete notare la funzione di omnicompletion in funzione nello screenshot qui a fianco. Notare come sulla parte superiore della finestra sia apparsa automaticamente la documentazione della classe sulla quale si sta utilizzando l'autocompletamento.
Identifier  "aticonfig-Device[0]"
Driver      "fglrx"
Option     "VideoOverlay" "on"
Option     "OpenGLOverlay" "off"
Option     "DesktopSetup" "horizontal,reverse"
BusID      "PCI:1:0:0"
EndSection


Section "Screen"
Per effettuare l'autocompletamento, quando si è in modalità inserimento basta premere <code>'''Ctrl+x Ctrl+o'''</code>.
Identifier "aticonfig-Screen[0]"
Device    "aticonfig-Device[0]"
Monitor    "aticonfig-Monitor[0]"
DefaultDepth    24
SubSection "Display"
Viewport  0 0
Depth    24
Modes    "1280x800" "1280x1024" "1024x768" "800x600" "640x480"
EndSubSection
EndSection


Section "DRI"
Per spostarsi nel riquadro della finestra occupato dalla documentazione o per chiuderlo si utilizzano i [[VimCS:_Gestione#Finestre|classici comandi di Vim]] per la gestione delle finestre, quali <code>'''CTRL+w w'''</code> e <code>''':close'''</code>.
Mode        0666
EndSection


### End Of File ###
A volte è anche comodo effettuare un autocompletamento ''non intelligente'', basato sulle parole presenti nel file corrente. Questo autocompletamento si ottiene premendo <code>'''CTRL+n'''</code>. Quest'ultimo metodo può risultare utile per completare nomi di variabili o di funzioni.
</pre>


== Alcuni Test ==
== Tips and Tricks ==
Alcuni ulteriori consigli nell'uso di Vim:


Per verificare se abbiamo installato tutto correttamente:
# '''Commentare un blocco di codice'''
<pre>$ fglrxinfo</pre>
#* Premere <code>'''CTRL+v'''</code> e selezionare le righe di codice interessate;
dovrebbe dare un output simile a questo:
#* premere <code>'''I'''</code> (i maiuscola) e digitare il carattere interessato (solitamente <code>#</code>);
<pre>display: :0.0  screen: 0
#* premere ESC;
OpenGL vendor string: ATI Technologies Inc.
#* spostarsi dalla riga corrente.
OpenGL renderer string: MOBILITY RADEON 9700 Generic
# '''Indentare e deindentare un blocco di codice'''
OpenGL version string: 2.0.5879 (8.26.18)</pre>
#* Premere <code>'''v'''</code> ed entrare in modalità "visuale linea";
Se al posto di ATI compare Mesa, c'� qualcosa che non va. L'installazione non � andata a buon fine.
#* selezionare la parte di codice da in/deindentare;
#* premere <code>'''>'''</code> per indentare o <code>'''<'''</code> per deindentare di 1 TAB.


Per testare l'accelerazione:
<pre>$ fgl_glxgears</pre>
Dovrebbe comparire un cubo rotante con sulle sei faccie degli ingranaggi rotanti e, sul terminale la conta dei frame:
<pre>Using GLX_SGIX_pbuffer
1610 frames in 5.0 seconds = 322.000 FPS
1640 frames in 5.0 seconds = 328.000 FPS
2093 frames in 5.0 seconds = 418.600 FPS</pre>
Se invece compaiono 4-5 righe di errori, c' qualcosa che non va. L'installazione non andata a buon fine. Ritenta, forse sarai pi fortunat*.


Per testare l'accelerazione � possibile utilizzare anche i tools di Mesa:
In alternativa al metodo indicato al punto 1, per commentare un blocco di testo è possibile mappare un tasto qualsiasi che faccia tutto il lavoro "sporco".
<pre># apt-get install mesa-utils
$ glxgears -printfps</pre>
Appaiono tre ingranaggi rotanti e la conta dei fotogrammi:
<pre>14045 frames in 5.0 seconds = 2808.862 FPS
14115 frames in 5.0 seconds = 2822.858 FPS
14196 frames in 5.0 seconds = 2839.177 FPS</pre>


==File di log==
Perché ciò avvenga, basterà aggiungere all'interno del file di configurazione lo snippet:
<pre>
" Python comments: # for adding and - for removing
map # :s/^/#/<CR>
map - :s/^#//<CR>
</pre>
La semplice digitazione del carattere  <code>'''#'''</code>  farà in modo che il blocco in quel momento selezionato sia commentato in automatico; quella del carattere  <code>'''-'''</code> invece lo decommenterà.


l file di log principale � '''<tt>/var/log/Xorg.0.log</tt>''' e seguenti. Da spulciare, analizare, bruciare, supplicare. Insomma qui c'� di tutto di pi�. Ma a volte si pu� anche non trovare nulla di anomalo e magari <tt>fgl_glxgears</tt> non funziona lo stesso. 8�(
== Conclusioni ==
Questi sono solo piccoli suggerimenti per programmare in Python con Vim. Come al solito correzioni, suggerimenti o aggiunte sono ben accetti e anzi incoraggiati.


Se abbiamo installato i driver con l'installer Ati, esiste anche questo piccolo log: <tt>/usr/share/fglrx/fglrx-install.log</tt>
== Link ==
* [http://www.vim.org/ Homepage di Vim]
* [http://www.python.org/ Homepage di Python]
* [http://www.vim.org/scripts/script.php?script_id=1542 Sito ufficiale di pythoncomplete.vim]


== Tips and Tricks ==
{{Autori
 
|Autore = [[Utente:TheNoise|~ The Noise]]
* Una cosa importante, ma che resta comunque strana, � scrivere, in <tt>/etc/X11/xorg.conf</tt>, i moduli <tt>dri</tt>, <tt>glx</tt> e <tt>GLcore</tt>, in questo ordine. Se ad esempio si mette <tt>GLcore</tt> per primo, l'accelerazione non andr� e il log <tt>/var/log/Xorg.0.log</tt> riporter� una serie di errori, tra cui warning sulla libreria <tt>/usr/lib/xorg/modules/extensions/libGLcore.so</tt> e  un errore verso la fine, tristemente incorniciato. Questo errore non so se sia circoscritto alla mia configurazione o se sia un cosa generale. L'unica cosa � fare un po' di test.
|Verificata_da =
* A volte si ottengono risultati migliori installando i driver con '''X non avviato'''.
:[[Utente:Stemby|Stemby]] 13:08, 23 mar 2015 (CET)
* Se i driver sono molto recenti il modulo <tt>GLcore</tt> non bisognerebbe inserirlo in <tt>/etc/X11/xorg.conf</tt> : viene caricato automaticamente.
|Numero_revisori = 1
* Aggiornando le librerie Mesa (<tt>libgl1-mesa-dri</tt> oppure <tt>libgl1-mesa-glx</tt> ad esempio), ahim�, pu� capitare che l'accelerazione sparisca all'improvviso. L'unica cosa da fare probabilmente � disinstallare i driver e installarli di nuovo.
|Estesa_da =
* Per quanto riguarda le trasparenze di KDE, credo non siano supportate a livello hardware. Io non sono riuscito ad attivarle, infatti se aggiungo a <tt>/etc/X11/xorg.conf</tt> la sezione:
: [[Utente:Stemby|Stemby]] 13:08, 23 mar 2015 (CET)
<pre>Section "Extensions"
}}
Option "Composite" "Enable"
EndSection</pre>
l'accelerazione 3D non viene caricata.
 
----
 
Autore: [[User:rasca|rasca]] 09:04, 17 July 2006 (CEST)
 
Ampliato da: [[Utente:Superflieriam|Superflieriam]]


[[Categoria:Hardware]]
[[Categoria:Elaborazione testi]][[Categoria:Programmi da terminale]][[Categoria:Python]]
[[Categoria:Desktop]]
[[Categoria:Kernel]]

Versione attuale delle 12:08, 23 mar 2015

Debian-swirl.png Versioni Compatibili

Tutte le versioni supportate di Debian

Introduzione

Questa pagina raccoglie piccoli suggerimenti per sfruttare al meglio Vim e gVim con il linguaggio di programmazione Python.

Syntax Higlight

La prima funzione che generalmente si abilita quando si usa un editor per programmazione è il syntax highlight.

Per abilitarlo in Vim per i vari linguaggi (incluso Python) è sufficiente decommentare in /etc/vim/vimrc la riga:

syntax on

Se invece si volesse abilitare questa funzionalità unicamente per il proprio utente, o se non si disponesse dei privilegi di superutente, si può creare un file ~/.vimrc contenente quella riga che dunque andrà a sovrascrivere il comportamento di default.

Gestire l'indentazione: TAB, spazi e autoindent

In Python è di vitale importanza gestire correttamente l'indentazione dato che (a differenza dei linguaggi free-form come il C) questa è parte integrante della sintassi.

Il Python di per sé riconosce ogni tipo di indentazione (TAB, spazi, o un mix dei due). Nei moderni sistemi il TAB ha tuttavia una larghezza variabile ed impostabile a piacere. Per evitare dunque problemi di interoperabilità tra persone che usano convezioni diverse è universalmente consigliato di usare nei file di codice Python solamente spazi oppure solamente TAB. Anche l'uso esclusivo di TAB può talvolta creare dei problemi di visualizzazione (e quindi difficoltà di lettura) a causa di una diversa larghezza usata. Per tagliare la testa al toro, dunque, il modo più robusto e portabile di programmare in Python è quello di usare soltanto spazi. È possibile impostare qualsiasi editor per programmazione in modo da sostituire automaticamente al TAB un numero di spazi pari alla larghezza dell'indentazione, e ovviamente anche Vim non è da meno. La larghezza per una unità di indentazione usata quasi universalmente in Python, come raccomandato nella PEP 8, è pari ad una larghezza di 4 spazi. Per ricapitolare il nostro scopo è ottenere:

  • sostituzione alla pressione del tasto TAB con un numero equivalente di spazi;
  • larghezza indentazione pari a 4 spazi.

Per ottenere questo comportamento in Vim/gVim si possono decommentare le seguenti righe nel file di configurazione /etc/vim/vimrc:

  if has("autocmd")
    filetype plugin indent on
  endif

ed inserire il seguente codice nello stesso file:

  autocmd FileType python setlocal et sw=4 sts=4 sta tw=79

Il primo abilita l'indentazione automatica per i vari linguaggi di programmazione. In particolare per il Python, se ad esempio dichiariamo una funzione su una riga, andando a capo avremo già il cursore indentato per poter scrivere il corpo della funzione con la giusta indentazione. Stessa cosa vale per i vari if, for, ecc... Questa funzione è utile anche per accorgersi di errori sintattici come la mancanza dei :, poiché la loro assenza fa si che il cursore non venga indentato.

La riga aggiunta associa ai tipi di file Python le seguenti impostazioni:

tabstop oppure ts
larghezza del carattere TAB, quando incontrato nel file. Noi non useremo caratteri TAB, quindi questa impostazione può essere ignorata (e infatti non è riportata nell'esempio precedente). Viene elencata qui solo per chiarezza e completezza.
expandtab oppure et
riempe con spazi le indentazioni generate dalla pressione del tasto TAB.
shiftwidth oppure sw
larghezza di un rientro dell'indentazione automatica. È usato anche per definire la larghezza del rientro che si aggiunge o toglie ad un blocco di testo quando si seleziona (con V) e poi si indenta/deindenta con > o con <.
softtabstop oppure sts
larghezza di un rientro causato dalla pressione di un TAB. Il rientro è creato inserendo spazi se et è settato, altrimenti viene usata una combinazione di spazi e caratteri TAB (questi ultimi hanno larghezza ts).
smarttab oppure sta
in combinazione con le opzioni precedenti questa impostazione permette di cancellare un rientro (4 spazi reali nel nostro caso) con una sola pressione del tasto BS (o BackSpace).
textwidth oppure tw
lunghezza massima del testo inserito. Una riga più lunga viene spezzata dopo uno spazio bianco per stare in questi limiti.

Folding: le piegature nel codice

Una funzione comoda durante la programmazione è la possibilità di ripiegare del codice (ad esempio una funzione o una classe) in modo di avere una visione più compatta del file e facilitare la navigazione.

Questo è possibile in Vim tramite il folding (piegature). Esistono dei plugin per Vim che riconoscono le strutture sintattiche del Python e creano automaticamente le piegature. Tuttavia il metodo illustrato di seguito è ancora più semplice: piegature automatiche in base all'indentazione. Nel caso del Python questo semplice metodo è particolarmente efficace.

Per abilitarlo basta inserire in /etc/vim/vimrc:

set foldmethod=indent

Di seguito sono elencati i principali comandi per gestire le piegature:

zo oppure Spazio
apre la piegature sotto il cursore (un solo livello)
zO
apre la piegature sotto il cursore e ricorsivamente tutte le piegature in essa contenute
zc
chiude la piegatura alla quale appartiene il blocco di codice indicato dal cursore (un solo livello)
zC
chiude la piegatura alla quale appartiene il blocco di codice indicato dal cursore e ricorsivamente tutte le piegature che la contengono
zr
apre tutte le piegature del file corrente di un livello
zR
apre completamente le piegature contenute nel file corrente (tutti i livelli)
zm
chiude tutte le piegature del file corrente di un livello
zM
chiude completamente le piegature contenute nel file corrente (tutti i livelli)

Eseguire Python da Vim

Vim possiede caratteristiche avanzate che permettono di impostare i compilatori da usare per ogni linguaggio e il metodo di esecuzione del make.

Nel caso del Python propongo una soluzione quick and dirty che associa ad un tasto l'esecuzione dello script.

Aggiungendo nell'ormai famoso /etc/vim/vimrc

" Running Python by pushing F5
map <f5> :w<CR>:!python %<CR>

oppure, nel caso in cui si usi Python 3,

" Running Python 3 by pushing F5
map <f5> :w<CR>:!python3 %<CR>

alla pressione del tasto F5 verrà eseguito python (o python3) passando come parametro il file corrente (indicato da %).

Se si è soliti usare entrambe le versioni di Python si può pensare di associare l'avvio di ciascun compilatore/interprete a tasti funzione diversi.

Autocompletamento e documentazione integrata

Info.png Attenzione
I pacchetti vim-tiny e vim non includono questa funzionalità. Occorre dunque installare uno tra i pacchetti seguenti: vim-nox, vim-gtk, vim-gnome o vim-athena.

Dalla versione 7 in Vim è stata inserita una funzione di autocompletamento intelligente (conosciuto anche come omnicompletion) per i vari linguaggi simile a quella presente in alcuni degli IDE più avanzati.

Screenshot della funzione di omnicompletion di Vim 7 con linguaggio di programmazione Python.

Per il Python questa funzione permette di completare i nomi delle classi, dei metodi e degli attributi tramite un comodo menu contestuale. Inoltre viene anche visualizzata contemporaneamente la docstring del metodo o della classe che si sta completando.

Una immagine vale più di mille parole. Potete notare la funzione di omnicompletion in funzione nello screenshot qui a fianco. Notare come sulla parte superiore della finestra sia apparsa automaticamente la documentazione della classe sulla quale si sta utilizzando l'autocompletamento.

Per effettuare l'autocompletamento, quando si è in modalità inserimento basta premere Ctrl+x Ctrl+o.

Per spostarsi nel riquadro della finestra occupato dalla documentazione o per chiuderlo si utilizzano i classici comandi di Vim per la gestione delle finestre, quali CTRL+w w e :close.

A volte è anche comodo effettuare un autocompletamento non intelligente, basato sulle parole presenti nel file corrente. Questo autocompletamento si ottiene premendo CTRL+n. Quest'ultimo metodo può risultare utile per completare nomi di variabili o di funzioni.

Tips and Tricks

Alcuni ulteriori consigli nell'uso di Vim:

  1. Commentare un blocco di codice
    • Premere CTRL+v e selezionare le righe di codice interessate;
    • premere I (i maiuscola) e digitare il carattere interessato (solitamente #);
    • premere ESC;
    • spostarsi dalla riga corrente.
  2. Indentare e deindentare un blocco di codice
    • Premere v ed entrare in modalità "visuale linea";
    • selezionare la parte di codice da in/deindentare;
    • premere > per indentare o < per deindentare di 1 TAB.


In alternativa al metodo indicato al punto 1, per commentare un blocco di testo è possibile mappare un tasto qualsiasi che faccia tutto il lavoro "sporco".

Perché ciò avvenga, basterà aggiungere all'interno del file di configurazione lo snippet:

" Python comments: # for adding and - for removing
map # :s/^/#/<CR>
map - :s/^#//<CR>

La semplice digitazione del carattere # farà in modo che il blocco in quel momento selezionato sia commentato in automatico; quella del carattere - invece lo decommenterà.

Conclusioni

Questi sono solo piccoli suggerimenti per programmare in Python con Vim. Come al solito correzioni, suggerimenti o aggiunte sono ben accetti e anzi incoraggiati.

Link




Guida scritta da: ~ The Noise Swirl-auth40.png Debianized 40%
Estesa da:
Stemby 13:08, 23 mar 2015 (CET)
Verificata da:
Stemby 13:08, 23 mar 2015 (CET)

Verificare ed estendere la guida | Cos'è una guida Debianized