Tekstitiedoston lukeminen rivi kerrallaan

Helpoin tapa tekstitiedoston lukemiseen lienee rivi kerrallaan. Yleinen muoto Pythonissa tälle on seuraava:

file = open(path)
for line in file:
    ... # Tehdään jotain linelle

Käsiteltävä tiedosto on siis ensin avattava Pythonin sisäänrakennetulla funktiolla open, minkä jälkeen voimme iteroida for-lauseella tiedoston rivien ylitse. Voisimme myös eksplisiittisesti lukea tiedostosta rivi kerrallaan seuraavasti:

file = open(path)
line = file.readline()
while line != '':
   ...
   line = file.readline()

Metodi file.readline() palauttaa tyhjän merkkijonon '' tiedoston päättyessä.

Jatkossa kuitenkin käytämme suoraviivaisempaa iterointia tiedon rivien ylitse.

Kokeillaan tehdä jotain tiedostolle bok.txt, jonka sisältö on seuraava:

"If you think education is expensive, try ignorance"

— Derek Bok, former President of Harvard University

Voisimme vaikkapa laskea rivien sekä merkkien määrän tiedostossa:

>>> path = 'bok.txt'
>>> file = open(path)
>>> lineCount = 0
>>> characterCount = 0
>>> for line in file:
...     lineCount += 1
...     characterCount += len(line)
...
>>> print("File {} has {} characters in {} lines".format(path, characterCount, lineCount))
File bok.txt has 109 characters in 3 lines

Hienoa!

Pari tärkeää asiaa on kuitenkin päässyt unohtumaan. Ensiksi, mitä tapahtuu, jos tiedostoa ei ole?

>>> path = 'otherfile.txt'
>>> file = open(path)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileNotFoundError: [Errno 2] No such file or directory: 'otherfile.txt'

Funktio open heittää siis poikkeuksen FileNotFoundError mikäli tiedostoa ei ole. The Python Standard Libraryn luvussa 2. Built-in Functions on kuvattu tarkemmin, mitä open tekee eri tilanteissa:

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
   Open file and return a corresponding file object. If the file cannot be opened, an OSError is raised.

Lienee siis syytä siepata luokan FileNotFoundError yläluokka OSError eikä pelkkää FileNotFoundErroria.

Muutetaan siis koodiamme niin, että mahdollinen OSError napataan:

path = 'bok.txt'
try:
    file = open(path)
except OSError:
    print("Could not open {}".format(path))
else:
    lineCount = 0
    characterCount = 0
    for line in file:
        lineCount += 1
        characterCount += len(line)
    print("File {} has {} characters in {} lines".format(path, characterCount, lineCount))

Tässä käytimme try-except-rakenteen else-osiota, joka siis suoritetaan vain jos try-osio ei heitä poikkeusta.

Yksi pieni tekninen ongelma koodissa vielä on. Kun open avaa tiedoston, varaa se sitä varten käyttöjärjestelmältä resurssin, niin sanotun tiedostokahvan (engl. file handle). Vaikka olemme lukeneet kaikki rivit tiedostosta, ei Python tiedä että emme enää tarvitse tiedostoa mihinkään eikä osaa vapauttaa tiedostokahvaa. Jos lukisimme monia tiedostoja näin, pitäisi Python turhaan varattuna tiedostokahvoja ja ne saattaisivat loppua jossain vaiheessa kesken.

On siis parasta vapauttaa kahva ja se tapahtuu metodille file.close(). Voisimme laittaa kutsun file.close() else-osion loppuun. Tässä esimerkissä tämä tuskin olisi vaarallista, mutta yleensä emme voi olla varmoja, että else-osion koodi ei heitä uusia poikkeuksia, joten on paras laittaa closen kutsu finally-osioon. Siellä tulee kuitenkin tarkistaa, että avaaminen on onnistunut. Tämä selviää tarkistamalla onko muuttuja file sidottu.

Kääräistään lopuksi koko koodi funktion sisälle.

import sys

def print_character_and_line_counts(path):
    input_file = None
    try:
        input_file = open(path)
    except OSError:
        print("Could not open {}".format(path), file=sys.stderr)
    else:
        lineCount = 0
        characterCount = 0
        for line in input_file:
            lineCount += 1
            characterCount += len(line)
        print("File {} has {} characters in {} lines".format(path, characterCount, lineCount))
    finally:
        if input_file:
            input_file.close()

Kokeillaan tätä tiedostoilla 'bok.txt' ja 'otherfile.txt':

