Stwórz Kosmiczny Monitor Zdrowia w Pythonie

Zapnij pasy, przyszły kosmiczny programisto! Dziś zbudujemy Kosmiczny Monitor Zdrowia - program w Pythonie, który zarządza danymi medycznymi astronautów na stacji kosmicznej. Do końca tej misji stworzysz w pełni funkcjonalny program z interfejsem graficznym, idealny do utrzymania naszych kosmicznych odkrywców w świetnej formie!

Uwaga: Pełny kod tego projektu znajdziesz w zakładce "Kod artykułu" powyżej treści tego artykułu. Możesz zerknąć do przodu, jeśli jesteś ciekaw, ale zalecamy podążanie krok po kroku, aby uzyskać najlepsze wyniki w nauce!

1. Przygotowanie naszego środowiska Python

Zanim wystartujemy, upewnijmy się, że mamy niezbędne oprogramowanie. Do tej misji będziemy potrzebować:

• Python 3.x zainstalowany na twoim komputerze
• SQLite (wbudowany w Pythona)
• Tkinter (zazwyczaj dołączony do Pythona, ale może być konieczna osobna instalacja)
• Utwórz nowy plik Pythona o nazwie cosmic_health_tracker.py. To będzie nasze centrum kontroli misji!

2. Projektowanie naszej bazy danych astronautów

Każda dobra misja kosmiczna potrzebuje solidnych fundamentów. W naszym przypadku to nasza baza danych. Użyjemy SQLite do utworzenia dwóch tabel:

1. astronauts: Do przechowywania danych osobowych
2. medical_records: Do śledzenia badań lekarskich

Napiszmy trochę kodu w Pythonie, aby skonfigurować naszą bazę danych i główną klasę, a następnie utworzyć instancję tej klasy:

import sqlite3

class CosmicHealthTracker:

    def __init__(self):

        #najpierw utworzmy bazę danych
        self.create_database()
        
    def create_database(self):
        conn = sqlite3.connect('space_station.db')
        cursor = conn.cursor()

        cursor.execute('''
        CREATE TABLE IF NOT EXISTS astronauts (
            id INTEGER PRIMARY KEY,
            name TEXT NOT NULL,
            age INTEGER,
            nationality TEXT
        )
        ''')

        cursor.execute('''
        CREATE TABLE IF NOT EXISTS medical_records (
            id INTEGER PRIMARY KEY,
            astronaut_id INTEGER,
            check_up_date TEXT,
            heart_rate INTEGER,
            blood_pressure TEXT,
            weight REAL,
            FOREIGN KEY (astronaut_id) REFERENCES astronauts (id)
        )
        ''')

        conn.commit()
        conn.close()
        
# Tworzymy instancję klasy
if __name__ == "__main__":
    CosmicHealthTracker() 

Ten kod tworzy naszą bazę danych i tabele, jeśli jeszcze nie istnieją. To jak budowanie kwater mieszkalnych i ambulatorium naszej stacji kosmicznej!

3. Uruchamianie graficznego interfejsu użytkownika

Teraz, gdy mamy naszą bazę danych, stwórzmy przyjazny dla użytkownika interfejs dla naszych kosmicznych oficerów medycznych. Użyjemy Tkintera, standardowej biblioteki GUI Pythona, do tworzenia okien, przycisków i pól wprowadzania.

# zmieniamy naszą sekcję importów
import sqlite3
import tkinter as tk
from tkinter import ttk

Nasz CosmicHealthTracker teraz potrzebuje master w swojej sekcji init i trochę konfiguracji GUI Tkinter z podstawowymi funkcjami, które zaimplementujemy później. Pass pozwala tworzyć puste funkcje, więc możesz uruchomić swój kod bez implementowania ich w tym momencie.

import sqlite3
import tkinter as tk
from tkinter import ttk

class CosmicHealthTracker:
    def __init__(self, master):
        self.master = master
        master.title("Kosmiczny Monitor Zdrowia") #tytuł dla naszego okna
        master.geometry("600x400") # rozmiar naszego Monitora Zdrowia

        self.notebook = ttk.Notebook(master)
        self.notebook.pack(expand=True, fill='both')

        self.astronaut_frame = ttk.Frame(self.notebook)
        self.medical_frame = ttk.Frame(self.notebook)

        self.notebook.add(self.astronaut_frame, text='Informacje o astronaucie')
        self.notebook.add(self.medical_frame, text='Karty medyczne')

        self.create_database()        
        self.load_astronauts()        
        self.setup_astronaut_tab()
        self.setup_medical_tab()        

    def create_database(self):
        # Funkcja już gotowa, więc po prostu skopiuj ją tutaj

    def setup_astronaut_tab(self):
        pass # Tutaj dodamy pola informacji o astronaucie    

    def load_astronauts(self):        
        pass # Tutaj przeładujemy listę astronautów

    def view_astronauts(self):
        pass # Tutaj wyświetlimy listę astronautów

    def setup_medical_tab(self):
        pass # Tutaj dodamy pola kart medycznych

    def view_medical_records(self):
        pass # Tutaj wyświetlimy listę kart medycznych

root = tk.Tk()
app = CosmicHealthTracker(root)
root.mainloop()

Ten kod konfiguruje podstawową strukturę naszego GUI. To jak projektowanie paneli kontrolnych naszej stacji kosmicznej!

4. Dane osobowe astronauty

Dodajmy kilka pól do wprowadzania informacji o astronautach. Implementujemy setup_astronaut_tab i add_astronaut:

    def setup_astronaut_tab(self):
        #nasze pole imienia
        ttk.Label(self.astronaut_frame, text="Imię:").grid(row=0, column=0, padx=5, pady=5)
        self.name_entry = ttk.Entry(self.astronaut_frame)
        self.name_entry.grid(row=0, column=1, padx=5, pady=5)

        #nasze pole wieku
        ttk.Label(self.astronaut_frame, text="Wiek:").grid(row=1, column=0, padx=5, pady=5)
        self.age_entry = ttk.Entry(self.astronaut_frame)
        self.age_entry.grid(row=1, column=1, padx=5, pady=5)

        #nasze pole narodowości
        ttk.Label(self.astronaut_frame, text="Narodowość:").grid(row=2, column=0, padx=5, pady=5)
        self.nationality_entry = ttk.Entry(self.astronaut_frame)
        self.nationality_entry.grid(row=2, column=1, padx=5, pady=5)

        # przycisk do dodawania danych z pól
        ttk.Button(self.astronaut_frame, text="Dodaj astronautę", command=self.add_astronaut).grid(row=3, column=0, columnspan=2, pady=10)

    def add_astronaut(self):
        name = self.name_entry.get()
        age = self.age_entry.get()
        nationality = self.nationality_entry.get()

        conn = sqlite3.connect('space_station.db')
        cursor = conn.cursor()
        cursor.execute("INSERT INTO astronauts (name, age, nationality) VALUES (?, ?, ?)", (name, age, nationality))
        conn.commit()
        conn.close()

        # Wyczyść pola wprowadzania
        self.name_entry.delete(0, tk.END)
        self.age_entry.delete(0, tk.END)
        self.nationality_entry.delete(0, tk.END)    
        self.load_astronauts()  # Przeładuj astronautów po dodaniu nowego

Ten kod pozwala nam wprowadzać i zapisywać informacje o astronautach. To jak rejestrowanie nowych członków załogi na naszą misję kosmiczną!

5. Badania lekarskie

Teraz dodajmy pola do badań lekarskich. Musimy:

• wyświetlić formularz używając setup_medical_tab z listą astronautów (load_astronauts),
• i zaimplementować funkcję dodawania danych add_medical_record.
• Na razie musimy też zaimplementować pustą funkcję view_medical_records.
• W naszej sekcji importów dodajemy from tkinter import messagebox. Pozwoli to na wyświetlanie komunikatów o naszych sukcesach i błędach.

import sqlite3
import tkinter as tk
from tkinter import ttk
from tkinter import messagebox #nowy import

Nasze nowe funkcje:

    def load_astronauts(self):
        conn = sqlite3.connect('space_station.db')
        cursor = conn.cursor()
        cursor.execute("SELECT id, name FROM astronauts")
        self.astronauts = cursor.fetchall()
        conn.close()
        
    def setup_medical_tab(self):
        ttk.Label(self.medical_frame, text="Astronauta:").grid(row=0, column=0, padx=5, pady=5)
        self.astronaut_var = tk.StringVar()
        self.astronaut_dropdown = ttk.Combobox(self.medical_frame, textvariable=self.astronaut_var)
        self.astronaut_dropdown.grid(row=0, column=1, padx=5, pady=5)
        self.astronaut_dropdown['values'] = [f"{id} - {name}" for id, name in self.astronauts]

        ttk.Label(self.medical_frame, text="Data badania:").grid(row=1, column=0, padx=5, pady=5)
        self.date_entry = ttk.Entry(self.medical_frame)
        self.date_entry.grid(row=1, column=1, padx=5, pady=5)

        ttk.Label(self.medical_frame, text="Tętno:").grid(row=2, column=0, padx=5, pady=5)
        self.heart_rate_entry = ttk.Entry(self.medical_frame)
        self.heart_rate_entry.grid(row=2, column=1, padx=5, pady=5)

        ttk.Label(self.medical_frame, text="Ciśnienie krwi:").grid(row=3, column=0, padx=5, pady=5)
        self.blood_pressure_entry = ttk.Entry(self.medical_frame)
        self.blood_pressure_entry.grid(row=3, column=1, padx=5, pady=5)

        ttk.Label(self.medical_frame, text="Waga:").grid(row=4, column=0, padx=5, pady=5)
        self.weight_entry = ttk.Entry(self.medical_frame)
        self.weight_entry.grid(row=4, column=1, padx=5, pady=5)

        ttk.Button(self.medical_frame, text="Dodaj kartę medyczną", command=self.add_medical_record).grid(row=5, column=0, columnspan=2, pady=10)

    def add_medical_record(self):
    
        astronaut = self.astronaut_var.get().split(' - ')
        if len(astronaut) != 2:
            messagebox.showerror("Błąd", "Proszę wybrać astronautę!")
            return
        astronaut_id = astronaut[0]
        date = self.date_entry.get()
        heart_rate = self.heart_rate_entry.get()
        blood_pressure = self.blood_pressure_entry.get()
        weight = self.weight_entry.get()

        if not astronaut_id or not date or not heart_rate or not blood_pressure or not weight:
            messagebox.showerror("Błąd", "Wszystkie pola są wymagane!")
            return

        try:
            astronaut_id = int(astronaut_id)
            heart_rate = int(heart_rate)
            weight = float(weight)
        except ValueError:
            messagebox.showerror("Błąd", "Nieprawidłowe typy danych!")
            return

        conn = sqlite3.connect('space_station.db')
        cursor = conn.cursor()
        cursor.execute("INSERT INTO medical_records (astronaut_id, check_up_date, heart_rate, blood_pressure, weight) VALUES (?, ?, ?, ?, ?)",
                       (astronaut_id, date, heart_rate, blood_pressure, weight))
        conn.commit()
        conn.close()

        messagebox.showinfo("Sukces", "Karta medyczna została dodana pomyślnie!")

        self.date_entry.delete(0, tk.END)
        self.heart_rate_entry.delete(0, tk.END)
        self.blood_pressure_entry.delete(0, tk.END)
        self.weight_entry.delete(0, tk.END)

    def view_medical_records(self):
        pass

Ten kod pozwala nam wprowadzać i zapisywać karty medyczne. To jak przeprowadzanie badań lekarskich w ambulatorium naszej stacji kosmicznej!

6. Wyświetlanie i Aktualizacja Rekordów

Aby ukończyć nasz Kosmiczny Monitor Zdrowia, dodajmy sposób na wyświetlanie i aktualizację rekordów:

    def setup_astronaut_tab(self):
    # ... (poprzedni kod pozostaje bez zmian)
        # Potrzebujemy przycisku do przełączania na listę astronautów
        ttk.Button(self.astronaut_frame, text="Zobacz Astronautów", command=self.view_astronauts).grid(row=4, column=0, columnspan=2, pady=10)

    def view_astronauts(self):
        conn = sqlite3.connect('space_station.db')
        cursor = conn.cursor()
        cursor.execute("SELECT * FROM astronauts")
        astronauts = cursor.fetchall()
        conn.close()

        # Utwórz nowe okno do wyświetlania astronautów
        astronaut_window = tk.Toplevel(self.master)
        astronaut_window.title("Rekordy Astronautów")

        for i, astronaut in enumerate(astronauts):
            ttk.Label(astronaut_window, text=f"ID: {astronaut[0]}, Imię: {astronaut[1]}, Wiek: {astronaut[2]}, Narodowość: {astronaut[3]}").grid(row=i, column=0, padx=5, pady=5)

    def setup_medical_tab(self):
         # ... (poprzedni kod pozostaje bez zmian)
         # Potrzebujemy przycisku do przełączania na listę danych medycznych
         ttk.Button(self.medical_frame, text="Zobacz Dane Medyczne", command=self.view_medical_records).grid(row=6, column=0, columnspan=2, pady=10)

    def view_medical_records(self):
        conn = sqlite3.connect('space_station.db')
        cursor = conn.cursor()
        cursor.execute("""
            SELECT m.id, m.astronaut_id, a.name, m.check_up_date, m.heart_rate, m.blood_pressure, m.weight 
            FROM medical_records m
            JOIN astronauts a ON m.astronaut_id = a.id
        """)
        records = cursor.fetchall()
        conn.close()

        medical_window = tk.Toplevel(self.master)
        medical_window.title("Rekordy Medyczne")

        for i, record in enumerate(records):
            ttk.Label(medical_window, text=f"ID: {record[0]}, Astronauta ID: {record[1]}, Imię: {record[2]}, Data: {record[3]}, Tętno: {record[4]}, Ciśnienie: {record[5]}, Waga: {record[6]}").grid(row=i, column=0, padx=5, pady=5)

Te dodatki umożliwiają nam przeglądanie przechowywanych danych. To jak dostęp do centralnej bazy danych stacji kosmicznej!

7. Obsługa Błędów

Aby nasz program był bardziej odporny, dodajmy podstawową obsługę błędów. Zmienimy funkcje add_astronaut i add_medical_record:

def add_astronaut(self):
    
    # dodaj po linii z nationality:
    if not name or not age or not nationality:
        messagebox.showerror("Błąd", "Wszystkie pola są wymagane!")
        return

    try:
        age = int(age)

    except ValueError:
        messagebox.showerror("Błąd", "Wiek musi być liczbą!")
        return
        # ... (reszta funkcji pozostaje bez zmian)

def add_medical_record(self):

    # dodaj po linii z weight:
    if not astronaut_id or not date or not heart_rate or not blood_pressure or not weight:
        messagebox.showerror("Błąd", "Wszystkie pola są wymagane!")
        return

    try:
        astronaut_id = int(astronaut_id)
        heart_rate = int(heart_rate)
        weight = float(weight)

    except ValueError:
        messagebox.showerror("Błąd", "Nieprawidłowe typy danych!")
        return
        # ... (reszta funkcji pozostaje bez zmian)

Ta obsługa błędów to jak protokoły bezpieczeństwa naszej stacji kosmicznej, zapobiegające awariom systemu i uszkodzeniom danych!

8. Misja zakończona: Nasz kompletny monitor zdrowia astronautów

Gratulacje, kosmiczny programisto! Pomyślnie zbudowałeś Kosmiczny Monitor Zdrowia do zarządzania danymi medycznymi astronautów. Ten program pozwala ci:

• Dodawać nowych astronautów do bazy danych
• Rejestrować wyniki badań lekarskich
• Przeglądać przechowywane dane astronautów i medyczne
• Obsługiwać potencjalne błędy, aby utrzymać system w sprawnym działaniu

Jeśli czujesz się pewnie w swoich kosmicznych umiejętnościach kodowania w Pythonie, możesz zmodyfikować nasz kod i dodać inne niezbędne funkcje, takie jak:

• edycja danych astronautów,
• edycja rekordów medycznych
• i ich usuwanie.

Pamiętaj, że pełny kod tego projektu znajdziesz w zakładce "Kod do artykułu". Śmiało eksperymentuj z nim i dodawaj własne funkcje. Może mógłbyś dodać wizualizację danych do śledzenia zdrowia astronauty w czasie lub zaimplementować funkcję generowania raportów zdrowotnych załogi?

Umiejętności, których się nauczyłeś:

• zarządzanie bazą danych w Pythonie,
• tworzenie GUI w Pythonie,
• i obsługa błędów

- są kluczowe nie tylko dla oprogramowania stacji kosmicznej, ale dla wielu ziemskich aplikacji również. Kontynuuj eksplorację, kontynuuj kodowanie, i kto wie? Może pewnego dnia twój kod będzie działał na prawdziwej stacji kosmicznej!

Udanego kodowania, kosmiczny odkrywco!