Python 2/Wikishakkisivu

Tälle sivulle kerätään wikishakkisivujen muokkaukseen liittyviä harjoitustehtäviä ja niiden ratkaisuja. Vastaavia sivuja voidaan perustaa myös muille aihepiireilla. Tämän harjoitustehtävien organisointi teemoittain, helpottaa aiempien tehtävien uudelleenkäyttöä ja edelleenkehittelyä tehtävien vaikeutuessa.

Tätä sivua kehitellään opintopiirin osallistujien yhteistyönä iteroiden. Aluksi tälle susivulle tuotetut ideointivaiheen luonnokset hävitetään ja/tai siirretään tilapäisesti keskustelusivun puolelle muistiin ja tälle sivulle muokataan kullekin harjoitustehtävälle mahdollisimman selväpiirteinen ja hyvin kommentoitu ratkaisu.

Testisivu

Seuraavasta linkistä avautuva testisivu sisältää vain tyhjän shakkilautamallineen (Python 2/Testilauta).

Shakkisiirto.py

Tehtävän määrittely

Shakkilaudan ruutujen nimeäminen

Suunnittele ohjelma seuraava_asema.py, joka saa parametreinä shakkilautamallineen sisältävän syote- ja tulostiedoston lyhyellä algebrallisella notaatiolla annetun shakkisiirron ja tulostiedoston nimen. Ohjelma lukee shakkilautamallineen siistii siitä standardimuotoisen mallineen, jossa ei ole kommenttitekstejä, säilyttää mahdolliset ylä- ja alaotsikkotekstit sellaisenaan, suorittaa laudan asemaan annettua siirtoa vastaavat muutokset ja tallettaa lopputuloksen tulostiedostoon.

Ohjelman alkuun ja loppuun lisätään vielä testilohkot, jotka lukevat ja tulostavat syote ja tilostiedostot. Mitään virhetarkistuksia ja virhetilanteista toipumisia ei tässä tehtävässä tarvitse ohjelmoida. Ellei oppikirjasta löydy kaikkia tarvitsemiasi tietoja, niin etsi ne muista lähteistä ja täydennä myös oppikirjaa puuttuvilla tiedoilla.

Shakkilaudan ruutujen nimeäminen: Shakkilaudan ruudut nimetään oheisen kuvan mukaisesti sarakekirjain (a...h) ja rivinumero (1...8) pareilla.

Nappuloiden nimeäminen

K Kuningas (K king)
D Kuningatar (Q queen)
T Torni (R rook)
L Lähetti (B bishop)
R Ratsu (N knight)
Sotilas (pawn). Nappulatunuksen poisjättö siirtomerkinnästä tarkoittaa sotilasta.

Siirtojen merkitseminen

Lyhyessä algebrallisessa notaatiossa siirrot merkitään kirjoittamalla nappulatunnuskirjain ja kohderuudun positiotunnus peräkkäin. Esimerkiksi merkintä Le5 tarkoittaa lähetin siirtoa ruutuun e5, merkintä Rf3 tarkoittaa ratsun siirtoa ruutuun f3 ja merkintä e5 tarkoittaa sotilaan siirtoa ruutuun e5 (nappulatunnuksen puuttuminen merkitsee sotilasta).

Lyönnin merkitseminen

Lyönti osoitetaan lisäämällä x nappulatunnuksen ja kohderuutumerkinnän väliin (sotilassiirrossa kohderuutumerkinnän eteen). Esimerkiksi merkintä Lxe5 tarkoittaa, että lähetti lyö ruudussa e5 olevan nappulan. Sotilaan lyönnissä lyöntimerkinnän eteen merkitään lyövän sotilaan lähtösarakekirjain. Esimerkiksi merkintä exd5 tarkoittaa, että e-sarakkeen sotilas lyö nappulan ruududta d5 (toisinaan ellei sekaannuksia aiheudu merkintää voidaan edelleen lyhentää jättämällä pois joko rivi numeron, lyöntimerkin tai molemmat; exd, ed5 or ed). Toisinaan käytetään kaksoispistettä (:) lyöntimerkin (x) asemasta joko samassa paikassa (L:e5) tai siirtomerkinnän lopussa (Be5:). Ohestalyönti (w:en:En passant) merkitään merkitsemällä lyöntimerkin jälkeen (ei lyötävän vaan) lyövän nappulan kohderuutu ja sen perään mahdollisesti täydennysmerkintänä o.l. tai e.p.. Täydennysmerkintä ei kuitenkaan ole pakollinen. Ns. Standardissa algebrallisessa notaatiossa lyöntimerkki merkitään aina näkyviin ja täydennysmerkintä jätetään aina pois. Jotkin tekstit, kuten w:en:Encyclopedia of Chess Openings ei pane lyöntimerkkiä näkyviin.

Siirtomerkintöjen moniselitteisyyden eliminointi

Jos kaksi tai useampi identtistä nappulaa voi siirtyä samaan ruutuun, pannaan siirtomerkinnän alkuun lähtöruudun ilmaukseksi seuraavassa luetellussa järjestyksessä joko sarake kirjain tai rivinumero tai molemmat(viimeksi mainittu tilanne on mahdollinen sotilaiden korottumisen jälkeen, kun kolme tai useampi identtinen nappula voi siirtyä samaan ruutuun). Esimerkiksi, jos kaksi ratsua ovat ruuduissa g1 ja d2, voivat ne molemmat siirtyä ruutuun f3. Tarkoitettu siirto on silloin tarkennettava seuraavasti Rgf3 tai Rdf3. Tilanteessa, jossa kaksi ratsua ovat ruuduissa g5ja g1, suoritettava siirto on tarkennettava joko muotoon R5f3 tai R1f3. Kuten aiemminkin lyöntimerkki voidaan haluttaessa lisätä täydennykseksi ennen positiomerkintää (R5xf3).

Sotilaan korottuminen

Sotilaan korottuminen siirtomerkintään osoitetaan lisäämällä positiomerkinnän perään se nappulatunnus, joksi korottuminen tapahtuu (e1D, b8L, ...). Toisinaan käytetään myös seuraavia epästandardeja merkintöjä: f8(D), f8=D ja f8/D.

Linnoitus

FIDE Handbook määrittelee kuningaspuolisen eli lyhyen linnoituksen merkinnäksi 0-0 ja kuningatarpuolisen eli pitkän linnoituksen merkinnäksi 0-0-0 (näissä merkinnöissä käytetään nollia), mutta PGN käyttää näiden asemasta merkintöjä O-O ja O-O-O(näissä merkinnöissä käytetään isoja O-kirjaimia). Vaihtoehtoisesti nämä siirrot voidaan merkitä pelkillä kuningassiirroilla Kg1 ja Kc1.

Shakki ja matti

Shakki ilmaistaan tavallisesti lisäämällä siirtomerkinnän perään + (The Encyclopedia of Chess Openings teoksessa ei ilmaista eksplisiittisesti shakkia). Toisinaan shakki ilmaistaan merkinnöillä † ja ch sekä kaksoisshakki merkinnällä ++. Matti osoitetaan merkinnällä # (myös seuraavia merkintöjä käytetään ++, ‡ ja matti).

Lopputulos

Valkean voitto 1-0
Mustan voitto 0-1
Tasapeli

½-½

Esimerkkejä

Siirrot merkitään valkean ja musta siirtopareina joiden eteen lisätään siirtonumero ja piste. Siirtosekvenssit voidaan esittää kahdella vaihtoehtoisella tavalla.

(1) Sarakemuodossa:

1. e4 e5

2. Rf3 Rc6

3. Lb5 a6

(2) Rivimuodossa: 1. e4 e5 2. Rf3 Rc6 3. Lb5 a6.

Valkean puuttuva siirto voidaan esittää kolmella pisteellä (...). Esimerkiksi seuraavasti:

1. e4 e5

2. Rf3

Black now defends his pawn

2. ... Rc6

3. Lb5 a6

Nappuloiden nimet eri kielillä

http://web.archive.org/20011026093336/www.geocities.com/TimesSquare/Metro/9154/nap-pieces.htm

PGN-notaatio

Perustana on lyhyt algebrallinen notaatio. Esitystapaa on täydenety muilla standardeilla esitystavoilla esitetyillä peliin liittyvillä tiedoilla
w:en:Portable Game Notation
http://www.saremba.de/chessgml/standards/pgn/pgn-complete.htm

Pitkä algebrallinen notaatio

Pitkässä algebrallisessa notaatiossa esitetään eksplisiittisesti sekä lähtö että kohde ruudut joiden väliin tulee tavuviiva, joka korvataan lyönneissä lyöntimerkillä x (esimerkkejä "e2-e4", "Rb1-c3", "Td3xd7"). FIDE ei ole enää vuoden 1981 jälkeen suositellut tämän esitystavan käyttöä.

Numeerinen notaatio

Kansainvälisessä kirjeshakissa käytetään lähtö ja kohde ruudut sperifioivaa numeerista notaatiota.

Kuvallinen algebrallinen notaatio

Kansalliset nappuloisen tunnuskirjaimet on korvattu Unicode-kuvasymboleilla.

Yleisesti käytetyt kommentointi lyhenteet

! hyvä siirto
!! erinomainen siirto
? heikko siirto
?? virhe (munaus)
!? kiinnostava (ei välttämättä paras) siirto
?! arveluttava siirto
□ ainoa mahdollinen siirto