>>> print_character_and_line_counts('bok.txt')
File bok.txt has 109 characters in 3 lines
>>> print_character_and_line_counts('otherfile.txt')
Could not open otherfile.txt

def print_character_and_line_counts(path):
    with open(path) as input_file:
        lineCount = 0
        characterCount = 0
        for line in input_file:
            lineCount += 1
            characterCount += len(line)
        print("File {} has {} characters in {} lines".format(path, characterCount, lineCount))

def print_character_and_line_counts3(path):
    try:
        with open(path) as input_file:
            lineCount = 0
            characterCount = 0
            for line in input_file:
                lineCount += 1
                characterCount += len(line)
            print("File {} has {} characters in {} lines".format(path, characterCount, lineCount))
    except OSError:
        print("Could not open {}".format(path), file=sys.stderr)

def print_sorted_file(path):
    try:
        with open(path) as input_file:
            lines = input_file.readlines()
            lines.sort()
            for line in lines:
                print(line.rstrip())
    except OSError:
        print("Could not open {}".format(path), file=sys.stderr)

Virta eli stream

Tähän asti olemme lukeneet tiedostoa käyttäen funktion open tuottamaa oliota miettimättä sen enempää, mikä kyseinen olio oikein on. Katsotaan, mitä Python toteaa oliosta:

>>> file=open('bok.txt')
>>> file
<_io.TextIOWrapper name='bok.txt' mode='r' encoding='UTF-8'>
>>> type(file)
<class '_io.TextIOWrapper'>

File on siis luokan io.TextIOWrapper ilmentymä. TextIOWrapper on tekstitiedostojen käsittelyyn tarkoitettu luokka ja sen dokumentaatio on the python standard libraryn luvussa 16.2. io — Core tools for working with streams, mistä löytyy tarkempi kuvaus tarjolla olevista luokista ja metodeista.

Tällaisia olioita kutsutaan tekstivirroiksi (engl. text stream). Tekstivirtaa voidaan ajatella peräkkäisenä jonona merkkejä c₀, c₁, ..., c_n-1 ja positiona i joka on välillä 0...n.

Positio i kertoo, mistä kohtaa seuraavaksi luetaan. Kun funktio open palauttaa avatun virran, on positio aluksi 0. Lukeminen siirtää positiota eteenpäin; esimerkiksi kun luemme tiedostosta 'bok.txt' ensimmäisen rivin, on positio 53, kun luemme toisen rivin 54 ja kolmannen rivin 109.

>>> file=open('bok.txt')
>>> file.tell()
0
>>> file.readline()
'"If you think education is expensive, try ignorance"\n'
>>> file.tell()
53
>>> file.readline()
'\n'
>>> file.tell()
54
>>> file.readline()
' --- Derek Bok, former President of Harvard University\n'
>>> file.tell()
109
>>> file.readline()
''
>>> file.tell()
109
>>> file.close()

Tämänhetkinen positio selviää metodilla file.tell(). Positiota voi myös siirtää metodilla file.seek().

>>> file=open('bok.txt')
>>> file.seek(10)
10
>>> file.readline()
'ink education is expensive, try ignorance"\n'
>>> file.close()

Tekstitiedoston lukeminen pienemmissä paloissa

Yllä luimme tekstivirtaa riveittäin tai kaikki rivit yhdellä kertaa. Toisinaan haluamme kuitenkin lukea tekstivirtaa pienemmissä paloissa, jopa vain yksi merkki kerrallaan. Tähän on tarjolla metodi file.read(). Metodille voidaan antaa parametrina lukumäärä, jonka verran merkkejä halutaan lukea kerrallaan. Lukeminen alkaa aina tekstivirran tämänhetkisestä positiosta. Jos merkkejä on jäljellä vähemmän kuin mitä pyysimme, saamme vain jäljellä olevat merkit.

>>> file=open('bok.txt')
>>> file
<_io.TextIOWrapper name='bok.txt' mode='r' encoding='UTF-8'>
>>> file.tell()
0
>>> x=file.read(13)
>>> x
'"If you think'
>>> len(x)
13
>>> file.tell()
13
>>> x=file.read(50)
>>> x
' education is expensive, try ignorance"\n\n --- Dere'
>>> len(x)
50
>>> file.tell()
63
>>> x=file.read(1000)
>>> x
'k Bok, former President of Harvard University\n'
>>> len(x)
46
>>> file.tell()
109
>>> file.close()

