Érdekes módon a deadlime kedvenc kódszerkesztő alkalmazása a Sublime. Egyrészt azért, mert a többszörös kijelölés az bizony hihetetlenül fantasztikus egy találmány. Másrészt pedig Python-ban lehet hozzá plugin-eket írni.

Kedves kollégám említette a minap, hogy egyik régebben használt szerkesztőjében volt valamiféle funkció, amivel a vágólap korábbi tartalmait lehetett újra felhasználni. Aztán elkezdtem gondolkodni rajta, hogy vajon lehetne-e egy ilyen plugin-t írni Sublime-hoz. Aztán megírtam. :)

Ha már így alakult, ragadjuk meg az alkalmat és nézzük meg kicsit, hogyan is néz ki egy Sublime plugin. A funkció meglepően kevés kódból megoldható: először is felül kell csapnunk a beépített copy és cut utasításokat sajáttal úgy, hogy megmaradjon az eredeti funkcionalitás is, de közbe mentsük egy tömbbe az adatokat.

class ClipboardHistoryCopyCommand(sublimeplugin.TextCommand):
    def run(self, view, args):
        saveSelections(view)
        view.runCommand('copy');

Egy kis XML-lel meg is mondjuk a proginak, hogy a mi parancsunkat használja a Ctrl+C nyomkodása esetén:

<bindings>
    <binding key="ctrl+c" command="clipboardHistoryCopy" />
</bindings>

A cut nem túl meglepő módon elég hasonlóan néz ki (csak a beépített cut parancsot hívjuk meg a végén). A saveSelections végzi a munka javát. Végigmegy az összes kijelölésen és amelyik nem üres, azt elpakolja egy tömbbe, aminél még arra is figyelünk, hogy ne lehessen túl nagy:

clipboardMaxSize = 100
clipboardData = []

def saveSelections(view):
    for region in view.sel():
        if region.begin() != region.end():
            clipboardData.insert(0, view.substr(region))
            if len(clipboardData) > clipboardMaxSize:
                clipboardData.pop()

Annyi maradt már csak, hogy valami kellően kézreálló billentyűkombinációra meg is jelenítse az előzményeket és tudjunk belőle kedvünkre válogatni. Legnagyobb szerencsénkre tudjuk használni a beépített lista ablakot, amiben még kereső is van (ugyanaz, ami a Ctrl+P vagy a Ctrl+R kombinációkra is bejön):

class ClipboardHistoryPasteCommand(sublimeplugin.TextCommand):
    def pasteSelected(self, view, index):
        for region in view.sel():
            view.insert(region.begin(), clipboardData[index])
    
    def run(self, view, args):
        view.window().showSelectPanel(
            clipboardData,
            functools.partial(self.pasteSelected, view),
            None,
            sublime.SELECT_PANEL_MONOSPACE_FONT
        );

És természetesen a hozzá tartozó kis XML részlet:

<binding key="alt+shift+q" command="clipboardHistoryPaste" />

Nem a legtökéletesebb megoldás, például plugin újratöltéseknél elveszik a clipboardData tömb tartalma (lehetne például fájlba menteni menet közben), de kezdetnek megteszi. A teljes csomagot innen le lehet rántani (érdekes módon ClipboardHistory.sublime-package fájlnévvel nem mentek volna a billentyűparancs felüldefiniálások, mivel az Sublime ABC sorrendben tölti be a plugineket és a Default később van... :)).

[a képet köszönjük ShutterBugChef-nek]

Ha vesszük az értékesítő-pénztáros-árukiadó modellt, érzésre úgy tűnik, hogy a több sor végigjárása miatt többet is várunk. De a sorbanállás pszichológiája fura egy dolog. Jó példa erre a hipermarket, ahol N pénztárnak van N sora azért, mert az N pénztár 1 sor felállás zavaró lehet az embereknek a hosszú sor miatt, holott a várakozási idő úgy kevesebb lenne.

Itt az ideje szimulálni. Két eset lesz (meg talán egy bónusz :)). Az egyikben van 4 ember, aki értékesít, 1 kezeli a pénzt és 1 kiadja a vásárolt árut. A másikban 6 ember, aki a teljes vásárlási folyamatért felelős. Mindkét esetben ahány ember van, annyi sor is, valamint hirtelen nagyobb mennyiségű vásárló esik be a boltba, akik mindig a legrövidebb sort célozzák meg. A helyek közötti közlekedésre szánt időt figyelmen kívül hagyjuk. Nincsenek kezelve az olyan vásárlók, akik az értékesítés után "feladják" és hazamennek (csak érdeklődni jöttek be a boltba). Az egyes helyeken töltött időt random generáltam a következő intervallumokat használva:

Értékesítés:

30 és 300 másodperc között

Pénztár:

15 és 30 másodperc között

Árukiadás:

30 és 120 másodperc között

Az első változat eredményei 4 különböző adathalmazra, 25 egyszerre érkező vásárlóval (az eredmények percben vannak):

A kettes számú verzió a 6 eladóval, aki nem specializálódott:

Ezzel úgy tűnik el is dőlt, hogy a többszörös sorbanállás nem csak lassabbnak érződik, de lassabb is. Már amennyire meg lehet bízni az általam írt szimulációkban. :)

A bónusz eset megegyezik a kettes verzióval annyi különbséggel, hogy nem eladónként van egy sor, hanem egy sor van összesen:

A különbség nem annyira látványos, de azért még sikerült lefaragni valamennyit az időkből (az A2 idejét leszámítva, az valamilyen rejtélyes oknál fogva több lett).

A kód egyébként Python-ban készült és a használt adathalmazokkal együtt letölthető itt. Kellemes szimulálást. :)

A programunk egy egyszerű "Hello World!" alkalmazás lesz parancssori stílusban. Két fajta bemenő paramétert fogad el. Az egyik a név, akinek köszönni fog, a másikra pedig megjeleníti a súgót, hogy hogyan is kell paraméterezni ezt a rettentő bonyolult programot.

A getopt

A legkézenfekvőbb módszer a paraméterek feldolgozására a getopt modul getopt() függvénye. Szükségünk lesz ezen kívül még a sys modulra, hogy a feldolgozandó lista is a birtokunkba kerüljön (mellesleg a getopt() függvény PHP-ban is létezik):

from getopt import getopt, GetoptError
import sys

A feldolgozás során a getopt() egy GetoptError kivételt dob, ha nem talál rendben valamit. A függvény első paramétere a bemenő adatok tömbje (az első indextől, mivel a nulladik index az a meghívott fájl neve), a második paraméter a rövid kapcsolók listája (kettőspont van a betűk mögött, amik paramétert várnak), a harmadik paraméter pedig a hosszú kapcsolók listája (egyenlőségjellel a név mögött, ha paramétert várnak). A visszatérési értéke két tömb, az első paraméternév-érték párokat tartalmaz, a második pedig a fel nem dolgozott parancssori argumentumokat.

try:
    opts, args = getopt(sys.argv[1:], 'hn:', ['help', 'name='])
except GetoptError:
    print 'Parameterezesi hiba'
    sys.exit(1)

Ha nem szállt el a program hibával, akkor megadjuk a változóinknak (jelen esetben csak a name-nek) az alapértelmezett értékeket és végigmegyünk az opts tömbön, hogy feltölthessük őket valós adatokkal.

name = False

for opt, arg in opts:
    if opt in ('-h', '--help'):
        print 'usage: %s --name=NAME' % sys.argv[0]
        sys.exit(0)
    elif opt in ('-n', '--name'):
        name = arg

Nem maradt más hátra, mint a name változó ellenőrzése és siker esetén a köszöntés kiiratása:

if not name:
    print 'Add meg a nevet!'
    sys.exit(2)

print 'Hello, ' + name + '!'

Ha a name változó kezdőértéke például 'World' lenne, akkor a feldolgozás utáni ellenőrzést el is hagyhatnánk és a programunk működése úgy módosulna, hogy a világot köszöntené, ha nem kap más paramétert.

Az optparse

A Python 2.3-as verziója óta rendelkezésre áll az optparse modul is, ami még egy pár gondot levesz a vállunkról méghozzá objektum-orientált módon. Ez esetben a sys modulra nem lesz szükségünk, a parancssori paraméterek begyűjtését az optparse végzi.

from optparse import OptionParser

Beállítjuk, hogy milyen paramétereket várunk és azt is, hogy mik lesznek ezeknek az alapértelmezett értékei. Ezek után feldolgozzuk a bejövő adatokat.

parser = OptionParser()
parser.add_option(
    '-n', '--name',
    dest = 'name',
    help = 'a koszontendo neve',
    metavar = 'NAME'
)
parser.set_defaults(name = False)
opts, args = parser.parse_args()

Ami azonnal feltűnhet, hogy a -h és --help kapcsolókat nem adtuk meg. Ezt az optparser automatikusan megteszi és még a segítség szövegét is legenerálja nekünk (az add_option() help és metavar paramétere alapján). A feldolgozás után kapott értékeket az opts tömbben érjük el az add_option()-nak megadott dest paraméter nevű kulcsként.