Tyhjä shakkilautamalline ilman kommenttitekstejä

Yläotsikkoteksti

Alaotsikkoteksti

Seuraava malline tuottaa oheisen kuvan mukaisen tyhjän laudan.

 
{{Šakkilauta|=
|tright
|Yläotsikkoteksti
|=
|  |  |  |  |  |  |  |  |=
|  |  |  |  |  |  |  |  |=
|  |  |  |  |  |  |  |  |=
|  |  |  |  |  |  |  |  |=
|  |  |  |  |  |  |  |  |=
|  |  |  |  |  |  |  |  |=
|  |  |  |  |  |  |  |  |=
|  |  |  |  |  |  |  |  |=
|Alaotsikkoteksti
}}

Alkuasemassa oleva shakkilauta rivi ja sarakekommenttiteksteillä

Seuraavassa mallineessa on nappulat alkuasemassa ja siihen on lisätty myös rivi ja sarakekommenttitekstit.

 
 {{Šakkilauta|=
 |tright
 |
 |= 
  8 |rd|nd|bd|qd|kd|bd|nd|rd|=
  7 |pd|pd|pd|pd|pd|pd|pd|pd|=
  6 |  |  |  |  |  |  |  |  |=
  5 |  |  |  |  |  |  |  |  |=
  4 |  |  |  |  |  |  |  |  |=
  3 |  |  |  |  |  |  |  |  |=
  2 |pl|pl|pl|pl|pl|pl|pl|pl|=
  1 |rl|nl|bl|ql|kl|bl|nl|rl|=
     a  b  c  d  e  f  g  h  
 |
 }}

Nämä kommenttitekstit voidaan poistaa siirron toteutuksen yksinkertaistamiseksi, koska ne eivät vaikuta laudan ulkoasuun mitenkään.

Mallineen alku voidaan tunnistaa rivistä {{Šakkilauta|= . Sitä seuraa vaihtelevan pituinen parametri ja otsikkotietoa sisältävä kaksirivinen merkkijono, joka päättyy |= merkkipariin. Tämän jälkeen seuraa shakkilaudan sisältötietorivit 8...1. Kunkin sisältörivin alussa voi olla kommenttitekstiä ja | merkin jälkeen ruutujen kaksimerkkiset sisältötiedot sisältötiedot | merkeillä erotettuna. Kukin rivi päätetään |= merkkipariin. Tämän jälkeen voi olla kommenttitekstirivi. Mallineen päättää | merkeillä alkava rivi (minkä sisältönä voi olla alaotsikkotekstiä) ja sittä seuraavalla rivillä oleva }} merkkipari.

Tehtävän ratkaisu

Luetaan tiedosto riveittäin ja toteutetaan seuraavat operaatiot:

Talletetaan ohjelman parametrit lukutiedoston nimi, tulostiedoston nimi ja suoritettava siirto ohjelman muuttujiin.
Avataan lukutiedosto lukemista varten.
Avataan tulostiedosto kirjoittamista varten
Luetaan lukutiedostosta rivi
Toistetaan edellinen kohta ellei se ollut alkurivi. (Jos tiedosto loppuu ennen alkuriviä, annetaan virheilmoitus, tuhotaan tulostiedosto ja lopetetaan ohjelman suoritus.)
Kopioidaan alkurivi tulostiedostoon
Luetaan rivi ja hukataan sen alusta merkit | merkkiin saakka ja talletaan tämä merkki sekä loppurivi tulostiedostoon edellisen sisällön jatkoksi. (Jos tiedosto loppuu ennen | merkkiin, annetaan virheilmoitus, tuhotaan tulostiedosto ja lopetetaan ohjelman suoritus.)
Luetaan rivi ja hukataan sen alusta merkit | merkkiin saakka ja talletaan tämä merkki sekä loppurivi tulostiedostoon. (Jos tiedosto loppuu ennen | merkkiä, annetaan virheilmoitus, tuhotaan tulostiedosto ja lopetetaan ohjelman suoritus.)
Asetetaan rivi-indeksi i=8
Luetaan rivi ja hukataan sen alusta merkit ensimmäiseen | merkkiin saakka ja talletaan sitä seuraava sisältörivi välitallennuspaikkaan i. (Jos tiedosto loppuu ennen | merkkiä, annetaan virheilmoitus, tuhotaan tulostiedosto ja lopetetaan ohjelman suoritus.)
Dekrementoidaan indeksiä i=i-1 ja toistetaan edellinen kohta, jos > 0.
Suoritetaan sisältöriveihin annettua siirtoparametriä vastaava modifiointi. (Luetaan siirtomerkintää vastaavan lähtöruurun sisältö, merkitään se tyhjäksi ruuduksi ja talletetaan sen edellinen sisältö kohderuudun sisällöksi.)
Talletetaan kaikki sisältörivit niiden lukemisjärjestyksessä tulostiedostoon edellisten rivien jatkoksi.
Luetaan rivi ja hukataan sen alusta merkit | merkkiin tai rivin loppuun saakka.
Toistetaan edellinen kohta, ellei riviltä löytynyt | merkkiä.
Talletetaan | merkki ja sitä seuraavat merkit mallineen loppua ilmaiseva }} merkkipari mukaan luettuna sellaisenaan tulostiedostoon.
Jos lukutiedosto loppuu ennen mallineen loppumerkin löytymisä, annetaan virheilmoitus, deletoidaan tulostiedosto ja lopetetaan ohjelman suoritus.
Suljetaan tulostiedosto.
Suljetaan lukutiedosto

Ratkaisu voidaan toteuttaa kahdessa vaiheessa

Toteutetaan tiedoston tiedoston luku sen muokkaaminen "standardimuotoon" ja talletus tulostiedostoon ilman siirtoparametrin määräämää peliaseman modifiointia.
Lisätäät toimintaan peliaseman modifiointi, jonka toteutuksessa voidaan käyttää seuraavia ideoita:
1. Ennen laudan sisältörivejä voi olla vaihteleva määrä merkkejä, mutta laudan vasemmalle ylänurkalle a8 voidaan laskea indeksi etsimällä mallineesta toista |= merkkiparia. Tästä merkkiparista eteenpäin "siistityn laudan jokainen sisältöruutu on vakiopaikoissa.
2. Riviindeksit voidaan tallettaa muuttujiin ri: r8, r7,... ,r1
3. Rivien alkuun suhteelliset sarakeindeksit voidaan tallettaa muuttujiin si: a, b,... ,h
4. Ruutuindeksi saadaan kaavalla ruutu = ri + si
5. Selvitetään siirtomerkinnästä lähtö ja kohderuudut
6. Kopioidaan tulostiedoston lähtöruudun sisältömerkintä kohderuudun sisällöksi ja tyhjätään lähtöruutu

Ensimmäisen vaiheen ratkaisu

Toinen karvalakkiversio

Seuraava ohjelma lukee kommentteja sisältävän shakkilautamallineen parametrinä annetusta syötetiedostosta asema0, siistii sen "standardimuotoiseksi" ja tallettaa sen parametrinä annettuun tulostiedostoon asema1. Parametrinä annetulla siirtotekstillä ei tehdä muuta kuin tulostetaan se sellaisenaan näkyviin. Allaesitetty koodi on nyt tehty funktioksi ja se on talletettu moduuliin shakkibotti.py

Toteutus poikkeaa hiukan edellä kuvatusta sanallisesta ideointivaiheen kuvauksesta.

Koodi

 
# -*- coding: cp1252 -*-
def shakkisiirto (asema0, asema1, siirto='ei siirtoa'):

    # -*- coding: cp1252 -*-

    # Avataan tiedosto asema0.txt lukemista varten
    f_syote = open(asema0, 'r')
    # Luetaan koko tiedosto merkkijonoksi s_peliasema
    syote = f_syote.read()
    # Suljetaan tiedosto f_peliaema - tiedosto voidaan sulkea heti kun se on luettu
    f_syote.close()
    # Tulostetaan merkkijono s_peliasema
    print " \n ==== Syotetiedosto ==== \n"
    print(syote)

    #--------------------------------------------------------
    
    print(' ==== Siirto ====  \n')
    print(siirto)

    #--------------------------------------------------------

    f_tulos = open(asema1, 'w')  # Tyhjennetaan
    f_tulos.close()                    # tulostiedosto.
    f_tulos = open(asema1, 'a')  # Avataan kirjoitusta varten.
    f_rivi = open(asema0, 'r')   # Avataan lukemista varten.

    rivi = f_rivi.readline()           # Luetaan ja tulostetaan
    f_tulos.write(rivi)                # ensimmainen otsikkorivi.

    for j in range(0,3):               # Siistitaan muut otsikkorivit.
        rivi = f_rivi.readline()
        for i in range(len(rivi)):
            if rivi[i]=='|':
                rivi=rivi[i:]
                break
        f_tulos.write(rivi)
        
    lauta = '87654321'                  # Siistitaan laudan rivit.
    for j in range(len(lauta)):
        rivi = f_rivi.readline()
        for i in range(len(rivi)):
            if rivi[i]=='|':
                rivi=rivi[i:]
                break
        f_tulos.write(rivi)
        
    rivi = f_rivi.readline()            # poistetaan sarakekommentit
    rivi = f_rivi.readline()            # siistitaan alaotsikkorivi
    for i in range(len(rivi)):
        if rivi[i]=='|':
            rivi=rivi[i:]
            break
    f_tulos.write(rivi)
    rivi = f_rivi.readline()            # siistitaan loppurivi
    for i in range(len(rivi)):
        if rivi[i]=='}':
            rivi=rivi[i:]
            break
    f_tulos.write(rivi)

    f_rivi.close()                      # suljetaan tiedosto 
    f_tulos.close()                     # suljetaan tiedosto

    #-----------------------------------------------------------

    # Avataan tiedosto asema1.txt lukemista varten
    f_tulos = open(asema1, 'r')
    # Luetaan koko tiedosto merkkijonoksi s_peliasema
    tulos = f_tulos.read()
    # Suljetaan tiedosto f_peliaema - tiedosto voidaan sulkea heti kun se on luettu
    f_tulos.close()
    print " \n ==== Tulostiedosto ==== \n"
    print(tulos)

