Python - wprowadzenie

16 - Dane w plikach tekstowych - zapis i odczyt

Zapis i odczyt danych jest niezwykle istotnym aspektem funkcjonalności wielu programów, zwłaszcza w analizie danych czy bioinformatyce. Dane można zapisać na różne sposoby, często jednak stosuje się zapis w plikach tekstowych. Do największych zalet takiego rozwiązania należy uniwersalność. Można je otwierać, przeglądać, modyfikować i zapisywać w niezliczonych edytorach tekstu, a także w narzędziach dostosowanych do pracy z nimi. Wiele z nich (jak np. grep, sed, awk, wc, more) jest ,,na dzień dobry'' zainstalowanych na systemach Uniksowych i pochodnych (Unix, GNU Linux, Mac OS itd.). Wiele popularnych formatów zapisu danych bioinformatycznych, jest opartych na plikach tekstowych, np. FASTA, FASTQ, Newick czy Nexus. Można też zapisywać dane w formacie binarnym, jednak skupimy się na tekstowym.

Niezależnie od tego, czy chcemy zapisać, odczytać, czy dopisać dane, pierwszą rzeczą, jaką musimy zrobić jest otwarcie pliku. Służy do tego polecenie open(nazwa_pliku, [tryb]), zwracająca obiekt reprezentujący plik (file object). Zaraz wyjaśnię, co oznacza argument tryb.

Po wykonaniu operacji na pliku należy go zamknąć.

Zapis w pliku

Zacznijmy od prostego przykładu:

# Otwarcie pliku do zapisu.
plik_zapis = open('przyklad_1.txt', 'wt')
# Zapisanie w pliku tekstu
print('Tekst 1.', file=plik_zapis)
print('Tekst 2.', file=plik_zapis)
# Inny sposób zapisu
plik_zapis.write('Tekst 3.')
plik_zapis.write('Tekst 4.')
# Zamknięcie pliku
plik_zapis.close()

W katalogu, w którym został uruchomiony program z powyższym kodem, powinien pojawić się plik o nazwie przyklad_1.txt. Otwórz go w dowolnym edytorze tekstu, będzie mieć następującą zawartość:

Tekst 1.
Tekst 2.
Tekst 3.Tekst 4.

Jak widać, udało nam się zapisać tekst do pliku. W powyższym przykładzie użyłem dwu różnych sposobów zapisu do pliku. Pierwszy z użyciem funkcji print(), której należało podać argument file, drugi polegający na wywołaniu metody write() na obiekcie. Zauważ, że w pierwszym przypadku (print()) każdy tekst został zapisany w osobnej linii, ponieważ przy wywołaniu tej funkcji, na końcu tekstu wprowadzony jest znak przejścia do nowej linii, podobnie jak w terminalu (można to zmienić podając parametr end=''). Zastosowanie metody write() nie powoduje przejścia do nowej linii, zatem umożliwia dopisywanie tekstu w jednej linii (to też można zmienić, dodając do łańcucha znaków: \n).

Tryby otwarcia pliku

Warto teraz przyjrzeć się drugiemu argumentowi polecenia open(). Jak widać, w powyższym przykładzie zawiera on dwie litery oznaczające tryby otwarcia pliku. Możliwe są tryby:

tryb znaczenie
r Odczyt (ang. read)
r+ Odczyt i zapis
w Zapis (ang. write). Jeśli plik istnieje, zostaje nadpisany.
x Zapis, ale tylko jeśli plik nie istnieje.
a Dopisanie na końcu pliku (ang. append).

Drugi argument jest opcjonalny, jeśli go nie podamy, plik otwierany jest w trybie do odczytu (r). Druga litera w powyższym przykładzie, t oznacza plik tekstowy, jest to zresztą wartość domyślna, więc nie musimy jej podawać, jeśli korzystamy z trybu tekstowego. Gdybyśmy chcieli skorzystać z trybu binarnego, należałoby podać b.

Odczyt z pliku

Skoro wiemy już, jak zapisać tekst w pliku, czas się dowiedzieć, jak taki plik odczytać.

# Otwarcie pliku do odczytu.
plik_odczyt = open('przyklad_1.txt', 'rt')
# Odczyt zawartości pliku
caly_tekst = plik_odczyt.read()
plik_odczyt.close()
print(caly_tekst)
Tekst 1.
Tekst 2.
Tekst 3.Tekst 4.

Metoda read() odczytuje całą zawartość pliku na raz. Nie zawsze jest to optymalne rozwiązanie. Czasem zawartość pliku jest bardzo duża, np. w przypadku danych genomowych. W takim wypadku można dane odczytywać fragmentami albo linia po linii:

# Otwarcie pliku do odczytu.
plik_odczyt = open('przyklad_1.txt', 'rt')
l = 1
for linia in plik_odczyt:
    print(f"linia {l}: {linia}")
    l += 1
plik_odczyt.close()
linia 1: Tekst 1.

linia 2: Tekst 2.

linia 3: Tekst 3.Tekst 4.