if not opts.name:
    parser.error('Add meg a nevet!')

print 'Hello ' + opts.name + '!'

Ezzel meg is lennénk. Nem tűnik sokkal rövidebbnek a kód, de több paraméter esetén szembetűnőbb lenne a getopt esetén a kód közepén az a hatalmas if-elif erdő. Ezen kívül ugye egy elég szép súgó kimenetet generál nekünk és bizonyos fokig kezeli a hibákat is (üres paraméter, nem numerikus paraméter - ha az van beállítva) egy kulturált hibakimenetet mutatva.

Példafájlok

• getopt példafájl
• optparse példafájl

A következő részben előreláthatólag különböző konfigurációs fájlok feldolgozásának módjáról lesz szó. Addig is kellemes paraméterezést.

Magáról a nyelvről azt lehet elmondani, hogy feltűnően szépnek mondható ahhoz képest, hogy a Pascal-stílusú nyelvek közé tartozik. És nem csak egyszerűen szép, hanem törekszik arra, hogy a benne írt kód is szép legyen (ahogy az a Python filozófiáinak listájában is szerepel: "Beautiful is better than ugly."). Persze ehhez az is kell, hogy ne csak Python nyelven, de Python stílusban is programozunk.
A kinézetet tekintve legszembetűnőbb különbség más nyelvekhez képest a kód kötelező indentálása. Nincsenek sorvégi pontok, pontosvesszők, if-eket és egyéb blokkszerkezeteket lezáró hullámos zárójelek vagy kulcsszavak. Minden az új sor karakterek és az indentálás alapján dől el. De mivel kódolás közben a nagy többség amúgy is szokott új sorokat és tabokat használni (és mivel a kötelező indentálás az esetek közel 100%-ában megegyezik azzal, amúgy is használnánk), ezért elég gyorsan hozzá lehet szokni ahhoz, hogy tulajdonképpen kevesebbet kell gépelni. Persze ez még kevés ahhoz, hogy használható is legyen valamire. Mivel napjaim nagy részét a webprogramozás teszi ki, ezért a szintaktikai ismerkedés után első dolgom az volt, hogy utánanézzek, mire is képes a kígyó a weben...

Itt már kezdődtek a gondok. Mutatkoztak annak a jelei, hogy a Python egy általános scriptnyelv, nem webre teremtették, mint a PHP-t. Ha mindenféle keretrendszer nélkül szeretnénk benne webprogramozni, csupán a megfelelő Apache beállítások elvégzésével és egy mod_python betöltésével... hát... nem lesz egy könnyű dolgunk (arról nem is beszélve, hogy a mod_python mellett van számos más alternatíva is és akkor még el sem jutottunk odáig, hogy keretrendszert válasszunk). Persze egy nagyon minimális keretrendszert össze lehet dobni pár tíz perc és 50-60 sor kód alatt (amit meg is tettem, just for fun), de végső soron arra jutottam, hogy ha webprogramozás, akkor egyelőre maradok a PHP-nél.

A gond ez után már csak az volt, hogy ha nem webprogramozásra, akkor mégis mi a fenére használjak egy scriptnyelvet? Mivel egy általános nyelvről van szó, elég sok dologra lehetne használni. Ennek okán úgy döntöttem, hogy ha valami nem webprogramozással kapcsolatos, de programozást igénylő problémába ütközöm, akkor azt Python-ban próbálom majd megoldani, ahelyett, hogy a jól bevált PHP-t használnám. Így ha épp egy random, 8 betűből álló stringre van szükségem, akkor nem azt írom, hogy:

$str = '';
for ($i = 0; $i < 8; ++$i) {
	$str .= chr(mt_rand(97, 122));
}
print $str;

Hanem inkább ezt:

from random import randint
print ''.join([chr(randint(97, 122)) for x in range(8)])

Valószínűleg így egyes problémákat tovább tart megoldani, mivel kénytelen vagyok utánanézni olyan dolgoknak, amiknek PHP-ban nem kellene, viszont ha sosem használom a nyelvet valós problémák megoldására, akkor egyrészt nem lesz benne gyakorlatom, másrészt pedig elfelejtem. Végeredményben tehát a Python egy szép nyelv (és nem csak külalakra, hanem működését és megoldásait tekintve is), amivel érdemes foglalkozni. Már csak azért is, hogy új szemléletmódokat szedjen magára az ember. Ezt pedig jól segíti ez az online is olvasható könyv.