Python a PyQt - 3

15. 3. 2006 | Jan Kaluza | Programování | 7635×

V dnešním díle si povíme více o polích, slovnících, n-ticích (tuples) a funkcích, které se jich týkají. V části o PyQT si řekneme o widgetu QLineEdit, layoutu QGridLayout a zaškrtávacím tlačítku QCheckBox.

Více o polích

K polím je přidružena řada funkcí.

insert(i, x)

Vloží položku x na pozici i.

append(x)

Vloží položku x na poslední pozici.

pop(i)

Vymaže položku na pozici i a tato položka bude návratovou hodnotou funkce. Pokud není i definováno, vymaže se poslední položka v poli.

index(x)

Vrací pozici položky x.

count(x)

Vrací kolikkrát je položka x zastoupena v poli.

sort()

Seřadí pole podle velikosti od nejmenší položky.

reverse()

Převrátí pole.

Pro lepší pochopení si ukážeme příklad v interpretu Pythonu.

>>> a = [21, 44, 88, 44, 15]
>>> print a.count(44), a.count(21), a.count(1)
2 1 0
>>> a.insert(4, -15)
>>> a.append(15)
>>> a
[21, 44, 88, 44, -15, 15, 15]
>>> a.remove(21)
>>> a
[44, 88, 44, -15, 15, 15]
>>> a.index(-15)
3
>>> a.reverse()
>>> a
[15, 15, -15, 44, 88, 44]
>>> a.sort()
>>> a
[-15, 15, 15, 44, 44, 88]

Funkce filter(), map() a reduce()

Tyto 3 funkce jsou užitečné při používání polí společně s funkcemi.

filter(funkce, pole)

Funkce filter() vrací ty prvký pole, pro které vrátí funkce True. Pro pochopení uvedu příklad.

>>> def f(x): return x*2>5 and x*2<20 # funkce vrati True,
plati-li podminka
...
>>> filter(f,range(2,25)) # vygenerujeme pole cisel 2 az 24 a kazdy
prvek pole otestujeme funkci.
[3, 4, 5, 6, 7, 8, 9]

map(funkce, pole)

Funkce map() vrací všechny navrácené hodnoty funkcí funkce. funkce je spuštěna pro každý prvek pole.

>>> def f(x): return x*x # funkce vraci druhou mocninu x
...
>>> map(f,range(1,5)) # vygenerujeme pole cisel 1 az 4 a kazdy prvek
pole predame funkci.
[1, 4, 9, 16]

Můžeme použít 2 i více polí.

>>> def f(x,y): return x+y # funkce vraci soucet x a y
...
>>> map(f,[1,2,3],[3,2,1]) # za x bude dosazeno pole [1,2,3] a za y
pole [3,2,1]
[4, 4, 4]

reduce(funkce, pole)

Funkce reduce() vrací celkovou hodnotu funkce funkce. V proměnné xfunkce se ukládá průběžně ona celková hodnota. V proměnné y j vždy jeden z prvků pole. To, co funkce vrátí je při jejím dalším volání uloženo v x. prvek pole.

>>> def f(x,y): return x+y
...
>>> reduce(f,range(1,10))
45

del

Příkazem del můžeme vymazat celé pole nebo jeho prvky. Na rozdíl od funkce pop() nebo remove() můžeme mazat i jednotlivé části pole.

>>> a=[-5,6,15,55,155,230]
>>> del a[0]
>>> a
[6, 15, 55, 155, 230]
>>> del a[1:3]
>>> a
[6, 155, 230]
>>> del a

n-tice (Tuples)

N-tice (tuples) se od polí liší tím, že není možno je po vytvoření měnit. Definují se mezi jednoduché závorky a oddělují se čárkou.

>>> t = ("foo","bar",12345)
>>> t
('foo', 'bar', 12345)
>>> t[:-1]
('foo', 'bar')
>>> t+(1,2,3,4)
('foo', 'bar', 12345, 1, 2, 3, 4)

Slovníky (Dictionaries)