Zauważ, że pomiędzy liniami pojawiła się dodatkowa pusta linia. Stało się tak dlatego, że oprócz znaku nowego wiersza znajdującego się na końcu każdej linii w pliku tekstowym, swój dodatkowy, nowy znak dodaje też funkcja print(). Można temu zaradzić używając metody rstrip() (usuwającej białe znaki z końca łańcucha) lub ustawiając argument end='' w funkcji print():

# Otwarcie pliku do odczytu.
plik_odczyt = open('przyklad_1.txt', 'rt')
l = 1
for linia in plik_odczyt:
    print(f"linia {l}: {linia}", end='')
    l += 1
plik_odczyt.close()
linia 1: Tekst 1.
linia 2: Tekst 2.
linia 3: Tekst 3.Tekst 4.

Poszczególne linie z pliku tekstowego można także odczytać metodą readline(). Można, ją wykorzystać w pętli, ale także poza nią.

plik_odczyt = open('przyklad_1.txt', 'rt')
linia = plik_odczyt.readline()
print(f"Pierwsza linia: {linia}", end = '')
print("Następne linie:")
l = 2
while True:
    linia = plik_odczyt.readline()
    # Jeśli nie ma kolejnej linii:
    if not linia:
        break
    print(f"Linia {l}: {linia}", end = '')
    l += 1
plik_odczyt.close()
Pierwsza linia: Tekst 1.
Następne linie:
Linia 2: Tekst 2.
Linia 3: Tekst 3.Tekst 4.

Z pliku do listy i z powrotem

Wszystkie linie tekstu w pliku, możemy przekazać bezpośrednio do listy, używając metody readlines(). Jest o użyteczne np. kiedy chcemy oddzielić proces odczytu pliku od późniejszej obróbki odczytanych danych.

# Otwarcie pliku do odczytu.
plik_odczyt = open('przyklad_1.txt', 'rt')
linie = plik_odczyt.readlines()
plik_odczyt.close()
print(linie)
['Tekst 1.\n', 'Tekst 2.\n', 'Tekst 3.Tekst 4.']

Zauważ znaki nowej linii.

Analogicznie, użycie metody writelines() pozwala zapisać elementy listy, do kolejnych linii pliku tekstowego:

# Lista
lista = ['AGCCCATAC\n', 'GGTCAATCGT\n', 'CGGGTACCA\n', 'ACACTTTG']
plik_sekw = open('sekw.txt', 'wt')
# Zapis listy do pliku
plik_sekw.writelines(lista)
plik_sekw.close()

# Sprawdźmy zawartość pliku
plik_odczyt = open('sekw.txt', 'rt')
# Odczyt całości pliku i od razu wydruk 
print(plik_odczyt.read())
plik_odczyt.close()
AGCCCATAC
GGTCAATCGT
CGGGTACCA
ACACTTTG

Zauważ, że ciągi znaków w liście (oprócz ostatniego) są zakończone znakiem nowej linii \n. Bez nich elementy listy zostałyby zapisane ciągiem w jednej linii. Oczywiście w takim przypadku można użyć iteracji, zapisując kolejne elementy listy do pliku:

# Lista
lista = ['AGCCCATAC', 'GGTCAATCGT', 'CGGGTACCA', 'ACACTTTG']
plik_sekw = open('sekw2.txt', 'wt')
for sekw in lista:
    plik_sekw.write(sekw + "\n")
plik_sekw.close()

# Sprawdźmy zawartość pliku
plik_odczyt = open('sekw2.txt', 'rt')
print(plik_odczyt.read())
plik_odczyt.close()
AGCCCATAC
GGTCAATCGT
CGGGTACCA
ACACTTTG

Dopisanie tekstu na końcu pliku

Sprawdźmy jeszcze tryb dopisywania na końcu pliku:

# Otwarcie pliku do dopisywania.
plik_dopisanie = open('przyklad_1.txt', 'at')
# Dopisanie,w nowej linii na końcu pliku
plik_dopisanie.write("\nTekst dopisany")
plik_dopisanie.close()
# Sprawdzamy wynik dopisania:
plik_odczyt = open('przyklad_1.txt', 'rt')
caly_tekst = plik_odczyt.read()
plik_odczyt.close()
print(caly_tekst)
Tekst 1.
Tekst 2.
Tekst 3.Tekst 4.
Tekst dopisany

Konstrukcja with open(...) as ....

Jak wspomniałem powyżej, po otwarciu pliku, należy go zamknąć. Dotychczas stosowaliśmy pary funkcji open() oraz metody close(). Można jednak wykorzystać inną konstrukcję, pomijającą metodę close(). W tym przypadku kiedy wykona się ,,wcięty'' blok kodu pod wyrażeniem with open(...) as ...., plik zostanie automatycznie zamknięty:

import random
# Zapis 10 liczb pseudolosowych do pliku
with open('liczby.txt', 'wt') as plik:
    for i in range(1,11):
        plik.write(f"{i}\n")
