Nous avons défini une classe intitulé MainWindow et à l'intérieur de cette classe, nous avons 6 fonctions:
class MainWindow(QMainWindow, Ui_MainWindow):
Class documentation goes here.
def __init__(self, parent = None):
Constructor
QMainWindow.__init__(self, parent)
self.setupUi(self)
@pyqtSignature()
def on_pushButton_clicked(self):
Slot documentation goes here.
url = unicode(self.lineEdit.text())
url=url.strip()
if not url.startswith(http://) : url=http://+url
self.webView.setUrl(QtCore.QUrl(url))
self.statusbar.setText(loading +url)
def on_pushButton_clicked(self):
Slot documentation goes here.
url = unicode(self.lineEdit.text())
url=url.strip()
if not url.startswith(http://) : url=http://+url
self.webView.setUrl(QtCore.QUrl(url))
self.statusbar.setText(loading +url)
@pyqtSignature()
Quand on clique sur le bouton go, le programme prend le texte du lineEdit et complète l'adresse URL en cas de besoin. Une fois que l'adresse URL est complète, le programme pourra afficher la page web dans WebView et indiquer au passage que la page web est en train de se télécharger dans statusbar. Dans cet objet graphique, nous avons l'exemple avec lemonde.fr.
def on_lineEdit_returnPressed(self):
Slot documentation goes here.
self.on_pushButton_clicked()
Cette fonction est une autre manière d'accéder à une page web sans cliquer sur le bouton go. L'utilisateur tape un nom de site web, par exemple lemonde.fr et ensuite, depuis son clavier, il peut taper sur entrée pour faire afficher la page web dans WebView.
def on_webView_loadFinished (self):
self.statusbar.setText(unicode(self.webView.url().toString())+ loaded)
html = unicode(self.webView.page().mainFrame().toHtml())
text=self.nettoie(html)
self.textEdit.setText(text)
musique=self.devinelangue(text)
print musique
self.languelabel.setText(musique)
@pyqtSignature()
def on_pushButton_search_clicked(self):
exp = re.compile(unicode(self.search.text()), re.U)
listedesmots = unicode(self.textEdit.toPlainText()).split()
nouveauText=
for mot in listedesmots:
if exp.search(mot): nouveauText+=mot+
self.plainTextEdit.setPlainText(nouveauText)
Quand la page web a fini de se télécharger, nous récupèrons le code html. Nous le nettoyons pour le mettre ensuite, dans une autre fenêtre, appelé textEdit. Dans cette fenêtre, nous avons le texte brut de la page web. Par ailleurs, le résultat s'affiche en dessous de cette fenêtre en nous disant quel langue il a trouvé.
def nettoie(self, codehtml):
codehtml=codehtml.replace(\n, )
expr=re.compile(, re.U)
codehtml=expr.sub( ,codehtml)
expr=re.compile(,re.U)
codehtml=expr.sub( ,codehtml)
expr=re.compile(<.*?>)
texte=expr.sub( ,codehtml)
expr=re.compile( , re.U)
texte=expr.sub( ,texte)
expr=re.compile(\s+, re.U)
texte=expr.sub( ,texte)
expr=re.compile(\d+, re.U)
texte=expr.sub( ,texte)
expr=re.compile([^\w]+, re.U)
texte=expr.sub( ,texte)
return texte
Cette fonction a pour objectif de prendre le code source de la page web et de le nettoyer pour obtenir un texte brut, c'est-à-dire obtenir une liste de mots. Tous les mots du site seront mis dans une nouvelle ligne (\n) qui va former un paragraphe avec l'ampleur des mots contenu dans le site.
Pour obtenir une liste de mots, il faut retirer des langages de programmation tels que le C.S.S et le javascript qui sont des langages à balises. Nous utiliserons des expressions régulières pour enlever ces deux codes. Pour nettoyer en profondeur le site, nous utiliserons d'autres expressions régulières pour retirer les espaces, les chiffres et tous les caractères qui ne correspondent pas à un mot.
def devinelangue (self, texte) :
listemots=texte.split() # séparation des mots du texte pour former une liste de mots
langues = {de: allemand, en: anglais, fr: ufrançais} #nous avons 4 corpus
dicoMots={} #dictionnaire de mots
resultat= [] #variable qui contiendra les résultats
for langue in langues: #c'est une boucle: pour chaque langues dans langues
fichier = open(liste.+langue+.txt) #ouverture de chaque fichier
texte = fichier.read() #lecture de chaque fichier
liste = texte.split() #on sépare les mots du texte
dicoMots[langue]=liste #obtention d'une liste de mots et on met dans une variable: dicoMots
#print dicoMots
for langue in langues: #c'est une boucle pour chaque langue dans langues
compteurmots=0 #comptage de mots. Le compteur part de zéro
#print ,langue
for mot in listemots:#autre boucle pour regarder s'il le mot est dans la listemots ou pas
if mot in dicoMots[langue]: #c'est une condition qui permet de garder ou pas le mot.
compteurmots+=1 #il garde le mot s'il est dans la liste de mots et compte + 1
#print mot
resultat+=[(compteurmots,langue)]#calcul du résultat
print langue,compteurmots
resultat.sort() #triage du résultat
return Ce texte est propablement en +langues [resultat [-1][1]]+ . #indication du résultat
Cette fonction a pour objectif de deviner la langue de la page web en nous disant si c'est de l'allemand, de l'anglais ou du français. Cette fonction n'est pas codé en QT Python mais en python.
Le programme compare les mots de la page web avec les listes de mots allemands, anglais et français stockés dans la variable dicoMot. Si le programme par exemple, trouve plus de mots en allemand dans le site web alors il affiche que le résultat est propablement en allemand.
Copyright 2009 Tubiana Séverine, tous droits réservés