Dictionary je typ pole v Pythonu, ve kterém můžeme uchovávat hodnotu k předem danému klíči. Definuje se mezi složenýma závorkama a klíč od hodnoty se odděluje dvojtečkou. Všechny klíče můžeme dostat funkcí keys() a zjistit, jestli je nějaká položka v klíči dictionary můžeme pomocí funkce has_key() nebo příkazu in. Typickým příkladem použití tohoto typu je telefoní seznam.

>>> tel={"Honza Novak":113,"Petr Novak":211,"Lukas Cech":121}
>>> tel['Petr Novak']
211
>>> tel.has_key('Honza Novak')
True
>>> "Honza Novak" in tel
True
>>> tel.keys()
['Petr Novak', 'Honza Novak', 'Lukas Cech']
>>> del tel["Lukas Cech"]
>>> tel
{'Petr Novak': 211, 'Honza Novak': 113}
>>> tel["Adam Michna"]=123
>>> tel
{'Petr Novak': 211, 'Adam Michna': 123, 'Honza Novak': 113}

Pole, Slovníky a For

Na následujících příkladech si ukážeme a vysvětlíme některé funkce, které nám mohou pomoci při použití polí a slovníků s cyklem for. První funkcí, používanou se slovníky, je iteritems(). Tato funkce vrací jako první hodnotu klíč a jako druhou proměnnou hodnotu klíče.

>>> tel={"Honza Novak":113,"Petr Novak":211,"Lukas Cech":121}
>>> for key,value in tel.iteritems():
...     print key,"===>",str(value)
...
Petr Novak ===> 211
Honza Novak ===> 113
Lukas Cech ===> 121

Teď už se budeme věnovat pouze polím a začneme situací, kdy je potřeba procházet současně 2 pole. Pomůže nám v tom funkce zip() jejíž použití pochopíte určitě na příkladu.

>>> a=[11,5,3,7]
>>> b=[9,2,8,16]
>>> for one,two in zip(a,b):
...     print one*two
...
99
10
24
112

Další funkcí je funkce enumerate(). Tu budeme potřebovat, pokud budeme procházet pole, ale nebudeme chtít přijít o pravidelně se zvyšující hodnotu. Z příkladu to bude opět jasné.

>>> jmena=["Jan","Petr","Karel"]
>>> for i,jmeno in enumerate(jmena):
...     print str(i+1)+". jmeno ===>",jmeno
...
1. jmeno ===> Jan
2. jmeno ===> Petr
3. jmeno ===> Karel

PyQT

QLineEdit - Editační pole

QLineEdit je editační pole, pomocí kterého můžeme editovat jeden řádek textu. QLineEdit umožňuje používat všechny dobře známé fuknce jako je Cut, Paste, Undo atd. Editační pole vytvoříme funkcí QLineEdit(rodic,nazev). Funkce text() vrací text, který je aktuálně v poli. Text v poli můžeme určit funkcí setText(text). Dnes opět vylepšíme a upravíme náš skript a výsledkem naší práce bude okno, pomocí něhož bude možné spouštět další programy. Pro spuštění dalších programů budeme potřebovat modul os, konkrétně jeho funkci system(), která spouští zadaný příkaz. Aby došlo ke spuštění, musíme na funkci run, která bude spouštět program, napojit signál editačního pole "returnPressed()". Ten je generován po stisknutí enteru na editačním poli.

from qt import *
import os # importujeme os
def run():
# funkce run je napojena na signal returnPressed() a spousti program.
# win.edit.text() vraci text v editacnim poli. Ten je typu QString, ale
# funkce os.system potrebuje string. Proto jej musime prevest.
    os.system(str(win.edit.text())+" &")