Samaten, jos emme anna lainkaan luettavien merkkien lukumäärää tai annamme arvon None tai -1, luetaan kaikki jäljellä olevat merkit.

>>> file=open('bok.txt')
>>> file.read()
'"If you think education is expensive, try ignorance"\n\n --- Derek Bok, former President of Harvard University\n'
>>> file.close()

Lukeminen merkkijonosta

Toisinaan haluamme käsitellä merkkijonoa ikään kuin se olisi tiedosto. Esimerkiksi syötettä lukevaa ohjelmaa testattaessa voi olla näppärää pitää syötteet merkkijonoissa tiedostojen sijaan.

Tätä varten on tarjolla valmis luokka StringIO, ja sitä käytetään seuraavasti:

>>> import io
>>>
>>> f = io.StringIO("""Mielivaltaista tekstiä
... joka voi jatkuva vaikka eri riveille""")
>>>
>>> f.readline()
'Mielivaltaista tekstiä\n'

Formatoitujen tiedostojen lukeminen

Yksi keskeinen ominaisuus lähes joka ohjelmassa on mahdollisuus tallentaa ohjelman toimintaan liittyvää tietoa tiedostoihin sekä ladata ohjelman käyttöön. Tallennettavalla tiedolla on lähes aina jokin selkeä rakenne. Tiedon esitystapaa tiedostoissa kutsutaan tiedostoformaatiksi.

Luvun 4.2 kotitehtävässä opettelemme lukemaan lohkopohjaista tiedostoformaattia. Tällaista käytetään usein esimerkiksi ääntä tai kuvaa käsittelevien ohjelmien syötteessä. Luvun 4.3 kotitehtävässä vastaavasti opimme lukemaan vapaamuotoisempaa tiedostoformaattia, jota ihmisen on helpompi lukea ja kirjoittaa, mutta jota konekin ymmärtää.

Lisämateriaalia: Monimutkaisempaa tekstisyötteen käsittelyä

Seuraavassa tarkastelemme muutamaa monimutkaisempaa tapaa käsitellä tekstisyötettä. Esitetyt tekniikat ovat jossain määrin monimutkaisempia kuin edellä esitetyt, eikä näitä tarvita esimerkiksi kotitehtävien tekemiseen. Nämä esitetään tässä lähinnä mielenkiinnon herättämiseksi ohjelmointi- ja muiden kielten koneelliseen käsittelyyn. Eli ei hätää, vaikka tämä vaikuttaisikin hämärältä.

f(x, g(y), 10)

Name(position=0, value=f)
Separator(position=1, value=()
Name(position=2, value=x)
Separator(position=3, value=,)
Name(position=5, value=g)
Separator(position=6, value=()
Name(position=7, value=y)
Separator(position=8, value=))
Separator(position=9, value=,)
Number(position=11, value=10)
Separator(position=13, value=))

class Token:
    def __init__(self, position, value):
        self.position = position
        self.value = value

    def __repr__(self):
        return "{}(position={}, value={})".format(type(self).__name__, self.position, self.value)

class Number(Token):
    pass

class Name(Token):
    pass

class Separator(Token):
    pass

class Tokenizer:
    def __init__(self, path):
        self.path = path
        self.file = open(path) # Jos tiedoston avaaminen ei onnistu, heittää OSErrorin
        self.buffer = []

    def close(self):
        self.file.close()

    def maybeReadCharToBuffer(self):
        """ Jos buffer on tyhjä, luetaan seuraava merkki filestä bufferiin """
        if self.buffer == []:
            nextChar = self.file.read(1)
            if nextChar == '':
                raise EOFError('End of file {}'.format(self.path))
            self.buffer.append(nextChar)

    def peekChar(self):
        """ Palautetaan seuraava merkki, mutta ei siirrytä eteenpäin syötteessä """
        self.maybeReadCharToBuffer()
        return self.buffer[0]

    def getChar(self):
        """ Palautetaan seuraava merkki, ja siirrytään eteenpäin syötteessä """
        self.maybeReadCharToBuffer()
        return self.buffer.pop()

    def unGetChar(self, char):
        """ Laittaa merkin takaisin bufferiin myöhempää lukemista varten """
        self.buffer.insert(0, char)

    def skipWhiteSpace(self):
        """ Ohitetaan välilyönnit ja muut tyhjät merkit """
        while self.peekChar().isspace():
            self.getChar()
        return self.peekChar()

    def getNextToken(self):
        """ Palautetaan seuraava token tai None jos syöte on loppu """
        try:
            nextChar = self.skipWhiteSpace()
            startPosition = self.file.tell()-1 # Tiedostopositio on yhden edellä
            if nextChar.isdigit():
                chars = [ self.getChar() ]
                while self.peekChar().isdigit():
                    chars.append(self.getChar())
                return Number(startPosition, int("".join(chars)))
            elif nextChar.isidentifier():
                chars = [ self.getChar() ]
                while self.peekChar().isidentifier():
                    chars.append(self.getChar())
                return Name(startPosition, "".join(chars))
            elif nextChar in ['(', ')', ',']:
                return Separator(startPosition, self.getChar())
            else:
                raise SyntaxError('{}:{}: Unexpected character {}'
                                  .format(self.path, startPosition, nextChar))
        except EOFError:
            return None

    def getTokens(self):
        """ Luetaan file ja muunnetaan se listaksi tokeneita """
        tokens = []
        nextToken = self.getNextToken()
        while nextToken:
            tokens.append(nextToken)
            nextToken = self.getNextToken()
        self.close()
        return tokens

