Différences entre les versions de « Léo »

De {}
Aller à la navigation Aller à la recherche
 
(2 versions intermédiaires par le même utilisateur non affichées)
Ligne 4 : Ligne 4 :
  
 
= '''SOURCES''' =
 
= '''SOURCES''' =
−
- https://remonterletemps.ign.fr/
 
  
 
- https://www.geographicus.com/
 
- https://www.geographicus.com/
  
 
- https://www.oldmapsonline.org/
 
- https://www.oldmapsonline.org/
−
 
−
- https://www.sanderusmaps.com/
 
  
 
- https://commons.wikimedia.org/
 
- https://commons.wikimedia.org/
Ligne 17 : Ligne 14 :
  
 
- https://www.mapsofthepast.com/
 
- https://www.mapsofthepast.com/
−
 
−
- https://www.pinterest.fr
 
  
 
= '''STRUCTURE''' =
 
= '''STRUCTURE''' =
  
 
[[Fichier:Structure.png]]
 
[[Fichier:Structure.png]]
 +
 +
= '''AVANCEMENT DU PREMIER QUADRI''' =
 +
Mon projet a un peu évolué au cours du premier quadri. Je ne cherche plus uniquement des cartes de Paris et de Bruxelles, mais d'un maximum de villes différentes. Mon objectif final est d'avoir suffisamment de matière pour m'initier au machine learning. J'ai une vague première idée, celle d'un générateur automatique de cartes. Je n'ai aucune connaissance en machine learning, alors je verrai ce qu'il en sera à ce moment-là. Pour l'instant, je veux accumuler un maximum de données. L'idée sera alors d'exporter les images de chaque carte, avec un nom "ordonné" : ville-siècle.extension. Par exemple, Bruxelles-17.jpeg. Ensuite, je souhaite classer ces images pour les retrouver plus rapidement, en autant de sous-dossiers que possible. Par exemple, "Europe → Belgique → Flandre → Gand-15.png".
 +
 +
J'ai réussi assez simplement à récupérer les infos qui m'intéressaient sur certains de mes sites sources (geographicus et mapsofthepast). Un problème auquel j'ai été confronté, fut de rendre l'information propre. Par exemple, lorsque je récupérais le titre de la carte, il y avait beaucoup d'infos inutiles. Comment, en partant de "Map of Brussels, from the royal archives", réussir à obtenir "Bruxelles" ?
 +
 +
J'ai dû coder un petit bout de programme qui me permettait, premièrement, de nettoyer la phrase de tous les caractères inutiles comme les virgules, parenthèses, etc.
 +
 +
Ensuite, le programme me permettait d'isoler chaque mot, afin qu'il soit lu séparément. J'utilisais alors la librairie "Geonamescache" pour identifier les noms de villes parmi les mots. Une fois ceux-ci trouvés et les mots inutiles enlevés, j'utilisais la bibliothèque deep_translator pour automatiquement détecter la langue dans laquelle le nom de la ville était écrit, puis pour le traduire en français.
 +
 +
= '''OBJECTIFS DU SECOND QUADRI''' =
 +
Mon premier objectif à court terme sera d'améliorer ce que j'ai déjà fait. J'ai deux problèmes principaux :
 +
 +
1 - Mon code est vraiment dégueulasse, c'est en grande partie pour ça que je ne le poste pas ici. J'apprends peu à peu le python, et me rends compte que je peux faire un code bien plus propre et compréhensible, notamment en utilisant des fonctions au lieu de recopier le même code à chaque fois. Je veux donc reprendre ce que j'ai fait, et le rendre plus compréhensible, car sinon je vais vite me perdre.
 +
 +
2 - En passant par la bibliothèque deep_translator, j'utilise un plugin google trad pour traduire les noms des villes. Problème : j'ai un nombre de requêtes (très) limité. Quand on les dépasse, le programme plante. Impossible de compter là-dessus pour la suite, alors je dois trouver une autre alternative. J'ai besoin de pouvoir détecter la langue automatiquement car il y en a de toutes sortes dans les noms des cartes, et aussi de traduire automatiquement. Je vais réfléchir à une solution dans ces prochaines semaines.
 +
 +