app=QApplication([])
win=QMainWindow()
win.layout=QVBoxLayout(win,0,1,"Layout") # vytvorime layout
win.label=QLabel(win,"text") # vytvorime QLabel
win.label.setText("Zadejte program :") # vlozime do label uvodni text
win.layout.addWidget(win.label) # vlozime win.label do layoutu
win.edit=QLineEdit(win,"edit") # vytvorime QLineEdit
win.layout.addWidget(win.edit) # vlozime win.edit do layoutu
win.konec=QPushButton(win,"quit") # vytvorime tlacito konec
win.konec.setText("Konec") # urcime text tlacitka
win.layout.addWidget(win.konec) # vlozime win.konec do layoutu
win.show()
app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
app.connect(win.edit, SIGNAL("returnPressed()"),run)
app.connect(win.konec, SIGNAL("clicked()"),win.close)
app.exec_loop()

QGridLayout

QGridLayout je pokročilejším layoutem, který umožňuje uspořádání widgetů do tabulky. Vytvořit jej můžeme pomocí QGridLayout(rodic,pocet_radku,pocet_sloupcu,odsazeni,mezera,nazev). Nové objekty se přidávají funkcí addWidget(objekt,radek,sloupec,zarovnani). QGridLayout umožňuje přidat objekt i přes více řádků a sloupců funkcí addMultiCellWidget(objekt,od_sloupce,do_sloupce,od_radku,do_radku, zarovnani). Zarovnání má v QT předdefinované hodnoty:

• Qt.AlignAuto - Zarovnání automaticky.
• Qt.AlignLeft - Zarovnání vlevo.
• Qt.AlignRight - Zarovnání vpravo
• Qt.AlignHCenter - Horizontální zarovnání na střed.
• Qt.AlignTop - Zarovnání nahoru.
• Qt.AlignBottom - Zarovnání dolů
• Qt.AlignVCenter - Vertikální zarovnání na střed.
• Qt.AlignCenter - Vertikální i horizontální zarovnání na střed.

Nyní vylepšíme náš program o tlačítko "Run", které bude umístěné vedle tlačítka "Konec".

from qt import *
import os # importujeme os
def run():
    os.system(str(win.edit.text())+" &")

app=QApplication([])
win=QMainWindow()
win.layout=QGridLayout(win,3,2,1,0,"layout") # vytvorime QGridLayout layout

win.label=QLabel(win,"label")
win.label.setText("Zadejte program :")
# vlozime win.label do layoutu na 1. radek pres 2 sloupce
win.layout.addMultiCellWidget(win.label,0,0,0,1,Qt.AlignHCenter)

win.edit=QLineEdit(win,"edit")
# vlozime win.edit do layoutu na 2. radek pres 2 sloupce
win.layout.addMultiCellWidget(win.edit,1,1,0,1,Qt.AlignAuto)

win.konec=QPushButton(win,"quit")
win.konec.setText("Konec")
# vlozime win.konec do layoutu na 2. radek do prvniho sloupce
win.layout.addWidget(win.konec,2,0,Qt.AlignHCenter)

win.run=QPushButton(win,"Run")
win.run.setText("Run")
win.layout.addWidget(win.run,2,1,Qt.AlignHCenter) # vlozime win.run do layoutu

win.show()
app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
app.connect(win.edit, SIGNAL("returnPressed()"),run)
app.connect(win.konec, SIGNAL("clicked()"),win.close)
app.connect(win.run, SIGNAL("clicked()"),run) # napojime tlacitko na fci run()
app.exec_loop()

QCheckBox

Zaškrtávací tlačítko určitě dobře znáte ze všech druhů aplikací. V PyQT jej můžeme jednoduše vytvořit pomocí QCheckBox(text,rodic,nazev). Stav zaškrtávacího tlačítka zjistíme funkcí isChecked(), která vrací True v případě, že je tlačítko zaškrtlé, a False pokud zaškrtlé není. Měnit stav tlačítka můžeme funkcí setChecked(True/False). Pokud jako parametr předáme True, bude tlačítko zaškrtlé. Nyní můžeme do našeho programu přidat QCheckBox pro otevření programu v Xtermu.

from qt import *
import os
def run():
    if win.xterm.isChecked() == True: # Pokud bude CheckBox