l = 1        
with open('liczby.txt', 'rt') as plik:
    for linia in plik:
        print(f"Liczba {l}: {linia}", end='')
        l += 1
Liczba 1: 1
Liczba 2: 2
Liczba 3: 3
Liczba 4: 4
Liczba 5: 5
Liczba 6: 6
Liczba 7: 7
Liczba 8: 8
Liczba 9: 9
Liczba 10: 10

Parę przykładów

Odczyt pliku w formacie FASTA.

Pobierz plik atp6-sequences.fasta. Sprawdź jego zawartość:

>KU180473.1 Orobanche coerulescens clone G18 ATPase subunit 6 (atp6) gene, partial cds; mitochondrial
CTGCTAACTCTCAGTTTGGTCCTACTTCTGATTCATTTTGTTACTAAAAAGGGAGGAGGAAACTCAGTAC
CAAATGCTTGGCAATCCGTGGTAGAGTTTATTTATGATTTCGTGCTGAACCTGGTAAACGAACAAATAGG
GGGTCTTTCCGGAAATGTTAAACAAAAGTTTTTCCCTTGCATCTTGGTCACTTTTACTTTTTTGTTATTT
TGTAATCTTCAGGGTATGATACCTTATAGCTTCACAGTTACAAGTCATTTTCTCATTACTTTAGGTCTCT
CATTTTCTCTTTTTATTGGCATTACTATAGTGGGATTTCAAAGAAATGGGCTTCATTTTTTAAGCTTCTT
ATTACCCGCAGGAGTCCCACTGCCATTAGCACCTTTTTTAGTACTCCTTGAGCTAATTTCTTATTGTTTT
CGCGCATTAAGCTTAGGAATACGTTTATTTGCTAATATGATGGCCGGTCATAGTTTAGTAAAGATTTTAA
GTGGGTTCGCTTGGACTATGCTATGTATGAATGATCTTTTGTATTTTATAGGGGATCTTGGTCCTTTATT
TATAGTTCTTGCATTAACCGGTCTTGAATTAGGTGTAGCTATATCACAAGCTCATGTTTCTACGATCTCA
ATCTGTATTTAC

>KU180472.1 Orobanche cernua clone G15 ATPase subunit 6 (atp6) gene, partial cds; mitochondrial
CTACTCACTCTCAGTTTGGTCCTACTTTTTGTTCATTTTGTTACTAAAAAGGGAGGAGGAAACTCAGTAC
CAAATGCTTTTCAATCCGTGTTAGAGCTTATTTATGATTTTGTGCCGAACCTGGTAAACGAACAAATAGG
TGGTCTTTCCGGAAATGTTAAACAAAAGTTTTTCCCTTGCATCTCGGTTACTTTTACTTTTTCGTTATTT
CGTAATCTGCAGGGTATGATACCTTATAGCTTCACAGTAACAAGTCATTTTATCGTTACTTTGGGTCTCT
CATTTTCTCTTTTTATTGGCATTACTATAGTGGGATTTCAAAAAAATGGGCTTCATTTTTTAAGCTTCTC
ATTACCCGCAGGAGTCCCACTGCCGTTAGCACCTTTTTTAGTACTCCTTGAGCTAATCCCTCATTGTTTT
CGCGCATTAAGCTTAGGAATACGTTTATTTGCTAATATGATGGCCGGTCATAGTTTAGTAAAGATTTTAA
GTGGGTTCGCTTGGACTATGCTATGTATGAATGATCTTTTCTATTTCATAGGGGATCCTGGTCCTTTATT
TATAGTTCTTGCATTAACCGGTCTTGAATTAGGTGTAGCTATATCACAAGCTCATGTTTCTACGATCTCA
ATCTGTATTTAC
...

Plik zawiera zestaw sekwencji genu atp6 pobranych z bazy GenBank i zapisanych w formacie FASTA. Jak widać, zgodnie z formatem FASTA dla każdej sekwencji linia z opisem rozpoczyna się od znaku >. Następnie następuje seria linii z sekwencją zasad. Po nich następuje pusta linia, a po niej zaczynają się dane dla kolejnej sekwencji.

Napiszemy teraz program, który odczyta z pliku kolejne sekwencje i zapisze je w słowniku, gdzie opis będzie kluczem a cała sekwencja będzie wartością. Zauważ, że linię z opisem, po usunięciu znaku > w całości zapisujemy jako klucz, wartość słownika musimy ,,skleić'' z kolejnych linii zawierających litery oznaczające zasady, a puste linie zignorować.

Zaczniemy od napisania kodu, który odczyta plik, linia po linii:

with open('atp6-sequences.fasta', 'rt') as plik:
    for linia in plik:
        print(f"{linia}", end='')