Une fois que j'aurai fait ça, je pourrai me pencher sur la suite. En vrac :
 +
 +
- Adapter mon code à tous mes sites
 +
- Extraire les images
 +
- Trouver comment automatiquement les renommer
 +
- Trouver comment automatiquement les ranger
 +
- Commencer à regarder le machine learning de plus près
 +
 +
= '''AVANCEMENT DU SECOND QUADRI''' =
 +
 +
J'ai réussi à bien avancer à partir du site Geographicus, à avoir l'accès à toutes les cartes qui m'intéressent depuis la page d'accueil du site. J'ai eu beaucoup de soucis pour les enregistrer, mais j'ai presque fini par réussir, il faudrait juste que j'ajoute un bypass pour éviter que le programme ne plante quand il y a une erreur 404. Si j'avais eu plus de temps, j'aurais aussi rendu l'enregistrement du nom de fichiers plus propre, et je les aurais classés par continent comme je comptais le faire. Voici le code en intégral :
 +
 +
import mechanize
 +
 +
import lxml.html as lh
 +
 +
import cssselect
 +
 +
import ssl
 +
 +
import geonamescache
 +
 +
from pathlib import Path
 +
 +
 +
numFichier = 1
 +
tousLesLiensImages = []
 +
 +
listeLiens = []
 +
parcourirListeLiens = 0    # listeLiens contient tous les liens des catégories (Asian Maps, Europe maps, etc.) et parcourirListeLiens permet de parcourir cette liste
 +
 +
listeVraisLiens = []
 +
parcourirListeVraisLiens = 0    # listeVraisLiens contient tous les liens des cartes dans chaque catégorie, et parcourirListeVraisLiens permet de parcourir cette liste
 +
 +
 +
br = mechanize.Browser()
 +
 +
br.addheaders = [('User-agent', 'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.1) Gecko/2008071615 Fedora/3.0.1-1.fc9 Firefox/3.0.1')]
 +
 +
br.set_handle_robots(False)
 +
#fin de la configuration de mechanize
 +
 +
try:
 +
    _create_unverified_https_context = ssl._create_unverified_context
 +
except AttributeError:
 +
 +
    pass
 +
else:
 +
 +
    ssl._create_default_https_context = _create_unverified_https_context
 +
 +
data = br.open('https://www.geographicus.com/P/RareMaps/city-maps-plans', timeout=50.0)
 +
 +
##data = br.open('https://www.geographicus.com/P/AntiqueMap/kremlenagrad-gerritsz-1642', timeout=50.0)
 +
 +
rawdata = data.read()
 +
unicode = rawdata.decode('utf-8', 'ignore')
 +
src = lh.fromstring(unicode)
 +
 +
 +
 +
selecteurs = cssselect.parse('blockquote a')
 +
 +
 +
 +
for selecteur in selecteurs:
 +
    chemin_xpath = cssselect.HTMLTranslator().selector_to_xpath(selecteur, translate_pseudo_elements=True)
 +
    resultats = src.xpath(chemin_xpath)
 +
    for resultat in resultats:
 +
        lienCategorie = resultat.get('href')
 +
        lienListe = lienCategorie.split("&")
 +
        del lienListe[-1]
 +
        lienListe.append("&Sort_By=price_desc&Per_Page=-1")
 +
        vraiLien = "".join(lienListe)
 +
        listeLiens.append(vraiLien)
 +
 +
for loop in range(len(listeLiens)):
 +
 +
    data = br.open(listeLiens[parcourirListeLiens], timeout=50.0)
 +
    rawdata = data.read()
 +
    unicode = rawdata.decode('utf-8', 'ignore')
 +
    src = lh.fromstring(unicode)
 +
    selecteurs = cssselect.parse('.column.half.medium-one-fourth.category-product a')
 +
 +
    for selecteur in selecteurs:
 +
        chemin_xpath = cssselect.HTMLTranslator().selector_to_xpath(selecteur, translate_pseudo_elements=True)
 +
        resultats = src.xpath(chemin_xpath)
 +
        for resultat in resultats:
 +
            listeVraisLiens.append(resultat.get('href'))
 +
    parcourirListeLiens += 1
 +
 +
for loop in range(len(listeVraisLiens)):
 +
 +
    data = br.open(listeVraisLiens[parcourirListeVraisLiens], timeout=50.0)
 +
    rawdata = data.read()
 +
    unicode = rawdata.decode('utf-8', 'ignore')
 +
    src = lh.fromstring(unicode)
 +
    selecteurs = (cssselect.parse('.normal.oldbeige.nm'))
 +
    selecteursImages = (cssselect.parse('.m-img-z'))
 +
 +
    for selecteur in selecteurs:
 +
        chemin_xpath = cssselect.HTMLTranslator().selector_to_xpath(selecteur, translate_pseudo_elements=True)
 +
        resultats = src.xpath(chemin_xpath)
 +
        for resultat in resultats:
 +
            nomCarte = resultat.text_content()
 +
            if nomCarte.find("map") != -1 or nomCarte.find("Map") != -1 or nomCarte.find("plan") != -1 or nomCarte.find("Plan") != -1 :
 +
                quasiLigneSansAs = nomCarte.replace(" as ", " ")
 +
                ligneSansAs = quasiLigneSansAs.replace("/", " ")
 +
 +
                espacesBrut = ""
 +
                espacesFinaux = ""
 +
                parcourirEspaces = 0
 +
                gc = geonamescache.GeonamesCache()
 +
                parcourirMots = 0
 +
 +
                listeLigneSansAs = ligneSansAs.split(" ")
 +
                dateCarte = listeLigneSansAs[0]
 +
                del listeLigneSansAs[0]
 +
                places = " ".join(listeLigneSansAs)
 +
                nomDeLieu = ""
 +
 +
                for loop in range(len(places)):
 +
                for char in places:
 +
                if(ord(char) == 39 or ord(char) == 45):
 +
                espacesBrut = espacesBrut + "?? ??" + char
 +
                if((ord(char) >= 97 and ord(char) <= 122) or (ord(char) >= 65 and ord(char) <= 90) or (ord(char) >= 192 and ord(char) <= 255 and ord(char) != 215 and ord(char) != 247) or (ord(char) == 32)):
 +
                espacesBrut += char
 +
                places = places[1:]
 +
 +
                for loop in range(len(espacesBrut)):
 +
                for char in espacesBrut:
 +
                if((ord(char) >= 97 and ord(char) <= 122) or (ord(char) >= 65 and ord(char) <= 90) or (ord(char) >= 192 and ord(char) <= 255 and ord(char) != 215 and ord(char) != 247) or (ord(char) == 32)):
 +
                espacesFinaux += char
 +
                espacesBrut = espacesBrut[1:]
 +
 +
                espaces = espacesFinaux.split(" ")
 +
 +
 +
 +
 +
                while len(espaces) > 0:
 +
                if len(espaces)-3 >= espaces.index(espaces[parcourirEspaces]):
 +
                resultat = espaces[parcourirEspaces]+" "+espaces[parcourirEspaces+1]+" "+espaces[parcourirEspaces+2]
 +
                villes = gc.search_cities(resultat)
 +
                if villes != []:
 +
                villeFinal = villes[0].get('name')
 +
                if villeFinal != 'Fier-Çifçi' :
 +
                nomDeLieu += villeFinal + " "
 +
                del espaces[parcourirEspaces]
 +
                del espaces[parcourirEspaces]
 +
                del espaces[parcourirEspaces]
 +
                else :
 +
                if len(espaces)-2 >= espaces.index(espaces[parcourirEspaces]):
 +
                resultat = espaces[parcourirEspaces]+" "+espaces[parcourirEspaces+1]
 +
                villes = gc.search_cities(resultat)
 +
                if villes != []:
 +
                villeFinal = villes[0].get('name')
 +
                if villeFinal != 'Fier-Çifçi' :
 +
                nomDeLieu += villeFinal + " "
 +
                del espaces[parcourirEspaces]
 +
                del espaces[parcourirEspaces]
 +
                else :
 +
                villes = gc.search_cities(espaces[parcourirEspaces])
 +
                if villes != []:
 +
                villeFinal = villes[0].get('name')
 +
                if villeFinal != 'Fier-Çifçi' :
 +
                nomDeLieu += villeFinal + " "
 +
 +
                del espaces[parcourirEspaces]
 +
                else :
 +
                del espaces[parcourirEspaces]
 +
 +
                elif len(espaces)-2 >= espaces.index(espaces[parcourirEspaces]):
 +
                resultat = espaces[parcourirEspaces]+" "+espaces[parcourirEspaces+1]
 +
                villes = gc.search_cities(resultat)
 +
                if villes != []:
 +
                villeFinal = villes[0].get('name')
 +
                if villeFinal != 'Fier-Çifçi' :
 +
                nomDeLieu += villeFinal + " "
 +
                del espaces[parcourirEspaces]
 +
                del espaces[parcourirEspaces]
 +
                else :
 +
                villes = gc.search_cities(espaces[parcourirEspaces])
 +
                if villes != []:
 +
                villeFinal = villes[0].get('name')
 +
                if villeFinal != 'Fier-Çifçi' :
 +
                nomDeLieu += villeFinal + " "
 +
 +
                del espaces[parcourirEspaces]
 +
                else :
 +
                del espaces[parcourirEspaces]
 +
 +
                else :
 +
                villes = gc.search_cities(espaces[parcourirEspaces])
 +
                if villes != []:
 +
                villeFinal = villes[0].get('name')
 +
                if villeFinal != 'Fier-Çifçi' :
 +
                nomDeLieu += villeFinal + " "
 +
                del espaces[parcourirEspaces]
 +
                else :
 +
                del espaces[parcourirEspaces]
 +
                print(nomDeLieu)
 +
 +
 +
                for selecteur in selecteursImages:
 +
                    chemin_xpath = cssselect.HTMLTranslator().selector_to_xpath(selecteur, translate_pseudo_elements=True)
 +
                    resultats = src.xpath(chemin_xpath)
 +
                    for resultat in resultats:
 +
 +
                        lienImage = resultat.get('src')
 +
                        if lienImage not in tousLesLiensImages :
 +
                            tousLesLiensImages.append(lienImage)
 +
                            lienImageListe = lienImage.split(".")
 +
                            extensionImage = lienImageListe[-1]
 +
                            nomSauvegarde = nomDeLieu + dateCarte +"."+extensionImage
 +
                            print (lienImage)
 +
                            if Path(nomSauvegarde).is_file():
 +
                                nomSauvegarde = nomDeLieu + dateCarte+"_"+ str(numFichier) +"."+extensionImage
 +
                                numFichier += 1
 +
                            data = br.open(lienImage).read()
 +
                            if data == True :
 +
                                save = open(nomSauvegarde, 'wb')
 +
                                save.write(data)
 +
                                save.close()
 +
    parcourirListeVraisLiens += 1
 +
 +
 +
= '''BILAN ET IDEES FUTURES''' =
 +
 +
J'ai beaucoup appris cette année, et j'ai très envie de continuer. Pour l'avenir, je voudrais achever de corriger les bugs qui restent, notamment de pouvoir bypasser les erreurs 404, enregistrer les noms plus proprement et mieux les classer.
 +
Ensuite, je voudrais les enregistrer dans la base de donnée, et adapter ce système aux autres sélecteurs.

Version actuelle datée du 26 avril 2021 à 16:22

PROJET

Je souhaite créer une base de données collectant un maximum de cartes anciennes, principalement de Bruxelles et de Paris, et classant ces cartes par lieu ainsi que par date. Etant très intéressé par l'urbanisme ainsi que par l'histoire, j'ai une grande curiosité pour ces vieilles cartes, et j'en consulte régulièrement. Je serai peut-être amené à en utiliser dans un projet artistique futur.

SOURCES

- https://www.geographicus.com/

- https://www.oldmapsonline.org/

- https://commons.wikimedia.org/

- https://www.discusmedia.com/

- https://www.mapsofthepast.com/

STRUCTURE

Structure.png

AVANCEMENT DU PREMIER QUADRI

Mon projet a un peu évolué au cours du premier quadri. Je ne cherche plus uniquement des cartes de Paris et de Bruxelles, mais d'un maximum de villes différentes. Mon objectif final est d'avoir suffisamment de matière pour m'initier au machine learning. J'ai une vague première idée, celle d'un générateur automatique de cartes. Je n'ai aucune connaissance en machine learning, alors je verrai ce qu'il en sera à ce moment-là. Pour l'instant, je veux accumuler un maximum de données. L'idée sera alors d'exporter les images de chaque carte, avec un nom "ordonné" : ville-siècle.extension. Par exemple, Bruxelles-17.jpeg. Ensuite, je souhaite classer ces images pour les retrouver plus rapidement, en autant de sous-dossiers que possible. Par exemple, "Europe → Belgique → Flandre → Gand-15.png".

J'ai réussi assez simplement à récupérer les infos qui m'intéressaient sur certains de mes sites sources (geographicus et mapsofthepast). Un problème auquel j'ai été confronté, fut de rendre l'information propre. Par exemple, lorsque je récupérais le titre de la carte, il y avait beaucoup d'infos inutiles. Comment, en partant de "Map of Brussels, from the royal archives", réussir à obtenir "Bruxelles" ?

J'ai dû coder un petit bout de programme qui me permettait, premièrement, de nettoyer la phrase de tous les caractères inutiles comme les virgules, parenthèses, etc.

Ensuite, le programme me permettait d'isoler chaque mot, afin qu'il soit lu séparément. J'utilisais alors la librairie "Geonamescache" pour identifier les noms de villes parmi les mots. Une fois ceux-ci trouvés et les mots inutiles enlevés, j'utilisais la bibliothèque deep_translator pour automatiquement détecter la langue dans laquelle le nom de la ville était écrit, puis pour le traduire en français.

OBJECTIFS DU SECOND QUADRI

Mon premier objectif à court terme sera d'améliorer ce que j'ai déjà fait. J'ai deux problèmes principaux :

1 - Mon code est vraiment dégueulasse, c'est en grande partie pour ça que je ne le poste pas ici. J'apprends peu à peu le python, et me rends compte que je peux faire un code bien plus propre et compréhensible, notamment en utilisant des fonctions au lieu de recopier le même code à chaque fois. Je veux donc reprendre ce que j'ai fait, et le rendre plus compréhensible, car sinon je vais vite me perdre.

2 - En passant par la bibliothèque deep_translator, j'utilise un plugin google trad pour traduire les noms des villes. Problème : j'ai un nombre de requêtes (très) limité. Quand on les dépasse, le programme plante. Impossible de compter là-dessus pour la suite, alors je dois trouver une autre alternative. J'ai besoin de pouvoir détecter la langue automatiquement car il y en a de toutes sortes dans les noms des cartes, et aussi de traduire automatiquement. Je vais réfléchir à une solution dans ces prochaines semaines.

Une fois que j'aurai fait ça, je pourrai me pencher sur la suite. En vrac :

- Adapter mon code à tous mes sites - Extraire les images - Trouver comment automatiquement les renommer - Trouver comment automatiquement les ranger - Commencer à regarder le machine learning de plus près

AVANCEMENT DU SECOND QUADRI

J'ai réussi à bien avancer à partir du site Geographicus, à avoir l'accès à toutes les cartes qui m'intéressent depuis la page d'accueil du site. J'ai eu beaucoup de soucis pour les enregistrer, mais j'ai presque fini par réussir, il faudrait juste que j'ajoute un bypass pour éviter que le programme ne plante quand il y a une erreur 404. Si j'avais eu plus de temps, j'aurais aussi rendu l'enregistrement du nom de fichiers plus propre, et je les aurais classés par continent comme je comptais le faire. Voici le code en intégral :

import mechanize

import lxml.html as lh

import cssselect

import ssl

import geonamescache

from pathlib import Path


numFichier = 1 tousLesLiensImages = []

listeLiens = [] parcourirListeLiens = 0 # listeLiens contient tous les liens des catégories (Asian Maps, Europe maps, etc.) et parcourirListeLiens permet de parcourir cette liste

listeVraisLiens = [] parcourirListeVraisLiens = 0 # listeVraisLiens contient tous les liens des cartes dans chaque catégorie, et parcourirListeVraisLiens permet de parcourir cette liste


br = mechanize.Browser()

br.addheaders = [('User-agent', 'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.1) Gecko/2008071615 Fedora/3.0.1-1.fc9 Firefox/3.0.1')]

br.set_handle_robots(False)

  1. fin de la configuration de mechanize

try: 

   _create_unverified_https_context = ssl._create_unverified_context

except AttributeError: 

   pass

else: 

   ssl._create_default_https_context = _create_unverified_https_context

data = br.open('https://www.geographicus.com/P/RareMaps/city-maps-plans', timeout=50.0)

    1. data = br.open('https://www.geographicus.com/P/AntiqueMap/kremlenagrad-gerritsz-1642', timeout=50.0)

rawdata = data.read() unicode = rawdata.decode('utf-8', 'ignore') src = lh.fromstring(unicode)


selecteurs = cssselect.parse('blockquote a')


for selecteur in selecteurs: 

   chemin_xpath = cssselect.HTMLTranslator().selector_to_xpath(selecteur, translate_pseudo_elements=True)
   resultats = src.xpath(chemin_xpath)
   for resultat in resultats:
       lienCategorie = resultat.get('href')
       lienListe = lienCategorie.split("&")
       del lienListe[-1]
       lienListe.append("&Sort_By=price_desc&Per_Page=-1")
       vraiLien = "".join(lienListe)
       listeLiens.append(vraiLien)

for loop in range(len(listeLiens)): 

   data = br.open(listeLiens[parcourirListeLiens], timeout=50.0)
   rawdata = data.read()
   unicode = rawdata.decode('utf-8', 'ignore')
   src = lh.fromstring(unicode)
   selecteurs = cssselect.parse('.column.half.medium-one-fourth.category-product a')

   for selecteur in selecteurs:
       chemin_xpath = cssselect.HTMLTranslator().selector_to_xpath(selecteur, translate_pseudo_elements=True)
       resultats = src.xpath(chemin_xpath)
       for resultat in resultats:
           listeVraisLiens.append(resultat.get('href'))
   parcourirListeLiens += 1

for loop in range(len(listeVraisLiens)): 

   data = br.open(listeVraisLiens[parcourirListeVraisLiens], timeout=50.0)
   rawdata = data.read()
   unicode = rawdata.decode('utf-8', 'ignore')
   src = lh.fromstring(unicode)
   selecteurs = (cssselect.parse('.normal.oldbeige.nm'))
   selecteursImages = (cssselect.parse('.m-img-z'))

   for selecteur in selecteurs:
       chemin_xpath = cssselect.HTMLTranslator().selector_to_xpath(selecteur, translate_pseudo_elements=True)
       resultats = src.xpath(chemin_xpath)
       for resultat in resultats:
           nomCarte = resultat.text_content()
           if nomCarte.find("map") != -1 or nomCarte.find("Map") != -1 or nomCarte.find("plan") != -1 or nomCarte.find("Plan") != -1 :
               quasiLigneSansAs = nomCarte.replace(" as ", " ")
               ligneSansAs = quasiLigneSansAs.replace("/", " ")

               espacesBrut = ""
               espacesFinaux = ""
               parcourirEspaces = 0
               gc = geonamescache.GeonamesCache()
               parcourirMots = 0

               listeLigneSansAs = ligneSansAs.split(" ")
               dateCarte = listeLigneSansAs[0]
               del listeLigneSansAs[0]
               places = " ".join(listeLigneSansAs)
               nomDeLieu = ""

               for loop in range(len(places)):
               	for char in places:
               		if(ord(char) == 39 or ord(char) == 45):
               			espacesBrut = espacesBrut + "?? ??" + char
               		if((ord(char) >= 97 and ord(char) <= 122) or (ord(char) >= 65 and ord(char) <= 90) or (ord(char) >= 192 and ord(char) <= 255 and ord(char) != 215 and ord(char) != 247) or (ord(char) == 32)):
               			espacesBrut += char
               		places = places[1:]

               for loop in range(len(espacesBrut)):
               	for char in espacesBrut:
               		if((ord(char) >= 97 and ord(char) <= 122) or (ord(char) >= 65 and ord(char) <= 90) or (ord(char) >= 192 and ord(char) <= 255 and ord(char) != 215 and ord(char) != 247) or (ord(char) == 32)):
               			espacesFinaux += char
               		espacesBrut = espacesBrut[1:]

               espaces = espacesFinaux.split(" ")




               while len(espaces) > 0:
               	if len(espaces)-3 >= espaces.index(espaces[parcourirEspaces]):
               		resultat = espaces[parcourirEspaces]+" "+espaces[parcourirEspaces+1]+" "+espaces[parcourirEspaces+2]
               		villes = gc.search_cities(resultat)
               		if villes != []:
               			villeFinal = villes[0].get('name')
               			if villeFinal != 'Fier-Çifçi' :
               				nomDeLieu += villeFinal + " "
               			del espaces[parcourirEspaces]
               			del espaces[parcourirEspaces]
               			del espaces[parcourirEspaces]
               		else :
               			if len(espaces)-2 >= espaces.index(espaces[parcourirEspaces]):
               				resultat = espaces[parcourirEspaces]+" "+espaces[parcourirEspaces+1]
               				villes = gc.search_cities(resultat)
               				if villes != []:
               					villeFinal = villes[0].get('name')
               					if villeFinal != 'Fier-Çifçi' :
               						nomDeLieu += villeFinal + " "
               					del espaces[parcourirEspaces]
               					del espaces[parcourirEspaces]
               				else :
               					villes = gc.search_cities(espaces[parcourirEspaces])
               					if villes != []:
               						villeFinal = villes[0].get('name')
               						if villeFinal != 'Fier-Çifçi' :
               							nomDeLieu += villeFinal + " "

               						del espaces[parcourirEspaces]
               					else :
               						del espaces[parcourirEspaces]

               	elif len(espaces)-2 >= espaces.index(espaces[parcourirEspaces]):
               		resultat = espaces[parcourirEspaces]+" "+espaces[parcourirEspaces+1]
               		villes = gc.search_cities(resultat)
               		if villes != []:
               			villeFinal = villes[0].get('name')
               			if villeFinal != 'Fier-Çifçi' :
               				nomDeLieu += villeFinal + " "
               			del espaces[parcourirEspaces]
               			del espaces[parcourirEspaces]
               		else :
               			villes = gc.search_cities(espaces[parcourirEspaces])
               			if villes != []:
               				villeFinal = villes[0].get('name')
               				if villeFinal != 'Fier-Çifçi' :
               					nomDeLieu += villeFinal + " "

               				del espaces[parcourirEspaces]
               			else :
               				del espaces[parcourirEspaces]

               	else :
               		villes = gc.search_cities(espaces[parcourirEspaces])
               		if villes != []:
               			villeFinal = villes[0].get('name')
               			if villeFinal != 'Fier-Çifçi' :
               				nomDeLieu += villeFinal + " "
               			del espaces[parcourirEspaces]
               		else :
               			del espaces[parcourirEspaces]
               print(nomDeLieu)



               for selecteur in selecteursImages:
                   chemin_xpath = cssselect.HTMLTranslator().selector_to_xpath(selecteur, translate_pseudo_elements=True)
                   resultats = src.xpath(chemin_xpath)
                   for resultat in resultats:

                       lienImage = resultat.get('src')
                       if lienImage not in tousLesLiensImages :
                           tousLesLiensImages.append(lienImage)
                           lienImageListe = lienImage.split(".")
                           extensionImage = lienImageListe[-1]
                           nomSauvegarde = nomDeLieu + dateCarte +"."+extensionImage
                           print (lienImage)
                           if Path(nomSauvegarde).is_file():
                               nomSauvegarde = nomDeLieu + dateCarte+"_"+ str(numFichier) +"."+extensionImage
                               numFichier += 1
                           data = br.open(lienImage).read()
                           if data == True :
                               save = open(nomSauvegarde, 'wb')
                               save.write(data)
                               save.close()
   parcourirListeVraisLiens += 1


BILAN ET IDEES FUTURES

J'ai beaucoup appris cette année, et j'ai très envie de continuer. Pour l'avenir, je voudrais achever de corriger les bugs qui restent, notamment de pouvoir bypasser les erreurs 404, enregistrer les noms plus proprement et mieux les classer. Ensuite, je voudrais les enregistrer dans la base de donnée, et adapter ce système aux autres sélecteurs.

Récupérée de « https://curlybraces.be/wiki/index.php?title=Léo&oldid=5088 »