Testikutsu

Esimerkiksi seuraavalla testikutsulla

 
# -*- coding: cp1252 -*-
from shakkibotti import shakkisiirto
shakkisiirto('asema0.txt', 'asema1.txt', '1.e2-e4')

saadaan seuraava testituloste

Testitulosteet

 
>>> 
 
 ==== Syotetiedosto ==== 

{{Šakkilauta|=
 |
 |
 |= 
  8 |rd|nd|bd|qd|kd|bd|nd|rd|=
  7 |pd|pd|pd|pd|pd|pd|pd|pd|=
  6 |  |  |  |  |  |  |  |  |=
  5 |  |  |  |  |  |  |  |  |=
  4 |  |  |  |  |  |  |  |  |=
  3 |  |  |  |  |  |  |  |  |=
  2 |pl|pl|pl|pl|pl|pl|pl|pl|=
  1 |rl|nl|bl|ql|kl|bl|nl|rl|=
     a  b  c  d  e  f  g  h  
 |
 }}

 ==== Siirto ====  

1.e2-e4
 
 ==== Tulostiedosto ==== 

{{Šakkilauta|=
|
|
|= 
|rd|nd|bd|qd|kd|bd|nd|rd|=
|pd|pd|pd|pd|pd|pd|pd|pd|=
|  |  |  |  |  |  |  |  |=
|  |  |  |  |  |  |  |  |=
|  |  |  |  |  |  |  |  |=
|  |  |  |  |  |  |  |  |=
|pl|pl|pl|pl|pl|pl|pl|pl|=
|rl|nl|bl|ql|kl|bl|nl|rl|=
|
}}

>>>

Kolmas karvalakkiversio

Seuraava ohjelma lukee kommentteja sisältävän shakkilautamallineen parametrinä annetusta syötetiedostosta asema0, tallettaa yläotsikkorivit sellaisenaan tulostiedosyoon, talletaa sisältörivit matriisiin, suorittaa siirron matriisissa (vasta testioperaation), tallettaa muokatun matriisin tulostiedostoon ja tallettaa alaotsikkorivit sellaisenaan tulostiedostoon.

Koodi

 
# -*- coding: cp1252 -*-

import numpy as N
def shakkisiirto (asema0, asema1, siirto='ei siirtoa'):


    #------------------------------------------------------------------  
    # Syotetiedoston testiluku ja tulostus 
    #------------------------------------------------------------------  
    f_syote = open(asema0, 'r') # Avataan lukemista varten
    syote = f_syote.read()      # Luetaan tiedosto merkkijonoksi
    f_syote.close()             # Suljetaan tiedosto
    print " \n ==== Syotetiedosto ==== \n"
    print(syote)                # Tulostetaan merkkijono
 
    #---------------------------------------------------------------------------------------
    # Matriisin sl eli shakkilauta alustus ruutujen posititiotunuksilla, seka sisaltorivien
    # alku- ja loppuosen tilavarauksilla. Matriisin sisalto ylikirjoitetaan myohemmin alkuaseman
    # mukaisella sisaltodatalla.
    #------------------------------------------------------------------------------------------
 
    sl = N.array((['    ', 'a8', 'b8', 'c8', 'd8', 'e8', 'f8', 'g8', 'h8', '  '],
                  ['    ', 'a7', 'b7', 'c7', 'd7', 'e7', 'f7', 'g7', 'h7', '  '],
                  ['    ', 'a6', 'b6', 'c6', 'd6', 'e6', 'f6', 'g6', 'h6', '  '],
                  ['    ', 'a5', 'b5', 'c5', 'd5', 'e5', 'f5', 'g5', 'h5', '  '],
                  ['    ', 'a4', 'b4', 'c4', 'd4', 'e4', 'f4', 'g4', 'h4', '  '],
                  ['    ', 'a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3', 'h3', '  '],
                  ['    ', 'a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2', 'h2', '  '],
                  ['    ', 'a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1', 'h1', '  ']))
 
    #-------------------------------------------------------------------------------------------
    # Matriisin solujen indeksit
    #--------------------------------------------------------------------------------------------
 
    #    alkuosa         a         b         c         d      e            f         g         h   loppuosa
    # 8  sl[0][0]  sl[0][1]  sl[0][2]  sl[0][3]  sl[0][4]  sl[0][5]  sl[0][6]  sl[0][7]  sl[0][8]  sl[0][9]
    # 7  sl[1][0]  sl[1][1]  sl[1][2]  sl[1][3]  sl[1][4]  sl[1][5]  sl[1][6]  sl[1][7]  sl[1][8]  sl[1][9] 
    # 6  sl[2][0]  sl[2][1]  sl[2][2]  sl[2][3]  sl[2][4]  sl[2][5]  sl[2][6]  sl[2][7]  sl[2][8]  sl[2][9] 
    # 5  sl[3][0]  sl[3][1]  sl[3][2]  sl[3][3]  sl[3][4]  sl[3][5]  sl[3][6]  sl[3][7]  sl[3][8]  sl[3][9] 
    # 4  sl[4][0]  sl[4][1]  sl[4][2]  sl[4][3]  sl[4][4]  sl[4][5]  sl[4][6]  sl[4][7]  sl[4][8]  sl[4][9] 
    # 3  sl[5][0]  sl[5][1]  sl[5][2]  sl[5][3]  sl[5][4]  sl[5][5]  sl[5][6]  sl[5][7]  sl[5][8]  sl[5][9] 
    # 2  sl[6][0]  sl[6][1]  sl[6][2]  sl[6][3]  sl[6][4]  sl[6][5]  sl[6][6]  sl[6][7]  sl[6][8]  sl[6][9] 
    # 1  sl[7][0]  sl[7][1]  sl[7][2]  sl[7][3]  sl[7][4]  sl[7][5]  sl[7][6]  sl[7][7]  sl[7][8]  sl[7][9] 
 
    #-------------------------------------------------------------------------------------------
    # Matriisin testitulostus
    #--------------------------------------------------------------------------------------------
 
    # print " \n ==== Alustetun matriisin testitulostus ==== \n"
    # print sl[0][0], sl[0][1], sl[0][2], sl[0][3], sl[0][4], sl[0][5], sl[0][6], sl[0][7], sl[0][8], sl[0][9]
    # print sl[0][0], sl[1][1], sl[1][2], sl[1][3], sl[1][4], sl[1][5], sl[1][6], sl[1][7], sl[1][8], sl[1][9]
    # print sl[0][0], sl[2][1], sl[2][2], sl[2][3], sl[2][4], sl[2][5], sl[2][6], sl[2][7], sl[2][8], sl[2][9]
    # print sl[0][0], sl[3][1], sl[3][2], sl[3][3], sl[3][4], sl[3][5], sl[3][6], sl[3][7], sl[3][8], sl[3][9]
    # print sl[0][0], sl[4][1], sl[4][2], sl[4][3], sl[4][4], sl[4][5], sl[4][6], sl[4][7], sl[4][8], sl[4][9]
    # print sl[0][0], sl[5][1], sl[5][2], sl[5][3], sl[5][4], sl[5][5], sl[5][6], sl[5][7], sl[5][8], sl[5][9]
    # print sl[0][0], sl[6][1], sl[6][2], sl[6][3], sl[6][4], sl[6][5], sl[6][6], sl[6][7], sl[6][8], sl[6][9]
    # print sl[0][0], sl[7][1], sl[7][2], sl[7][3], sl[7][4], sl[7][5], sl[7][6], sl[7][7], sl[7][8], sl[7][9]
 
    #----------------------------------------------------------
    # Talletetaan syötetiedoston sisaltorivit matriisiin
    #----------------------------------------------------------
    f_tulos = open(asema1, 'w')  # Tyhjennetaan tulostiedosto.
    f_tulos.close()              
    f_tulos = open(asema1, 'a')  # Avataan lisayskirjoitusta varten.
    f_rivi = open(asema0, 'r')   # Avataan lukemista varten.
 
    for j in range(0,4):         # Luetaan ja talletaan otsikkorivit tulostiedostoon.
        rivi = f_rivi.readline()
        f_tulos.write(rivi)
 
    for j in range(0,8):         # Luetaan ja talletaan sisaltorivit matriisiin
        rivi = f_rivi.readline()
        r = rivi.split('|')
        sl[j] = r 
 
    #----------------------------------------------------------
    # Mariisin sisalto ennen siirtoa
    #----------------------------------------------------------
    print '  \n ====sisaltomatriisi ennen sirtoa====  \n'
    print sl 
 
    #--------------------------------------------------------
    # Suoritetaan siirto 
    #--------------------------------------------------------
 
    # Parametrina annetun siirtomerkinnan tulostus
    print('  \n ==== Siirto ====  \n')
    print(siirto)
 
    # ==== Tama on vasta testisiirto!!!!!!!=====
    # Seuraavat rivit pitaa korvata yleisella logiikalla.
    sl[4][5] = sl[6][5] # e4 <- e2
    sl[6][5] = '  '     # tyhjataan e2
 
    #----------------------------------------------------------
    # Mariisin sisallon testitulostus siirron jalkeen
    #----------------------------------------------------------
    print '  \n ====sisaltomatriisi siirron jalkeen====  \n'
    print sl
 
    #----------------------------------------------------------
    # Talletaan muokattu matriisi tulostiedostoon
    #----------------------------------------------------------
    for j in range(0,8):
        for i in range(0,10):
            # print sl[j][i],
            if i==0:
                jono = sl[j][i]
            else:
                jono = '|' + sl[j][i]
            f_tulos.write(jono)
            
    #------------------------------------------------------------------  
    # Talletaan alaotsikkorivit (3 kpl) tulostiedostoon
    #------------------------------------------------------------------  
    for j in range(0,3):
        rivi = f_rivi.readline()
        f_tulos.write(rivi)
    f_rivi.close()               # suljetaan tiedosto 
    f_tulos.close()              # suljetaan tiedosto
 
    #------------------------------------------------------------------  
    # Tulostiedoston testiluku ja tulostus 
    #------------------------------------------------------------------  
    # Avataan tiedosto asema1.txt lukemista varten
    f_tulos = open(asema1, 'r')
    # Luetaan koko tiedosto merkkijonoksi s_peliasema
    tulos = f_tulos.read()
    # Suljetaan tiedosto f_peliaema - tiedosto voidaan sulkea heti kun se on luettu
    f_tulos.close()
    print " \n ==== Tulostiedosto ==== \n"
    print(tulos)

