Pliki: zapisywanie i odczytywanie danych

Witaj z powrotem.

W poprzedniej lekcji nauczyłeś się funkcji.

Twoje programy nauczyły się organizować kod w bloki wielokrotnego użytku.

Pisałeś rzeczy takie jak:

def greet_user(name):
    print(f"Hello, {name}!")

Bardzo dobrze.

Funkcje sprawiły, że twój kod stał się czystszy.

Mniej powtórzeń.

Mniej chaosu kopiuj-wklej.

Mniej “dlaczego napisałem to samo siedem razy?”

Świetny postęp.

Ale teraz mamy kolejny problem.

Twój program może przechowywać dane w zmiennych.

Twój program może przechowywać listy.

Twój program może przechowywać słowniki.

Ale kiedy program się kończy, wszystko znika.

Bardzo smutne.

Bardzo tymczasowe.

Przykład:

tasks = ["Buy milk", "Study Python", "Drink coffee"]

Ta lista istnieje, kiedy program działa.

Ale kiedy program się kończy?

Znika.

Jak motywacja po przeczytaniu błędu na 300 linii.

Pliki rozwiązują ten problem.

Pliki pozwalają programowi zapisywać dane.

Potem program może odczytać te dane później.

To duży krok.

Programy stają się dużo bardziej użyteczne, kiedy potrafią pamiętać rzeczy.

Zadania.

Notatki.

Kontakty.

Ustawienia.

Raporty.

Logi.

Małe wspomnienia.

Bardzo użyteczne.

Bardzo Python.

Czego się nauczysz

W tej lekcji nauczysz się:

• dlaczego pliki są użyteczne;
• jak zapisywać tekst do pliku;
• jak czytać tekst z pliku;
• jak używać open();
• dlaczego with open() jest ważne;
• jak działają tryby plików;
• jak zapisywać wiele linii;
• jak czytać linia po linii;
• jak dopisywać dane do pliku;
• jak zapisać listę;
• jak wczytać listę z pliku;
• jak zbudować mały task manager, który pamięta zadania;
• typowych błędów początkujących przy plikach.

Pod koniec tej lekcji twoje programy nie będą już natychmiast wszystkiego zapominać.

Będą mogły zapisywać dane.

Czytać dane.

Dopisywać dane.

Ładować dane.

Bardzo potężne.

Bardzo praktyczne.

Bardzo “teraz ten program zaczyna być użyteczny”.

Dlaczego pliki są ważne

Zmienne żyją w pamięci.

Pliki żyją na dysku.

Zmienna jest tymczasowa:

name = "Anna"

Kiedy program się kończy, zmienna znika.

Plik może zostać po zakończeniu programu.

Na przykład:

notes.txt
tasks.txt
contacts.txt
report.txt

Twój program może zapisać dane do pliku.

Później program może otworzyć plik i odczytać dane.

To ważne dla wielu prawdziwych programów.

Przykłady:

Task manager zapisuje zadania.
Aplikacja notatek zapisuje notatki.
Kalkulator zapisuje historię.
Gra zapisuje postęp.
Strona internetowa zapisuje logi.
Skrypt zapisuje raport.

Bez plików twój program ma bardzo krótką pamięć.

Jak złota rybka z klawiaturą.

Urocze.

Niezbyt użyteczne.

Zapisywanie do pliku

Utwórz plik:

write_file.py

Napisz:

file = open("message.txt", "w")

file.write("Hello from Python!")

file.close()

Uruchom:

python write_file.py

albo:

python3 write_file.py

Python stworzy plik o nazwie:

message.txt

W środku pliku powinieneś zobaczyć:

Hello from Python!

Ta linia otwiera plik:

file = open("message.txt", "w")

Ta linia zapisuje tekst:

file.write("Hello from Python!")

Ta linia zamyka plik:

file.close()

Bardzo ważne:

Zawsze zamykaj pliki, jeśli otwierasz je ręcznie.

Ale Python ma lepszy sposób.

Bo Python zobaczył, że ludzie zapominają rzeczy, i powiedział:

Dobrze, pomogę.

Używanie with open()

Lepszym sposobem jest with open().

Przykład:

with open("message.txt", "w") as file:
    file.write("Hello from Python!")

To robi to samo.

Ale automatycznie zamyka plik.

Dużo lepiej.

Dużo bezpieczniej.

