Bygg ditt eget verktyg för kopieringskontroll och lär dig om Difflib-modulens kraftfulla funktioner.
I takt med att digitalt innehåll har ökat i popularitet har det blivit viktigare än någonsin att skydda det från kopiering och missbruk. Ett verktyg för att upptäcka plagiat kan hjälpa lärare att utvärdera elevernas arbete, institutioner kontrollera forskningsrapporter och författare att upptäcka stöld av deras immateriella rättigheter.
Att bygga ett plagiatverktyg kan hjälpa dig att förstå sekvensmatchning, filoperationer och användargränssnitt. Du kommer också att utforska naturliga språkbehandlingstekniker (NLP) för att förbättra din applikation.
Tkinter och Difflib-modulen
För att bygga en plagiatdetektor använder du Tkinter och Difflib-modulen. Tkinter är ett enkelt plattformsoberoende bibliotek som du kan använda för att skapa grafiska användargränssnitt snabbt.
Difflib-modulen är en del av Python-standardbiblioteket som tillhandahåller klasser och funktioner för att jämföra sekvenser som strängar, listor och filer. Med den kan du bygga program som en automatisk textkorrigerare, en förenklad
versionskontrollsystem, eller ett verktyg för textsammanfattning.Hur man bygger en plagiatdetektor med Python
Du kan hitta hela källkoden som bygger en plagiatdetektor med Python i detta GitHub-förråd.
Importera de nödvändiga modulerna. Definiera en metod, load_file_or_display_contents() som tar inträde och text_widget som argument. Denna metod kommer att ladda en textfil och visa dess innehåll i en textwidget.
Använd skaffa sig() metod för att extrahera filsökvägen. Om användaren inte har angett något, använd askopenfilename() metod för att öppna ett fildialogfönster för att välja önskad fil för plagiatkontroll. Om användaren väljer filsökvägen, rensa den tidigare posten, om någon, från början till slutet och infoga sökvägen de valde.
import tkinter as tk
from tkinter import filedialog
from difflib import SequenceMatcherdefload_file_or_display_contents(entry, text_widget):
file_path = entry.get()ifnot file_path:
file_path = filedialog.askopenfilename()
if file_path:
entry.delete(0, tk.END)
entry.insert(tk.END, file_path)
Öppna filen i läsläge och lagra innehållet i text variabel. Rensa innehållet i text_widgeten och infoga texten du extraherade tidigare.
with open(file_path, 'r') as file:
text = file.read()
text_widget.delete(1.0, tk.END)
text_widget.insert(tk.END, text)Definiera en metod, compare_text() som du kommer att använda för att jämföra två textstycken och beräkna deras likhetsprocent. Använd Difflib's SequenceMatcher() klass för att jämföra sekvenser och bestämma likhet. Ställ in den anpassade jämförelsefunktionen till Ingen för att använda standardjämförelsen och skicka texten som du vill jämföra.
Använd förhållandemetoden för att få likheten i ett flyttalsformat som du kan använda för att beräkna likhetsprocenten. Använd get_opcodes() metod för att hämta en uppsättning operationer som du kan använda för att markera liknande delar av text och returnera den tillsammans med likhetsprocenten.
defcompare_text(text1, text2):
d = SequenceMatcher(None, text1, text2)
similarity_ratio = d.ratio()
similarity_percentage = int(similarity_ratio * 100)
diff = list(d.get_opcodes())
return similarity_percentage, diff
Definiera en metod, show_similarity(). Använd skaffa sig() metod för att extrahera texten från båda textrutorna och skicka dem till compare_text() fungera. Rensa innehållet i textrutan som visar resultatet och infoga likhetsprocenten. Ta bort "samma" taggen från föregående markering (om någon).
defshow_similarity():
text1 = text_textbox1.get(1.0, tk.END)
text2 = text_textbox2.get(1.0, tk.END)
similarity_percentage, diff = compare_text(text1, text2)
text_textbox_diff.delete(1.0, tk.END)
text_textbox_diff.insert(tk.END, f"Similarity: {similarity_percentage}%")
text_textbox1.tag_remove("same", "1.0", tk.END)
text_textbox2.tag_remove("same", "1.0", tk.END)De get_opcode() metod returnerar fem tuplar: opcode-strängen, startindexet för den första sekvensen, slutindexet för den första sekvensen, startindexet för den andra sekvensen och slutindexet för den andra sekvens.
Opcode-strängen kan vara ett av fyra möjliga värden: ersätt, ta bort, infoga och lika. Du kommer att få byta ut när en del av texten i båda sekvenserna är olika, och någon har ersatt en del med en annan. Du kommer att få radera när en del av texten finns i den första sekvensen men inte i den andra.
Du får Föra in när en del av texten saknas i den första sekvensen men finns i den andra. Du blir lika när delarna av texten är lika. Lagra alla dessa värden i lämpliga variabler. Om opcode-strängen är likvärdig, Lägg till samma tagga till textsekvensen.
for opcode in diff:
tag = opcode[0]
start1 = opcode[1]
end1 = opcode[2]
start2 = opcode[3]
end2 = opcode[4]
if tag == "equal":
text_textbox1.tag_add("same", f"1.0+{start1}c", f"1.0+{end1}c")
text_textbox2.tag_add("same", f"1.0+{start2}c", f"1.0+{end2}c")
Initiera Tkinter-rotfönstret. Ställ in fönstrets titel och definiera en ram inuti det. Organisera ramen med lämplig stoppning i båda riktningarna. Definiera två etiketter som ska visas Text 1 och Text 2. Ställ in det överordnade elementet det ska finnas i och texten det ska visa.
Definiera tre textrutor, två för de texter du vill jämföra och en för att visa resultatet. Deklarera det överordnade elementet, bredden och höjden och ställ in alternativet för radbrytning till tk. ORD för att säkerställa att programmet slår in orden vid närmaste gräns och inte bryter något ord däremellan.
root = tk.Tk()
root.title("Text Comparison Tool")
frame = tk.Frame(root)
frame.pack(padx=10, pady=10)
text_label1 = tk.Label(frame, text="Text 1:")
text_label1.grid(row=0, column=0, padx=5, pady=5)
text_textbox1 = tk.Text(frame, wrap=tk.WORD, width=40, height=10)
text_textbox1.grid(row=0, column=1, padx=5, pady=5)
text_label2 = tk.Label(frame, text="Text 2:")
text_label2.grid(row=0, column=2, padx=5, pady=5)
text_textbox2 = tk.Text(frame, wrap=tk.WORD, width=40, height=10)
text_textbox2.grid(row=0, column=3, padx=5, pady=5)
Definiera tre knappar, två för att ladda filerna och en för jämförelse. Definiera det överordnade elementet, texten det ska visa och funktionen det ska köra när det klickas. Skapa två inmatningswidgetar för att mata in filsökvägen och definiera det överordnade elementet tillsammans med dess bredd.
Organisera alla dessa element i rader och kolumner med hjälp av rutnätshanteraren. Använd pack för att organisera jämför_knapp och den text_textbox_diff. Lägg till lämplig stoppning vid behov.
file_entry1 = tk.Entry(frame, width=50)
file_entry1.grid(row=1, column=2, columnspan=2, padx=5, pady=5)
load_button1 = tk.Button(frame, text="Load File 1", command=lambda: load_file_or_display_contents(file_entry1, text_textbox1))
load_button1.grid(row=1, column=0, padx=5, pady=5, columnspan=2)
file_entry2 = tk.Entry(frame, width=50)
file_entry2.grid(row=2, column=2, columnspan=2, padx=5, pady=5)
load_button2 = tk.Button(frame, text="Load File 2", command=lambda: load_file_or_display_contents(file_entry2, text_textbox2))
load_button2.grid(row=2, column=0, padx=5, pady=5, columnspan=2)
compare_button = tk.Button(root, text="Compare", command=show_similarity)
compare_button.pack(pady=5)
text_textbox_diff = tk.Text(root, wrap=tk.WORD, width=80, height=1)
text_textbox_diff.pack(padx=10, pady=10)Markera texten markerad som samma med en gul bakgrund och röd teckenfärg.
text_textbox1.tag_configure("same", foreground="red", background="lightyellow")
text_textbox2.tag_configure("same", foreground="red", background="lightyellow")De mainloop() funktionen säger åt Python att köra Tkinter-händelsslingan och lyssna efter händelser tills du stänger fönstret.
root.mainloop()Sätt ihop allt och kör koden för att upptäcka plagiat.
Exempel på utdata från plagiatdetektorn
När du kör programmet visar det ett fönster. På att slå Ladda fil 1 knappen öppnas en fildialogruta och ber dig välja en fil. När du väljer en fil visar programmet innehållet i den första textrutan. På att gå in på stigen och slå Ladda fil 2, visar programmet innehållet i den andra textrutan. På att slå Jämföra knappen får du likheten som 100 %, och den framhäver hela texten för 100 % likhet.
Om du lägger till ytterligare en rad i en av textrutorna och trycker Jämföra, markerar programmet den liknande delen och utelämnar resten.
Om det finns liten eller ingen likhet markerar programmet några bokstäver eller ord, men likhetsprocenten är ganska låg.
Använder NLP för att upptäcka plagiat
Även om Difflib är en kraftfull metod för textjämförelse, är den känslig för mindre förändringar, har begränsad förståelse av sammanhanget och är ofta ineffektiv för stora texter. Du bör överväga att utforska Natural Language Processing eftersom den kan utföra semantisk analys av texten, extrahera meningsfulla egenskaper och har kontextuell förståelse.
Dessutom kan du träna din modell för olika språk och optimera den för effektivitet. Några av de tekniker som du kan använda för att upptäcka plagiat inkluderar Jaccard-likhet, cosinuslikhet, ordinbäddningar, latent sekvensanalys och sekvens-till-sekvens-modeller.