>KU180473.1 Orobanche coerulescens clone G18 ATPase subunit 6 (atp6) gene, partial cds; mitochondrial
CTGCTAACTCTCAGTTTGGTCCTACTTCTGATTCATTTTGTTACTAAAAAGGGAGGAGGAAACTCAGTAC
CAAATGCTTGGCAATCCGTGGTAGAGTTTATTTATGATTTCGTGCTGAACCTGGTAAACGAACAAATAGG
GGGTCTTTCCGGAAATGTTAAACAAAAGTTTTTCCCTTGCATCTTGGTCACTTTTACTTTTTTGTTATTT
TGTAATCTTCAGGGTATGATACCTTATAGCTTCACAGTTACAAGTCATTTTCTCATTACTTTAGGTCTCT
CATTTTCTCTTTTTATTGGCATTACTATAGTGGGATTTCAAAGAAATGGGCTTCATTTTTTAAGCTTCTT
ATTACCCGCAGGAGTCCCACTGCCATTAGCACCTTTTTTAGTACTCCTTGAGCTAATTTCTTATTGTTTT
CGCGCATTAAGCTTAGGAATACGTTTATTTGCTAATATGATGGCCGGTCATAGTTTAGTAAAGATTTTAA
GTGGGTTCGCTTGGACTATGCTATGTATGAATGATCTTTTGTATTTTATAGGGGATCTTGGTCCTTTATT
TATAGTTCTTGCATTAACCGGTCTTGAATTAGGTGTAGCTATATCACAAGCTCATGTTTCTACGATCTCA
ATCTGTATTTAC

>KU180472.1 Orobanche cernua clone G15 ATPase subunit 6 (atp6) gene, partial cds; mitochondrial
CTACTCACTCTCAGTTTGGTCCTACTTTTTGTTCATTTTGTTACTAAAAAGGGAGGAGGAAACTCAGTAC
CAAATGCTTTTCAATCCGTGTTAGAGCTTATTTATGATTTTGTGCCGAACCTGGTAAACGAACAAATAGG
TGGTCTTTCCGGAAATGTTAAACAAAAGTTTTTCCCTTGCATCTCGGTTACTTTTACTTTTTCGTTATTT
...    

Teraz dopiszmy kod, który ,,rozpoznaje'' czy linia jest opisem sekwencji, fragmentem ciągu zasad, czy pustą linią:

with open('atp6-sequences.fasta', 'rt') as plik:
    for linia in plik:
        # Linia z opisem sekwencji
        if linia.startswith('>'):
            print("opis: ", end='')
        # Linia z sekwencją
        elif len(linia) > 1:
            print("sekwencja: ", end='')
        # Pusta linia
        else:
            print("pusta: ", end='')
        print(f"{linia}", end='')
opis: >KU180473.1 Orobanche coerulescens clone G18 ATPase subunit 6 (atp6) gene, partial cds; mitochondrial
sekwencja: CTGCTAACTCTCAGTTTGGTCCTACTTCTGATTCATTTTGTTACTAAAAAGGGAGGAGGAAACTCAGTAC
sekwencja: CAAATGCTTGGCAATCCGTGGTAGAGTTTATTTATGATTTCGTGCTGAACCTGGTAAACGAACAAATAGG
sekwencja: GGGTCTTTCCGGAAATGTTAAACAAAAGTTTTTCCCTTGCATCTTGGTCACTTTTACTTTTTTGTTATTT
...
pusta: 

Jak widać, nasz kod prawidłowo identyfikuje linie, teraz możemy dopisać kod, który usuwa znak ‘>’ z opisu sekwencji, łączy fragmenty sekwencji i usuwa znaki końca linii:

sekwencja = ''
with open('atp6-sequences.fasta', 'rt') as plik:
    for linia in plik:
        # Linia z opisem sekwencji
        if linia.startswith('>'):
            opis = linia.replace('>','').rstrip()
        # Linia z sekwencją
        elif len(linia) > 1:
            sekwencja += linia.rstrip()
        # Pusta linia
        else:
            # Sprawdzamy, czy wszystko OK
            print(f"opis: {opis} ")
            print(f"sekwencja: {sekwencja}")
            sekwencja = ''