Dużo mniej “ups, zapomniałem close()”.

Utwórz plik:

write_file_with.py

Napisz:

with open("message.txt", "w") as file:
    file.write("Hello from Python with with open()!")

Uruchom.

Otwórz message.txt.

Powinieneś zobaczyć:

Hello from Python with with open()!

Od teraz używaj:

with open(...)

To jest zalecany styl.

Czystszy.

Bezpieczniejszy.

Bardziej profesjonalny.

Mniej powodów, żeby Python wzdychał.

Tryby plików

Kiedy otwierasz plik, wybierasz tryb.

Tryb mówi Pythonowi, co chcesz zrobić.

Najczęstsze tryby:

"r"  read, czyli czytanie
"w"  write, czyli pisanie
"a"  append, czyli dopisywanie

Przykład:

open("file.txt", "r")

oznacza:

Otwórz plik do czytania.

Przykład:

open("file.txt", "w")

oznacza:

Otwórz plik do pisania.

Przykład:

open("file.txt", "a")

oznacza:

Otwórz plik do dopisywania na końcu.

Ważne ostrzeżenie:

"w" nadpisuje plik.

Jeśli plik miał już zawartość, "w" ją zastępuje.

Bez litości.

Bez dramatu.

Po prostu znika.

Python w trybie "w" jest jak:

Nowy plik. Nowe życie. Stara zawartość? Do widzenia.

Uważaj.

Zapisywanie wielu linii

Możesz zapisywać wiele linii, używając \n.

Przykład:

with open("notes.txt", "w") as file:
    file.write("First line\n")
    file.write("Second line\n")
    file.write("Third line\n")

\n oznacza:

nowa linia

Po uruchomieniu programu notes.txt będzie zawierał:

First line
Second line
Third line

Bez \n wszystko zostaje w jednej linii.

Przykład:

file.write("First")
file.write("Second")

Wynik:

FirstSecond

Nieładnie.

Nieczytelnie.

Wszystko sklejone.

Używaj \n, kiedy chcesz nową linię.

Mały symbol.

Duża moc formatowania.

Odczytywanie pliku

Utwórz plik o nazwie:

message.txt

Wpisz do niego tekst:

Hello from a file!

Teraz utwórz plik Python:

read_file.py

Napisz:

with open("message.txt", "r") as file:
    content = file.read()

print(content)

Uruchom.

Output:

Hello from a file!

Ta linia otwiera plik do czytania:

with open("message.txt", "r") as file:

Ta linia czyta cały plik:

content = file.read()

Potem drukujemy zawartość:

print(content)

Bardzo proste.

Bardzo użyteczne.

Twój program właśnie odczytał dane z dysku.

Mały moment.

Duża moc.

Czytanie całego pliku czy linii

read() czyta cały plik.

Przykład:

with open("notes.txt", "r") as file:
    content = file.read()

To jest w porządku dla małych plików.

Ale czasem chcesz czytać linia po linii.

Przykład:

with open("notes.txt", "r") as file:
    for line in file:
        print(line)

Jeśli notes.txt zawiera:

First line
Second line
Third line

Output może wyglądać tak:

First line

Second line

Third line

Dlaczego są dodatkowe puste linie?

Bo każda linia już ma znak nowej linii na końcu.

A print() dodaje kolejną nową linię.

Bardzo hojnie.

Zbyt hojnie.

Możemy to poprawić przez .strip().

Używanie strip()

.strip() usuwa dodatkowe białe znaki z początku i końca stringa.

Usuwa też znaki nowej linii.

Przykład:

text = "Hello\n"
clean_text = text.strip()

print(clean_text)

Output:

Hello

Używaj tego podczas czytania linii:

with open("notes.txt", "r") as file:
    for line in file:
        print(line.strip())

Teraz output jest czystszy:

First line
Second line
Third line

.strip() jest bardzo użyteczne przy czytaniu plików.

Pliki często zawierają nowe linie.

Ludzie często nie chcą widzieć dziwnych odstępów.

Python daje .strip().

Małe narzędzie.

Duża ulga.

Dopisywanie do pliku

Tryb "w" nadpisuje plik.

Tryb "a" dopisuje na końcu.

Utwórz plik:

append_file.py

Napisz:

with open("notes.txt", "a") as file:
    file.write("New note\n")

Uruchom go kilka razy.

Za każdym razem Python dopisze:

New note

na końcu pliku.

To jest użyteczne dla:

logów
notatek
zadań
historii
raportów

Tryb append jest bezpieczniejszy, kiedy nie chcesz usuwać starej zawartości.

Pamiętaj:

"w" pisze od zera.
"a" dopisuje na końcu.

Bardzo ważne.

Bardzo przetrwanie plików.

Zapisywanie inputu użytkownika do pliku

Utwórz plik:

save_note.py

Napisz:

note = input("Write a note: ")

with open("notes.txt", "a") as file:
    file.write(note + "\n")

print("Note saved.")

Przykład:

Write a note: Study Python files

Program zapisuje notatkę do:

notes.txt

Jeśli uruchomisz go ponownie, doda kolejną notatkę.

To już jest użyteczne.

Malutki zapis notatek.

Nie fancy.

Nie cloud-based.

Bez abonamentu.

Po prostu plik.

Pięknie.

Czytanie zapisanych notatek

Utwórz plik:

show_notes.py

Napisz:

with open("notes.txt", "r") as file:
    for line in file:
        print(f"- {line.strip()}")

Jeśli notes.txt zawiera:

Study Python files
Drink coffee
Build something useful

Output:

- Study Python files
- Drink coffee
- Build something useful

Teraz masz dwa programy:

save_note.py
show_notes.py

Jeden zapisuje notatki.

Drugi czyta notatki.

Malutki system.

Bardzo skromny.

Bardzo użyteczny.

Początek software.

Z mniejszą ilością formularzy logowania.

Na razie.

FileNotFoundError

Jeśli spróbujesz czytać plik, który nie istnieje, Python da błąd.

Przykład:

with open("missing.txt", "r") as file:
    content = file.read()

Błąd:

FileNotFoundError

Dlaczego?

Bo "missing.txt" nie istnieje.

Python nie może czytać pliku, którego nie ma.

Bardzo logiczne.

Bardzo irytujące.

Jeden prosty sposób to najpierw stworzyć plik.

Inny sposób to obsłużyć błąd.

Obsługi błędów nauczymy się głębiej później.

Na razie pamiętaj:

Czytanie wymaga, żeby plik istniał.
Pisanie może stworzyć plik.
Append może stworzyć plik, jeśli go nie ma.

To ważne.

Bardzo praktyczne.

Bardzo “dlaczego mój skrypt się wywalił?” praktyczne.

Zapisywanie listy do pliku

Wyobraź sobie, że mamy listę:

tasks = ["Buy milk", "Study Python", "Clean desk"]

Możemy zapisać każdy element w osobnej linii.

Przykład:

tasks = ["Buy milk", "Study Python", "Clean desk"]

with open("tasks.txt", "w") as file:
    for task in tasks:
        file.write(task + "\n")

Plik tasks.txt będzie zawierał:

Buy milk
Study Python
Clean desk

To jest proste i użyteczne.

Każde zadanie staje się jedną linią.

Lista w Pythonie staje się liniami w pliku.

Bardzo jasno.

Bardzo przyjaźnie dla początkujących.

Bardzo praktycznie.

Ładowanie listy z pliku

Teraz możemy odczytać plik i odbudować listę.

Przykład:

tasks = []

with open("tasks.txt", "r") as file:
    for line in file:
        tasks.append(line.strip())

print(tasks)

Output:

['Buy milk', 'Study Python', 'Clean desk']

Co się dzieje?

Zaczynamy od pustej listy.
Otwieramy plik.
Czytamy każdą linię.
Usuwamy nową linię przez strip().
Dodajemy czysty tekst do listy.

Teraz plik znowu stał się listą Pythona.

To bardzo ważne.

Tak program może pamiętać dane między uruchomieniami.

Zapisz listę.

Zamknij program.

Otwórz program później.

Wczytaj listę.

Pamięć osiągnięta.

Małe zwycięstwo.

Budowanie funkcji pomocniczych

Znamy już funkcje.

Możemy więc zorganizować logikę plików w funkcje.

Przykład:

def save_tasks(tasks):
    with open("tasks.txt", "w") as file:
        for task in tasks:
            file.write(task + "\n")

I:

def load_tasks():
    tasks = []

    with open("tasks.txt", "r") as file:
        for line in file:
            tasks.append(line.strip())

    return tasks

Teraz główny program może używać:

tasks = load_tasks()
save_tasks(tasks)

To jest czystsze.

Funkcje i pliki dobrze ze sobą współpracują.

Funkcje organizują zachowanie.

Pliki przechowują dane.

Bardzo ładnie.

Energia prawdziwego software.

Prosta obsługa brakującego pliku

Jeśli plik nie istnieje, load_tasks() się wywali.

Możemy obsłużyć to przez try i except.

Bez paniki.

To tylko prosta wersja.

Przykład:

def load_tasks():
    tasks = []

    try:
        with open("tasks.txt", "r") as file:
            for line in file:
                tasks.append(line.strip())
    except FileNotFoundError:
        pass

    return tasks

Co się dzieje?

Spróbuj otworzyć tasks.txt.
Jeśli istnieje, wczytaj zadania.
Jeśli nie istnieje, zignoruj błąd.
Zwróć pustą listę.

To jest użyteczne.

Za pierwszym razem, kiedy uruchamiasz program, plik może jeszcze nie istnieć.

To normalne.

Program nie powinien eksplodować teatralnie.

To try i except utrzymuje go spokojnym.

Jak joga dla Pythona.

Przeważnie.

Mini program: zapis jednego zadania

Utwórz plik:

save_task.py

Napisz:

task = input("Task: ")

with open("tasks.txt", "a") as file:
    file.write(task + "\n")

print("Task saved.")

Uruchom.

Przykład:

Task: Study Python files

Uruchom ponownie.

Przykład:

Task: Build a small app

Teraz tasks.txt zawiera:

Study Python files
Build a small app

To już jest użyteczny mały skrypt.

Mały.

Prosty.

Ale pamięta.

A pamiętanie jest potężne.

Chyba że pamięta kompromitujące nazwy zmiennych.

Wtedy trochę mniej potężne.

Mini program: pokazywanie zadań

Utwórz plik:

show_tasks.py

Napisz:

try:
    with open("tasks.txt", "r") as file:
        print("Tasks:")

        for line in file:
            print(f"- {line.strip()}")
except FileNotFoundError:
    print("No tasks found.")

Jeśli plik istnieje, pokazuje zadania.

Jeśli plik nie istnieje, drukuje:

No tasks found.

To lepsze niż crash.

Crash jest edukacyjny.

Ale nie zawsze przyjazny.

Dobry program obsługuje proste problemy.

Brakujący plik to prosty problem.

Przeważnie.

Mini program: task manager z plikami

Teraz zbudujemy task manager, który pamięta zadania.

Utwórz plik:

task_manager_files.py

Napisz:

FILE_NAME = "tasks.txt"

def load_tasks():
    tasks = []

    try:
        with open(FILE_NAME, "r") as file:
            for line in file:
                tasks.append(line.strip())
    except FileNotFoundError:
        pass

    return tasks

def save_tasks(tasks):
    with open(FILE_NAME, "w") as file:
        for task in tasks:
            file.write(task + "\n")

def show_menu():
    print("----- Task Manager -----")
    print("1. Add task")
    print("2. Show tasks")
    print("q. Quit")

def add_task(tasks):
    task = input("Task: ")
    tasks.append(task)
    save_tasks(tasks)
    print("Task saved.")

def show_tasks(tasks):
    if len(tasks) == 0:
        print("No tasks yet.")
    else:
        print("Tasks:")

        for task in tasks:
            print(f"- {task}")

tasks = load_tasks()

while True:
    show_menu()

    choice = input("Choose an option: ").lower()

    if choice == "1":
        add_task(tasks)
    elif choice == "2":
        show_tasks(tasks)
    elif choice == "q":
        print("Goodbye.")
        break
    else:
        print("Unknown option.")

To prawdziwa poprawa.

Wcześniej task manager wszystko zapominał.

Teraz zapisuje zadania do pliku.

Kiedy program startuje, ładuje zadania z pliku.

Kiedy dodajesz zadanie, zapisuje listę ponownie.

To zachowanie prawdziwego programu.

Bardzo dobrze.

Bardzo praktycznie.

Bardzo “mój kod ma teraz pamięć”.

Jak działa task manager

Nazwa pliku jest zapisana tutaj:

FILE_NAME = "tasks.txt"

Ta funkcja ładuje zadania:

def load_tasks():

Ta funkcja zapisuje zadania:

def save_tasks(tasks):

Ta funkcja dodaje zadanie:

def add_task(tasks):

W środku add_task robimy:

tasks.append(task)
save_tasks(tasks)

To znaczy:

Dodaj zadanie do listy.
Zapisz zaktualizowaną listę do pliku.

Ważna idea:

Lista jest używana, gdy program działa.
Plik przechowuje dane między uruchomieniami programu.

To bardzo ważny schemat programowania.

Pamięć w RAM.

Przechowywanie na dysku.

Twój program używa teraz obu.

Bardzo poważnie.

Bardzo użytecznie.

Pisanie vs dopisywanie w task managerze

W save_tasks używamy "w":

with open(FILE_NAME, "w") as file:

Dlaczego nie "a"?

Bo chcemy zapisać całą aktualną listę.

Gdybyśmy użyli "a", zadania mogłyby się dublować przy każdym zapisie.

Przykład:

Buy milk
Study Python
Buy milk
Study Python

Niedobrze.

Dlatego przy zapisywaniu całego aktualnego stanu używaj "w".

Do dodawania jednej nowej linii bezpośrednio używaj "a".

Prosta zasada:

Używaj "w", kiedy zapisujesz cały aktualny stan.
Używaj "a", kiedy dodajesz jeden nowy element na końcu.

To bardzo ważne.

Mała litera trybu.

Duża różnica.

Typowy błąd: zapomnienie o zamknięciu pliku

Ręczny sposób:

file = open("notes.txt", "w")
file.write("Hello")

Tutaj brakuje:

file.close()

Lepiej:

with open("notes.txt", "w") as file:
    file.write("Hello")

Używaj with open().

To automatycznie zamyka plik.

To styl, którego powinieneś używać przez większość czasu.

Czysto.

Bezpiecznie.

Profesjonalnie.

Bez zapomnianych otwartych plików błąkających się jak zagubione kozy.

Typowy błąd: użycie w i usunięcie starych danych

To może być niebezpieczne:

with open("notes.txt", "w") as file:
    file.write("New note\n")

Jeśli notes.txt miał już zawartość, zostanie zastąpiona.

Zniknie.

Jeśli chcesz dodać do pliku, użyj "a":

with open("notes.txt", "a") as file:
    file.write("New note\n")

Pamiętaj:

"w" nadpisuje.
"a" dopisuje.

To jedna z najważniejszych lekcji o plikach.

Nie ucz się jej bolesnym sposobem.

Bolesny sposób jest bardzo skuteczny.

Ale bardzo bolesny.

Typowy błąd: zapomnienie nowej linii

Źle:

with open("tasks.txt", "a") as file:
    file.write("Buy milk")
    file.write("Study Python")

Wynik w pliku:

Buy milkStudy Python

Poprawnie:

with open("tasks.txt", "a") as file:
    file.write("Buy milk\n")
    file.write("Study Python\n")

Wynik w pliku:

Buy milk
Study Python

Używaj \n, kiedy każdy element powinien być w nowej linii.

Nowe linie są małe.

Ale bez nich tekst staje się makaronem.

Nie dobrym makaronem.

Bugowym makaronem.

Typowy błąd: czytanie brakującego pliku

Źle:

with open("tasks.txt", "r") as file:
    content = file.read()

To nie zadziała, jeśli tasks.txt nie istnieje.

Bezpieczniej:

try:
    with open("tasks.txt", "r") as file:
        content = file.read()
except FileNotFoundError:
    content = ""

Teraz program nie crashuje.

Używa pustej zawartości, jeśli plik nie istnieje.

To jest użyteczne, kiedy plik ma zostać stworzony później.

Wiele początkujących programów z plikami pada przy pierwszym uruchomieniu.

Dlaczego?

Bo plik jeszcze nie istnieje.

Klasyka.

Bardzo klasyka.

Typowy błąd: nieużywanie strip()

Kiedy czytasz linie, możesz dostać znaki nowej linii.

Przykład:

tasks = []

with open("tasks.txt", "r") as file:
    for line in file:
        tasks.append(line)

To może zapisać:

["Buy milk\n", "Study Python\n"]

Lepiej:

tasks.append(line.strip())

Teraz dostajesz:

["Buy milk", "Study Python"]

Używaj .strip(), kiedy chcesz czysty tekst.

Zwłaszcza przy czytaniu linia po linii.

Twój przyszły output będzie wyglądał lepiej.

I mniej jak nawiedzony.

Typowy błąd: zamieszanie ze ścieżką pliku

To:

with open("tasks.txt", "r") as file:

szuka tasks.txt w aktualnym katalogu roboczym.

To znaczy:

folder, z którego uruchamiasz komendę Python

Jeśli Python mówi, że pliku nie ma, może plik istnieje w innym folderze.

Przykład:

python scripts/task_manager.py

Aktualny katalog może nie być tym samym folderem, w którym jest skrypt.

To może mylić początkujących.

Bardzo normalne.

Na razie trzymaj plik Python i plik tekstowy w tym samym folderze.

Uruchamiaj komendę z tego folderu.

Prosto.

Mniej dramatu ścieżek.

Dramat ścieżek jest prawdziwy.

I czasem pikantny.

Praktyka

Utwórz plik:

practice_files.py

Napisz program, który:

• pyta użytkownika o imię;
• pyta użytkownika o miasto;
• zapisuje obie wartości do profile.txt;
• czyta profile.txt;
• wyświetla zapisany profil.

Przykładowe rozwiązanie:

name = input("Name: ")
city = input("City: ")

with open("profile.txt", "w") as file:
    file.write(name + "\n")
    file.write(city + "\n")

with open("profile.txt", "r") as file:
    lines = []

    for line in file:
        lines.append(line.strip())

print("----- Profile -----")
print(f"Name: {lines[0]}")
print(f"City: {lines[1]}")

Przykład:

Name: Anna
City: Rome

Output:

----- Profile -----
Name: Anna
City: Rome

Ten program zapisuje dane.

Potem czyta dane.

Potem używa wczytanych danych.

Bardzo ważny schemat.

Zapisz.

Wczytaj.

Użyj.

To jest obsługa plików w pigułce.

Małej pigułce.

Z Pythonem w środku.

Mini wyzwanie

Utwórz plik:

notes_app.py

Twój program powinien:

• używać pliku notes.txt;
• pokazywać menu;
• pozwalać użytkownikowi dodać notatkę;
• pozwalać użytkownikowi pokazać wszystkie notatki;
• pozwalać użytkownikowi wyjść;
• zachowywać notatki między uruchomieniami programu.

Menu:

1. Add note
2. Show notes
q. Quit

Przykładowe rozwiązanie:

FILE_NAME = "notes.txt"

def show_menu():
    print("----- Notes App -----")
    print("1. Add note")
    print("2. Show notes")
    print("q. Quit")

def add_note():
    note = input("Note: ")

    with open(FILE_NAME, "a") as file:
        file.write(note + "\n")

    print("Note saved.")

def show_notes():
    try:
        with open(FILE_NAME, "r") as file:
            print("Notes:")

            has_notes = False

            for line in file:
                print(f"- {line.strip()}")
                has_notes = True

            if not has_notes:
                print("No notes yet.")
    except FileNotFoundError:
        print("No notes yet.")

while True:
    show_menu()

    choice = input("Choose an option: ").lower()

    if choice == "1":
        add_note()
    elif choice == "2":
        show_notes()
    elif choice == "q":
        print("Goodbye.")
        break
    else:
        print("Unknown option.")

To prawdziwa mini aplikacja.

Używa:

• plików;
• funkcji;
• pętli;
• warunków;
• inputu użytkownika;
• trybu append;
• czytania linia po linii;
• obsługi błędu brakującego pliku.

Bardzo mocne.

Bardzo użyteczne.

Projekt dla początkujących, ale już realny.

Mała aplikacja notatek, która pamięta notatki.

Wcale nieźle.

Extra challenge: zapisywanie kontaktów

Utwórz plik:

contacts_file.py

Zbuduj program, który:

• pozwala użytkownikowi dodawać kontakty;
• zapisuje kontakty do contacts.txt;
• pokazuje wszystkie kontakty;
• każdy kontakt ma imię, email i telefon.

Prosty format pliku:

Anna,anna@example.com,123456
Marco,marco@example.com,987654

Przykładowy pomysł:

FILE_NAME = "contacts.txt"

def add_contact():
    name = input("Name: ")
    email = input("Email: ")
    phone = input("Phone: ")

    with open(FILE_NAME, "a") as file:
        file.write(f"{name},{email},{phone}\n")

    print("Contact saved.")

def show_contacts():
    try:
        with open(FILE_NAME, "r") as file:
            print("Contacts:")

            for line in file:
                parts = line.strip().split(",")

                if len(parts) == 3:
                    name = parts[0]
                    email = parts[1]
                    phone = parts[2]

                    print("-----")
                    print(f"Name: {name}")
                    print(f"Email: {email}")
                    print(f"Phone: {phone}")
    except FileNotFoundError:
        print("No contacts yet.")

while True:
    print("----- Contact Book -----")
    print("1. Add contact")
    print("2. Show contacts")
    print("q. Quit")

    choice = input("Choose an option: ").lower()

    if choice == "1":
        add_contact()
    elif choice == "2":
        show_contacts()
    elif choice == "q":
        print("Goodbye.")
        break
    else:
        print("Unknown option.")

Ten program zapisuje dane strukturalne w prostym formacie tekstowym.

Ważne:

line.strip().split(",")

To bierze linię taką jak:

Anna,anna@example.com,123456

i zamienia ją na:

["Anna", "anna@example.com", "123456"]

To bardzo użyteczny pomysł.

Później możesz nauczyć się lepszych formatów, takich jak JSON.

Ale na razie proste pliki tekstowe wystarczą.

Jeden krok naraz.

Nie trzeba jeszcze przywoływać smoka JSON.

Checklist dla początkujących

Kiedy kod z plikami nie działa, sprawdź:

Czy użyłem with open()?
Czy wybrałem poprawny tryb?
Czy przypadkiem użyłem "w" zamiast "a"?
Czy dodałem "\n" dla nowych linii?
Czy plik istnieje przed czytaniem?
Czy powinienem obsłużyć FileNotFoundError?
Czy użyłem strip() podczas czytania linii?
Czy uruchamiam Pythona z właściwego folderu?
Czy dobrze napisałem nazwę pliku?
Czy zapisałem plik po napisaniu kodu?

Błędy z plikami często są proste.

Ale irytujące.

Szczególnie problemy ze ścieżkami.

Jeśli Python mówi:

FileNotFoundError

nie panikuj.

Sprawdź:

nazwę pliku
folder
tryb
aktualny katalog

Najczęściej plik po prostu nie jest tam, gdzie Python go szuka.

Python jest surowy.

Nie przeszukuje całego komputera emocjonalnie.

Szuka tam, gdzie mu powiedziałeś.

Bardzo dosłownie.

Bardzo Python.

Podsumowanie

Dzisiaj nauczyłeś się:

• zmienne są tymczasowe;
• pliki mogą przechowywać dane po zakończeniu programu;
• open() otwiera pliki;
• with open() automatycznie zamyka pliki;
• "r" oznacza czytanie;
• "w" oznacza pisanie i nadpisywanie;
• "a" oznacza dopisywanie;
• write() zapisuje tekst do pliku;
• read() czyta cały plik;
• pętle mogą czytać pliki linia po linii;
• \n tworzy nową linię;
• .strip() usuwa dodatkowe białe znaki i nowe linie;
• FileNotFoundError pojawia się przy czytaniu brakującego pliku;
• listy można zapisywać linia po linii;
• listy można ładować z plików;
• funkcje mogą organizować logikę plików;
• task manager może pamiętać zadania dzięki plikowi.

To ogromny krok.

Twoje programy mogą teraz pamiętać rzeczy.

Mogą zapisywać dane.

Mogą ładować dane.

Mogą stać się bardziej użyteczne.

Tutaj małe skrypty zaczynają przypominać prawdziwe aplikacje.

Program z pamięcią jest dużo potężniejszy niż program, który wszystko zapomina.

Nawet jeśli ta pamięć to tylko mały tasks.txt.

Mały plik.

Duży upgrade.

Następna lekcja

W następnej lekcji nauczymy się podstawowej obsługi błędów.

Twoje programy nauczą się przetrwać problemy bardziej elegancko.

Na przykład:

użytkownik wpisuje tekst zamiast liczby
plik nie istnieje
dzielenie przez zero
zła opcja menu
brakujące dane

Zamiast crashować teatralnie, program będzie mógł odpowiedzieć spokojnie.

Bardzo użyteczne.

Bardzo dorosłe.

Bardzo Python.

Bo prawdziwi użytkownicy robią dziwne rzeczy.

A czasem prawdziwym użytkownikiem jesteś ty.

Szczególnie w nocy.