stisknuty =>
        os.system("xterm -e
'"+str(win.edit.text())+"' &") # spustime v xtermu
    else: # pokud ne =>
        os.system(str(win.edit.text())+"
&") # spustime rovnou program

app=QApplication([])
win=QMainWindow()
win.layout=QGridLayout(win,4,2,1,0,"layout")

win.label=QLabel(win,"label")
win.label.setText("Zadejte program :")
win.layout.addMultiCellWidget(win.label,0,0,0,1,Qt.AlignHCenter)

win.edit=QLineEdit(win,"edit")
win.layout.addMultiCellWidget(win.edit,1,1,0,1,Qt.AlignAuto)

win.xterm=QCheckBox("Spustit v Xterm",win,"xterm") # Vytvorime QCheckBox
win.layout.addMultiCellWidget(win.xterm,2,2,0,1,Qt.AlignHCenter)

win.konec=QPushButton(win,"quit")
win.konec.setText("Konec")
win.layout.addWidget(win.konec,3,0,Qt.AlignHCenter)

win.run=QPushButton(win,"Run")
win.run.setText("Run")
win.layout.addWidget(win.run,3,1,Qt.AlignHCenter)

win.show()
app.connect(app, SIGNAL("lastWindowClosed()"), app, SLOT("quit()"))
app.connect(win.edit, SIGNAL("returnPressed()"),run)
app.connect(win.konec, SIGNAL("clicked()"),win.close)
app.connect(win.run, SIGNAL("clicked()"),run)
app.exec_loop()

       

Komentáře

[Jáchym Čepický]

zdravim, nebylo by zajimavejsi spoustet programy pomoci os.popen(prikaz).readlines()? Daly by se tim zpravovat pripadne chybove hlasky...

[hanzz]

Diky za nazor :) Rozhodne na toto v serialu jeste dojde, az se bude psat GUI k nejakemu textovemu programu, coz mam taky v planu. Ted by to bylo jeste myslim zbytecne, kdyz jde v tomto clanku jen o obycejne spusteni programu.

[Jarda]

Zdravim, porad mi neni jasne, k cemu se hodi tuples. A dalsi dotaz: cim se nahrazuji v pythonu struktury z C. Diky.

[zack]

Pokud chapes strukturu jako prostredek pro ulozeni dat ruznych typu pak Python nabizi mnohem lepsi prostedky : napriklad slovniky nebo tridy. Ty se chovaji jako dynamicke struktury - t,j, polozky lze kdykoliv pridavat nebo ubirat.

Pokud skutecne potrebujes Ceckove binarni struktury (napr. pro cteni/zapis binarnich souboru ) tak na to Python ma vestaveny modul struct.

[Dunric]

N-tice (tuples) se od polí liší tím, že není možno je po vytvoření měnit.

Hodí se pro všechny případy, kdy je potřeba seznam s konstantními prvky. V podobném duchu jako proč mít konstanty, když můžu mít proměnné, které nebudu v kódu měnit. Většina lidí se radši opře o syntaktickou analýzu překladače/interpretru než o vlastní hlavu - snižování pravděpodobnosti výskytu chyby.

[Petr Mach]

N-tice se od polí liší v hodně směrech, třeba v tom, že pole může obsahovat jen jeden datový typ:

>>> import array     
>>> a = array.array('i')
>>> a.append(1)
>>> a.append(5)
>>> a
array('i', [1, 5])
>>> a.append('xxx')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: an integer is required

Na n-ticích je nejdůležitejší to, že jsou nemodifikovatelné, mohou mít svůj hash a jako takové mohou být hodnotou klíče slovníku.

[trancelius]

array() není klasické pole, to pochopitelně víc datových typů obsahovat může

>>> pole = []
>>> pole.append(False)
>>> pole.append(1)
>>> pole.append(3.141593654)
>>> pole.append("Hello world")
>>> pole.append(Neco())
>>> pole
[False, 1, 3.1415936539999998, 'Hello world', <__main__.Neco instance at 0xb7e7692c>]

[Petr Mach]

To o čem si myslíš že je pole není pole, natož klasické, ale datový typ seznam. Lze si to lehce ověřit.

>>> type([])
<type 'list'>

[hanzz]

Jenom doplnim prechozi argumenty jeste o jeden priklad pouziti tuples. Jde o to, kdyz potrebujete, aby funkce vratila vice promennych. V tom pripade je mozne vratit promenne jako tuples a pak je zase jako tuples nacist

>>> def secti_nasob(x,y):
... return (x+y,x*y)
...
>>> (x,y)=secti_nasob(3,6)
>>> print x,y
9 18


[David Watzke]

Pěkný, díky

Bylo by prosím možné zdrojáky házet i na server v souborech? Než to spustím, musím si převést mezery na taby, kontrolovat všelijaký zalamování, protože Python je na to citlivý. Díky.

[jkt]

musím si převést mezery na taby

nemusis, staci v jednom souboru pouzivat jeden styl.

[David Watzke]

V tom případě byl problém jen s tím zalamováním - nejdřív jsem předělával ty mezery, tak je to možný...

[hanzz]

Jestli myslis ten posledni kod, tak to nevim, proc mi to na abicku vydali s tim zalomenim. :) Ja to odeslal dobre :) Mozna to bylo proste moc dlouho...