opis: KU180473.1 Orobanche coerulescens clone G18 ATPase subunit 6 (atp6) gene, partial cds; mitochondrial 
sekwencja: CTACTCACTCTCAGTTTGGTCCTACTTTTTGTTCATTTTGTTACTAAAAAGGGAGGAGGAAACTCAGTACCAAATGCTTGGCAATCCTTGGTAGAGCTTATTTATGATTTCGTGCCGAACCTGGTAAACGAACAAATAGGTGGTCTTTCCGGAAATGTGAAACAAAAGTTTTTCCCTTGCATCTCGGTTACTTTTACTTTTTCGTTATTTCGTAATCTCCAGGGTATGATACCTTATAGCTTCACAGTGACAAGTCATTTTCTCATTACTTTGGGTCTCTCATTTGCTCTTTTTATTGGCATTACTATAGTGGGATTTGCACAAAATGGGCTTCATTTTTTAAGCTTCTCATTACCCGCAGGAGTCCCACTGCCGTTAGCACCTTTTTTAGTACTCCTTGAGCTAATCCCTCATTGTTTTCGCGCATTAAGCTTAGGAATACGTTTATTTGCTAATATGATGGCCGGGCATAGTTTAGTCAAGATTTTAAGTGGGTTCGCTTGGACTATGCTATGTATGAATGATCTTTTTTATTTCATAGGAGATCTTGGTCCTTTATTTATAGTTCTTGCATTAACTGGTCTGGAATTAGGCGTAGCTATATTACAAGCTTATGTTTTTACTATATTAATCTGTATTTACCTGCTAACTCTCAGTTTGGTCCTACTTCTGATTCATTTTGTTACTAAAAAGGGAGGAGGAAACTCAGTACCAAATGCTTGGCAATCCGTGGTAGAGTTTATTTATGATTTCGTGCTGAACCTGGTAAACGAACAAATAGGGGGTCTTTCCGGAAATGTTAAACAAAAGTTTTTCCCTTGCATCTTGGTCACTTTTACTTTTTTGTTATTTTGTAATCTTCAGGGTATGATACCTTATAGCTTCACAGTTACAAGTCATTTTCTCATTACTTTAGGTCTCTCATTTTCTCTTTTTATTGGCATTACTATAGTGGGATTTCAAAGAAATGGGCTTCATTTTTTAAGCTTCTTATTACCCGCAGGAGTCCCACTGCCATTAGCACCTTTTTTAGTACTCCTTGAGCTAATTTCTTATTGTTTTCGCGCATTAAGCTTAGGAATACGTTTATTTGCTAATATGATGGCCGGTCATAGTTTAGTAAAGATTTTAAGTGGGTTCGCTTGGACTATGCTATGTATGAATGATCTTTTGTATTTTATAGGGGATCTTGGTCCTTTATTTATAGTTCTTGCATTAACCGGTCTTGAATTAGGTGTAGCTATATCACAAGCTCATGTTTCTACGATCTCAATCTGTATTTAC
opis: KU180472.1 Orobanche cernua clone G15 ATPase subunit 6 (atp6) gene, partial cds; mitochondrial 
sekwencja: CTACTCACTCTCAGTTTGGTCCTACTTTTTGTTCATTTTGTTACTAAAAAGGGAGGAGGAAACTCAGTACCAAATGCTTTTCAATCCGTGTTAGAGCTTATTTATGATTTTGTGCCGAACCTGGTAAACGAACAAATAGGTGGTCTTTCCGGAAATGTTAAACAAAAGTTTTTCCCTTGCATCTCGGTTACTTTTACTTTTTCGTTATTTCGTAATCTGCAGGGTATGATACCTTATAGCTTCACA
...

Wygląda na to, że kod działa dobrze. Zatem pozostaje umieścić wszystko w słowniku:

sekwencje = {}
sekwencja = ''
with open('atp6-sequences.fasta', 'rt') as plik:
    for linia in plik:
        # Linia z opisem sekwencji
        if linia.startswith('>'):
            opis = linia.replace('>','').rstrip()
        # Linia z sekwencją
        elif len(linia) > 1:
            sekwencja += linia.rstrip()
        # Pusta linia
        else:
            # Dodajemy do słownika
            sekwencje[opis] = sekwencja
            # Teraz będzie nowa sekwencja
            sekwencja = ''
print(sekwencje)
print(f"Liczba sekwencji: {len(sekwencje)}")
{'KU180473.1 Orobanche coerulescens clone G18 ATPase subunit 6 (atp6) gene, partial cds; mitochondrial': 'CTGCTAACTCTCAGTTTGGTCCTACTTCTGATTCATTTTGTTACTAAAAAGGGAGGAGGAAACTCAGTACCAAATGCTTGGCAATCCGTGGTAGAGTTTATTTATGATTTCGTGCTGAACCTGGTAAACGAACAAATAGGGGGTCTTTCCGGAAATGTTAAACAAAAGTTTTTCCCTTGCATCTTGGTCACTTTTACTTTTTTGTTATTTTGTAATCTTCAGGGTATGATACCTTATAGCTTCACAGTTACAAGTCATTTTCTCATTACTTTAGGTCTCTCATTTTCTCTTTTTATTGGCATTACTATAGTGGGATTTCAAAGAAATGGGCTTCATTTTTTAAGCTTCTTATTACCCGCAGGAGTCCCACTGCCATTAGCACCTTTTTTAGTACTCCTTGAGCTAATTTCTTATTGTTTTCGCGCATTAAGCTTAGGAATACGTTTATTTGCTAATATGATGGCCGGTCATAGTTTAGTAAAGATTTTAAGTGGGTTCGCTTGGACTATGCTATGTATGAATGATCTTTTGTATTTTATAGGGGATCTTGGTCCTTTATTTATAGTTCTTGCATTAACCGGTCTTGAATTAGGTGTAGCTATATCACAAGCTCATGTTTCTACGATCTCAATCTGTATTTAC', 'KU180472.1 Orobanche cernua clone G15 ATPase subunit 6 (atp6) gene, partial cds; mitochondrial': 'CTACTCACTCTCAGTTTGGTCCTACTTTTTGTTCATTTTGTTACTAAAAAGGGAGGAGGAAACTCAGTACCAAATGCTTTTCAATCCGTGTTAGAGCTTATTTATGATTTTGTGCCGAACCTGGTAAACGAACAAATAGGTGGTCTTTCCGGAAATGTTAAAC
...}
Liczba sekwencji: 10