Testitulostus

 
>>> 
 
 ==== Syotetiedosto ==== 

{{Šakkilauta|=
 |
 |
 |= 
  8 |rd|nd|bd|qd|kd|bd|nd|rd|=
  7 |pd|pd|pd|pd|pd|pd|pd|pd|=
  6 |  |  |  |  |  |  |  |  |=
  5 |  |  |  |  |  |  |  |  |=
  4 |  |  |  |  |  |  |  |  |=
  3 |  |  |  |  |  |  |  |  |=
  2 |pl|pl|pl|pl|pl|pl|pl|pl|=
  1 |rl|nl|bl|ql|kl|bl|nl|rl|=
     a  b  c  d  e  f  g  h  
 |
 }}

  
 ====sisaltomatriisi ennen sirtoa====  

[['  8 ' 'rd' 'nd' 'bd' 'qd' 'kd' 'bd' 'nd' 'rd' '=\n']
 ['  7 ' 'pd' 'pd' 'pd' 'pd' 'pd' 'pd' 'pd' 'pd' '=\n']
 ['  6 ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '=\n']
 ['  5 ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '=\n']
 ['  4 ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '=\n']
 ['  3 ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '=\n']
 ['  2 ' 'pl' 'pl' 'pl' 'pl' 'pl' 'pl' 'pl' 'pl' '=\n']
 ['  1 ' 'rl' 'nl' 'bl' 'ql' 'kl' 'bl' 'nl' 'rl' '=\n']]
  
 ==== Siirto ====  

1.e2-e4
  
 ====sisaltomatriisi siirron jalkeen====  

[['  8 ' 'rd' 'nd' 'bd' 'qd' 'kd' 'bd' 'nd' 'rd' '=\n']
 ['  7 ' 'pd' 'pd' 'pd' 'pd' 'pd' 'pd' 'pd' 'pd' '=\n']
 ['  6 ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '=\n']
 ['  5 ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '=\n']
 ['  4 ' '  ' '  ' '  ' '  ' 'pl' '  ' '  ' '  ' '=\n']
 ['  3 ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '=\n']
 ['  2 ' 'pl' 'pl' 'pl' 'pl' '  ' 'pl' 'pl' 'pl' '=\n']
 ['  1 ' 'rl' 'nl' 'bl' 'ql' 'kl' 'bl' 'nl' 'rl' '=\n']]
 
 ==== Tulostiedosto ==== 

{{Šakkilauta|=
 |
 |
 |= 
  8 |rd|nd|bd|qd|kd|bd|nd|rd|=
  7 |pd|pd|pd|pd|pd|pd|pd|pd|=
  6 |  |  |  |  |  |  |  |  |=
  5 |  |  |  |  |  |  |  |  |=
  4 |  |  |  |  |pl|  |  |  |=
  3 |  |  |  |  |  |  |  |  |=
  2 |pl|pl|pl|pl|  |pl|pl|pl|=
  1 |rl|nl|bl|ql|kl|bl|nl|rl|=
     a  b  c  d  e  f  g  h  
 |
 }}

>>>

Toisen vaiheen ratkaisu

Ratkaisu on työnalla. Nyt ohjelmaan lisätään parametrointi ja parametrinä annetun siirron toteutus. Siirron toteutus voidaan ohjelmoida kolmessa vaiheessa

Parametri annetaan pitkällä algebrallisella notaatiolla, jolloin siitä saadaan sekä lähtö että kohderuutu.

Neljas karvalakkiversio

Seuraava ohjelma lukee kommentteja sisältävän shakkilautamallineen parametrinä annetusta syötetiedostosta asema0, tallettaa yläotsikkorivit sellaisenaan tulostiedosyoon, talletaa sisältörivit matriisiin, suorittaa pitkalla algebrallisella notaatiolla annetun siirron matriisissa, tallettaa muokatun matriisin tulostiedostoon ja tallettaa alaotsikkorivit sellaisenaan tulostiedostoon.

Koodi

 
# -*- coding: cp1252 -*-

import numpy as N
def shakkisiirto (asema0, asema1, siirto='ei siirtoa'):

    #------------------------------------------------------------------  
    # Syotetiedoston testiluku ja tulostus 
    #------------------------------------------------------------------  
    f_syote = open(asema0, 'r') # Avataan lukemista varten
    syote = f_syote.read()      # Luetaan tiedosto merkkijonoksi
    f_syote.close()             # Suljetaan tiedosto
    print " \n ==== Syotetiedosto ==== \n"
    print(syote)                # Tulostetaan merkkijono
 
    #---------------------------------------------------------------------------------------
    # Matriisin sl eli shakkilauta alustus ruutujen posititiotunuksilla, seka sisaltorivien
    # alku- ja loppuosen tilavarauksilla. Matriisin sisalto ylikirjoitetaan myohemmin alkuaseman
    # mukaisella sisaltodatalla.
    #------------------------------------------------------------------------------------------
 
    sl = N.array((['    ', 'a8', 'b8', 'c8', 'd8', 'e8', 'f8', 'g8', 'h8', '  '],
                  ['    ', 'a7', 'b7', 'c7', 'd7', 'e7', 'f7', 'g7', 'h7', '  '],
                  ['    ', 'a6', 'b6', 'c6', 'd6', 'e6', 'f6', 'g6', 'h6', '  '],
                  ['    ', 'a5', 'b5', 'c5', 'd5', 'e5', 'f5', 'g5', 'h5', '  '],
                  ['    ', 'a4', 'b4', 'c4', 'd4', 'e4', 'f4', 'g4', 'h4', '  '],
                  ['    ', 'a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3', 'h3', '  '],
                  ['    ', 'a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2', 'h2', '  '],
                  ['    ', 'a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1', 'h1', '  ']))
 
    #-------------------------------------------------------------------------------------------
    # Matriisin solujen indeksit
    #--------------------------------------------------------------------------------------------
 
    #    alkuosa         a         b         c         d      e            f         g         h   loppuosa
    # 8  sl[0][0]  sl[0][1]  sl[0][2]  sl[0][3]  sl[0][4]  sl[0][5]  sl[0][6]  sl[0][7]  sl[0][8]  sl[0][9]
    # 7  sl[1][0]  sl[1][1]  sl[1][2]  sl[1][3]  sl[1][4]  sl[1][5]  sl[1][6]  sl[1][7]  sl[1][8]  sl[1][9] 
    # 6  sl[2][0]  sl[2][1]  sl[2][2]  sl[2][3]  sl[2][4]  sl[2][5]  sl[2][6]  sl[2][7]  sl[2][8]  sl[2][9] 
    # 5  sl[3][0]  sl[3][1]  sl[3][2]  sl[3][3]  sl[3][4]  sl[3][5]  sl[3][6]  sl[3][7]  sl[3][8]  sl[3][9] 
    # 4  sl[4][0]  sl[4][1]  sl[4][2]  sl[4][3]  sl[4][4]  sl[4][5]  sl[4][6]  sl[4][7]  sl[4][8]  sl[4][9] 
    # 3  sl[5][0]  sl[5][1]  sl[5][2]  sl[5][3]  sl[5][4]  sl[5][5]  sl[5][6]  sl[5][7]  sl[5][8]  sl[5][9] 
    # 2  sl[6][0]  sl[6][1]  sl[6][2]  sl[6][3]  sl[6][4]  sl[6][5]  sl[6][6]  sl[6][7]  sl[6][8]  sl[6][9] 
    # 1  sl[7][0]  sl[7][1]  sl[7][2]  sl[7][3]  sl[7][4]  sl[7][5]  sl[7][6]  sl[7][7]  sl[7][8]  sl[7][9] 
 
    #----------------------------------------------------------
    # Talletetaan syötetiedoston sisaltorivit matriisiin
    #----------------------------------------------------------
    f_tulos = open(asema1, 'w')  # Tyhjennetaan tulostiedosto.
    f_tulos.close()              
    f_tulos = open(asema1, 'a')  # Avataan lisayskirjoitusta varten.
    f_rivi = open(asema0, 'r')   # Avataan lukemista varten.
 
    for j in range(0,4):         # Luetaan ja talletaan otsikkorivit tulostiedostoon.
        rivi = f_rivi.readline()
        f_tulos.write(rivi)
 
    for j in range(0,8):         # Luetaan ja talletaan sisaltorivit matriisiin
        rivi = f_rivi.readline()
        r = rivi.split('|')
        sl[j] = r 
 
    #----------------------------------------------------------
    # Mariisin sisalto ennen siirtoa
    #----------------------------------------------------------
    print '  \n ====sisaltomatriisi ennen sirtoa====  \n'
    print sl 
 
    #----------------------------------------------------------------
    # Suoritetaan pitkalla algebrallisella notaatiolla annetu siirto
    #----------------------------------------------------------------
 
    # Parametrina annetun siirtomerkinnan tulostus
    print('  \n ==== Siirto ====  \n')
    print(siirto)
 
    # Siirron toteutus
    # poimitaan siirtonotaatiosta lahto- ja kohderuutujen indeksimerkinnat
    for i in range(0, len(siirto)):
        if siirto[i] in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']:
            # print siirto[i], siirto[i+1], siirto[i+3], siirto[i+4]
            lr = siirto[i+1]; # print 'lr: ',lr
            ls = siirto[i];   # print 'ls: ',ls
            kr = siirto[i+4]; # print 'kr: ',kr
            ks = siirto[i+3]; # print 'ks: ',ks
            break
    
    # Muunnetaan indeksimerkinnat matriisin lahtoruudun indekseiksi
    lri = 0
    lsi = 1
    for si in ['a','b','c','d','e','f','g','h']:
        if si == ls:
            break
        lsi =lsi+1
    for ri in ['8','7','6','5','4','3','2','1']:
        if ri == lr:
            break
        lri =lri+1
    # Muunnetaan indeksimerkinnat matriisin kohderuudun indekseiksi
    kri = 0
    ksi = 1
    for si in ['a','b','c','d','e','f','g','h']:
        if si == ks:
            break
        ksi =ksi+1
    for ri in ['8','7','6','5','4','3','2','1']:
        if ri == kr:
            break
        kri =kri+1
    
    # Toteutetaan siirto
    sl[kri][ksi] = sl[lri][lsi] # lahtoruudun sisalto kohderuutuun
    sl[lri][lsi] = '  '         # tyhjataan lahtoruutu

    #----------------------------------------------------------
    # Mariisin sisallon testitulostus siirron jalkeen
    #----------------------------------------------------------
    print '  \n ====sisaltomatriisi siirron jalkeen====  \n'
    print sl
 
    #----------------------------------------------------------
    # Talletaan muokattu matriisi tulostiedostoon
    #----------------------------------------------------------
    for j in range(0,8):
        for i in range(0,10):
            # print sl[j][i],
            if i==0:
                jono = sl[j][i]
            else:
                jono = '|' + sl[j][i]
            f_tulos.write(jono)
            
    #------------------------------------------------------------------  
    # Talletaan alaotsikkorivit (3 kpl) tulostiedostoon
    #------------------------------------------------------------------  
    for j in range(0,3):
        rivi = f_rivi.readline()
        f_tulos.write(rivi)
    f_rivi.close()               # suljetaan tiedosto 
    f_tulos.close()              # suljetaan tiedosto
 
    #------------------------------------------------------------------  
    # Tulostiedoston testiluku ja tulostus 
    #------------------------------------------------------------------  
    # Avataan tiedosto asema1.txt lukemista varten
    f_tulos = open(asema1, 'r')
    # Luetaan koko tiedosto merkkijonoksi s_peliasema
    tulos = f_tulos.read()
    # Suljetaan tiedosto f_peliaema - tiedosto voidaan sulkea heti kun se on luettu
    f_tulos.close()
    print " \n ==== Tulostiedosto ==== \n"
    print(tulos)

Testitulostus: siirrolle 1. Rg1-h3

 
>>> 
 
 ==== Syotetiedosto ==== 

{{Šakkilauta|=
 |
 |
 |= 
  8 |rd|nd|bd|qd|kd|bd|nd|rd|=
  7 |pd|pd|pd|pd|pd|pd|pd|pd|=
  6 |  |  |  |  |  |  |  |  |=
  5 |  |  |  |  |  |  |  |  |=
  4 |  |  |  |  |  |  |  |  |=
  3 |  |  |  |  |  |  |  |  |=
  2 |pl|pl|pl|pl|pl|pl|pl|pl|=
  1 |rl|nl|bl|ql|kl|bl|nl|rl|=
     a  b  c  d  e  f  g  h  
 |
 }}

  
 ====sisaltomatriisi ennen sirtoa====  

[['  8 ' 'rd' 'nd' 'bd' 'qd' 'kd' 'bd' 'nd' 'rd' '=\n']
 ['  7 ' 'pd' 'pd' 'pd' 'pd' 'pd' 'pd' 'pd' 'pd' '=\n']
 ['  6 ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '=\n']
 ['  5 ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '=\n']
 ['  4 ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '=\n']
 ['  3 ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '=\n']
 ['  2 ' 'pl' 'pl' 'pl' 'pl' 'pl' 'pl' 'pl' 'pl' '=\n']
 ['  1 ' 'rl' 'nl' 'bl' 'ql' 'kl' 'bl' 'nl' 'rl' '=\n']]
  
 ==== Siirto ====  

1. Rg1-h3
  
 ====sisaltomatriisi siirron jalkeen====  

[['  8 ' 'rd' 'nd' 'bd' 'qd' 'kd' 'bd' 'nd' 'rd' '=\n']
 ['  7 ' 'pd' 'pd' 'pd' 'pd' 'pd' 'pd' 'pd' 'pd' '=\n']
 ['  6 ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '=\n']
 ['  5 ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '=\n']
 ['  4 ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' '=\n']
 ['  3 ' '  ' '  ' '  ' '  ' '  ' '  ' '  ' 'nl' '=\n']
 ['  2 ' 'pl' 'pl' 'pl' 'pl' 'pl' 'pl' 'pl' 'pl' '=\n']
 ['  1 ' 'rl' 'nl' 'bl' 'ql' 'kl' 'bl' '  ' 'rl' '=\n']]
 
 ==== Tulostiedosto ==== 

{{Šakkilauta|=
 |
 |
 |= 
  8 |rd|nd|bd|qd|kd|bd|nd|rd|=
  7 |pd|pd|pd|pd|pd|pd|pd|pd|=
  6 |  |  |  |  |  |  |  |  |=
  5 |  |  |  |  |  |  |  |  |=
  4 |  |  |  |  |  |  |  |  |=
  3 |  |  |  |  |  |  |  |nl|=
  2 |pl|pl|pl|pl|pl|pl|pl|pl|=
  1 |rl|nl|bl|ql|kl|bl|  |rl|=
     a  b  c  d  e  f  g  h  
 |
 }}

>>>

Parametri annetaan lyhyellä algebrallisella notaatiolla, jolloin lähtöruutu pitää päätellä nappulakirjaimen ja kohderuudun sekä mahdollisen lisävihjeen perusteella. Sotilaiden etenemissuunnan selvittämiseksi tarvitaan myös siirtovuorotieto, jota saadaan siirtonotaatioss olevien pisteiden määrästä. Valkoisen siirrossa on vain yksipiste (.) siirtonumeron perässä ja mustan sirrossa on kolme pistettä (...)

Viides karvalakkiversio

Seuraava ohjelma lukee kommentteja sisältävän shakkilautamallineen parametrinä annetusta syötetiedostosta asema0, tallettaa yläotsikkorivit sellaisenaan tyotiedostoon temp, talletaa sisältörivit matriisiin, suorittaa lyhyella algebrallisella notaatiolla annetun siirron matriisissa, tallettaa muokatun matriisin ja alaotsikkorivit sellaisenaan työtiedostoon sekä kopioi lopuksi tyotiedoston takaisin syötetiedostoon.

Ohjelman rakenetta on selkeytetty kayttamalla aiempaa enemman aliohjelmia. Ohjelmasta puuttuu vielä moniselitteisten siirtojen tarkennusmerkintojen kasittely, linnoittautuminen ja valinnainen korottuminen (siina on toteutettu talla hetkella automaattinen korottuminen kuningattareksi).

Koodi

 
# -*- coding: cp1252 -*-
import numpy as N

#------------------------------------------------------------------------
# Positiomerkinnasta sl-matriisin indekseiksi
#------------------------------------------------------------------------
def s2x(sarake):
    si = 1
    for s_i in ['a','b','c','d','e','f','g','h']:
        if s_i == sarake:
            break
        si = si+1 # tuntematon palauttaa 9
    return si

def r2y(rivi):
    ri=0
    for r_i in ['8','7','6','5','4','3','2','1']:
        if r_i == rivi:
            break
        ri =ri+1  # tuntematon palauttaa 8
    return ri

def pos2ind(sarake, rivi):
    si = s2x(sarake)
    ri = r2y(rivi)
    return [ri, si]

#------------------------------------------------------------------------
# Nappuloiden (T, L, D ja K) lahderuutujen hakufunktiot
#------------------------------------------------------------------------
# Seuraavat funktiot palauttavat ensimmaisen ei tyhjan ruudun sisalon ja indeksit
# tai tyhjan sisallon ja laitaruudun indeksin ellei nappulaa loydy.

# haetaan ensimmainen nappula kohteesta sarakesuuntaan ylos
def sy_haku(ks, kr, matriisi):
    (y, x) = pos2ind(ks, kr)
    if y > 0:
        y = y-1
    while  matriisi[y][x] == '  ':
        if y==0:
            break
        y = y-1
    return [matriisi[y][x], y, x]
    
# haetaan ensimmainen nappula kohteesta sarakesuuntaan alas    
def sa_haku(ks, kr, matriisi):
    (y, x) = pos2ind(ks, kr)
    if y < 7:
        y = y+1
    while  matriisi[y][x] == '  ':
        if y==7:
            break
        y = y+1
    return [matriisi[y][x], y, x]
    
# haetaan ensimmainen nappula kohteesta rivin uuntaan vasemmalle    
def rv_haku(ks, kr, matriisi):
    (y, x) = pos2ind(ks, kr)
    if x > 1:
        x = x-1
    while  matriisi[y][x] == '  ':
        if x==1:
            break
        x = x-1
    return [matriisi[y][x], y, x]
    
# haetaan ensimmainen nappula kohteesta rivin suuntaan oikealle    
def ro_haku(ks, kr, matriisi):
    (y, x) = pos2ind(ks, kr)
    if x < 8:
        x = x+1
    while  matriisi[y][x] == '  ':
        if x==8:
            break
        x = x+1
    return [matriisi[y][x], y, x]
    
# haetaan ensimmainen nappula kohteesta diagonaalin suuntaan oikealle ylos    
def oy_haku(ks, kr, matriisi):
    (y, x) = pos2ind(ks, kr)
    if (y > 0) and (x < 8):
        y = y-1
        x = x+1
    while  matriisi[y][x] == '  ':
        if (x==8) or (y==0):
            break
        y = y-1
        x = x+1
    return [matriisi[y][x], y, x]
    
# haetaan ensimmainen nappula kohteesta diagonaalin suuntaan oikealle alas    
def oa_haku(ks, kr, matriisi):
    (y, x) = pos2ind(ks, kr)
    if (y < 7) and (x < 8):
        y = y+1
        x = x+1
    while  matriisi[y][x] == '  ':
        if (x==8) or y==7:
            break
        y = y+1
        x = x+1
    return [matriisi[y][x], y, x]
    
# haetaan ensimmainen nappula kohteesta diagonaalin suuntaan vasemmalle ylos    
def vy_haku(ks, kr, matriisi):
    (y, x) = pos2ind(ks, kr)
    if (y > 0) and (x > 1):
        y = y-1
        x = x-1
    while  matriisi[y][x] == '  ':
        if (x==1) or (y==0):
            break
        y = y-1
        x = x-1
    return [matriisi[y][x], y, x]
    
# haetaan ensimmainen nappula kohteesta diagonaalin suuntaan vasemmalle alas    
def va_haku(ks, kr, matriisi):
    (y, x) = pos2ind(ks, kr)
    if (y < 7) and (x > 1):
        y = y+1
        x = x-1
    while  matriisi[y][x] == '  ':
        if (x==1) or (y==7):
            break
        y = y+1
        x = x-1
    return [matriisi[y][x], y, x]

#-----------------------------------------------------------------------
# LTDK-haku
#----------------------------------------------------------------------

# Lahettihaku n = 1...4
# Tornihaku n = 5...8
# Kuningatar- ja kuningashaku n = 1...8

# TAHAN LISATAAN VIELA TARKENNUSTEN TESTAUS (Jos tarkennusmerkkeja ei ole suoritetaan
# yksi haku. Jos on yksi tarkennus, toistetaan hakua niin kauan, etta myos se tasmaa.
# Jos on kaksi tarkennusta, ei suoritetaan haun asemasta vain koordinaattimuunnos.)
# JA LINNOITUSTESTAUS (Jos kuningas siirtyy kaksi ruutua, niin myos tornia siirretaan.)

def LTDK_haku(ks, kr, sl, n): # n on jarjestys indeksi
    if n==1:
        (nappula, ly, lx)=oy_haku(ks, kr, sl)
    elif n==2:
        (nappula, ly, lx)=oa_haku(ks, kr, sl)
    elif n==3:
        (nappula, ly, lx)=vy_haku(ks, kr, sl)
    elif n==4:
        (nappula, ly, lx)=va_haku(ks, kr, sl)
    elif n==5:
        (nappula, ly, lx)=sy_haku(ks, kr, sl)
    elif n==6:
        (nappula, ly, lx)=sa_haku(ks, kr, sl)
    elif n==7:
        (nappula, ly, lx)=ro_haku(ks, kr, sl)
    elif n==8:
        (nappula, ly, lx)=rv_haku(ks, kr, sl)
    return [nappula, ly, lx]

#-------------------------------------------------------------------------
# Ratsu-haku
#-----------------------------------------------------------

# haetaan kohderuudun ymparistosta ensimmainen mahdollinen kohderuutuun siirtyva ratsu

def ratsu_haku(ks, kr, matriisi, n): # n on jarjestys indeksi
    (y, x) = pos2ind(ks, kr)
    if n==1:
        if (y-2 >= 0) and (x+1 <= 8):
            y = y-2
            x = x+1
            return [matriisi[y][x], y, x]
        else:
            return ['  ', y, x]
    elif n==2:
        if (y-1 >= 0) and (x+2 <= 8):
            y = y-1
            x = x+2
            return [matriisi[y][x], y, x]
        else:
            return ['  ', y, x]
    elif n==3:
        if (y+1 <= 7) and (x+2 <= 8):
            y = y+1
            x = x+2
            return [matriisi[y][x], y, x]
        else:
            return ['  ', y, x]
    elif n==4:
        if (y+2 <= 7) and (x+1 <= 8):
            y = y+2
            x = x+1
            return [matriisi[y][x], y, x]
        else:
            return ['  ', y, x]
    elif n==5:
        if (y+2 <= 7) and (x-1 >= 1):
            y = y+2
            x = x-1
            return [matriisi[y][x], y, x]
        else:
            return ['  ', y, x]
    elif n==6:
        if (y+1 > 0) and (x-2 >= 1):
            y = y+1
            x = x-2
            return [matriisi[y][x], y, x]
        else:
            return ['  ', y, x]
    elif n==7:
        if (y-2 >= 0) and (x-1 >= 1):
            y = y-2
            x = x-1
            return [matriisi[y][x], y, x]
        else:
            return ['  ', y, x]
    elif n==8:
        if (y-1 >= 0) and (x-2 >= 1):
            y = y-1
            x = x-2
            return [matriisi[y][x], y, x]
        else:
            return ['  ', y, x]

#-----------------------------------------------------------------------
# Sotilashaku (lahderuudun sisalto ja indeksit)
#----------------------------------------------------------------------
def sotilas_haku(ks, kr, sl, siirto):

    # Tahan pitaa lisata viela valinnainen korotus
    i=0
    while siirto[i]!='.':
        i=i+1
    if siirto[i+2] == '.':
        vuoro = 'musta'
        if kr=='1':
            nappulakoodi = 'qd' # automaattinen korotus kuningattareksi
        else:
            nappulakoodi = 'pd'
    else:
        vuoro = 'valkea'
        if kr=='8':
            nappulakoodi = 'ql' # automaattinen korotus kuningattareksi
        else:
            nappulakoodi = 'pl'

    for i in range(0, len(siirto)):
        if siirto[i] in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']:
            if siirto[i+1] =='x':
                lx = s2x(siirto[i])
                if (vuoro == 'musta'):
                    ly = r2y(kr) - 1
                else:
                    ly = r2y(kr) + 1
            else:
                # muu sotilassiirto
                lx = s2x(siirto[i])
                
                if (vuoro == 'musta'):
                    if kr == '5': # Kylla. Vuoro on mustalla.
                        (y,x)=pos2ind(ks, '6')
                        if sl[y][x]=='  ': #Kahden askeleen siirto?
                            ly = r2y('7') # Kylla
                        else: 
                            ly = r2y('6') # Ei
                    else:
                        ly = r2y(kr) - 1  # yhdenaskeleen siirto
                else: # vuoro == valkea
                    if kr == '4':
                        (y,x)=pos2ind(ks, '3')
                        if sl[y][x]=='  ': #Kahden askeleen siirto?
                            ly = r2y('2')  # Kylla
                        else: 
                            ly = r2y('3')# Ei
                    else:
                        ly = r2y(kr) + 1  # yhdenaskeleen siirto
            break
    
    # Ohestalyontitesti
    if sl[r2y(kr)][s2x(ks)] =='  ':  #Onko lyonnin kohderuutu tyhja?
        ol=1
    else:
        ol=0

    return [nappulakoodi, ly, lx, ol]

#------------------------------------------------------------------------
# Siirtyvan nappulan vari, nappulatunnus, sisaltokoodi,kohdetunnus ja kohdeindeksit
#------------------------------------------------------------------------
def siirtyva_nappula(siirto):
    # siirtonotaation analyysi. Sirtomerkinnassa voi olla seuraavia merkkeja:
    
    # a = sarakeaakkonen (a...h)
    # n = rivinumero (1...8)
    # x = lyontimerkki
    # U = upseeritunnus
    #   = valilyonti
    # . = sarakeaakkonen

    # Siirtonotaatiolla voi olla seuraavia muotoja:

    # n.Uan
    # n.aUan
    # n.nUan
    # n.anUan
    # n.Uxan
    # n.aUxan
    # n.nUxan
    # n.anUxan
    # n...Uan
    # n...aUan
    # n...nUan
    # n...anUan
    # n...Uxan
    # n...aUxan
    # n...nUxan
    # n...anUxan
    # n. ...Uan
    # n. ...aUan
    # n. ...nUan
    # n. ...anUan
    # n. ...Uxan
    # n. ...aUxan
    # n. ...nUxan
    # n. ...anUxan

    # Etsitaan U, jolloin seuraavat merkit tai mahdollista lyontimerkkia
    # seuraavat merkit antavat kohdeposition ja edelliset pienella testauksella 
    # mahdolliset tarkennukset. Seuraavassa on U:n suhteen mahdolliset tapaukset:
    
    # i-1 ei sarakekirjain eika rivinumero  ==>> haussa ensimmainen loytyva on lahderuutu
    # i-1 = sarakekirjain, i-2 ei rivinumero  ==>> jatkettava hakua ellei sarake tasmaa
    # i-1 = rivinumero, i-2 ei sarakekirjain  ==>> jatkettava hakua ellei rivi tasmaa
    # i-1 = rivinumero, i-2 = sarakekirjain  ==>> ei tarvita hakua (suora muunnos riittaa)
    
    # jos ennen U-tunnusta loytyy sarakekirjain, on kyseessa sotilas
    
    # n.an
    # n.axan
    # n. an
    # n. axan
    # n...an
    # n...axan
    # n. ...an
    # n. ...axan
    
    # selvitetaan pienella testauksella kohde ja mahdollinen tarkennus. Seuraavassa on
    # sarakekirjaimen suhteen mahdolliset tapaukset:
    
    # i+1 = kohteen rivinumero, i = kohteen sarakekirjain,  i = lahteen sarakekirjain
    # i+1 = x, i+2 = kohteen sarakekirjain i+3 = kohteen rivinumero, i = lahteen sarakekirjain

    # Lahteen rivi riippuu siirtovuorosta (se on yhta pienempi tai suurempi kohderivia,
    # paitsi mahdollisen kaksoisaskeleen tapauksessa) Tama selvitetaan sotilas_haku-funktiossa
    # Huom! Vuoro selviaa myös implisiittisesti tassa funktiossa lasketusta sisaltokoodista.


    # Siirtovuoron selvitys
    # mahdollisia siirto notaatioita mustan vuorolla
    # nn...
    # nn. ...
    # etsitään ensimmäisen pisteen indeksi i ja tarkistetaan
    # onko piste myös paikassa i+2, jos on vuoro on mustalla
    
    i=0
    nappulatunnus = '?' # merkitaan aluksi tuntemattomaksi
    while siirto[i]!='.':
        i=i+1
    if siirto[i+2] == '.':
        vuoro = 'musta'
    else:
        vuoro = 'valkea'
        
    for i in range(0, len(siirto)):
        if siirto[i] in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']:
            nappulatunnus= ' ' #sotilas'
            if siirto[i+1] == 'x': # lyontisiirto sisaltaa x-merkin
                ks = siirto[i+2]
                kr = siirto[i+3]
            else:
                ks = siirto[i]
                kr = siirto[i+1]
            break
        elif siirto[i] in ['D', 'K', 'L', 'R', 'T']:
            # nappula on  upseeri 
            nappulatunnus = siirto[i]
            # seuraava toimii vain yksiselitteisessa tapauksessa
            if siirto[i+1] == 'x': # lyontisiirto sisaltaa x-merkin
                ks = siirto[i+2]
                kr = siirto[i+3]
            else:
                ks = siirto[i+1]
                kr = siirto[i+2]
            break
    # siirtomerkinta oli virheellinen (nappulatunnus = '?')

    (ky,kx) = pos2ind(ks, kr)

    if vuoro == 'valkea':
        if nappulatunnus == ' ':
            sisaltokoodi = 'pl'
        elif nappulatunnus == 'D':
            sisaltokoodi = 'ql'
        elif nappulatunnus == 'K':
            sisaltokoodi = 'kl'
        elif nappulatunnus == 'L':
            sisaltokoodi = 'bl'
        elif nappulatunnus == 'R':
            sisaltokoodi = 'nl'
        elif nappulatunnus == 'T':
            sisaltokoodi = 'rl'
        else:
            sisaltokoodi = '?l'
    else: # vuoro == musta
        if nappulatunnus == ' ':
            sisaltokoodi = 'pd'
        elif nappulatunnus == 'D':
            sisaltokoodi = 'qd'
        elif nappulatunnus == 'K':
            sisaltokoodi = 'kd'
        elif nappulatunnus == 'L':
            sisaltokoodi = 'bd'
        elif nappulatunnus == 'R':
            sisaltokoodi = 'nd'
        elif nappulatunnus == 'T':
            sisaltokoodi = 'rd'
        else:
            sisaltokoodi = '?d'
            
    #print 'vuoro=', vuoro, 'nappula=', nappulatunnus, 'ks=', ks, 'kr=', kr
    #print 'sisalto=', sisaltokoodi, 'ky=', ky, 'kx=', kx

    return [vuoro, nappulatunnus, ks, kr, sisaltokoodi, ky, kx] # !!!!!!!!!!!!
    # HUOM! Vuorotieto ja nappulatunnus sisaltyy implisiitisesti sisaltokoodiin.
    # Samoin ks ja kr on redundanttista tietoa ky ja kx sisaltaa saman tiedon

#------------------------------------------------------------------------
# Tiedoston tulostus
#------------------------------------------------------------------------
def print_file(tiedosto):
    f_kahva = open(tiedosto, 'r') # Avataan lukemista varten
    data = f_kahva.read()         # Luetaan tiedosto merkkijonoksi
    f_kahva.close()               # Suljetaan tiedosto
    print(data)                   # Tulostetaan merkkijono

#------------------------------------------------------------------------
# Tiedoston kopiointi
#------------------------------------------------------------------------
def copy_file(mista, mihin):
    fr_kahva = open(mista, 'r') # Avataan lukemista varten
    fw_kahva = open(mihin, 'w') # Avataan lukemista varten
    data = fr_kahva.read()      # Luetaan tiedosto merkkijonoksi
    fw_kahva.write(data)        # Kirjoitetaan merkkijono tiedostoon
    fr_kahva.close()            # Suljetaan tiedosto
    fw_kahva.close()            # Suljetaan tiedosto

#---------------------------------------------------------
# Funktio suorittaa shakkisiirron
#---------------------------------------------------------
def shakkisiirto (siirto, asema='asema0.txt', temp='asema1.txt'):

    #------------------------------------------------------------------  
    # Syotetiedoston testiluku ja tulostus 
    #------------------------------------------------------------------  
    print " \n ==== Asema ennen siirtoa ==== \n"
    print_file(asema)
 
    #---------------------------------------------------------------------------------------
    # Matriisin sl eli shakkilauta alustus ruutujen posititiotunuksilla, seka sisaltorivien
    # alku- ja loppuosen tilavarauksilla. Matriisin sisalto ylikirjoitetaan myohemmin alkuaseman
    # mukaisella sisaltodatalla.
    #------------------------------------------------------------------------------------------
 
    sl = N.array((['    ', 'a8', 'b8', 'c8', 'd8', 'e8', 'f8', 'g8', 'h8', '  '],
                  ['    ', 'a7', 'b7', 'c7', 'd7', 'e7', 'f7', 'g7', 'h7', '  '],
                  ['    ', 'a6', 'b6', 'c6', 'd6', 'e6', 'f6', 'g6', 'h6', '  '],
                  ['    ', 'a5', 'b5', 'c5', 'd5', 'e5', 'f5', 'g5', 'h5', '  '],
                  ['    ', 'a4', 'b4', 'c4', 'd4', 'e4', 'f4', 'g4', 'h4', '  '],
                  ['    ', 'a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3', 'h3', '  '],
                  ['    ', 'a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2', 'h2', '  '],
                  ['    ', 'a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1', 'h1', '  ']))
 
    #-------------------------------------------------------------------------------------------
    # Matriisin solujen indeksit
    #--------------------------------------------------------------------------------------------
 
    #    alkuosa         a         b         c         d      e            f         g         h   loppuosa
    # 8  sl[0][0]  sl[0][1]  sl[0][2]  sl[0][3]  sl[0][4]  sl[0][5]  sl[0][6]  sl[0][7]  sl[0][8]  sl[0][9]
    # 7  sl[1][0]  sl[1][1]  sl[1][2]  sl[1][3]  sl[1][4]  sl[1][5]  sl[1][6]  sl[1][7]  sl[1][8]  sl[1][9] 
    # 6  sl[2][0]  sl[2][1]  sl[2][2]  sl[2][3]  sl[2][4]  sl[2][5]  sl[2][6]  sl[2][7]  sl[2][8]  sl[2][9] 
    # 5  sl[3][0]  sl[3][1]  sl[3][2]  sl[3][3]  sl[3][4]  sl[3][5]  sl[3][6]  sl[3][7]  sl[3][8]  sl[3][9] 
    # 4  sl[4][0]  sl[4][1]  sl[4][2]  sl[4][3]  sl[4][4]  sl[4][5]  sl[4][6]  sl[4][7]  sl[4][8]  sl[4][9] 
    # 3  sl[5][0]  sl[5][1]  sl[5][2]  sl[5][3]  sl[5][4]  sl[5][5]  sl[5][6]  sl[5][7]  sl[5][8]  sl[5][9] 
    # 2  sl[6][0]  sl[6][1]  sl[6][2]  sl[6][3]  sl[6][4]  sl[6][5]  sl[6][6]  sl[6][7]  sl[6][8]  sl[6][9] 
    # 1  sl[7][0]  sl[7][1]  sl[7][2]  sl[7][3]  sl[7][4]  sl[7][5]  sl[7][6]  sl[7][7]  sl[7][8]  sl[7][9] 
 
    #-------------------------------------------------------------------------------------
    # Syotetiedoston ylaotsikkorivit tulostiedostoon ja sisaltorivit matriisiin
    #-------------------------------------------------------------------------------------
    f_tulos = open(temp, 'w')  # Tyhjennetaan tulostiedosto.
    f_tulos.close()              
    f_tulos = open(temp, 'a')  # Avataan lisayskirjoitusta varten.
    f_rivi = open(asema, 'r')   # Avataan lukemista varten.
 
    for j in range(0,4):         # Luetaan ja talletaan otsikkorivit tulostiedostoon.
        rivi = f_rivi.readline()
        f_tulos.write(rivi)
 
    for j in range(0,8):         # Luetaan ja talletaan sisaltorivit matriisiin
        rivi = f_rivi.readline()
        r = rivi.split('|')
        sl[j] = r 
 
    #----------------------------------------------------------------
    # Parametrina annetun siirtomerkinnan testitulostus
    #----------------------------------------------------------------
    print('  \n ==== Siirto ====  \n')
    print(siirto)
 
    #----------------------------------------------------------------
    # Analysoidaan siirtonotaatio eli paatellaan
    # lahto- ja kohderuutujen positiomerkinnat
    #----------------------------------------------------------------
    
    # siirtovuoro, siirtyvan nappulan tunnus, kohdepositiotunnus ja sisaltokoodi
    (vuoro, nappula, ks, kr, sisaltokoodi, ky, kx) = siirtyva_nappula(siirto)
    # HUOM! Vuorotieto ja nappulatunnus sisaltyy implisiitisesti sisaltokoodiin.
    # Samoin ks ja kr on redundanttista tietoa ky ja kx sisaltaa saman tiedon
    # Seuraava koodilohko muokataan ensin niin että redundanttiset muuttujat
    # voidaan poistaa ja sen jälkeenedellä olevan funktion palautusarvoihin
    # lisataan tarkennusrivi- ja saraketiedot ja seuraavaa koodilohkoa taydennetaan
    # ne huomioon ottavaksi. Toteutuksen ideointia on funktion sisaisissa kommenteissa
    # Taman hetkisessa toteutuksessa sotilaslyonnin tarkennus oletetaan aina
    # merkittavaksi ja upseerisiirron tarkennusta ei viela ole toteutettu.

    #----------------------------------------------------------------
    # Lahderuutujen haku (ei huomioi viela siirron tarkennuksia...on tyonalla)
    #----------------------------------------------------------------
    ol=0
    if nappula == ' ': # siirtyva nappula onsotilas
        (nappulakoodi, ly, lx, ol) = sotilas_haku(ks, kr, sl, siirto)
    elif nappula == 'R':
        for n in range(1,9):
            (nappulakoodi, ly, lx) = ratsu_haku(ks, kr, sl, n)
            if nappulakoodi == sisaltokoodi:
                break
    elif nappula == 'L':
        for n in range(1,5):
            (nappulakoodi, ly, lx) = LTDK_haku(ks, kr, sl, n)
            if nappulakoodi == sisaltokoodi:
                break
    elif nappula == 'T':
        for n in range(5,9):
            (nappulakoodi, ly, lx) = LTDK_haku(ks, kr, sl, n)
            if nappulakoodi == sisaltokoodi:
                break
    elif (nappula == 'D'):
        for n in range(1,9):
            (nappulakoodi, ly, lx) = LTDK_haku(ks, kr, sl, n)
            if nappulakoodi == sisaltokoodi:
                break
    elif (nappula == 'K'):
        for n in range(1,9):
            (nappulakoodi, ly, lx) = LTDK_haku(ks, kr, sl, n)
            if nappulakoodi == sisaltokoodi:
                break
        # Jos kuningas siirtyy kaksi askelta asetetaan vastaava linnoituslippu 
        # pitka_valkea, lyhyt_valkea, pitka_musta, lyhyt_musta
        
    #----------------------------------------------------------------
    # Siirron toteutus (loppu osa yhteneva pitkan notaation kanssa)
    #----------------------------------------------------------------

    # Tasta puuttuu viela LINNOITUS ja KOROTTUMINEN
   
    # Toteutetaan siirto
    sl[ky][kx] =  nappulakoodi # sl[ly][lx] lahtoruudun sisalto kohderuutuun
    sl[ly][lx] = '  '         # tyhjataan lahtoruutu

    # Ohestalyonnin lisatoiminto
    if ol==1:
        if vuoro == 'musta':
            sl[ky-1][kx] = '  '         # poistetaan ohestalyotava musta sotilas
        else:
            sl[ky+1][kx] = '  '         # poistetaan ohestalyotava valkea sotilas

    # Tahan tulee linnoitustestin mukainen tornisiirron toteutus. Jos linnoituslippu 
    # pitka_valkea, lyhyt_valkea, pitka_musta tai lyhyt_musta
    # on asetettu, toteutetaan myos vastaava tornisiirto
 
    #----------------------------------------------------------
    # Talletaan muokattu matriisi tulostiedostoon
    #----------------------------------------------------------
    for j in range(0,8):
        for i in range(0,10):
            # print sl[j][i],
            if i==0:
                jono = sl[j][i]
            else:
                jono = '|' + sl[j][i]
            f_tulos.write(jono)
            
    #------------------------------------------------------------------  
    # Talletaan alaotsikkorivit (3 kpl) tulostiedostoon
    #------------------------------------------------------------------  
    for j in range(0,3):
        rivi = f_rivi.readline()
        f_tulos.write(rivi)
    f_rivi.close()               # suljetaan tiedosto 
    f_tulos.close()              # suljetaan tiedosto

    #------------------------------------------------------------------  
    # Kopioidaan tyotiedosto temp tiedostoon asema 
    #------------------------------------------------------------------  
    copy_file(temp, asema) # ----------
 
    #------------------------------------------------------------------  
    # Tiedosto asema siirron jalkeen 
    #------------------------------------------------------------------  
    print " \n ==== Asema siirton jalkeen ==== \n"
    #print_file(temp) # -----------
    print_file(asema)  #-------------

    #------------------------------------------------------------------  
    # Siirtokehoite 
    #------------------------------------------------------------------
    if vuoro=='valkea':
        print 'Anna mustan siirto!'
    else:
        print 'Anna valkean siirto!'

    return [ks, kr, sl, vuoro]

#------- testilohko ----------------------------------------------
shakkisiirto('1.Rf3')

Testaus

Ohjelmaa voidaan testata esim. kirjoittamalla ohjelman lopussa olevaan testikutsuun seuraavaksi suoritettava siirto. Siirto pitaa kirjoittaa lyhyen algebrallisen notaation mukaan oikeassa muodossa. Mitaan virhetarkistuksia ei ole viela toteutettu. Siirto toteutetaan tiedostossa asema0.txt olevalle laudalle ja uusi asema talletetaan takaisin samaan tiedostoon.

Seuraavaan versioon pitää taydentaa edellisessä versiossa vielä olevat toiminnalliset puutteet ja lisätä kaikkiin virheellisiin syötteisiin äänimerkki virheilmoitukseksi (mitään muutoksia tulostiedostoon ei virheellisillä syötteillä tehdä).

Aiheesta muualla

Python-kielisen_ohjelmoinnin_perusteet (Wikiopiston opintopiirin opiskeluohjeita)
FIFE (katso kohta E. Description of the Algebraic System)
Chess/Notation
w:en:Algebraic chess notation

Python 2

Johdanto:	Yleistä - Syntaksi - Operaattorit - Ohjelman luonti
Tietotyypit ja tietorakenteet:	Luvut - Merkkijonot - Lista - Monikko (tuple) - Sanakirja - Joukko (set)
Ohjausrakenteet	if-lause - while-silmukka - for-silmukka
Muut kielen rakenteet:	Moduuli - Luokka - Funktio - Virheidenhallinta - Tiedosto
Graafinen käyttöliittymä:	GUI
Harjoitustehtäviä:	Hello, world! - Wikishakkisivujen muokkaustehtäviä
Lisätiedot ja lähteet:	Aiheesta muualla