Instruilo por la programlingvo Pitono

Bonvolu sendi korektojn, proponojn, kaj sugestojn al vilcxjo ĉe esperanto-me.org

Enkonduko al la Pitona Lingvo

Komentoj

Numeroj

Ĉenoj

Listoj

Opoj kaj Sekvencoj

Vortaroj

La instrukcio del

En la sekvaj ekzemploj, vi 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 vi devas tajpi vakan linion; oni uzas tion por fini multilinian komandon.

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 blankspacon 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."

Numeroj

La interpretilo agas kiel simpla kalkulilo: Vi povas entajpi esprimon kaj la interpretilo skribos la valoron. La operatoroj "+", "-", "*", kaj "/" funkcias kiel tiuj en la plejparto de aliaj programlingvoj; vi 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 asigni valoron al variablo. La interpretilo ne skribas rezulton de asigno.

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

En Pitono, vi 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 `j' aŭ `J'. Kompleksaj numeroj kun ne-nula reela parto estas skribataj kiel '(reel+imagj)', aŭ vi 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 glitpunktajn 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 funkcion 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 (innermost last):
File "<stdin>", line 1, in ?
TypeError: can't convert complex to float; use e.g. abs(z)

>>> a.real
3.0
>>> a.imag
4.0
>>> abs(a)
  # sqrt(a.real**2 + a.imag**2)
5.0

En la interaga reĝimo, Pitono asignas la lastan videbligitan esprimon al la variablo _ (unu substreko). Rezulte, kiam vi 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 -- vi kreus sendependan lokan variablon kun la sama nomo, do kaŝus la primativan variablon.

 

Ĉenoj

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

 Vi 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

 Vi 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 enhavante\
...kelkajn liniojn"
>>>print ekzemplo
ĉi tiu estas iom longa ĉeno enhavante kelkajn liniojn

 '\n' indikas novlinian signon (fino de aktuala linio)

   >>>ekzemplo = "ĉi tiu estas iom longa ĉeno enhavante\n\
kelkajn liniojn de teksto kiel vi faros en C.\n\
    Rimarku ke blankspaco\
je linia komenco havas signifon.\n"
>>>print ekzemplo
ĉi tiu estas iom longa ĉeno enhavante
kelkajn liniojn de teksto kiel vi faros en C.
   Rimarku ke blankspaco je linia komenco havas signifon.

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

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

 Alternative, vi 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' # ne ambaŭ literaloj: + bezonita
'string'
>>> string.strip('str') 'ing' # nevalida: ne ambaŭ literaloj
  File "<stdin>", line 1, in ?
   string.strip('str') 'ing'
                         ^
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'

Vi 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 ?
TypeError: object doesn't support item assignment

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

   >>> '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'

 Trogranda 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:] #lastaj du
'pO'
>>> vorto[:-2] #ĉiuj krom la lastaj du
'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:]
'HelpO'
>>> vorto[-10] #eraro
Traceback (innermost last):
File "<stdin>", line 1
IndexError: string index out of range

 La plej bona metodo por kompreni kaj memori pri sekcoj estas, ke vi 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

Listoj

Pitono konas kelkajn nesimplajn tipojn de datumoj, kiu vi povas uzi por kungrupi aliajn bazajn tipojn. La plej diverse kapabla estas la listo, kiun vi povas skribi kiel liston de valoroj, apartigitaj per komoj, la tuto 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 vi 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!']

 Malsama al ĉenoj, kiu estas neŝanĝeblaj, vi ja povas ŝanĝi la individuajn erojn en listo:

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

 Vi 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

Vi povas krei listojn kiu enhavas aliajn listojn:

   >>> 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.

Vi povas malpaki liston en individuajn varioblojn . Vi 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

Opoj kaj sekvencoj

Estas alia norma datuma tipo, la opo.

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

Ekz.:

   >>> t = 12345, 54321, 'saluton!'
>>> t[0]
12345
>>> t
(12345, 54321, 'saluton!')
>>>#Vi 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 la enhavo estas taŭge komprenita.;vi rajtas entajpi ilin sen rondaj krampoj (se krampoj ne necesas por klarigi esprimon).

Opoj, kiel ĉenoj, estas neŝanĝeblaj; vi ne povas asigni valoron al individua ero de opo (aliaflanke, vi povas trafi la saman celon per tranĉado kaj kroĉado). Vi povas krei opojn, kiu enhavas ŝanĝeblajn objektojn, kiel listoj.

Opoj havas multajn uzojn, ekz., (x,y) koordinataj paroj,  k.t.p.

Speciala problemo estas la konstruado de opo kiu enhavas nul aŭ unu erojn: la sintakso havas strangaĵojn por akomodi tiujn. Vi konstruas malplenan opon per malplena paro de rondaj krampoj; vi 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 opo. La inversa manipulo ankaŭ eblas, ekz:

   >>> a, b, c = t 

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

Vortaroj

 Alia utila primativa tipo en Pitono estas la vortaro. V estas neordigita aro de paroj, nome ŝlosilvorto:valoro, kaj ĉiu ŝlosilvorto estas unika en ĉiu vortaro. Malsama ol sekvencoj, kiun vi indicas per numeroj, vortaroj estas indicitaj per ŝlosilvortoj, kiu povas esti iu ajn neŝanĝeblajn tipojn; ĉenoj kaj numeroj povas esti ŝlosilvortoj. Opoj povas esti ŝlosilvorto se ili enhavas nur ĉenojn, numerojn, aŭ opoj. Vi ne povas uzi listojn.

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 konservi valoron kun ŝlosilvorto, kaj ekstrakti valoron per uzo de ŝlosilvorto. Se vi konservas valoron kun ŝlosilvorto jam uzita, la malnova valoro estas perdita. Se vi 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). 

 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

{'vilĉjo': 4127, 'guido': 4127, 'jakobo': 4098}
>>> tel.keys()
{'guido', 'vilĉjo', 'jakobo'}

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}

La instrukcio del

 Estas ilo por forigi eron de listo: la instrukcio del. Vi povas uzi ĉi tiun metodon por forigi erojn uzante la sekcan signaron (ni faris tiun supre per asigno de malplena listo al la sekcaj eroj). 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, vi povas forigi paron en vortaro jene:

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

   {'guido': 4127, 'jakobo': 4098}

Vi povas uzi la instrukcion del por forigi tutajn variablojn:

>>> del a

Aludo al la variablo post forigo igas eraron (ĝis vi asignas al ĝi alian valoron).

Supren