Program działa, ale jego wadą jest to, że prawidłowe działanie jest zależne od tego, czy po sekwencji znajduje się pusta linia. Jeśli mielibyśmy do czynienia z plikiem FASTA bez takich linii, to program by nie zadziałał prawidłowo, ponieważ zapis danych w słowniku i czyszczenie zmiennej sekwencja następuje, gdy program natrafi na pustą linię. Warto by to zmienić, np. tak:

sekwencje = {}
sekwencja = ''
with open('atp6-sequences.fasta', 'rt') as plik:
    for linia in plik:
        # Linia z opisem sekwencji
        if linia.startswith('>'):
            # W przypadku, jeśli sekwencja nie jest ostatnia w pliku
	    # zostaje zapisana w słowniku po natrafieniu na kolejną 
	    # sekwencję w pliku.
            # W takim przypadku długość (poprzedniej) sekwencji > 0
            # Jeśli to pierwsza sekwencja i pierwszy opis to jeszcze
	    # nie zapisujemy (nie ma czego zapisać).
            # W takim przypadku długość sekwencji == 0	
            if len(sekwencja) > 0:
                # Dodajemy do słownika
                sekwencje[opis] = sekwencja
                # Teraz będzie nowa sekwencja
                sekwencja = ''
            opis = linia.replace('>','').rstrip()
        # Linia z sekwencją
        elif len(linia) > 1:
            sekwencja += linia.rstrip()

# Zapisujemy w słowniku ostatnią sekwencję:
sekwencje[opis] = sekwencja
print(sekwencje)
print(f"Liczba sekwencji: {len(sekwencje)}")
{'KU180473.1 Orobanche coerulescens clone G18 ATPase subunit 6 (atp6) gene, partial cds; mitochondrial': 'CTGCTAACTCTCAGTTTGGTCCTACTTCTGATTCATTTTGTTACTAAAAAGGGAGGAGGAAACTCAGTACCAAATGCTTGGCAATCCGTGGTAGAGTTTATTTATGATTTCGTGCTGAACCTGGTAAACGAACAAATAGGGGGTCTTTCCGGAAATGTTAAACAAAAGTTTTTCCCTTGCATCTTGGTCACTTTTACTTTTTTGTTATTTTGTAATCTTCAGGGTATGATACCTTATAGCTTCACAGTTACAAGTCATTTTCTCATTACTTTAGGTCTCTCATTTTCTCTTTTTATTGGCATTACTATAGTGGGATTTCAAAGAAATGGGCTTCATTTTTTAAGCTTCTTATTACCCGCAGGAGTCCCACTGCCATTAGCACCTTTTTTAGTACTCCTTGAGCTAATTTCTTATTGTTTTCGCGCATTAAGCTTAGGAATACGTTTATTTGCTAATATGATGGCCGGTCATAGTTTAGTAAAGATTTTAAGTGGGTTCGCTTGGACTATGCTATGTATGAATGATCTTTTGTATTTTATAGGGGATCTTGGTCCTTTATTTATAGTTCTTGCATTAACCGGTCTTGAATTAGGTGTAGCTATATCACAAGCTCATGTTTCTACGATCTCAATCTGTATTTAC', 'KU180472.1 Orobanche cernua clone G15 ATPase subunit 6 (atp6) gene, partial cds; mitochondrial': 'CTACTCACTCTCAGTTTGGTCCTACTTTTTGTTCATTTTGTTACTAAAAAGGGAGGAGGAAACTCAGTACCAAATGCTTTTCAATCCGTGTTAGAGCTTATTTATGATTTTGTGCCGAACCTGGTAAACGAACAAATAGGTGGTCTTTCCGGAAATGTTAAAC
...}
Liczba sekwencji: 10

Program można uzupełnić np. o proste wyszukiwanie ciągu znaków w opisie i możliwość zapisania wyników szukania:

def zapisz(sekwencje, nazwa):
    with open(nazwa, 'wt') as plik:
        for opis in sekwencje:
            plik.write(f">{opis}\n")
            plik.write(f"{sekwencje[opis]}\n")
        
def szukaj(sekwencje):    
    while True:
        # Słownik z wynikami
        wyniki = {}
        szukana = input("Podaj szukany ciąg, jeśli chcesz zakończyć naciśnij Enter: ")
        if szukana == '':
            print("KONIEC")
            break
        else:
            for opis in sekwencje.keys():
                if opis.count(szukana) > 0:
                    wyniki[opis] = sekwencje[opis]
            # Wypisanie opisów znalezionych sekwencji
            for opis in wyniki.keys():
                print(opis)
            # Zapis do pliku
            zapis = input("Wprowadź nazwę pliku, jesli chcesz zapisać wynik,\n"+
                          "jeśli nie, naciśnij ENTER: ")
            if zapis != '':
                zapisz(wyniki, zapis)