[David Watzke]

Jj, ten poslední...

[Petr Mach]

Nechápu jak autor může psát o seznamech (list) a nazývat to zcestně a blbě pole? Co bude dělat, až se dostane k array? Seznamy nejsou pole, a touto špatnou terminologií nadělá víc škody než užitku, protože zblbne každého začátečníka, který pak bude mít problémy s ostatními texty o Pythonu. Doufám že to uvede v příštím díle na pravou míru.

[hanzz]

Uznavam, ze je to chyba. Seznam je svym zpusobem pole avsak mel by byt nazyvan seznamem. Pole je chapano v ruznych jazycich ruzne. Ja jsem se s nim prvne setkal v C a jako nejblizsi datovy typ podobny poli mi prisel prave seznam. Proto jsem jej zacal takto chybne nazyvat. Jinak moc dekuju za konstruktivni kritiku. Nikdo nejsme bezchybny a kazdy nejak zacinal. Timto se Vam za tuto chybu omlouvam a beru si z toho ponauceni pro priste.

[David Watzke]

Btw, jeden warning u posledního příkladu (na Gentoo/AMD64):

QLayout "unnamed" added to QMainWindow "unnamed", which already has a layout

Mám Python 2.4.2 a PyQt 3.15.1.

[OndraH]

Mám ten samý warning, ale asi to nijak nevadí, programy běhají normálně.

[Jan Samohýl]

Zdravím,

myslím, že nový článek o Pythonu by na nešťastné filter, map a reduce už neměl upozorňovat, a místo toho používat generátorové výrazy, jako např.

i=( x**2 for x in range(20) if x%2==0 )

což do i vloží iterátor, který projde druhé mocniny sudých čísel menších než 20. Můžete místo () psát [] a dostanete přímo seznam (to první chodí od verze 2.4, to druhé už od verze 2.2 tuším). Tohle naprosto nahrazuje map a filter a je to čistčí/čitelnější (sám autor Pythonu Guido van Rossum to tak tvrdí).

Co se týče reduce, je to věc, která není moc používaná a možná patří spíš do knihovny. Říkám to proto, že se v budoucnosti vážně uvažuje o odstranění těchto 3 funkcí.

[Jirka bianco Vágner]

" i=( x**2 for x in range(20) if x%2==0 ) "? No tfuuuj! :)

Z estetickeho hlediska :) me ty nove featury a jejich zapis v pythonu tak nejak nesedi, nejak zacina ztracet tu lehkost a vzdusnost pro kterou jsem si ho zamiloval. Kdyz jsem napriklad videl jak spousta lidi ujizdi napr. na dekoratorech, mno nevim nevim.

[Jan Samohýl]

To je jen příklad, samozřejmě. Nikdo vás nenutí tak psát. Ale vám skutečně připadá

i=map(lambda x: x**2, filter(lambda x: x%2==0, range(20)))

