Enhavolisto

Antaŭa temo

5. Interpretilo

Sekva temo

7. Regi fluon

6. Enkonduko al la Pitona lingvo

En la sekvaj ekzemploj, oni devas tajpi ĉion post la invito (<<<...). Linioj sen invito estas respondo el la interpretilo. Rimarku, ke la dunivela invito (...) sen sekvaj literoj je la linio signifas ke oni devas tajpi vakan linion; oni uzas tion por fini multilinian komandon.

6.1. Komentoj

Kelkaj el la ekzemploj en ĉi tiu eklernilo, eĉ tiuj entajpitaj ĉe la interaga invito, inkludas komentojn. Komentoj en Pitono komencas per la signo #, kaj etendas ĝis la fino de la linio. Komento povas aperi ĉe la komenco de linio, aŭ povas sekvi spaceton aŭ kodon. Komentoj ne povas aperi en ĉena literalo. # en literalo estas nur signo.

Ekzemploj:

>>> # ĉi tiu estas la unua komento
...
>>> SPAMO = 1 # ĉi tiu estas la dua
>>> ĈENO = "# ĉi tiu ne estas komento."

6.2. Numeroj

La interpretilo agas kiel simpla kalkulilo: oni povas entajpi esprimon kaj ĝi skribos la valoron. La operatoroj +, -, *, kaj / funkcias kiel tiuj en la plejparto de aliaj programlingvoj; oni povas uzi rondajn krampojn por grupigi esprimojn. Jen ekzemploj:

>>> 2+2
4
>>> # ĉi tiu estas komenta linio
... 2+2
4
>>> 2+2 # komento je la sama linio de kodo
4
>>> (50-5*6)/4
5
>>> #Entjera divido resendas nur la entjeran rezulton:
... 7/3
2
>>> 7/-3
-3
>>> # modulo resendas nur la ceteron:
... 7%3
1

Pitono uzas la egalsignon (=) por valorizi variablon. La interpretilo ne skribas rezulton de valorizo.

>>> larĝeco = 20
>>> alteco = 5*9
>>> larĝeco * alteco
900

En Pitono, oni povas valorizi plurajn variablojn samtempe.

>>> a = b = c = 0   #Nuligu variablojn a, b kaj c
>>> a
0
>>> b
0
>>> c
0

Ĉiu esprimo je la dekstra flanko estas elvalorigita (maldekstra al dekstra), kaj nur poste la variabloj estas valorizitaj.

>>> a, b = 0, 1
>>> print b
1
>>> a, b = b, a+b
>>> print b        #a=1,b=0+1
1
>>> a, b = b, a+b
>>> print b        #a=2,b=1+1
2

Estas kompleta kapableco por glitpunktaj numeroj. Kiam tipoj estas miksitaj, la rezulto estas glitpunkta.

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

Pitono subtenas ankaŭ kompleksajn numerojn; oni skribas imagajn numerojn kun sufikso jJ. Kompleksaj numeroj kun ne-nula reela parto estas skribataj kiel (reel+imagj) aŭ oni povas krei ilin per la funkcio complex(reela valoro, imaga valoro).

>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0,1)
(-1+0j)
>>> 3+1j*3
(3+3j)
>>> (3+1j)*3
(9+3j)
>>> (1+2j)/(1+1j)
(1.5+0.5j)

Pitono ĉiam prezentas kompleksajn numerojn kiel du numerojn, la reelan parton kaj la imagan parton. Por elĉerpi tiujn partojn el kompleksa numero z, uzu metodojn z.real kaj z.imag.

>>> z=1.5+0.5j
>>> z.real
1.5
>>> z.imag
0.5

La funkcioj uzitaj por ŝanĝi tipon al entjeroj aŭ al glitpunktoj [nome: float(), int() kaj long()] ne funkcias ĉe kompleksaj numeroj – ne estas unu taŭga metodo por ŝanĝi kompleksan numeron al reela numero. Uzu abs(z) por trovi ĝian grandecon (kiel glitpunkto) aŭ metodon z.real por trovi ĝian reelan parton.