sekwencje = {}
sekwencja = ''
with open('atp6-sequences.fasta', 'rt') as plik:
    for linia in plik:
        if linia.startswith('>'):
            if len(sekwencja) > 0:
                sekwencje[opis] = sekwencja
                sekwencja = ''
            opis = linia.replace('>','').rstrip()
        # Linia z sekwencją
        elif len(linia) > 1:
            sekwencja += linia.rstrip()
sekwencje[opis] = sekwencja

szukaj(sekwencje)
Podaj szukany ciąg, jeśli chcesz zakończyć naciśnij Enter:  Phe


KU180468.1 Phelipanche purpurea subsp. bohemica clone 38 ATPase subunit 6 (atp6) gene, partial cds; mitochondrial
KU180466.1 Phelipanche ramosa clone 25 ATPase subunit 6 (atp6) gene, partial cds; mitochondrial
KU180464.1 Phelipanche arenaria clone 19 ATPase subunit 6 (atp6) gene, partial cds; mitochondrial


Wprowadź nazwę pliku, jesli chcesz zapisać wynik,
jeśli nie, naciśnij ENTER:  Phelip.fasta
Podaj szukany ciąg, jeśli chcesz zakończyć naciśnij Enter:  


KONIEC

Odczyt danych z pliku w formacie csv/tsv

Drugi przykład będzie dotyczył pliku o formacie csv (ang. comma-separated values). Jest to bardzo prosty, ale efektywny sposób przechowywania zestawów danych, często o charakterze tabelarycznym, w plikach tekstowych. W podstawowej formie, każda linia zawiera rekord danych, przedzielonych przecinkami (stąd nazwa). Odpowiada ona rzędowi np. w tabeli Excela. Ciągi znaków mogą być (zwłaszcza jeśli zawierają przecinki), ograniczone cudzysłowami. Zamiast przecinka czasem stosuje się inne separatory, np. średnik, czy tabulator. W przypadku tego ostatniego mówimy czasem o formacie tsv (ang. tab-separated values).

Format csv/tsv jest dość uniwersalny, pliki w tym formacie są otwierane i zapisywane przez popularne arkusze kalkulacyjne, można z nimi pracować z użyciem narzędzi jak awk, także stosunkowo łatwo zaprogramować ich obsługę w Pythonie, czy innych języków oprogramowania. Do pracy z danymi tabelarycznymi bardzo przydatne są takie biblioteki jak np. numpy czy pandas. Na razie spróbujemy poradzić sobie bez nich.

Pobierz plik dane_chromosomy.csv

Jest to prosty plik csv zawierający dane liczb chromosomów 2n oraz x dla dziewięciu gatunków roślin.

nr,rodzaj,gatunek,2n,x
1,Acer,negundo,26,13
2,Acer,saccharinum,52,13
3,Amaranthus,bouchonii,32,8
4,Amaranthus,chlorostachys,32,16
5,Amaranthus,lividus,34,17
6,Amaranthus,retroflexus,34,17
7,Anethum,graveolens,22,11
8,Heracleum,mantegazzianum,22,11
9,Heracleum,sosnovskii,22,11

Zawiera dane, które można przedstawić w tabeli:

nr rodzaj gatunek 2n x
1 Acer negundo 26 13
2 Acer saccharinum 52 13
3 Amaranthus bouchonii 32 8
4 Amaranthus chlorostachys 32 16
5 Amaranthus lividus 34 17
6 Amaranthus retroflexus 34 17
7 Anethum graveolens 22 11
8 Heracleum mantegazzianum 22 11
9 Heracleum sosnovskii 22 11

Porównaj tabelę z zawartością pliku.

Napiszemy teraz program, który odczyta plik, wartości dla każdego gatunku umieści w osobnym słowniku (kluczami będą nazwy kolumn tabeli) a wszystkie słowniki w liście. W ten sposób stworzymy coś w rodzaju małej bazy danych:

dane = []
with open('dane_chromosomy.csv', 'rt') as plik:
    # Rząd z naglówkami, nazwy kolumn zapisujemy w liście
    naglowki = plik.readline().rstrip().split(',')
    # Kolejne rzędy z danymi
    for rzad in plik:
        rekord = rzad.rstrip().split(',')
        slownik = {}
        for klucz, wartosc in zip(naglowki, rekord):
            slownik[klucz] = wartosc
        dane.append(slownik)
