Python
>>> passe = 3 #bez chyby
>>> pass = 3 #chyba, pass je rezervovane
slovo!
V Pythone nie je problém priradiť viacerým premenným jednu hodnotu naraz:
>>> a, b, c = 3
Takisto sa dá použiť viacnásobné priradenie:
>>> a, b, c = 1, 2, 3
ktoré je ekvivalentné príkazu:
>>> a = 1
>>> b = 2
>>> c = 3
>>> pocet = 1 #toto je komentar
>>> '#toto nie je komentar'
'#toto nie je komentar'
>>> 100 #celociselny zapis (int)
100
>>> 100L #celociselny zapis (long)
100L
>>> 0255 #oktanovy zapis (int)
173
>>> 0x30aL #hexadecimalny zapis (int)
778L
>>> 123.3 #desatinny zapis (float)
123.3
>>> 1e2 #exponencialny zapis (float)
100.0
>>> 1e-2L #exponencialny zapis (float)
0.01L
>>> 1J #zapis komplexneho cisla
1j
Python podporuje klasické zátvorkovanie pomocou "()".Základné operátory funkcie na prácu s číslami sú:
| +, -, *, / | plus, mínus, krát, delene |
| pow(a,b) | umocní a na b |
| a%b | operátor modulo, vydá zvyšok z delenia
a/b |
| hex(a) | vráti hodnotu decimálneho čísla a v
hexadecimálnej sústave |
| oct(a) | vráti hodnotu decimálneho čísla a v oktánovej
sústave |
| long(a) | ak je to možné, vráti číslo a v tvare
celočíselnom tvare (long), desatinnú časť zaokrúhli na
nulu smerom na dol |
| int(a) | ak je to možné, vráti číslo a v celočíselnom
tvare (int), desatinnú časť zaokrúhli na nulu smerom na
dol |
| float(a) | ak je to možné, vráti číslo a v desatinnom
tvare |
| coerce(a,b) | ak sa dajú obidva argumenty upraviť na ten istý typ,
vráti tuple s týmito upravenými argumentami, ináč vráti
hodnotu None (nič) |
| divmod(a,b) | vráti tuple s ((a-a%b)/b, a%b) |
| complex(real, imag) | vytvorí komplexné číslo z reálnej časti a z
imagnárnej časti, pričom imaginárna časť je
nepovinná |
| abs(z) | vráti absolútnu hodnotou argumentu z |
| z.real | vráti reálnu časť čísla z |
| z.imag | vráti imaginárnu časť čísla z |
| range(start=0,koniec,krok=1) | vráti pole s číslami od start (štandardne 0)
do koniec s krokom (štandardne 1) |
| round(x,n=0) | zaokrúhli x na n miest (štandardne
0) |
| xrange(start=0,koniec,krok=1) | vráti tuple s číslami od start (štandardne 0)
do koniec s krokom (štandardne 1) |
Príklady:
>>> 100L-100/4*(3-10+17)
-150L
>>> 10%3
1
>>> hex(100)
'0x64'
>>> oct(100)
'0144'
>>> a=long(3) ; a #bodkociarkou sa oddeluju 2
prikazy
3L
>>> int(a)
3
>>> float(a)
3.0
>>> coerce(3.67,8)
(3.67, 8.0)
>>> divmod(33,5)
(6, 3)
>>> a=complex(3,8) ; a
(3+8j)
>>> round(abs(a),3) #ukazka abs() a round()
8.544
>>> a.real
3.0
>>> a.imag
8.0
>>> range(0,10,3)
[0, 3, 6, 9]
>>> xrange(5)
(0, 1, 2, 3, 4)
>>> string='retazec'
>>> string[1] #klasicke indexovanie
'e'
>>> string[-3]
'z'
>>> string[1:6] #slice notácia
'etaze'
>>> string[:5]
'retaz'
>>> string[-3:]
'zec'
>>> string[-5:-2]
'taz'
>>> string[:4]= 'be' #chyba, retazce su
nemenne
Schéma indexovania pri použití slice notácie:
| r e t a z e c |
| ----------------------- |
| 0 1 2 3 4 5 6 7 |
| -7 -6 -5 -4 -3 -2 -1 |
>>> "retazec"
'retazec'
>>> '23+23' #dalsi retazec
'23+23'
Ak má byť v samotnom reťazci apostrof "'" alebo úvodzovka """, tak je nevyhnutné dať pred tento znak spätné lomítko "\". Týmto vytvoríme tzv. "escape sekvenciu", pomocou ktorej nahradzujeme znaky, ktoré majú v Pythone rezervovaný význam a tiež znaky, so zadávaním ktorých by sme mohli mať problémy (napr. ASCII znaky, ktoré sú štandardne neviditeľné ako napr. medzera, nový riadok ...).
| Escape sekvencie | |
|---|---|
| \<enter> | prázdna escape sekvencia |
| \\ | spätné lomítko (\) |
| \' | apostrof (') |
| \" | úvodzovka (") |
| \a | pípnutie (BEL) |
| \b | backspace (BS) |
| \e | escape (ESC) |
| \t | horizontálny tabulátor (HT) |
| \v | vertikálny tabulátor (VT) |
| \n | nový riadok (NL) |
| \r | návrat vozíka (CR) |
| \f | odstránkovanie (FF) |
| \0XX | ASCII znak v oktánovej sústave s hodnotou XX |
| \xXX | ASCII znak v hexadecimalnej sústave s hodnotou
XX |
>>> 'Martin\'s'
"Martin's"
>>> print '\"Ano\",\n povedal mi a odisiel\a'
"Ano",
povedal mi a odisiel<pipnutie>
>>> print "\x50\x79\x74\x68\x6f\x6e"
Python
Funkciu print sme museli použiť, ináč by bol znak nového riadku "\n" vypísaný ako ASCII hodnota. Funkcia print tiež vypúšťa vonkajšie apostrofy alebo úvodzovky, ktoré sú okolo reťazca. Dlhý reťazec, ktorý sa nevojde na jeden riadok, vytvoríte takto:
pozdrav="tymto dlhociznym retazcom\n\
... zdravim citatelov PC Revue"
Použitím spätného lomítka "\" a stlačením klávesy <enter> na konci prvého riadku sme vytvorili prázdnu escape sekvenciu, ktorá je nevyhnutná kvôli prehľadnosti zdrojového textu. Pomocou nej zapíšeme príkazy, ktoré môžu byť len na jednom riadku, prehľadnejším spôsobom do viacerých riadkov. Existuje ešte aj druhá možnosť ako vytvoriť viacriadkový reťazec, a to síce pomocou trojice apostrofov '''reťazec''' alebo úvodzoviek """reťazec""", presne tak ako sme to videli v programe lincal:
"""linuxovsky calendar verzia 0.1\n
pouzitie: ./lincal.py rok
./lincal.py rok1 rok2 ..."""
Pospájať reťazce je možné uvedením týchto reťazcov vedľa seba, pričom sa musí jednať len o reťazce, nesmú to byť funkcie, metódy alebo mená premenných! Ak potrebujeme spojiť reťazce s hodnotami uloženými v premenných alebo výstupnymi hodnotami funkcií, musíme použiť operátor "+".
>>> 'Toto ' 'je ' 'moj ' 'retazec'
'Toto je moj retazec'
>>> a='retazec'
>>> 'Toto je ' + a + ' cislo 2'
'Toto je retazec cislo 2'
Funkcie na prácu s reťazcami:
| repr(s) | vráti argument s v apostrofoch |
| str(s) | vráti argument s ak je reťazec, ak s
nie je reťazec, tak ho konvertuje na reťazec a
vráti |
| eval(s) | vyhodnotí a vráti výraz v reťazci s,
náprotivok funkcie repr() |
| ord(c) | vráti ASCII hodnotu znaku c |
| chr(i) | vráti ASCII znak, ktorému zodpovedá hodnota argumentu
i, náprotivok funkcie ord(), 0 <= i <
256 |
Príklady:
>>> 'Slovo \"pes\" ma ' + repr(len("pes")) +
' pismen(a)'
'Slovo "pes" ma 3 pismen(a)'
>>> eval('23+23') #pouzitie funkcie eval()
46
>>> ord('s') #ASCII hodnota znaku 's'
115
>>> chr(115) #ktory znak ma ASCII hodnotu
115?
's'
Obrátené apostrofy "`" ponúkajú presne to isté čo funkcia repr() v elegantnej a kratšej forme. Stačí uviesť `len("pes")` a je po probléme:
>>> 'Slovo \"pes\" ma ' + `len("pes")` + '
pismen(a)'
'Slovo "pes" ma 3 pismen(a)'
>>> lang=['python','c']
>>> lang[1]='tcl'
>>> lang
['python', 'tcl']
Použitím slice notácie je možné zmeniť viac prvkov poľa naraz. Ak priraďujeme menej hodnôt ako je prvkov, na ktoré ukazujeme, budú prebytočné prvky zmazané!
>>> cisla=[1,2,3,4,5,6,7,8,9]
>>> cisla[:3]=[10,20,30] #zmenime prve 3
prvky
>>> cisla
[10, 20, 30, 4, 5, 6, 7, 8, 9]
>>> cisla[:7]=[100,200] #prvky 3 az 7 zmiznu
>>> cisla
[100, 200, 8, 9]
Vnorené polia nie sú pre Python ničím neznámym. V iných jazykoch napr. C sa takýmto poliam hovorí viacrozmerné polia:
>>> lang=['python', 'tcl', 'c']
>>> lang[2]=['java','javascript'] ; lang
['python', 'tcl', ['java', 'javascript']]
>>> lang[2][0]
'java'
List unpacking je extrahovanie prvkov poľa do jednotlivých premenných:
>>> [a1, a2, a3] = lang
>>> a1
'python'
>>> a2
'tcl'
>>> a3
['java', 'javascript']
No a ešte treba spomenúť niekoľko dôležitých metód a funkcií, ktoré sa nám zídu pri práci s poľami:
| a.append(x) | na koniec poľa a pripojí hodnotu
x |
| a.extend(P) | na koniec poľa a pripojí pole P |
| a.insert(i, x) | na pozíciu (index) v poli a, danú argumentom
i, priradí hodnotu x |
| a.remove(x) | zmaže prvý prvok poľa a s hodnotou
x |
| a.pop([i]) | zmaže a vráti prvok poľa a z pozície i,
pri použití bez argumentu, zmaže a vráti posledný prvok
poľa |
| a.index(x) | vráti index prvého prvku s hodnotou x v poli
a, v prípade, že žiaden prvok poľa nemá hodnotu
x, vráti chybu |
| a.count(x) | vráti, koľko krát sa nachádza prvok s hodnotou
x v poli a |
| a.sort() | zoradí prvky poľa a podľa abecedy |
| a.reverse() | to isté čo sort, len zoradí prvky poľa a v
obrátenom poradí |
| list(sekvencia) | vráti pole, ktorého prvky sú prebraté zo
sekvencie |
| del a[x] | zmaže prvok poľa a s indexom x, dá sa
použiť aj s slice notáciou a môže zmazávať celé premenné
(napr. del a) |
Príklady:
>>> a=['Zuza', 'Julia'] # zoznam
priatelok
>>> a.append('Liza') #pridame Lizu
['Zuza', 'Julia', 'Liza']
>>> a.extend(['Misa', 'Kata']) #pridame 2
priatelky
['Zuza', 'Julia', 'Liza', 'Misa', 'Kata']
>>> a.insert(0, 'Petra') #Petru dame na
zaciatok
['Petra', 'Zuza', 'Julia', 'Liza', 'Misa', 'Kata']
>>> a.remove('Kata') #vyhodime Katu
['Petra', 'Zuza', 'Julia', 'Liza', 'Misa']
>>> a.pop() #aj Misa ma smolu
Misa
>>> a.index('Zuza') #Zuza je druha,indexovanie od
0!
1
>>> a.count('Julia') #kolko mame Julii
1
>>> a.sort() ; a
['Julia', 'Liza', 'Petra', 'Zuza']
>>> list(a[0])
['J', 'u', 'l', 'i', 'a']
>>> del a #zmazeme premennu "a"
>>> a=1,2,3 #a=(1,2,3) je to iste
Ak chceme vytvoriť tuple len s jednou hodnotou, treba za ňou uviesť čiarku:
>>> a='python',
>>> a
('python',)
Presne ako u polí funguje aj pri dátovom type tuple vnorenie, extrahovanie prvkov. Kedže jednotlivé prvky tuple sú nemenné, nefunguje nahradzovanie indexovaných prvkov!
>>> a=('python','tcl','java') #vytvorime
tuple
>>> a[1:] #v poriadku, nic nenahradzujeme
('tcl', 'java')
>>> a[0]='perl' #chyba, tuple je nemenne!
>>> a[1:]=('c','scheme') #chyba, tuple je
nemenne!
Pre tuple existuje funkcia podobná funkcii list(), ktorú využívame u polí. Funkcia sa volá tuple() a vracia tuple, ktorého prvky sú prebraté z argumentu, ktorý musí byť sekvenčný dátový typ (reťazec, pole, tuple).
>>> tuple(['pes','macka']) #argument je
pole
('pes', 'macka') #argument je retazec
>>> tuple('Python')
('P', 'y', 't', 'h', 'o', 'n')
Spoločne pre všetky sekvenčné dátové typy existujú tieto funkcie:
| min(s) | vráti najmenší prvok zo sekvencie s |
| max(s) | vráti najväčší prvok zo sekvencie s |
| z [not] in s | ak je písmeno z v sekvencii s, tak
vráti 1, ináč vráti 0. Použitím not sa otázka
neguje |
| len(s) | vráti počet prvkov v poli alebo tuple pri použití na
reťazec jeho dŀžku |
| s1 + s2 | spojí sekvenciu s1 so sekvenciou
s2 |
| seq * x | opakuje sekvenciu seq x krát, x musí
byť prirodzené číslo |
Príklady:
>>> a=(3,4,'psi','macka', ' nema rada
')
>>> a[3] + a[4] + (str(min(a))) + ' ' +
max(a)
'macka nema rada 3 psi'
>>> 'a' not in a[2]
1
>>> a=['Qmail','Exim']
>>> len(a), len(a[1]) #pocet prvkov a dlzka prvku
a[1]
(2, 4)
>>> a*2 + ['Sendmail','Smail']
['Qmail', 'Exim', 'Qmail', 'Exim', 'Sendmail',
'Smail']
>>> ('Send' + a[0][1:])*2
'SendmailSendmail'
>>> telcisla={'robert':'183
426','manfred':'684 158'}
>>> telcisla['robert']
'183 426'
| slov.items() | vydá pole s pármi kľúč:hodnota zo slovníka
slov |
| slov.keys() | vydá pole s kľúčmi zo slovníka slov |
| slov.values() | vydá pole s hodnotami zo slovníka slov |
| slov.has_key(k) | ak slovník slov obsahuje kľúč k, tak
vráti 1, ináč 0 |
| slov[k]=x | priradí slovníku slov kľúč k s hodnotou
x |
| len(slov) | vráti počet prvkov v slovníku slov |
| del slov[k] | zmaže zo slovníka slov prvok s kľúčom k
|
Príklady:
>>> telcisla.items()
[('robert', '183 426'), ('manfred', '684 158')]
>>> telcisla.keys()
['robert', 'manfred']
>>> telcisla.values()
['183 426', '684 158']
>>> telcisla.has_key('robert')
1
>>> telcisla['joe']='313 213' ; telcisla
{'robert': '183 426', 'joe': '313 213', 'manfred': '684
158'}
>>> len(a)
3
>>> del telcisla['robert']; telcisla
{'joe': '313 213', 'manfred': '684 158'}