Skip to content
The Chat Archive
o1-preview-2024-09-12· OpenAI WildChat-4.8M (AI2)

programmiere mir bitte eine anwendung die auf einer website und ihren unterseiten die 20…

  1. User

    programmiere mir bitte eine anwendung die auf einer website und ihren unterseiten die 20 am häufigsten vorkommende Wörter rausgibt. programmiere mir bitte ein interface dazu wo man den link der seite einfügen kann und dann auf einen button "Checken" klickt um die suche aus zuführen. dann sollen einem die 20 häufigst genannten wörter in einer box angezeigt werden. unter der box kann man auf "Speichern" klicken und die 20 wörter in einer textdatei speichern ( auswählen wohin). Es sollen nur nomen, Verben und adjektive gezählt werden und auch so websites wie https://www.rubikon.news/ sollen funktionieren.

  2. Assistant

    Natürlich! Ich kann Ihnen ein Python-Programm erstellen, das die gewünschten Funktionen erfüllt. Das Programm wird eine grafische Benutzeroberfläche (GUI) mit tkinter bereitstellen, in der Sie einen Link eingeben, auf "Checken" klicken und die 20 häufigsten Nomen, Verben und Adjektive anzeigen können. Außerdem gibt es eine "Speichern"-Schaltfläche, um die Wörter in einer Textdatei zu speichern.

    Hier ist der vollständige Code:

    import tkinter as tk
    from tkinter import messagebox, filedialog
    import requests
    from bs4 import BeautifulSoup, SoupStrainer
    from urllib.parse import urljoin, urlparse
    from collections import Counter
    import threading
    import nltk
    from nltk.corpus import stopwords
    from nltk import pos_tag, word_tokenize
    
    # Stellen Sie sicher, dass die erforderlichen NLTK-Resourcen heruntergeladen sind
    nltk.download('punkt')
    nltk.download('averaged_perceptron_tagger')
    nltk.download('universal_tagset')
    nltk.download('stopwords')
    
    # Sprachspezifische Stopwörter einstellen
    stop_words = set(stopwords.words('german'))
    
    class WordFrequencyApp:
        def __init__(self, master):
            self.master = master
            master.title("Wortfrequenz-Analyse")
    
            self.label = tk.Label(master, text="Geben Sie die Website-URL ein:")
            self.label.pack()
    
            self.url_entry = tk.Entry(master, width=50)
            self.url_entry.pack()
    
            self.check_button = tk.Button(master, text="Checken", command=self.start_analysis)
            self.check_button.pack()
    
            self.result_text = tk.Text(master, height=15, width=50)
            self.result_text.pack()
    
            self.save_button = tk.Button(master, text="Speichern", command=self.save_results)
            self.save_button.pack()
    
        def start_analysis(self):
            url = self.url_entry.get()
            if not url:
                messagebox.showwarning("Warnung", "Bitte geben Sie eine gültige URL ein.")
                return
    
            # Threading verwenden, um GUI nicht einfrieren zu lassen
            threading.Thread(target=self.analyze_website, args=(url,)).start()
    
        def analyze_website(self, base_url):
            self.check_button.config(state=tk.DISABLED)
            self.result_text.delete(1.0, tk.END)
            try:
                visited = set()
                words = []
    
                def crawl(url):
                    if url in visited or urlparse(url).netloc != urlparse(base_url).netloc:
                        return
                    visited.add(url)
                    try:
                        response = requests.get(url)
                        response.raise_for_status()
                    except requests.RequestException:
                        return
                    only_tags = SoupStrainer(['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6'])
                    soup = BeautifulSoup(response.content, 'html.parser', parse_only=only_tags)
                    text = soup.get_text()
                    tokens = word_tokenize(text, language='german')
                    tokens = [word.lower() for word in tokens if word.isalpha() and word.lower() not in stop_words]
                    tagged = pos_tag(tokens, lang='ger', tagset='universal')
    
                    for word, tag in tagged:
                        if tag in {'NOUN', 'VERB', 'ADJ'}:
                            words.append(word)
    
                    # Links zu weiteren Seiten sammeln
                    for link in soup.find_all('a', href=True):
                        full_url = urljoin(url, link['href'])
                        crawl(full_url)
    
                crawl(base_url)
    
                word_counts = Counter(words)
                most_common = word_counts.most_common(20)
                result = "\n".join([f"{word}: {count}" for word, count in most_common])
                self.result_text.insert(tk.END, result)
            except Exception as e:
                messagebox.showerror("Fehler", f"Es ist ein Fehler aufgetreten: {e}")
            finally:
                self.check_button.config(state=tk.NORMAL)
    
        def save_results(self):
            content = self.result_text.get(1.0, tk.END).strip()
            if not content:
                messagebox.showwarning("Warnung", "Es gibt keine Ergebnisse zum Speichern.")
                return
            file_path = filedialog.asksaveasfilename(defaultextension=".txt",
                                                     filetypes=[("Textdatei", "*.txt"), ("Alle Dateien", "*.*")])
            if file_path:
                with open(file_path, 'w', encoding='utf-8') as f:
                    f.write(content)
                messagebox.showinfo("Gespeichert", f"Die Ergebnisse wurden in {file_path} gespeichert.")
    
    if __name__ == "__main__":
        root = tk.Tk()
        app = WordFrequencyApp(root)
        root.mainloop()
    

    Anforderungen

    Bevor Sie das Programm ausführen, stellen Sie sicher, dass Sie die folgenden Python-Pakete installiert haben:

    • requests
    • beautifulsoup4
    • nltk

    Sie können diese Pakete mit pip installieren:

    pip install requests beautifulsoup4 nltk
    

    Außerdem müssen die NLTK-Resourcen für Deutsch heruntergeladen werden. Das wird durch die nltk.download()-Aufrufe im Code sichergestellt.

    Funktionserklärung

    • GUI mit tkinter: Das Programm verwendet die tkinter-Bibliothek, um eine einfache grafische Benutzeroberfläche bereitzustellen.

    • URL-Eingabe: Der Benutzer kann eine URL in ein Eingabefeld eingeben.

    • "Checken"-Schaltfläche: Startet die Analyse des eingegebenen Links und seiner Unterseiten.

    • Webseiten-Crawling: Die Funktion crawl() besucht die angegebene Seite und alle Unterseiten innerhalb derselben Domain, um den Textinhalt zu sammeln.

    • Textverarbeitung:

      • Verwendet BeautifulSoup, um Text aus den relevanten HTML-Tags (<p>, <h1>, etc.) zu extrahieren.
      • Tokenisiert den Text und filtert nach Wörtern, die nur aus Buchstaben bestehen und keine Stopwörter sind.
      • Verwendet NLTK's pos_tag() mit dem universellen Tagset, um die Wortarten zu bestimmen.
      • Zählt nur Nomen (NOUN), Verben (VERB) und Adjektive (ADJ).
    • Häufigkeitszählung: Die Wörter werden mit collections.Counter gezählt, und die 20 häufigsten werden ermittelt.

    • Ergebnisse anzeigen: Die Ergebnisse werden in einem Textfeld angezeigt.

    • "Speichern"-Schaltfläche: Ermöglicht dem Benutzer, die Ergebnisse in einer Textdatei an einem gewünschten Ort zu speichern.

    Hinweise

    • Threading: Das Programm verwendet einen separaten Thread für die Analyse, um zu verhindern, dass die GUI während des Crawling einfriert.

    • Domain-Einschränkung: Das Crawling beschränkt sich auf die eingegebene Domain, um zu verhindern, dass es externe Seiten besucht.

    • Fehlerbehandlung: Das Programm fängt mögliche Ausnahmen ab und zeigt Fehlermeldungen an, falls etwas schiefgeht.

    Beispielverwendung

    1. Programm starten: Führen Sie das Skript aus (python scriptname.py).

    2. URL eingeben: Geben Sie z.B. https://www.rubikon.news/ in das Eingabefeld ein.

    3. Analyse starten: Klicken Sie auf die Schaltfläche "Checken".

    4. Ergebnisse ansehen: Nach Abschluss der Analyse werden die 20 häufigsten Wörter angezeigt.

    5. Ergebnisse speichern: Klicken Sie auf "Speichern", um die Ergebnisse in einer Textdatei zu speichern.

    Wichtiger Hinweis

    Bitte beachten Sie, dass das Crawlen von Websites den Nutzungsbedingungen der Website unterliegen kann. Stellen Sie sicher, dass Sie die Berechtigung haben, die Seiten zu crawlen, oder dass es zumindest nicht gegen die Nutzungsbedingungen verstößt. Einige Websites könnten Maßnahmen gegen automatisiertes Crawling haben.


    Ich hoffe, dieses Programm erfüllt Ihre Anforderungen!