>>> from tokenizer import Tokenizer
>>> for token in Tokenizer('call').getTokens():
...   print(token)
...
Name(position=0, value=f)
Separator(position=1, value=()
Name(position=2, value=x)
Separator(position=3, value=,)
Name(position=5, value=g)
Separator(position=6, value=()
Name(position=7, value=y)
Separator(position=8, value=))
Separator(position=9, value=,)
Number(position=11, value=10)
Separator(position=13, value=))

expr       ::= Number | call
call       ::= Name [ '(' [ exprList ] ')' ]
exprList   ::= expr ( ',' expr )*

def parseExpr(self):
    pass

def parseCall(self):
    pass

def parseExprList(self):
    pass

def parseExpr(self):
     if isinstance(self.peekToken(), Number):
         return self.getToken().value
     elif isinstance(self.peekToken(), Name):
         return self.parseCall()
     else:
         # Virhe

 def parseCall(self):
     name = self.getToken().value # Nimi talteen
     # Jos edessä on '(' kyseessä on oikea funktiokutsu
     if isinstance(self.peekToken(), Separator) and self.peekToken().value == '(':
         # Ohitetaan '('
         self.getToken()
         # Jos edessä on ')', on parametrilista tyhjä
         if isinstance(self.peekToken(), Separator) and self.peekToken().value == ')':
             parameters = list()
         else: # Muuten jäsennetään parametrit
             parameters = self.parseExprList()
             # Nyt pitäisi edessä olla ')'
             if isinstance(self.peekToken(), Separator) and self.peekToken().value == ')':
                 self.getToken()
             else:
                 # Virhe
         return ... # Palautetaan olio, joka kuvaa funktiokutsua
     else:
         return name # Palautetaan name, tämä ei ollutkaan varsinainen kutsu vaan muuttujan nimi

 def parseExprList(self):
     exprList = [ self.parseExpr() ] # Luetaan ensimmäinen expr
     # Niin kauan kun edessä on ',', luetaan seuraava expr
     while isinstance(self.peekToken(), Separator) and self.peekToken().value == ',':
         self.getToken()
         exprList.append(self.parseExpr())
     return exprList

Merkkijonojen muotoilu tulostusta varten

Tulostuksen yhteydessä tarvitaan usein muotoiltuja merkkijonoja ja Python tarjoaa useita tapoja niiden tekemiseen.

Suoraviivaisin tapa on liimailla haluttu lopputulos palasista käyttäen + -operaattoria. Jos käytetään muita kuin merkkijonoja, pitää ne konvertoida esim. str -funktiolla merkkijonoiksi. Esimerkiksi näin:

>>> nimi = "Maija Metso"
>>> ika = 37
>>> asema = "Johtaja"
>>>
>>> print(nimi + " " + str(ika) + ", " + asema)
Maija Metso 37, Johtaja

Tämä on toki täysin kelvollinen tapa muotoilla merkkijonoja, mutta +-merkkejä ja str -kutsuja tulee helposti runsaasti. Muotoilulausekkeista on tällöin vaikea ilman ohjelman suorittamista nähdä, millaisia merkkijonoja ollaan tekemässä.

Parempi on kuitenkin käyttää valmista metodia str.format, jolla saa hienostuneita ulkoasuja pienellä vaivalla. Käsittelemme sitä tarkemmin luvussa Merkkijonojen muotoilu metodilla str.format.