Différences entre les versions de « Utilisateur:Thomas »

De {}
Aller à la navigation Aller à la recherche
Ligne 972 : Ligne 972 :
 
====Supression====
 
====Supression====
  
Il y a certaines lignes qui n'ont pas les données de latitude/longitude dans le tableau : on les supprime aussi.
+
Il y a certaines lignes qui n'ont pas les données de latitude/longitude dans le tableau, ou qui n'ont pas de valeur pour la longitude ("-") : on les supprime aussi.
  
 
<syntaxhighlight lang="python">
 
<syntaxhighlight lang="python">
Ligne 1 004 : Ligne 1 004 :
  
 
##########################ENLEVER LES LIGNES VIDES (SANS LONG/LAT)###########################
 
##########################ENLEVER LES LIGNES VIDES (SANS LONG/LAT)###########################
for i in range(len(d['latitude'])):
+
for i in range(len(d['longitude'])):
     if d['latitude'][i] == "":
+
     if d['longitude'][i] == "" or d['longitude'][i] == "-":
 
         # print('vide')
 
         # print('vide')
 
         rows.append(i)
 
         rows.append(i)

Version du 1 avril 2020 à 09:17

Poésie binaire

Poème de 6 vers, de 4 pieds chacun (en binaire ASCII):

100110011001011110011010000011001011100100110100111101001101001110111111011101110011000110101000101001100110010101000001000011110000111011101100001111000011001010100010000110111011010100111110000111101101100001110100111001011101110111010001000001100100110111111011101101110110010100011011110101110111011001010100000110110111010011110011111001111010011101111110111001000000111010000110111101011101110010000011001111110010110000111011101100100010000011100101101111110110111000011101110000110111101001110010110000111011101110011110011011011111110010110110111010011110011111010011001010101110

La traduction :

Les éditions

"Le Canapé"

m'avaient donné

une mission :

un grand roman

transformiste

Bonjour Python

Opérations sur les chaînes de caractères

Créer un programme qui agit sur le poème écrit au premier cours.

Je voudrais créer un programme qui transforme les "a" en "aaaaah",

(la référence en vidéo -> [1])

et qui transforme une lettre sur 2 en Capitale, pour donner un style ado en train de muer.


Ou alors un programme qui rajoute "xx" à la fin des mots qui finissent par "a", comme dans "chanmax" et qui rajoute "ss" à la fin des mots qui terminent par "s" comme dans "cooloss". Si le mot modifié se trouve en fin de vers, alors on rajoute une ligne intercalaire qui fait "Cooloss !" ou "Chanmax !" selon la fin du vers précédent (et qui fait "Stylé !" à la fin des vers qui se terminent par "é".

OU ALORS le programme ultime qui rajoute les chanmax, cooloss et stylé et ensuite demande à l'utilisateur s'il.elle veut prendre un lysopaïne, qui transforme les a en aaaah. Si oui, alors exécuter la première partie (changer les a en aaaah et alterner capitales et bas de casse).

Le programme lysopaïne.py :

#!/usr/bin/env python
# -*- coding: utf-8 -*-

print("Tu veux un lysopaine ?")
reponse = raw_input()
reponse = str(reponse.lower())

if reponse == "oui" :
    import re

    f= open("poeme.txt", "r")

    poeme = f.read()

    poeme = poeme.lower()

    #transforme les a en aaaah
    lyso = re.sub("a", "aaaah", poeme)

    # boucle qui imprime 1 caractère sur 2 en capitale
    i = 1
    poeme = ""
    while i < len(lyso):
        poeme = poeme + lyso[i-1].upper() + lyso[i].lower()
        i += 2

    print(poeme)
    f.close()

else:
    print("Ben tant pis pour toi.")
Tu veux un lysopaine ?
oui
LeS EdItIoNs
"Le cAaAaHnAaAaHpE"
m'aAaAhVaAaAhIeNt dOnNe
uNe mIsSiOn :
uN GrAaAaHnD RoMaAaAhN
TrAaAaHnSfOrMiStE.
cEsT VrAaAaHi oU FaAaAhUx
uN Ou zErO
CeSt nOiR Ou bLaAaAhNc
lAaAaHrMe aAaAhMmE BiEn
lE CoDe bInAaAaHiRe
tOuTs eSt tReS ClAaAaHiRe
l oRdInAaAaHtEuR
CiRcUiTs iMmEnSeS
ZeRoS Et uNs
rYtHmEnT Le cOd(e).
rEpEtItIoN,
zErOs eT UnS
SaAaAhUt aAaAh lAaAaH LiGnE,
c'eSt uN SeCrEt.
ÉCrIrE à l'oRdInAaAaHtEuR,
oU ├á lAaAaH MaAaAhIn ?
├ëcRiRe sUr lE PaAaAhSs├®,
Ou sUr dEmAaAaHiN ?
ÉCrIrE DeS MoTs,
Ou uN Po├¿Me ?
ÉcRiRe sUr l'aAaAhMoUr,
Ou sUr lAaAaH HaAaAhInE ?
PlUs dE PoInTs
dÔÇÖiNtErRoGaAaAhTiOn,
├®CrIvEz jUsTe
uNe aAaAhSsErTiOn !

Le programme de Violette (loup-garou.py):

#!/usr/bin/env python
#coding: utf-8
'''Un programme qui
- demande le nom de l'utilisateur qui sera enregistré comme nom de poète
- rajoute aouuuu quand il y a a lettre a
- rajoute grrrrrrrrrr quand il y a la lettre g '''

print("Quel est ton nom, poète.esse ?")
nom = raw_input()

import re

f= open("poeme.txt", "r+")

poeme = f.read()

#poeme = re.sub('a', "aouuuu", poeme)
poeme = re.sub('([aA])', r"\1ouuuu", poeme)
poeme = re.sub('([gG])', r"\1rrrrrrrrrr", poeme)

nom = re.sub('([aA])', r"\1ouuuu", nom)
nom = re.sub('([gG])', r"\1rrrrrrrrrr", nom)
print(poeme)
print("Signé, " + nom + " le loup grrrrrrrrrraouuuurou")

f.close()
Quel est ton nom, po├¿te.esse ?
Gaspard
Les editions
"Le Caouuuunaouuuupe"
m'aouuuuvaouuuuient donne
une mission :
un grrrrrrrrrrraouuuund romaouuuun
traouuuunsformiste.
Cest vraouuuui ou faouuuuux
un ou zero
Cest noir ou blaouuuunc
laouuuurme aouuuumme bien
le code binaouuuuire
touts est tres claouuuuire
L ORDINAouuuuTEUR
Circuits Immenses
Zeros et uns
Rythment le cod(e).
Repetition,
Zeros et uns
Saouuuuut aouuuu laouuuu ligrrrrrrrrrrne,
C'est un secret.
Écrire à l'ordinaouuuuteur,
ou ├á laouuuu maouuuuin ?
├ëcrire sur le paouuuuss├®,
ou sur demaouuuuin ?
Écrire des mots,
ou un po├¿me ?
Écrire sur l'aouuuumour,
ou sur laouuuu haouuuuine ?
Plus de points
dÔÇÖinterrogrrrrrrrrrraouuuution,
├®crivez juste
une aouuuussertion !
Sign├®, Grrrrrrrrrraouuuuspaouuuurd le loup grrrrrrrrrraouuuurou

Le programme de Stijn (pluie.py):

#!/usr/bin/env python
# -*- coding: utf-8 -*-

'''demander est ce qu’il pleut? oui: changer tous les a e i o u -> ! non: print chance '''

print("Est-ce qu'il pleut ?")
print("(oui/non)")
pluie = str(raw_input())
pluie = pluie.lower()

import re

f= open("poeme.txt", "r+")
poeme = f.read()

if pluie == "oui":
    oui = re.sub('a|e|i|o|u', "!", poeme, flags=re.IGNORECASE)
    print(oui)
    print("Quel temps pourri...")
else:
    print("Chouette alors !")

f.close()
Est-ce qu'il pleut ?
(oui/non)
oui
L!s !d!t!!ns
"L! C!n!p!"
m'!v!!!nt d!nn!
!n! m!ss!!n :
!n gr!nd r!m!n
tr!nsf!rm!st!.
C!st vr!! !! f!!x
!n !! z!r!
C!st n!!r !! bl!nc
l!rm! !mm! b!!n
l! c!d! b!n!!r!
t!!ts !st tr!s cl!!r!
L !RD!N!T!!R
C!rc!!ts !mm!ns!s
Z!r!s !t !ns
Rythm!nt l! c!d(!).
R!p!t!t!!n,
Z!r!s !t !ns
S!!t ! l! l!gn!,
C'!st !n s!cr!t.
Écr!r! à l'!rd!n!t!!r,
!! ├á l! m!!n ?
├ëcr!r! s!r l! p!ss├®,
!! s!r d!m!!n ?
Écr!r! d!s m!ts,
!! !n p!├¿m! ?
Écr!r! s!r l'!m!!r,
!! s!r l! h!!n! ?
Pl!s d! p!!nts
dÔÇÖ!nt!rr!g!t!!n,
├®cr!v!z j!st!
!n! !ss!rt!!n !
Quel temps pourri...

Le programme de Léna (inverse.py)

#!/usr/bin/env python
#coding: utf-8

'''inverser 1er et dernier mot de chaque vers + inverser la première et la dernière lettre du premier mot'''

#ouvrir le fichier
f = open("poeme.txt", "r")

poeme = f.read()

#décomposer le tableau en lignes
lines = poeme.splitlines()
for line in lines:
    mots = line.split(" ")

#inverser la dernière lettre et la première lettre du dernier mot (qui deviendra le premier ensuite)
    last_mot = mots[len(mots)-1]
    last_lettre = last_mot[0]
    last_mot = last_mot.replace(last_mot[0], last_mot[len(last_mot)-1], 1)
    #petite technique : utiliser [:x] pour afficher toute la chaîne/le tableau jusqu'à l'indice donné
    #fonctionne aussi avec [x:] pour afficher tout après l'indice donné
    last_mot = last_mot[:len(last_mot)-1] + last_lettre

#inverser le premier et le dernier mot de chaque ligne
    momo = mots[0]
    mots[0] = last_mot
    mots[len(mots)-1] = momo

#petite correction pour que les lignes de 1 mot soient modifiées (sinon, vu que le programme remplace le dernier mot par le premier il annule le changement de lettres effectué avant et seulement sur le dernier mot de chauqe ligne)
    if len(mots)-1 == 0:
        mots[len(mots)-1] = last_mot

    new_line = str()

#reconstituer la ligne youpi
    for mot in mots:
        new_line = new_line + " " + mot

    print(new_line)

f.close()
 sditione Les
 "anapeC "Le
 eonnd m'avaient
 : mission une
 nomar grand un
 .ransformistet
 xauf vrai ou Cest
 oerz ou un
 clanb noir ou Cest
 nieb amme larme
 einairb code le
 elairc est tres touts
 RRDINATEUO L
 smmenseI Circuits
 snu et Zeros
 .od(e)c le Rythment
 ,epetitionR
 snu et Zeros
 ,ignel a la Saut
 .ecrets un C'est
 ,'ordinateurl à Écrire
 ? à la main ou
 ,ass├®p sur le ├ëcrire
 ? sur demain ou
 ,otsm des Écrire
 ? un poème ou
 ,'amourl sur Écrire
 ? sur la haine ou
 sointp de Plus
 ,ÔÇÖinterrogationd
 eustj ├®crivez
 ! assertion une

Dernier énoncé

Le programme ci-dessous marche

#!/usr/bin/env python
# -*- coding: utf-8 -*-

'''Le programme demande à l'utilisateur le nombre de vers à generer.
Le programme genère autant de vers aleatoires que le nombre entre par l'utilisateur, à partir des mots du poème source et en utilisant la formule syntaxique "article + nom + complement + verbe"
BONUS
Une fois que ça marche deux ameliorations possibles:
* accorder en genre et en nombre les phrases (ortographe inclusive ou non)
* avoir plusieurs formules syntaxiques et les choisir aleatoirement (ou selon une certaine logique) à chaque vers
'''
article = ['les', 'le', 'la', 'un', 'une', 'des', 'de', 'du', 'l\'', 'd\'']
nom = ['ordinateur', 'editions', 'canape', 'mission', 'zero', 'repetition', 'circuits', 'tout', 'code', 'larme' 'saut', 'ligne', 'secret', 'main', 'passe', 'demain', 'mots', 'poeme', 'amour', 'haine', 'interrogation', 'points', 'plus', 'assertion']
complement = ['grand', 'transformiste', 'vrai', 'juste', 'faux', 'noir', 'blanc', 'immenses', 'binaire', 'clair', 'bien']
verbe = ['donne', 'est', 'm\'avaient', 'rythment', 'ecrire', 'ecrivez']
ponctuation = ['…', '!', '?', '.', ',', ':']

import random
import re
from time import sleep
print("Combien j't'en sers ?")
nbre = raw_input()
nbre = int(nbre)

with open('poeme.txt', 'r') as teteLecture:
    poeme = teteLecture.read()

for i in range(0, nbre):
    vers = print(random.choice(article) + " " + random.choice(complement) + " " + random.choice(nom) + " " + random.choice(verbe) + " " + random.choice(ponctuation))

    pt_s_espace = ['.', ',', '…']

    if ponctuation == '.'|','|'…':
        vers = re.sub(' (.|,|…)', r'\1', vers)

    #sleep(0.1)
teteLecture.close()

Le programme marche à peu près en l'état, mais il faut corriger les espaces avant les points et les virgules ainsi que les articles avec apostrophes qui se mettent devant les mots qui commencent par une consonne. Pour régler l'accord en nombre on peut mettre tous les mots au singulier et n'accorder que quand les pronoms pluriels (les, des) sont choisis au hasard.

Combien j't'en sers ?
19
la immenses secret ecrivez !
un noir haine ecrivez ,
une vrai larmesaut ecrivez 
la transformiste zero ecrire !
les transformiste passe ecrivez !
une faux code donne ?
l' transformiste interrogation rythment ?
de clair amour donne 
de blanc plus ecrivez .
le grand amour ecrivez !
l' binaire ordinateur m'avaient ,
les vrai tout est 
du grand canape donne ,
l' binaire ligne donne ?
les clair mots est 
les clair plus m'avaient :
un faux code ecrire !
les grand haine m'avaient ?
un vrai code ecrire !

Version plus améliorée du programme :

(exemples ci-dessous)

Transformiste poeme noir
L'immense plus
Le secret ecrit
Les binaires demains rythment
Les mains,
Une haine binaire et une juste haine
L'immense interrogation
Claire repetition juste
Une repetition transformiste :
Des mains, les haines, un plus !
Les secrets blancs et le faux demain
Les missions blanches,
L'assertion vraie ?
Claire edition transformiste
Un saut juste
Claire mission claire
L'ordinateur juste ou une noire assertion
Blancs ordinateurs clairs
Une grande mission ecrit !
Une noire assertion ecrit,
Les points immenses et blancs
Le poeme ecrit
Noir passe faux
L'edition.
La vraie edition m'avait donne ?
Un mot binaire ou immense
Les blancs codes
Vraies interrogations immenses
Une ligne, des demains, les zeros.
Des sauts vrais ou des fausses assertions
Les transformistes codes ecrivent,
Une transformiste edition...
Les fausses assertions sont
Le plus rythme ?
Les assertions claires ou la vraie edition !
La binaire edition donne
Un code, le circuit, les interrogations
Les binaires secrets m'avaient donne...
L'interrogation ?
Justes mots immenses
Le secret grand :
Des points immenses ou les blancs ordinateurs...
Une haine fausse...
Les justes interrogations sont ?
Le juste secret rythme
Les larmes noires ou immenses
Une haine grande ou une fausse larme
Les mains

Le programme amélioré :

#!/usr/bin/env python
# -*- coding: utf-8 -*-

'''Le programme demande à l'utilisateur le nombre de vers à generer.
Le programme genère autant de vers aleatoires que le nombre entre par l'utilisateur, à partir des mots du poème source et en utilisant la formule syntaxique "article + nom + complement + verbe"
BONUS
Une fois que ça marche deux ameliorations possibles:
* accorder en genre et en nombre les phrases (ortographe inclusive ou non)
* avoir plusieurs formules syntaxiques et les choisir aleatoirement (ou selon une certaine logique) à chaque vers
'''
##définition des listes de mots à utiliser ensuite

#essayer de faire des listes à 2 dimensions (tableaux de tableaux)
singulier = ['le', 'la', 'un', 'une']
pluriel = ['les', 'des']
voyelle = ['l\'', 'd\'']
article = [singulier, singulier, pluriel]
#article = [singulier]

masculin = ['ordinateur', 'canape', 'zero', 'circuit', 'code', 'saut', 'secret', 'passe', 'demain', 'mot', 'poeme', 'amour', 'point', 'plus']
feminin = ['edition', 'mission', 'repetition', 'larme', 'ligne', 'main', 'haine', 'interrogation', 'assertion']
gender = [masculin, feminin]

complement = ['grand', 'transformiste', 'vrai', 'juste', 'faux', 'noir', 'blanc', 'immense', 'binaire', 'clair']
complement_f = ['grande', 'transformiste', 'vraie', 'juste', 'fausse', 'noire', 'blanche', 'immense', 'binaire', 'claire']

verbe = ['donne', 'est', 'm\'avait donne', 'rythme', 'ecrit']
verbe_pl = ['donnent', 'sont', 'm\'avaient donne', 'rythment', 'ecrivent']

ponctuation = [',', ':', '', '', '', '', '', '', '...', '!', '?', '.']
liaison = ['et', 'ou']

autre = ['tout', 'de', 'bien']

import random
import re
from time import sleep

print("Combien j't'en sers ?")
nbre = raw_input()
nbre = int(nbre)

with open('poeme.txt', 'r') as teteLecture:
    poeme = teteLecture.read()

vers = ""
vers_list = []

#générer les composants des vers
for i in range(0, nbre):
    #première fournée
    genre = random.choice(gender)

    if genre == feminin:
        singulier = ['une', 'la']
        s_nom = random.choice(feminin)
        s_complement = random.choice(complement_f)
        s_complementBis = random.choice(complement_f)
        s_article = random.choice(article)

    else:
        singulier = ['le', 'un']
        s_nom = random.choice(masculin)
        s_complement = random.choice(complement)
        s_complementBis = random.choice(complement)
        s_article = random.choice(article)

    if s_article == pluriel:
        s_nom = s_nom +'s'

        if s_complement == 'immense':
            s_articleBis = 'd\''
        else:
            s_articleBis = random.choice(pluriel)

        s_article = random.choice(pluriel)

        s_complement = s_complement + 's'
        s_complementBis = s_complementBis + 's'
        s_verbe = random.choice(verbe_pl)
        s_ponctuation = random.choice(ponctuation)

    else:
        s_verbe = random.choice(verbe)
        if s_complement == 'immense':
            s_articleBis = 'l\''
        else:
            s_articleBis = random.choice(singulier)

        if re.match('^[aeiouy]', s_nom) is not None:
            s_article = 'l\''
        else :
            s_article = random.choice(singulier)

    s_ponctuation = random.choice(ponctuation)

    #deuxième fournée
    genre2 = random.choice(gender)

    if genre2 == feminin:
        singulier = ['une', 'la']
        s_nom2 = random.choice(feminin)
        s_complement2 = random.choice(complement_f)
        s_article2 = random.choice(article)

    else:
        singulier = ['le', 'un']
        s_nom2 = random.choice(masculin)
        s_complement2 = random.choice(complement)
        s_article2 = random.choice(article)

    if s_article2 == pluriel:
        s_nom2 = s_nom2 +'s'
        s_article2 = random.choice(pluriel)
        s_complement2 = s_complement2 + 's'

        if s_complement2 == 'immense':
            s_articleBis2 = 'd\''
        else:
            s_articleBis2 = random.choice(pluriel)
    else:
        if s_complement2 == 'immense':
            s_articleBis2 = 'l\''
        else:
            s_articleBis2 = random.choice(singulier)

        if re.match('^[aeiouy]', s_nom) is not None:
            s_article2 = 'l\''
        else :
            s_article2 = random.choice(singulier)

    #troisième fournée
    genre3 = random.choice(gender)

    if genre3 == feminin:
        singulier = ['une', 'la']
        s_nom3 = random.choice(feminin)
        s_complement3 = random.choice(complement_f)
        s_article3 = random.choice(article)

    else:
        singulier = ['le', 'un']
        s_nom3 = random.choice(masculin)
        s_complement3 = random.choice(complement)
        s_article3 = random.choice(article)

    if s_article3 == pluriel:
        s_nom3 = s_nom3 +'s'
        s_complement3 = s_complement3 + 's'
        s_article3 = random.choice(pluriel)

    else:
        if re.match('^[aeiouy]', s_nom) is not None:
            s_article3 = 'l\''
        else :
            s_article3 = random.choice(singulier)

#composition des vers
    choix = random.randint(1, 3)
    if choix == 1:
        vers = s_articleBis + " " + s_complement + " " + s_nom + s_ponctuation
    else:
        vers = s_articleBis + " " + s_complement + " " + s_nom + " " + s_verbe + s_ponctuation

    if choix == 1:
        vers2 = s_article + " " + s_nom + s_ponctuation
    else:
        vers2 = s_article + " " + s_nom + " " + s_verbe + s_ponctuation

    if choix == 1:
        vers3 = s_article + " " + s_nom + s_ponctuation
    else:
        vers3 = s_article + " " + s_nom + " " + s_complement + s_ponctuation

    vers4 = s_complement + " " + s_nom + " " + s_complementBis
    vers5 = s_article + " " + s_nom + ", " + s_article2 + " " + s_nom2 + ", " + s_article3 + " " + s_nom3 + s_ponctuation
    vers6 = s_article + " " + s_nom + " " + s_complement + " " + random.choice(liaison) + " " + s_articleBis2 + " " + s_complement2 + " " + s_nom2 + s_ponctuation
    vers7 = s_article + " " + s_nom + " " + s_complement + " " + random.choice(liaison) + " " + s_complementBis

    #crée une liste de vers possible et choisit un vers. (il y a plusieurs fois vers pour influencer la probabilité que vers apparaissent plus souvent que les autres)
    vers_list = [vers, vers, vers2, vers3, vers4, vers5, vers6, vers7]
    #vers_list = [vers]

    '''print('s_nom :')
    print(type(s_nom))
    print('s_article :')
    print(type(s_article))
    print('s_complement :')
    print(type(s_complement))
    print('s_nom2 :')
    print(type(s_nom2))
    print('s_article2 :')
    print(type(s_article2))
    print('s_complement2 :')
    print(type(s_complement2))
    print('s_nom3 :')
    print(type(s_nom3))
    print('s_article3 :')
    print(type(s_article3))
    print('s_complement3 :')
    print(type(s_complement3))
    print('s_ponctuation :')
    print(type(s_ponctuation))
    print('s_verbe :')
    print(type(s_verbe))'''

    oui = random.choice(vers_list)

    #met la première lettre du vers en capitale
    oui = oui[0].upper() + oui[1:]
    #met une espace avant les caractères qui en nécessitent une typographiquement
    oui = re.sub(r'(:|\?|!)$', r' \1', oui)
    #supprime les erreurs
    oui = re.sub('fauxs', 'faux', oui)
    oui = re.sub('pluss', 'plus', oui)
    oui = re.sub('(.\') ', r'\1', oui)

    print(oui)
    #sleep(0.1)

#verbes ne se mettent pas au pluriel à la fin de vers
#pas de point sur la dernière ligne

teteLecture.close()

HTML2PRINT

Créer un recueil de poèmes mis en page grâce à HTML/CSS (et possiblement js ?)

Idées

Je pourrais faire un programme qui génère (avec le programme du dernier énoncé aléat.py) à chaque page le nombre de vers correspondant au nombre de pages souhaitées (sur la page 1 il y aurait 1 vers et sur la page 36 il y aurait 36 vers par exemple). Le corps de texte s'adapterait automatiquement pour que tout rentre sur une seule page. On pourrait choisir de générer autant de pages que l'on veut


Writing bot

idées

Créer un bot qui fait un voyage dans la campagne à travers des villes/villages avec des noms rigolos. Tous les jours, il poste le nom d'un village de moins de XXX habitants, avec une photo de ce village. Le village suivant est choisi suivant ces paramètres : - la taille du village (moins de XXX habitants) - la distance (possibilité d'y aller à moins de 8h de marche depuis le village du jour) - direction aléatoire en (évitant peut-être les demi-tours complets ?) - pas 2 fois le même village

Créer un bot qui fait des mots-valises ((dans quel contexte ?))

Créer un bot qui donne des avant-goûts gratuits d'images de sites de stock photos ou vidéos :

  • (pour "pomme" sur Shutterstock) -> Pommes isolées. Fruit de pomme rouge entier avec tranche (coupée) isolé sur blanc avec chemin de détourage
  • (pour "roux" sur Shutterstock) -> Capture d'écran d'un homme caucasien séduisant avec une barbe de gingembre épaisse et une coupe de cheveux branchée, habillé en t-shirt blanc décontracté, regardant directement la caméra, portant des lunettes rondes, isolé sur fond blanc
  • (pour "connexion" sur Shutterstock) -> Deux mains en aidant une autre. Des gens s'aidant les uns les autres.


L'idée serait de poster la description des images de sites de stock photos qui est souvent très détaillée pour avoir plein de mots clés, sans que l'on puisse voir l'image. La description rajoute des interprétations du contexte de l'image, ce qui est intéressant car ces images sont utilisées souvent car elles n'ont pas de contexte et peuvent être accolées à n'importe quoi pour être une simple illustration. Exemple :

(pour "énervé" sur Shutterstock) -> Une jeune femme énervée et furieuse, furieuse et folle de spams, téléphone bloqué, regardant un smartphone isolé sur fond studio vierge, adolescente furieuse ayant des problèmes avec son téléphone portable, irritée par un téléphone portable cassé

Permet de stimuler l'imagination sans débourser un rond.
Le choix du mot pourrait être au hasard, ou bien partir d'un mot existant dans la définition précédente (risque de tourner en rond ?). Il y aurait sûrement besoin d'un peu de NLP (Natural Language Processing) pour ne pas choisir des stopwords.

Pour le choix de l'image dans les résultats de recherche je ne sais pas comment procéder. Sur le site des descriptions en français et anglais cohabitent, mais j'aimerais ne garder que celles en français car elles ont des formulations particulières (peut-être des traductions automatiques ? Mais alors pourquoi certaines restent en anglais ?).

Il y a souvent plusieurs phrases, qui vont du contexte général de ce qui est représenté (une personne fait telle action pour telle raison) à des détails plus techniques (isolé sur fond blanc, détourage, illustration vectorielle...). J'aimerais ne pas garder ces descriptions qui sortent du contexte d'une narration et renvoie vers le type d'image.

Pour le réseau utilisé je ne sais pas lequel serait le plus judicieux. Peut être que la limitation de Twitter en terme de nombre de caractères est intéressante ? Ça peut couper une description à un moment et créer une sorte de cliffhanger ?

Le bot serait une sorte de Père Castor qui raconte des "histoires" sans les images, peut-être que ça peut être à l'heure où on couche les enfants, tous les soirs ?
Ou alors il en poste plusieurs à la suite (5-10 ?) et fait un lien entre tous pour créer une petite histoire du soir ?

En fait c'est pas assez narratif mais c'est rigolo quand même :/.

balade_campagnarde.py

Mise au point du fonctionnement

Le site https://territoires-fr.fr/communes-list1.php peut peut-être être utile.

Le programme part d'un endroit sur la carte (chez moi en France par exemple). Avec l'API de TomTom et les filtres on peut créer un cercle dans un rayon de XXX km dans lequel on peut chercher des POI (points of interest)

L'API de TomTom recherche le point d'intérêt "mairie" ou "village" dans un certain rayon, et récupère la ville où elle se trouve. Grâce au site territoires-fr on peut vérifier : que le village est assez petit (pas plus de XXX habitants), car grâce à l'API TomTom on connaît le département et la ville dans laquelle on se trouve.

Le bot Twitter poste le nom de la ville/village en question, puis une photo de l'endroit (possible avec TomTom ? Google Street View ? Sinon avec Google Images).

Si la ville/village en question a un compte Twitter, le bot pourrait poster une photo/retweeter un message de la ville pour dire qu'il est passé par là.


Liens utiles :


J'arrive pas trop à trouver comment trouver des villes sur l'API de TomTom, dans les paramètre de recherche on peut rechercher un point d'intérêt dans un rayon autour du point où on se trouve, mais quand on recherche "ville" ou "mairie" ça marche pas vraiment. C'est plus fait pour rechercher une pizzeria ou une station essence pas loin de nous.

Donc j'ai récupéré un fichier.csv du site data.gouv.fr [2] qui devrait me permettre de créer un rayon juste en utilisant les données géolocalisées.
Par exemple je peut rechercher les villes/villages qui correspondent à une distance de XXX km autour de là où on se trouve en disant de rechercher les correspondances entre les latitudes x+r et x-r et les longitudes y+r et y-r (ou x et y sont les latitudes/longitudes de la position actuelle et r le rayon d'action).

Ensuite on a une liste de matches qui vont dans une liste en python (avec leur code postal), et on peut alors chercher dans les détails de la commune pour avoir le nombre d'habitants :

https://territoires-fr.fr/communes-detail.php?dep=35&com=001&actual=1
Avec dep=(le numéro de département) et com=(le numéro de la commune), on tombe sur la page de la commune avec dans le tableau le nombre d'habitants. L'idée est de supprimer les communes trop grandes (plus de 5000 habitants ?) pour mettre en valeur les campagnes du terroir.

Ou alors on peut aller sur Wikipédia qui a peut-être des infos mises à jour plus régulièrement
(exemple : https://fr.wikipedia.org/wiki/Liste_des_communes_de_l'Ain )
et qui évite de devoir faire 1000 requêtes puisqu'on a direct le nom de la commune + le nombre d'habitants dans le tableau (sachant qu'on a accès au nom des communes et des départements dans le .csv du gouvernement)

Par contre il y a sûrement plusieurs lieux-dits avec le même code postal, ça va être plus long à régler.

En fait le plus simple est de supprimer du csv toutes les villes ayant plus de x habitants, comme ça le programme ne les détectera pas de toute façon dans son rayon.
Pour ça je vais utiliser cette page de Wikipédia [3] qui va me permettre, grâce au numéro des départements, de trouver toutes les pages listant les communes fraçaises par département. Ensuite je n'ai plus qu'à faire un tableau des communes de plus de x habitants et dans mon csv je supprime ces villes.

Peut-être que l'API TomTom peut servir pour le "routing", pour créer le chemin/le temps de trajet d'une commune à l'autre. (qui peut être posté dans le tweet du bot). Ça permettrait même éventuellement de faire une carte qui se remplit au fur et à mesure pour voir le chemin total parcouru

Schéma approximatif des étapes de fonctionnement

SchémaCampagne.png

Préparation du tableau

J'ai retaillé le tableau pour enlever les colonnes qui ne servaient à rien, et on utilisant le module csv j'ai pu transformer mon fichier en dictionnaire (plus ou moins un tableau de tableaux). J'ai donc maintenant 6 tableaux qui me permettent de trouver le nom des communes qui correspondent à une certaine longitude/latitude ou à un département par exemple.

#!/usr/bin/env python3
#coding: utf-8

import csv

d = {}
d['numéro_département'] = []
d['nom_département'] = []
d['nom_commune'] = []
d['codes_postaux'] = []
d['latitude'] = []
d['longitude'] = []

with open('tableau_simplifié.csv', 'r+') as csvfile:
    reader = csv.DictReader(csvfile)
    for row in reader:
        for i in range (0,6):
            valeur = list(row.items())[i][0]
            d[valeur].append(row[valeur])
            print(valeur + ' = ' + row[valeur])
        print('')

Maintenant on passe au scraping du nombre d'habitants sur Wikipédia. Je part de la page https://fr.wikipedia.org/wiki/Listes_des_communes_de_France et j'utilise les librairies mechanize, lxml et cssselector

#!/usr/bin/env python3
#coding: utf-8

###TWITTER API
from accès import *
import tweepy

###TEMPORAIRE
import lxml.html as parser
import cssselect, mechanize

###avec mechanize
br = mechanize.Browser()
br.addheaders = [('User-agent', 'Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0')]
br.set_handle_robots(False)

data = br.open('https://fr.wikipedia.org/wiki/Listes_des_communes_de_France')

source = data.read()
tree = parser.fromstring(source)
num_dpt = []
lien_dpt = []

for selector in cssselect.parse('table.wikitable:nth-of-type(2) td:nth-child(3)'):
    ##on convertit l'objet selector en xpath
    xpath_selector = cssselect.HTMLTranslator().selector_to_xpath(selector)
    ##pour chaque lien trouvé par ce xpath
    for link in tree.xpath(xpath_selector):
        num_dpt.append(link.text_content().rstrip())

for selector in cssselect.parse('td:nth-child(5)'):
    ##on convertit l'objet selector en xpath
    xpath_selector = cssselect.HTMLTranslator().selector_to_xpath(selector)
    ##pour chaque lien trouvé par ce xpath
    for link in tree.xpath(xpath_selector):
        lien_dpt.append(link.text_content().rstrip())

for i in range(len(num_dpt)):
    try:
        print('%s => %s' % (num_dpt[i], lien_dpt[i]))
    except:
        print('zut')

Ce bout de code permet de récupérer les 3e et 5e éléments du 2e tableau, c'est-à-dire les numéros de département ainsi que les liens vers les liste des communes par département (à partir de la page Wikipédia citée plus haut).

Mais ça me sert à rien, j'avais juste besoin des liens en fait (5e colonne du 2e tableau).

J'ai réussi à récupérer les liens dans la 5e colonne du 2e tableau de la page "Liste des communes de France" avec la méthode (?) .get('href') qui me permet de récupérer le contenu de l'attribut href des éléments a dans le tableau.

Maintenant pour chacun de ces liens je dois récupérer les valeurs de la colonne "Nom de la commune" et "Nombre d'habitants". Pour cela même principe en changeant les sélecteurs CSS. MAIS subtilités il faut faire attention de sélectionner le bon tableau avec :nth-of-type(), parce que pour certains départements il y a plusieurs tableaux, donc le script peut récupérer les colonnes de tous les tableaux de la page (là c'était un peu relou, il y a plusieurs types de pages donc c'était long de trouver la règle commune qui marche pour tous les départements).

J'ai fait une grosse fonction qui prend plusieurs paramètres et me permet de récupérer soit les liens, soit les habitants/communes :

def getLiens(url, css_select, type):
    data = br.open(url, timeout=50)
    source = data.read()
    tree = parser.fromstring(source)

    liens = []
    habitants = []
    commune = []

    if type == 'liens':
        for selector in cssselect.parse(css_select):
            ##on convertit l'objet selector en xpath
            xpath_selector = cssselect.HTMLTranslator().selector_to_xpath(selector)
            ##pour chaque lien trouvé par ce xpath
            for link in tree.xpath(xpath_selector):
                href = link.get('href')
                liens.append(wiki_base+href)
            return liens

    elif type == 'habitants':
        results = []
        for selector in cssselect.parse(css_select):
            ##on convertit l'objet selector en xpath
            xpath_selector = cssselect.HTMLTranslator().selector_to_xpath(selector)
            ##pour chaque lien trouvé par ce xpath
            for link in tree.xpath(xpath_selector):
                hab = link.text
                # hab = re.sub(r"\s+", "", hab, flags=re.UNICODE)
                hab = re.sub(r"\s+", "", hab)
                habitants.append(int(hab))

        # for selector in cssselect.parse('table.wikitable.sortable:nth-of-type(1) td:nth-child(1)'):
        for selector in cssselect.parse('table.wikitable.sortable.titre-en-couleur td:nth-child(1)'):
            ##on convertit l'objet selector en xpath
            xpath_selector = cssselect.HTMLTranslator().selector_to_xpath(selector)
            ###pour chaque lien trouvé par ce xpath
            for link in tree.xpath(xpath_selector):
                com = link.text_content().rstrip()
                ###suppriemer les parenthèses si besoin
                com = re.sub(r"\(.+\)", "", com)
                commune.append(com)
            return habitants, commune

Debugging

Permet de tester à quelle(s) ligne(s) ça bugge :

for i in liens_dpt:
## choper les noms des communes et le nombre d'habitants de chaque département
    try:
        alors = getLiens(i, 'td:nth-child(8)', 'habitants')

###problème de longueur des arrays : il prend en compte les mauvais tableaux pour :nth-child(1)
        if len(alors[0]) == len(alors[1]):
            print('yes')
        else:
            print('%d oh non' % count)
    except:
        print('%d bug de liens' % count)
        coucount.append(count)

    count += 1


Permet de tester la ligne (cette page département) en particulier pour trouver qu'est-ce que le script a mal sélectionné :

alors = getLiens(liens_dpt[56], 'td:nth-child(8)', 'habitants')

for i in alors[1]:
    print(i)
print('len_arr =  %s' % len(alors[1]))

Ça m'a permis de trouver que pour certaines pages les tableaux ne sont pas dans le même ordre, et n'ont pas la même classe. Il doit y avoir 6 pages pour lesquelles je dois faire des conditions et changer le sélecteur précisément pour chaque page (un plaisir).

J'ai réussi à corriger le script pour rajouter des exceptions à chaque page qui posait problème.

    if dpt == 44:
            css_select = 'table.wikitable.sortable.titre-en-couleur td:nth-child(8)'
        elif dpt == 48:
            css_select = 'table.wikitable.sortable:nth-of-type(2) td:nth-child(8)'
        elif dpt == 70:
            css_select = 'table.wikitable.sortable.titre-en-couleur td:nth-child(5)'
        elif dpt == 95:
            css_select = 'table.wikitable.sortable.titre-en-couleur td:nth-child(8)'
        elif dpt == 103:
                css_select = 'table.wikitable.sortable.titre-en-couleur td:nth-child(5)'


        if dpt == 56:
            css_select_2 = 'table.wikitable.sortable td:nth-child(1)'
        else:
            css_select_2 = 'table.wikitable.sortable.titre-en-couleur td:nth-child(1)'

Maintenant il fait que je supprime du tableau les villes de plus de 2000 habitants (c'est la limite entre village et ville [4]).
Pour ça je vais créer un fichier texte avec le nom de toutes les communes dépassant le seuil de 2000 habitants. Apparemment il n'y a que 5413 communes en France qui ont plus de 2000 habitants. Sur 36 000, il y a donc une grande majorité de villages. Ensuite je n'aurais plus qu'à supprimer dans le tableau les lignes correspondant à ces communes.

Supression

Il y a certaines lignes qui n'ont pas les données de latitude/longitude dans le tableau, ou qui n'ont pas de valeur pour la longitude ("-") : on les supprime aussi.

#!/usr/bin/env python3
#coding: utf-8

import csv

###fonction pour supprimer les lignes qu'on veut pas
def supp(arr):
    for didi in d:
        for r in range(len(arr)):
            ###petite astuce : puisque pop() enlève une valeur il change l'index de toutes les autres. Il faut donc compenser en faisant -r, pour retrouver la bonne valeur
            d[didi].pop(arr[r]-r)

d = {}
d['index_commune'] = []
d['nom_commune'] = []
d['latitude'] = []
d['longitude'] = []

rows = []

##########################LIRE LE CSV##########################
with open('tableau_simplifié.csv', 'r+') as csvfile:
    reader = csv.DictReader(csvfile)
    for row in reader:
        for i in range (0,4):
            valeur = list(row.items())[i][0]
            d[valeur].append(row[valeur])

##########################ENLEVER LES LIGNES VIDES (SANS LONG/LAT)###########################
for i in range(len(d['longitude'])):
    if d['longitude'][i] == "" or d['longitude'][i] == "-":
        # print('vide')
        rows.append(i)
 
###il y a 2875 communes pour lesquelles on a pas la valeur de la latitude/longitude : on les supprime du csv
supp(rows)

##########################ENLEVER LES COMMUNES DE + DE 2000 HAB###########################
with open('villes1999', 'r+', encoding='utf8') as g:
    file = g.read()
    villes = file.splitlines()

liste_villes = []

for r in range(len(d['nom_commune'])):
    # print(d['nom_commune'][r])
    if d['nom_commune'][r] in villes:
        liste_villes.append(r)
###on supprime aussi les 5000 et quelques villes
supp(liste_villes)

Maintenant il faut recréer un nouveau fichier avec les valeurs du dictionnaire, pour éviter que cette étape de suppression se fasse à chaque fois. Le plus simple est alors du json, parce que les opérations d'encodage/décodage en python sur du json marchent bien et sont efficaces.

Encodage/décodage

Le code pour convertir le dictionnaire "d" en un fichier json (le mode 'w' pour write -> écriture) :

with open('result.json', 'w', encoding="utf8") as fp:
    json.dump(d, fp)

(s'éxécute une seule fois, lors de la création du fichier result.json)

et le code pour le décoder (le mode 'r' pour read -> lecture) :

with open('result.json', 'r', encoding="utf8") as f:
    data = f.read()
    d = json.loads(data)

(s'exécute chaque lancement de programme, pour récupérer la "base de données")

Ne pas oublier le encoding='utf8', pour ne pas avoir des noms de communes qui font bugger les accents !

Trouver les communes dans un rayon donné

J'ai réussi à faire une fonction qui vérifie si il y a des communes dans le rayon en latitude, mais maintenant il faut que je trouve comment garder en mémoire les index pour checker seulement sur ceux-ci la longitude. Pour ça j'utilise des tuples qui me permettent de garder en mémoire l'index des communes correspondant pour la latitude, pour pouvoir les tester sur la longitude.

Le point de coordonnées lat_base et long_base change chaque jour.

La variable km_lat est une approximation en degrés de la longueur d'1 km. Comme ça on peut facilement changer le rayon r en un nombre de kilomètres différent (ici c'est 25km pour l'instant).

###fonction qui checke si la latitude est comprise dans le rayon voulu
def check_lat(val):
    if lat_base - r <= val <= lat_base + r:
        return True
    return False

###fonction qui checke si la longitude est comprise dans le rayon voulu
def check_long(val):
    if long_base-r <= val <= long_base+r:
        return True
    return False

lat_base = float('48.632954')
long_base = float('-2.874094')
#1 km +- = à km_lat degrés
km_lat = 0.0090437173295
#r correspond environ à un rayon de 25 km
r = 25*km_lat

foirages = 0

# print(lat_base)
# print(long_base)
compteur = 0

###on crée 2 listes pour ranger les valeurs correspondant au rayon souhaité
lat_good = []
long_good = []

###affiche seulement les communes qui correspondent et leur nom
for index in range(len(d['latitude'])):
    try:
        if check_lat(float(d['latitude'][index])):
            # print(d['nom_commune'][index])
            tuplo = (index, d['nom_commune'][index])
            lat_good.append(tuplo)
    except:
        foirages += 1
        print('oupsi')

for i in lat_good:
    try:
        if check_long(float(d['longitude'][i[0]])):
            long_good.append(i)
            print(i[1])
            compteur += 1
    except:
        print('%s oupso -> %s' % (i[0], d['longitude'][i[0]]))
        foirages +=1

##affiche le nombre de communes matchant avec la requête
print('\n%s communes correspondantes' % compteur)
print('foirages-> %s' % foirages)

Ce bout de code affiche le nom des communes qui correspondent au rayon donné (et les stocke en même temps dans une liste).
Le problème est que certaines communes n'ont pas de valeur pour la longitude dans le csv de départ (bizarre mais bon). Il faut donc que je modifie mon json pour enlever ces valeurs qui ne marchent pas.

Ensuite il faut juste que je choisisse une commune au hasard.

print(random.choice(long_good)[1])