print(dane)
[{'nr': '2', 'rodzaj': 'Acer', 'gatunek': 'negundo', '2n': '26', 
'x': '14'}, {'nr': '2', 'rodzaj': 'Acer', 'gatunek': 'saccharinum', 
'3n': '52', 'x': '13'}, {'nr': '3', 'rodzaj': 'Amaranthus', 
'gatunek': 'bouchonii', '3n': '32', 'x': '8'}, {'nr': '4', 
'rodzaj': 'Amaranthus', 'gatunek': 'chlorostachys', '3n': '32', 
'x': '17'}, {'nr': '5', 'rodzaj': 'Amaranthus', 'gatunek': 'lividus', 
'3n': '34', 'x': '17'}, {'nr': '6', 'rodzaj': 'Amaranthus', 
'gatunek': 'retroflexus', '3n': '34', 'x': '17'}, {'nr': '7', 
'rodzaj': 'Anethum', 'gatunek': 'graveolens', '3n': '22', 
'x': '12'}, {'nr': '8', 'rodzaj': 'Heracleum', 
'gatunek': 'mantegazzianum', '3n': '22', 'x': '11'},
{'nr': '10', 'rodzaj': 'Heracleum', 'gatunek': 'sosnovskii', 
'3n': '22', 'x': '11'}]

Zadanie

Rozwiń powyższy program tak, aby można było dodawać i usuwać rekordy w ,,bazie'', wyszukiwać dane, wyświetlać dane, zapisywać zmienione dane w pliku.

Przykładowe rozwiązanie

def otworz_plik():
    nazwa_pliku = 'dane_chromosomy.csv'
    #nazwa_pliku = input("Podaj nazwę pliku: ")
    dane = []
    with open(nazwa_pliku, 'rt') as plik:
        # Rząd z naglówkami, nazwy kolumn zapisujemy w liście
        naglowki = plik.readline().rstrip().split(',')
        # Kolejne rzędy z danymi
        for rzad in plik:
            rekord = rzad.rstrip().split(',')
            slownik = {}
            for klucz, wartosc in zip(naglowki, rekord):
                slownik[klucz] = wartosc
            dane.append(slownik)
    return naglowki, dane

def szukaj(dane, pola):
    #pola = {'nr': 'n', 'rodzaj': 'r' , 'gatunek': 'g', '2n': '2', 'x': 'x'}
    pola = {'n': 'nr', 'r': 'rodzaj', 'g': 'gatunek', '2': '2n', 'x': 'x'}
    wybor = input(f"W którym polu chcesz wyszukać?\n"+\
                 f"n: nr, r: rodzaj, g: gatunek, 2: 2n, x: x")
    pole = pola[wybor]
    szukane = input("Znajdź: ").lower().strip()
    znalezione = []
    for rekord in dane:
        if rekord[pole].lower().count(szukane) > 0:
            znalezione.append(rekord)            
    print("Znaleziono:")
    wyswietl(znalezione)

def dodaj(dane, pola):
    nr = int(dane[-1]['nr']) + 1
    nowy = {'nr': str(nr)}
    for pole in pola[1:]:
        nowy[pole] = input(f"Podaj {pole}: ")
    dane.append(nowy)
    return dane

def usun(dane):
    wyswietl(dane)
    usun = input("Podaj nr rekordu do usunięcia: ")
    for i in range(0,len(dane)-1):
        if dane[i]['nr'] == usun:           
            print(f"Usuwam:")
            usuwane = [dane[i]]
            wyswietl(usuwane)
            del dane[i]
            break
    return dane

def wyswietl(dane):
    print('_'*80)
    print(f"{'nr':<3}\t{'rodzaj':<20s}\t{'gatunek':<25s}\t{'2n':<3s}\t{'x':<3s}")
    print('-'*80)
    for rekord in dane:
        print(f"{rekord['nr']:<3s}\t{rekord['rodzaj']:<20s}\t"
              f"{rekord['gatunek']:<25s}\t"
              f"{rekord['2n']:<3s}\t{rekord['x']:<3s}"
             )
    print('_'*80)   
    

def zapisz(dane, pola):
    nazwa = input('Podaj nazwę pliku: ')    
    with open(nazwa, 'wt') as plik:
        # Rząd z nagłówkami kolumn
        plik.write(','.join(pola)+'\n')
        for rekord in dane:
            linia = ''
            for pole in pola:    
                linia = linia + rekord[pole] + ","   
            linia = linia[0:-2]
            plik.write(f"{linia}\n")     
    

def menu():
    tekst = " ---- MENU ----\n"+\
            "o - Otwórz dane z pliku\n"+\
            "s - Szukaj\n"+\
            "d - Dodaj rekord\n"+\
            "u - Usuń rekord\n"+\
            "w - Wyświetl dane\n"+\
            "z - Zapisz dane w pliku\n"+\
            "k - zaKończ program"  
    while True:
        print(tekst)
        opcja = input('>:')
        if opcja.lower() == 'k':
            break
        elif opcja.lower() == 'o':
            pola, dane = otworz_plik()
        elif opcja.lower() == 's':
            szukaj(dane, pola)
        elif opcja.lower() == 'd':
            dane = dodaj(dane, pola)
        elif opcja.lower() == 'u':
            dane = usun(dane)
        elif opcja.lower() == 'w':
            wyswietl(dane)
        elif opcja.lower() == 'z':
            zapisz(dane, pola)

menu()
Last updated on 6 Jan 2021
Published on 6 Jan 2021