vzdušnější? Mě rozhodně ne, a proto také, doufám, v Pythonu 3000 map a filter (a lambda) zmizí. Mimochodem, já to používám poměrně často, a to tehdy, pokud chci zdůraznit: tady se děje jenom nějaká technická věc, která není z celkového pohledu tak důležitá (něco jako potřebuji tento vektor vynásobit třemi, nebo si převést tento seznam do trochu jiné formy).

Vlastně, když nad tím tak přemýšlím, je to jako kdybyste tvrdil, že místo

y = x**3 + 2*x**2 + 3

by se mělo psát

x1 = power(x, 3)
x2 = multiply(2, power(x, 2))
y = add(add(x1, x2), 3)

Proč se tak bránit více operacím v jednom výrazu? Akorát u generátorového výrazu máte místo skaláru vektor..

Krásné na Pythonu je to, že nemusíte znát všechny jeho možnosti, abyste ho mohl celkem bez problémů používat (a číst).

Generátory moc nevyužívám, ale takové věci jako @exposed v Cherrypy nebo něco jako @synchronized v Javě považuji za naprosto legitimní a velice elegantní řešení.

[tulpik]

Jaky fuj? Tohle je naprosto korektni "klasickej" python zapis.

[Kyosuke]

Cože? Co je na tom klasickýho? Dyť to tam doštrikovali před časem. Nemáte nějakou krátkou paměť?

[Mikos]

Je to rozhodně krásnej, čistej a estetickej zápis. Mohem přehlednější a (z mého pohledu) rozhodně lepší než konstrukce jako lambda, filter a map.

Jsem nesmírně rád, že se Python ubírá tímto směrem, generátory a list comprehension je naprosto úžasná věc a mimo jiné jeden z důvodů, proč jsem si Python vybral (rozhodoval jsem se jestli se začít učit Ruby nebo Python, Tython to celkem jasně vyhrál, ale důvodů bylo mnoho, toto je de facto jen detajl ).

[Mikos]

Heh, Python a né Tython samozřejmě

[Kyosuke]

A je to hezčí než lispovský ITER?

Krásný, čistý a estetický jsou (z jiného pohledu) i funkce vyššího řádu, pokud má pro ně jazyk dobrou podporu (což Python IMHO tak úplně neměl nikdy...kdyby se v něm nepoužívaly tak hovadsky, byl by rozdíl o dost menší...). Svým způsobem jsou čistší - ta comprehension je na úrovni jazyka? Blok? Funkce? Snippet kódu? (Taky - teď si teď úplně nejsem jistý, jak to python implementuje - mám pocit, že mi u nich mírně hapruje asociativita těch for cyklů. To by ale samozřejmě byla hodně subjektivní námitka.) Samozřejmě ale chápu, že s tak primitivními prostředky, jaké Python měl, jsou list comprehensions rozhodně relativně větší pokrok, než by byly v jiných vyšších jazycích. Apropos, tyhlety "naprosto úžasné věci" jsou v některých jazycích prakticky odjakživa...

Ještě takovou blbost, jakým způsobem se dá v Pythonu udelat lit comprehension, která destrukturuje n-tice do proměnných? Jako v Haskellu

addPairwise :: [(Integer,Integer)] -> [Integer]
addPairwise ap  =  [ x+y | (x,y) <- ps ]

Na takovéhle fíčury jsem zatím nepřišel, jak se dělají.

[Jan Samohýl]

Neznám Haskell, ale možná máte na mysli:

[ x+y for x,y in [(1,2),(2,3),(3,4)] ]

Jinak, comprehensions jsou výrazy.

[Kyosuke]

Ten výraz prostě bere prvky rovnou po dvou, ne po jednom. Asi to nepůjde, nebo jsem alespoň nenašel žádný takový příklad. Na druhou stranu, stačí zřejmě použít generátorový oneliner. (Tedy s tím, že záhlaví deklarace funkce se nepočítá... )

[Kyosuke]

BTW já jsem nepsal, že není krásnej a estetickej (aspoň v jednodušších případech rozhodně je), já napadal tvrzení, že je v Pythonu "klasickej" a to je, řekl bych, trošku rozdíl.