>>> a=3.0+4.0j
>>> float(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't convert complex to float
>>> a.real
3.0
>>> a.imag
4.0
>>> abs(a)  # sqrt(a.real**2  + a.imag**2)
5.0

En interaga reĝimo, Pitono asignas la lastan videbligitan esprimon al la variablo _ (unu substreko). Rezulte, kiam oni uzas Pitonon kiel kalkulmaŝinon, estas iom facila daŭrigi la kalkulojn, ekz.:

>>> imposto = 17.5 / 100
>>> prezo = 3.50
>>> prezo * imposto
0.6125
>>> prezo + _   #_ egalas 0.6125
4.1125
>>> round(_,2)  #_ egalas 4.1125
4.11

Ne eksplicite asignu valoron al ĉi tiu variablo - oni kreus sendependan lokan variablon kun la sama nomo, do kaŝus la primitivan variablon.

6.3. Ĉenoj

Krom numeroj, oni povas ankaŭ manipuli ĉenojn, kiujn oni povas esprimi per kelkaj manieroj.

Oni povas ĉirkaŭi ĉenon per apostrofoj aŭ citiloj. Citiloj ĉirkaŭas la ĉenon se la ĉeno enhavas apostrofon kaj ne enhavas citilojn, alie apostrofoj povas ĉirkaŭi la ĉenon.

>>> 'spamaj ovoj'
'spamaj ovoj'
>>> "salut' amiko"
"salut' amiko"
>>> '"Jes," li diris.'
'"Jes," li diris.'

La signo \ (maloblikvo) en ĉeno antaŭ apostrofo aŭ citilo indikas, ke la sekvanta signo ja estas parto de la ĉeno, ne limdifino.

>>> 'salut\' amiko'
"salut' amiko"
>>> "\"Jes,\" li diris."
'"Jes," li diris.'
>>> '"estas bel\'," ŝi diris.'
'"estas bel'," ŝi diris.'

Por enmeti maloblikvojn en ĉeno, uzu du apudajn maloblikvojn.

>>> a = 'c:\\data\\test\\spam.py'
>>> print a
c:\data\test\spam.py

Oni povas indiki per kelkaj manieroj, ke ĉenaj datumoj etendiĝos super pluraj linioj.

Maloblikvo ĉe la fino de linio indikas, ke la ĉenaj datumoj etendiĝos al la venonta linio.

>>> ekzemplo = "ĉi tiu estas iom longa ĉeno enhavanta \
... kelkajn liniojn"
>>> print ekzemplo
ĉi tiu estas iom longa ĉeno enhavanta kelkajn liniojn

\n indikas novlinian signon (finon de aktuala linio):

>>> ekzemplo = "ĉi tiu estas iom longa ĉeno enhavanta\n\
... kelkajn liniojn de teksto kiel oni faros en C.\n\
... Rimarku ke spaceto\
... je linia komenco signifas.\n"
>>> print ekzemplo
ĉi tiu estas iom longa ĉeno enhavanta
kelkajn liniojn de teksto kiel oni faros en C.
Rimarku ke spaceto je linia komenco signifas.

Se ni faras “krudan” ĉenliteralon (r”ĉeno”), la signo \n ne estas konvertita al novlinia signo, kaj la signo \n kaj la maloblikvo estas inkludita en la ĉeno.

>>> ekzemplo = r"ĉi tiu estas iom longa ĉeno enhavanta\n\
... kelkajn liniojn de teksto kiel oni faros en C."
>>> print ekzemplo
ĉi tiu estas iom longa ĉeno enhavanta\n\
kelkajn liniojn de teksto kiel oni faros en C.

Alternative, oni povas ĉirkaŭi ĉenojn per paro de triopaj citiloj aŭ apostrofoj: """'''. Ne inkludu novliniajn signojn; ili estas aŭtomate aldonitaj.

>>> print """
... Uzado: iu ajn [ELEKTOJ]
... -h                  Montri ĉi tiun mesagon pri uzado
... -H hostnomo         Hostnomo por konekto
... """

la rezulto estas:

Uzado: iu ajn [ELEKTOJ]
-h                  Montri ĉi tiun mesagon pri uzado
-H hostnomo         Hostnomo por konekto

Oni povas kroĉi ĉenojn kun la operatoro +, kaj ripeti ĉenon kun la operatoro *:

>>> vorto = 'Help' + 'O'
>>> vorto
'HelpO'
>>> '<' + vorto*5 + '>'
'<HelpOHelpOHelpOHelpOHelpO>'

Du ĉenliteraloj apude estas aŭtomate kroĉitaj. Ambaŭ devas esti literaloj.

>>> import string
>>> 'str' 'ing' # apudaj literaloj
'string'
>>> string.strip('str') + 'ing'
'string'
>>> string.strip('str') 'ing' # nevalida: ne ambaŭ literaloj
  File "<stdin>", line 1
    string.strip('str') 'ing' # nevalida: ne ambaŭ literaloj
                            ^
SyntaxError: invalid syntax

Pitono povas indici ĉenojn. Kiel en programlingvo C, la unua signo havas la indicon 0. Ne estas aparta tipo por signo - signo estas nur ĉeno kiu havas unu eron. Kiel en la programlingvo Icon, Pitono povas indiki parton de ĉeno per sekc-notacio: duopaj indicoj apartigitaj per dupunkto.

>>> vorto[4] #vorto = HelpO
'O'
>>> vorto[0:2] #de la nula ĝis la dua
'He'
>>> vorto[2:4]
'lp'

Sekc-indicoj havas implicitajn valorojn; la unua indico implicite estas nulo, la dua indico implicite estas la nombroj da eroj en la aktuala aro (por ĉeno, nombro de signoj en tiu ĉeno).

>>> vorto[:2] #La nula kaj unua signoj
'He'
>>> vorto[2:] #ĉiu signoj krom la du komencaj
'lpO'

Oni ne rajtas ŝanĝi ĉenon (t.e. valorizi indicitan lokon en ĉeno).

>>> vorto[0] = 'x'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

Tamen, krei novan ĉenon kun kroĉa enhavo estas facila kaj efika.

>>> 'x' + vorto[1:] #vorto = HelpO
'xelpO'
>>> 'vort' + vorto[4]
'vortO'

Jen utila regulo de sekcaj agoj: s[:i] + s[i:] egalas s.

>>> vorto = 'HelpO'
>>> vorto[:2] + vorto[2:]
'HelpO'
>>> vorto[:3] + vorto[3:]
'HelpO'

Tro granda indico estas anstataŭigita per nombro de eroj en la aro (por ĉeno, nombro de signoj en tiu ĉeno); se supra limo estas pli malgranda ol malsupra, rezulto estas malplena aro (ĉeno).

>>> vorto[1:100] #vorto = HelpO
'elpO'
>>> vorto[10:]
''
>>> vorto[2:1]
''

Indicoj povas esti negativaj numeroj, por komenci kalkulon je la dekstra. Ekzemple:

>>> vorto[-1] #lasta
'O'
>>> vorto[-2] #antaŭlasta
'p'
>>> vorto[-2:] #du lastaj
'pO'
>>> vorto[:-2] #ĉiuj krom la du lastaj
'Hel'

Rimarku, ke -0 egalas 0, do kalkulo okazas je la maldekstra!

>>> vorto[-0] #ĉar -0 egalas 0
'H'

Eksterlimaj negativaj sekcaj indicoj estas stumpigitaj, sed tiaj estas malpermesita je unuopa indico:

>>> vorto[-100:]
'HelpA'
>>> vorto[-10] #eraro
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

La plej bona metodo por kompreni kaj memori pri sekcoj estas, ke oni imagu, ke la indico okazas inter la eroj, kaj la maldekstra limo de la unua ero estas indicita per 0. Tiam la dekstra limo de la lasta ero estas indicita per n (grandeco de la aro).

Por ekzemplo:

 +---+---+---+---+---+
 | H | e | l | p | O |
 +---+---+---+---+---+
 0   1   2   3   4   5
-5  -4  -3  -2  -1

La unua vico de numeroj donas la poziciojn de la indicoj 0...5 en la ĉeno; la dua vico donas la respondajn negativajn indicojn. La sekco de i al j konsistas el ĉiu signo inter la limoj i kaj j, respektive.

Por ne-negativaj indicoj, la longeco de sekco estas la diferenco inter la indicaj valoroj (se ambaŭ estas en la indicaj limoj), ekz., la longeco de vorto[1:3] estas 2.

La prafunkcio len() resendas la longecon de ĉeno.

>>> s = 'antaŭvidebleco'
>>> len(s)
14

6.4. Listoj

Pitono konas kelkajn nesimplajn tipojn de datumoj, kiujn oni povas uzi por kungrupi aliajn bazajn tipojn. La plej diverse kapabla estas la listo, kiun oni povas skribi kiel liston de valoroj, apartigitajn per komoj, la tuton en ortaj krampoj. Listeroj ne devas esti la sama baza tipo.

>>> a = ['spamo', 'ovoj', 100, 1234]
>>> a
['spamo', 'ovoj', 100, 1234]

Same kiel ĉenaj indicoj, listaj indicoj komencas per 0, kaj oni povas sekci aŭ kungrupi listojn, k.t.p.:

>>> a[0]
'spamo'
>>> a[3]
1234
>>> a[-2]
100
>>> a[1:-1]
['ovoj', 100]
>>> a[:2] + ['lardo', 2*2]
['spamo', 'ovoj', 'lardo', 4]
>>> 2*a[:3] + ['Boe!']
['spamo', 'ovoj', 100, 'spamo', 'ovoj', 100, 'Boe!']

Malsame al ĉenoj, kiuj estas neŝanĝeblaj, oni ja povas ŝanĝi la individuajn erojn en listo:

>>> a
['spamo', 'ovoj', 100, 1234]
>>> a[2] = a[2] + 23
>>> a
['spamo', 'ovoj', 123, 1234]

Oni povas valorizi sekciojn, kaj ĉi tiu povas ŝanĝi la grandecon de la listo:

>>> # Anstataŭigu iom da eroj:
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> #Forĵetu iom:
... a[0:2] = []
>>> a
[123, 1234]
>>> #Aldonu iom:
... a[1:1] = ['umas', 'ĉoŭĉoŭ']
>>> a
[123, 'umas', 'ĉoŭĉoŭ', 1234]
>>> a[:0] = a #Enmetu kopion de aktuala listo je la komenco
>>> a
[123, 'umas', 'ĉoŭĉoŭ', 1234, 123, 'umas', 'ĉoŭĉoŭ', 1234]

La prafunkcio len() ankaŭ aplikas al listoj:

>>> len(a)
8

Oni povas ingi listojn (krei listojn kiu enhavas aliajn listojn).

Por ekzemplo:

>>> t = [2, 3]
>>> p = [1, t, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
>>> p[1].append('krom')  #klarigo de 'append' okazos poste
>>> p
[1, [2, 3, 'krom'], 4]
>>> t
[2, 3, 'krom']

Rimarku, ke en la lasta ekzemplo, p[1] kaj t aludas al la sama objekto! Ni revizitos poste objektajn semantikojn en leciono pri valorizado.

Oni povas malpaki liston en individuajn variablojn. Oni faras tion per enmeti la listerojn en ortaj krampoj, ekz.:

>>> a = ['spam', 'ovoj', 100, 1234] #kreu liston
>>> [a1, a2, a3, a4] = a            #malpaku liston
>>> a1
spam

6.5. Opoj kaj sekvencoj

Estas alia norma datuma tipo, la opo.

Same kiel listoj, opo konsistas el nombro de valoroj, apartigita per komoj. Oni povas ingi opon en opo.

Ekz.:

>>> t = 12345, 54321, 'saluton!'
>>> t[0]
12345
>>> t
(12345, 54321, 'saluton!')
>>> #Oni povas ingi opojn
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'saluton!'), (1, 2, 3, 4, 5))

Pitono videbligas opojn en rondaj krampoj, por ke ingitaj opoj estu taŭge komprenitaj. Oni rajtas entajpi ilin sen rondaj krampoj (se krampoj ne necesas por klarigi esprimon).

Opoj, kiel ĉenoj, estas neŝanĝeblaj; oni ne povas valorizi individuan eron de opo (aliflanke, oni povas trafi la saman celon per tranĉado kaj kroĉado). Oni povas krei opojn kiu enhavas ŝanĝeblajn objektojn, kiel listoj.

Opoj havas multajn uzojn, ekz. (x,y) koordinataj paroj, datumaro de datumbazo pri dungatoj, k.t.p.

Speciala problemo estas la konstruado de opo kiu enhavas neniun aŭ unu erojn: la sintakso havas strangaĵojn por akomodi tiujn. Oni konstruas malplenan opon per malplena paro de rondaj krampoj; oni konstruas opon kun unu ero per uzo de fina komo post la valoro (ne sufiĉas enmeti solan valoron en rondaj krampoj). Malbela, sed efika, ekz.:

>>> malplena = ()
>>> unuopo = 'saluton', #<-- rimarku finan komon
>>> len(malplena)
0
>>> len(unuopo)
1
>>> unuopo
('saluton',)

La instrukcio:

t = 12345, 54321, 'saluton!'

estas ekzemplo de opa pakado*. Pitono pakas la valorojn 12345, 54321 kaj 'saluton!' kune en opon. La inversa manipulo ankaŭ eblas, ekz:

>>> a, b, c = t
>>> b
54321

Pitono nomas ĉi tiun ‘sekvenca malpakado’. Sekvenca malpakado postulas, ke la listo de variabloj ĉe la maldekstro havu la saman kvanton da eroj kiel la eroj en la opo. Rimarku ke mult-samtempaj valorizoj estas nur kombino de opa pakado kaj sekvenca malpakado!

6.6. Vortaroj

Alia utila primitiva tipo en Pitono estas la vortaro. Pripensu vortaron kiel neordigitan aron de paroj, nome ŝlosilvorto:valoro, kaj la ŝlosilvorto estas unika en ĉiu vortaro. Malsama ol sekvencoj, kiun oni indicas per numeroj, vortaroj estas indicataj per ŝlosilvortoj, kiuj povas esti iu ajn neŝanĝeblaj tipoj; ĉenoj kaj numeroj povas esti ŝlosilvortoj. Opoj povas esti ŝlosilvorto se ili enhavas nur ĉenojn, numerojn aŭ opoj. Oni ne povas uzi listojn kiel ŝlosilvorto.

Paro de kurbaj krampoj kreas malplenan vortaron: {}.

Por krei vortaron, enmetu parojn (ŝlosilvorto:valoro) apartigitajn per komoj, en kurbajn krampojn:

>>> tel = {'jakobo': 4098, 'vilĉjo': 4139}

Pitono uzas ĉi tiun formaton por montri vortaron.

>>> tel
{'jakobo': 4098, 'vilĉjo': 4139}

La ĉefaj vortaraj manipuloj estas stapli valoron kun ŝlosilvorto, kaj ekstrakti valoron per uzo de ŝlosilvorto. Se oni staplas valoron kun ŝlosilvorto jam uzita, la malnova valoro estas forgesita. Se oni provas ekstrakti per nekonata ŝlosilvorto, eraro okazos.

La metodo keys() de vortara objekto resendas liston de ĉiu ŝlosilvorto en la vortaro, neordigitaj. (uzu metodon sort() por ordigi liston). Por kontroli se individua ŝlosilvorto estas en la vortaro, uzu la metodon in de la vortaro.

Ŝanĝo de la originala instruilo

Ĉar has_key() estas forigita de Pitono 3.x, uzu in por kontroli ĉu la ŝlosilvorto estas en la vortaro (vidu PEP 361):

>>> 'jakobo' in tel
True

Jen malgranda ekzemplo de vortara uzado:

>>> tel = {'jakobo': 4098, 'vilĉjo': 4139}
>>> tel['guido'] = 4127 #aldonu paron
>>> tel
{'vilĉjo': 4139, 'guido': 4127, 'jakobo': 4098}
>>> tel['jakobo']
4098
>>> tel['vilĉjo'] = 4127 #ŝanĝu valoron
>>> tel
{'vilcjo': 4127, 'jakobo': 4098, 'guido': 4127}
>>> tel.keys()
['vilcjo', 'jakobo', 'guido']
>>> 'guido' in tel
True

La konstruilo dict() konstruas vortarojn rekte el listoj de opoj (ŝlosilvorto, valoro).

>>> dict([('vilĉjo', 4139), ('guido', 4127), ('jakobo', 4098)])
{'vilĉjo': 4139, 'jakobo': 4098, 'guido': 4127}

6.7. La instrukcio del

La instrukcio del estas ilo por forigi eron de listo. Oni povas uzi ĉi tiun metodon por forigi erojn uzante la sekcan signaron, ekz.:

>>> a = [-1, 1, 66.6, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.6, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.6, 1234.5]

Plue, oni povas forigi paron en vortaro jene:

>>> tel
{'vilĉjo': 4139, 'guido': 4127, 'jakobo': 4098}
>>> del tel['vilĉjo']
>>> tel
{'guido': 4127, 'jakobo': 4098}

Oni povas uzi la instrukcion del por forigi tutajn variablojn:

>>> del a

Aludo al la variablo post forigo igas eraron (ĝis oni revalorizis ĝin).

>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined