Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-pro· GoogleHugging Face LMArena Human Preference 140K

napisz program w python który zamieni we wszystkich nagłówkach w pliku…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with grok-3-mini-high’s answer.
  1. User

    napisz program w python który zamieni we wszystkich nagłówkach w pliku template_zasilacz.docx słowa {urzadzenie} na TEST i zapisze w nowym pliku, tekst może być ukryty np w tabeli, więc ma przeszukać nagłówek na wszystkie możliwe sposoby

  2. Gemini Assistant

    Oczywiście. Poniżej znajduje się bardziej zaawansowany program, który przeszukuje nagłówki w sposób kompleksowy, uwzględniając tekst znajdujący się bezpośrednio w akapitach oraz tekst osadzony w tabelach wewnątrz nagłówka.

    Kluczowe ulepszenia w tej wersji:

    • Przeszukiwanie tabel: Program iteruje przez wszystkie tabele w każdym nagłówku, a następnie przez każdą komórkę w tabeli, aby znaleźć i zamienić tekst.
    • Modułowość: Logika zamiany tekstu została wydzielona do oddzielnych funkcji, co sprawia, że kod jest czystszy i łatwiejszy do zrozumienia.
    • Obsługa błędów: Dodano podstawową obsługę błędów, na wypadek gdyby plik wejściowy nie istniał.

    Przed uruchomieniem upewnij się, że masz zainstalowaną bibliotekę python-docx:

    pip install python-docx
    

    Kod programu

    from docx import Document
    from docx.document import Document as _Document
    from docx.oxml.text.paragraph import CT_P
    from docx.oxml.table import CT_Tbl
    from docx.table import _Cell, Table
    from docx.text.paragraph import Paragraph
    
    def zamien_tekst_w_akapicie(paragraph: Paragraph, stary_tekst: str, nowy_tekst: str):
        """
        Znajduje i zamienia tekst w danym akapicie, zachowując formatowanie.
        Działa dla prostych przypadków, gdzie tekst do zamiany jest w jednym 'run'.
        """
        for run in paragraph.runs:
            if stary_tekst in run.text:
                run.text = run.text.replace(stary_tekst, nowy_tekst)
    
    def iteruj_elementy_bloku(parent):
        """
        Generator, który przechodzi przez akapity i tabele w danym kontenerze
        (np. w ciele dokumentu, komórce tabeli lub nagłówku/stopce).
        """
        if isinstance(parent, _Document):
            parent_elm = parent.element.body
        elif isinstance(parent, _Cell):
            parent_elm = parent._tc
        else:
            raise ValueError("Nieobsługiwany typ rodzica")
    
        for child in parent_elm.iterchildren():
            if isinstance(child, CT_P):
                yield Paragraph(child, parent)
            elif isinstance(child, CT_Tbl):
                yield Table(child, parent)
    
    def kompleksowa_zamiana_w_naglowkach(plik_wejsciowy: str, plik_wyjsciowy: str, slownik_zamian: dict):
        """
        Otwiera dokument, przeszukuje nagłówki (w tym tabele) i zamienia tekst
        zgodnie z podanym słownikiem.
    
        Args:
            plik_wejsciowy (str): Ścieżka do pliku DOCX do przetworzenia.
            plik_wyjsciowy (str): Ścieżka do zapisu nowego pliku DOCX.
            slownik_zamian (dict): Słownik, gdzie klucze to tekst do znalezienia,
                                    a wartości to tekst do wstawienia.
        """
        try:
            doc = Document(plik_wejsciowy)
            print(f"Otwarto plik: {plik_wejsciowy}")
    
            # Iteracja przez wszystkie sekcje w dokumencie
            for section in doc.sections:
                header = section.header
                
                # 1. Przeszukiwanie akapitów bezpośrednio w nagłówku
                for paragraph in header.paragraphs:
                    for stary_tekst, nowy_tekst in slownik_zamian.items():
                        zamien_tekst_w_akapicie(paragraph, stary_tekst, nowy_tekst)
    
                # 2. Przeszukiwanie tabel w nagłówku
                for table in header.tables:
                    for row in table.rows:
                        for cell in row.cells:
                            # Każda komórka może zawierać wiele akapitów
                            for paragraph in cell.paragraphs:
                                for stary_tekst, nowy_tekst in slownik_zamian.items():
                                    zamien_tekst_w_akapicie(paragraph, stary_tekst, nowy_tekst)
    
            doc.save(plik_wyjsciowy)
            print(f"Dokument został pomyślnie przetworzony i zapisany jako: {plik_wyjsciowy}")
    
        except FileNotFoundError:
            print(f"BŁĄD: Nie można znaleźć pliku '{plik_wejsciowy}'. Upewnij się, że plik istnieje i ścieżka jest poprawna.")
        except Exception as e:
            print(f"Wystąpił nieoczekiwany błąd: {e}")
    
    # --- Główna część programu ---
    if __name__ == '__main__':
        # Konfiguracja
        plik_wejsciowy = 'template_zasilacz.docx'
        plik_wyjsciowy = 'wynikowy_zasilacz.docx'
        
        # Słownik z danymi do zamiany. Można go łatwo rozbudować.
        dane_do_zamiany = {
            '{urzadzenie}': 'TEST'
            # Możesz dodać więcej par klucz-wartość, np.
            # '{data}': '2023-10-27',
            # '{autor}': 'Jan Kowalski'
        }
    
        # Wywołanie funkcji
        kompleksowa_zamiana_w_naglowkach(plik_wejsciowy, plik_wyjsciowy, dane_do_zamiany)
    

    Jak używać programu:

    1. Zapisz kod: Zapisz powyższy kod w pliku o nazwie, na przykład, przetwarzacz_docx.py.
    2. Przygotuj plik: Upewnij się, że plik template_zasilacz.docx znajduje się w tym samym folderze co skrypt Pythona.
    3. Uruchom: Otwórz terminal lub wiersz poleceń, przejdź do folderu z plikami i uruchom skrypt:
      python przetwarzacz_docx.py
      
    4. Sprawdź wynik: Po pomyślnym wykonaniu programu w folderze pojawi się nowy plik o nazwie wynikowy_zasilacz.docx. Otwórz go i sprawdź, czy tekst w nagłówkach (również w tabelach) został poprawnie zamieniony.

    Uwagi dotyczące działania

    • Problem podzielonego tekstu (split run): W programach Word tekst może zostać wewnętrznie podzielony na kilka fragmentów (tzw. "runów"), nawet jeśli wygląda jak jedno słowo. Na przykład, jeśli część słowa {urzadzenie} będzie pogrubiona, Word zapisze to jako oddzielne "runy". Ten kod poradzi sobie z tym, o ile cały tekst {urzadzenie} znajduje się wewnątrz jednego "runa". Dla typowych szablonów jest to wystarczające. Rozwiązanie problemu "split run" jest znacznie bardziej złożone.
    • Rozszerzalność: Dzięki użyciu słownika dane_do_zamiany możesz łatwo dodać więcej pól do jednoczesnej zamiany bez modyfikowania logiki pętli.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.