commited all contents created by participants
This commit is contained in:
Bachir Soussi Chiadmi
Binary file not shown.
Binary file not shown.
|
After Width: | Height: | Size: 250 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 135 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 135 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 65 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 239 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 65 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 230 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 270 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 135 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 65 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 183 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 239 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 235 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 141 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 148 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 188 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 125 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 121 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 250 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 250 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 270 KiB |
@@ -0,0 +1,7 @@
|
||||
---
|
||||
Author: Léo Coquet
|
||||
Title: Archi-écriture
|
||||
Src: sources/diff_permute.txt
|
||||
---
|
||||
|
||||
Relecture d'un extrait d'"Écriture et différence" par un programme basé sur le concept derridien de la "différance".
|
||||
@@ -0,0 +1,12 @@
|
||||
---
|
||||
Author: Léo Coquet
|
||||
Title: Archi-écriture
|
||||
Src: sources/diff_permute.txt
|
||||
---
|
||||
|
||||
Relecture d'un extrait de "L'Écriture et la Différence" par un programme basé sur le concept derridien de la différance.
|
||||
|
||||
!images/ecritureetdifference.jpeg!
|
||||
|
||||
Écrire différemment des mots qui se prononcent de la même manière.
|
||||
Disséminer de la différence sans qu'elle ne soit audible.
|
||||
@@ -0,0 +1,9 @@
|
||||
---
|
||||
Author: Léo Coquet
|
||||
Title: Archi-écriture
|
||||
Src: sources/diff_permute.txt
|
||||
---
|
||||
|
||||
Relecture d'un extrait de "L'Écriture et la Différence" par un programme basé sur le concept derridien de la différance.
|
||||
Écrire différemment des mots qui se prononcent de la même manière.
|
||||
Disséminer de la différence sans qu'elle ne soit audible.
|
||||
@@ -0,0 +1,14 @@
|
||||
h1. Différance
|
||||
|
||||
h2. Léo Coquet
|
||||
|
||||
Relecture d'un extrait d'"Écriture et différence" par un programme basé sur le concept derridien de la "différance".
|
||||
|
||||
!images/tutorial-getting-started-krita_part1_14_net.jpg!
|
||||
|
||||
Pour insérer des images, comme des shoot écrans de votre travail, commencez par les déposer dans le dossier images de votre dossier perso
|
||||
puis ajouter cette ligne:
|
||||
|
||||
bc. !images/nomdemonimage.jpeg!
|
||||
|
||||
Toutes les images seront insérez automatiquement a la fin de votre description dans la documentation finale, sauf celle ajouté manuellement dans le texte.
|
||||
@@ -0,0 +1,5 @@
|
||||
h1. Archi-écriture
|
||||
|
||||
h2. Léo Coquet
|
||||
|
||||
Relecture d'un extrait d'"Écriture et différence" par un programme basé sur le concept derridien de la "différance".
|
||||
@@ -0,0 +1,6 @@
|
||||
h1. Archi-écriture
|
||||
|
||||
h2. Léo Coquet
|
||||
|
||||
Relecture d'un extrait de "L'Écriture et la Différence" par un programme basé sur le concept derridien de la différance.
|
||||
!images/ecritureetdifference.jpeg!
|
||||
@@ -0,0 +1,5 @@
|
||||
h1. Archi-écriture
|
||||
|
||||
h2. Léo Coquet
|
||||
|
||||
Relecture d'un extrait de "L'Écriture et la Différence" par un programme basé sur le concept derridien de la différance.
|
||||
@@ -0,0 +1,6 @@
|
||||
|
||||
h1. Archi-écriture
|
||||
|
||||
h2. Léo Coquet
|
||||
|
||||
Relecture d'un extrait de "L'Écriture et la Différence" par un programme basé sur le concept derridien de la différance.
|
||||
@@ -0,0 +1,58 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
'ai' : 'ê' ,
|
||||
'li' : 'ly' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("texteSOURCE.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("texteDESTINATION.txt", "w") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,58 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
'ai' : 'ê' ,
|
||||
'li' : 'ly' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("texteINPUT.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("texteOUTPUT.txt", "w") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,58 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
'ai' : 'ê' ,
|
||||
'li' : 'ly' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("texteSOURCE.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("texteDESTINATION.txt", "w") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,58 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
'ai' : 'ê' ,
|
||||
'li' : 'ly' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("texteINPUT.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("texteOUTPUT.txt", "w") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,58 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
'ai' : 'ê' ,
|
||||
'li' : 'ly' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("texteINPUT", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("texteOUTPUT", "w") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,58 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
'ai' : 'ê' ,
|
||||
'li' : 'ly' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("diff.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("diff_permute.txt", "w") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,58 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
'ai' : 'ê' ,
|
||||
'li' : 'ly' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("texteSOURCE.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("texteDESTINATION.txt", "w") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
+54
@@ -0,0 +1,54 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'f' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'y' : 'i' ,
|
||||
'ss' : 'ç' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("diff.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("diff_permute.txt", "w") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
+59
@@ -0,0 +1,59 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'f' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'y' : 'i' ,
|
||||
'ss' : 'ç' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("diff.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
print("word", word)
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
print("key", key)
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
print("key in word", key)
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
print("aleatoire dict", aleatoire)
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
print('\n')
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("diff_permute.txt", "w") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,56 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("diff.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("diff_permute.txt", "w") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,58 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
'ai' : 'ê' ,
|
||||
'li' : 'ly' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("diff.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("diff_permute.txt", "w") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,59 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
'ai' : 'ê' ,
|
||||
'li' : 'ly' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("diff.txt", "r", encoding="ISO-8859-1") as source:
|
||||
print("texte source", source)
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("diff_permute.txt", "w") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,58 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
'ai' : 'ê' ,
|
||||
'li' : 'ly' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("diff.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("diff_permute.txt", "w") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,58 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
'ai' : 'ê' ,
|
||||
'li' : 'ly' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("texteINPUT.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("texteOUTPUT.txt", "w") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,26 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#Passer un texte en liste de mots séparés
|
||||
with open("diff.txt", "r") as source:
|
||||
for line in source:
|
||||
words = line.split(" ")
|
||||
print(words)
|
||||
|
||||
#Créez un ensemble de relations
|
||||
permutations = {
|
||||
'ph' : 'f' ,
|
||||
'qu' : 'kh' ,
|
||||
'y' : 'i' ,
|
||||
't' : 'th' ,
|
||||
'ê' : 'ai' ,
|
||||
'ss' : 'ç' ,
|
||||
}
|
||||
|
||||
def permutation_possible_mot ( mot ) :
|
||||
liste = []
|
||||
|
||||
'''
|
||||
with open(fichier_texte, "w") as destination:
|
||||
destination.write(sentence)
|
||||
'''
|
||||
@@ -0,0 +1,25 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
#Le séparer en lignes
|
||||
#le séparer en mots
|
||||
with open("diff.txt", "r") as source:
|
||||
for line in source:
|
||||
words = line.split(" ")
|
||||
print(words)
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ph' : 'f' ,
|
||||
'qu' : 'kh' ,
|
||||
'y' : 'i' ,
|
||||
't' : 'th' ,
|
||||
'ê' : 'ai' ,
|
||||
'ss' : 'ç' ,
|
||||
}
|
||||
|
||||
'''
|
||||
with open(fichier_texte, "w") as destination:
|
||||
destination.write(sentence)
|
||||
'''
|
||||
@@ -0,0 +1,31 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
diff_words = []
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ph' : 'f' ,
|
||||
'qu' : 'kh' ,
|
||||
'y' : 'i' ,
|
||||
't' : 'th' ,
|
||||
'ê' : 'ai' ,
|
||||
'ss' : 'ç' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
#Le séparer en lignes
|
||||
#le séparer en mots
|
||||
with open("diff.txt", "r", encoding="ISO-8859-1") as source:
|
||||
for line in source:
|
||||
words = line.split(" ")
|
||||
for word in words:
|
||||
for key, value in permutations.items():
|
||||
if key in word:
|
||||
word = word.replace(key, value)
|
||||
diff_words.append(word)
|
||||
|
||||
|
||||
with open("diff_permute.txt", "w") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
|
||||
@@ -0,0 +1,25 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
#Le séparer en lignes
|
||||
#le séparer en mots
|
||||
with open("diff.txt", "r") as source:
|
||||
for line in source:
|
||||
words = line.split(" ")
|
||||
print(words)
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ph' : 'f' ,
|
||||
'qu' : 'kh' ,
|
||||
'y' : 'i' ,
|
||||
't' : 'th' ,
|
||||
'ê' : 'ai' ,
|
||||
'ss' : 'ç' ,
|
||||
}
|
||||
|
||||
'''
|
||||
with open(fichier_texte, "w") as destination:
|
||||
destination.write(sentence)
|
||||
'''
|
||||
@@ -0,0 +1,7 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
sentence = "Aussi, ne pouvant échapper à l'ascendance de la lumière"
|
||||
sentence.replace('i' , 'y')
|
||||
sentence = sentence.replace('i' , 'y')
|
||||
print(sentence)
|
||||
@@ -0,0 +1,7 @@
|
||||
# Write sentence as string
|
||||
sentence = "Ne nous arrêtons pas ici à ce qui peut ressembler à l'essence du mythique"
|
||||
# Print sentence
|
||||
print(sentence)
|
||||
|
||||
sentence = sentence.replace("c", "ss").replace("qu", "kh")
|
||||
print(sentence)
|
||||
@@ -0,0 +1,5 @@
|
||||
# Write sentence as string
|
||||
sentence = "Ne nous arrêtons pas ici à ce qui peut ressembler à l'essence du mythique"
|
||||
|
||||
sentence = sentence.replace("c", "ss").replace("qu", "kh")
|
||||
print(sentence)
|
||||
@@ -0,0 +1,11 @@
|
||||
with open("ecriture_et_difference.txt", "r") as source:
|
||||
|
||||
# Split sentence into words
|
||||
words = sentence.split()
|
||||
print(words)
|
||||
|
||||
sentence = sentence.replace("c", "ss").replace("qu", "kh")
|
||||
print(sentence)
|
||||
|
||||
with open(fichier_texte, "w") as destination:
|
||||
destination.write(sentence)
|
||||
@@ -0,0 +1,10 @@
|
||||
with open("ecriture_et_difference.txt", "r") as source:
|
||||
for line in source:
|
||||
line = line.strip()
|
||||
sentence = line.split()
|
||||
print(sentence)
|
||||
sentence = sentence.replace("c", "ss").replace("qu", "kh")
|
||||
print(sentence)
|
||||
|
||||
with open(fichier_texte, "w") as destination:
|
||||
destination.write(sentence)
|
||||
@@ -0,0 +1,8 @@
|
||||
with open("ecriture_et_difference.txt", "r") as source:
|
||||
# for each line
|
||||
for line in source:
|
||||
words = sentence.split(" ")
|
||||
print(words)
|
||||
|
||||
with open(fichier_texte, "w") as destination:
|
||||
destination.write(sentence)
|
||||
@@ -0,0 +1,8 @@
|
||||
# Write sentence as string
|
||||
sentence = "Je vois La Vie en rose..."
|
||||
# Print sentence
|
||||
print("phrase originale:", sentence)
|
||||
|
||||
# Split sentence into words
|
||||
words = sentence.lower().split()
|
||||
print(words)
|
||||
@@ -0,0 +1,8 @@
|
||||
# Write sentence as string
|
||||
sentence = "Ne nous arrêtons pas ici à ce qui peut ressembler à l'essence du mythique"
|
||||
# Print sentence
|
||||
print("phrase originale:", sentence)
|
||||
|
||||
# Split sentence into words
|
||||
words = sentence.split()
|
||||
print(words)
|
||||
@@ -0,0 +1,11 @@
|
||||
# Write sentence as string
|
||||
sentence = "Ne nous arrêtons pas ici à ce qui peut ressembler à l'essence du mythique"
|
||||
# Print sentence
|
||||
print(sentence)
|
||||
|
||||
# Split sentence into words
|
||||
words = sentence.split()
|
||||
print(words)
|
||||
|
||||
sentence = sentence.replace("c", "ss")
|
||||
print(sentence)
|
||||
@@ -0,0 +1,11 @@
|
||||
# Write sentence as string
|
||||
sentence = "Ne nous arrêtons pas ici à ce qui peut ressembler à l'essence du mythique"
|
||||
# Print sentence
|
||||
print(sentence)
|
||||
|
||||
# Split sentence into words
|
||||
words = sentence.split()
|
||||
print(words)
|
||||
|
||||
sentence = sentence.replace("c", "ss").replace("qu", "kh")
|
||||
print(sentence)
|
||||
@@ -0,0 +1,11 @@
|
||||
# Write sentence as string
|
||||
sentence = "Ne nous arrêtons pas ici à ce qui peut ressembler à l'essence du mythique"
|
||||
# Print sentence
|
||||
print(sentence)
|
||||
|
||||
# # Split sentence into words
|
||||
# words = sentence.split()
|
||||
# print(words)
|
||||
|
||||
sentence = sentence.replace("c", "ss").replace("qu", "kh")
|
||||
print(sentence)
|
||||
@@ -0,0 +1,14 @@
|
||||
# Write sentence as string
|
||||
sentence = "Ne nous arrêtons pas ici à ce qui peut ressembler à l'essence du mythique"
|
||||
# Print sentence
|
||||
print(sentence)
|
||||
|
||||
# # Split sentence into words
|
||||
# words = sentence.split()
|
||||
# print(words)
|
||||
|
||||
sentence = sentence.replace("c", "ss").replace("qu", "kh")
|
||||
print(sentence)
|
||||
|
||||
with open("differance.txt", "w") as destination:
|
||||
destination.write(sentence)
|
||||
@@ -0,0 +1,17 @@
|
||||
|
||||
fichier_texte = "differance.txt"
|
||||
|
||||
# Write sentence as string
|
||||
sentence = "Ne nous arrêtons pas ici à ce qui peut ressembler à l'essence du mythique"
|
||||
# Print sentence
|
||||
print(sentence)
|
||||
|
||||
# # Split sentence into words
|
||||
# words = sentence.split()
|
||||
# print(words)
|
||||
|
||||
sentence = sentence.replace("c", "ss").replace("qu", "kh")
|
||||
print(sentence)
|
||||
|
||||
with open(fichier_texte, "w") as destination:
|
||||
destination.write(sentence)
|
||||
@@ -0,0 +1,18 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#Ask to write a sentence
|
||||
sentence = "Les gouvernements suspectent la littérature parce qu'elle est une force qui leur échappe"
|
||||
# print sentence
|
||||
print("phrase originale:", sentence)
|
||||
|
||||
# Split sentence into words
|
||||
words = sentence.lower().split()
|
||||
print(words)
|
||||
|
||||
# ordre alphabétique
|
||||
words.sort()
|
||||
print(words)
|
||||
|
||||
# print sorted wordlist as string
|
||||
print("phrase alphabétique:", " ".join(words).capitalize()+'.')
|
||||
@@ -0,0 +1,58 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
'ai' : 'ê' ,
|
||||
'li' : 'ly' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("texteSOURCE.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("texteDESTINATION.txt", "w") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,58 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
'ai' : 'ê' ,
|
||||
'li' : 'ly' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("texte_source.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("texte_dest.txt", "w") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,58 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
'ai' : 'ê' ,
|
||||
'li' : 'ly' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("texte_source.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("texte_dest.txt", "w", encoding = "utf-8") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,57 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
'li' : 'ly' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("texte_source.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("texte_dest.txt", "w", encoding = "utf-8") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,59 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
'li' : 'ly' ,
|
||||
'ô' : 'au' ,
|
||||
'ai' : 'è' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("texte_source.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("texte_dest.txt", "w", encoding = "utf-8") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,58 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'ain' : 'un' ,
|
||||
'li' : 'ly' ,
|
||||
'ô' : 'au' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("texte_source.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("texte_dest.txt", "w", encoding = "utf-8") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,57 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'li' : 'ly' ,
|
||||
'ô' : 'au' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("texte_source.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("texte_dest.txt", "w", encoding = "utf-8") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,58 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'li' : 'ly' ,
|
||||
'ô' : 'au' ,
|
||||
'é' : 'ai' ,
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("texte_source.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("texte_dest.txt", "w", encoding = "utf-8") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,59 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#importez module
|
||||
import random
|
||||
|
||||
#déclarez une liste
|
||||
diff_words = []
|
||||
|
||||
#déclarez un nouveau dictionnaire
|
||||
aleatoire = {}
|
||||
|
||||
#Créez un dictionnaire
|
||||
permutations = {
|
||||
'ff' : 'ph' ,
|
||||
'qu' : 'kh' ,
|
||||
'ss' : 'ç' ,
|
||||
'ch' : 'sh' ,
|
||||
'il' : 'yl' ,
|
||||
'li' : 'ly' ,
|
||||
'ô' : 'au' ,
|
||||
'é' : 'ai' ,
|
||||
'éc' : 'aik'
|
||||
}
|
||||
|
||||
#Ouvrir un texte comme matériau brut
|
||||
with open("texte_source.txt", "r", encoding="ISO-8859-1") as source:
|
||||
# lire chaque ligne
|
||||
for line in source:
|
||||
# séparer la ligne en liste de mots
|
||||
words = line.split(" ")
|
||||
# pour chaque mot de la liste de mots
|
||||
for word in words:
|
||||
# pour chaque élément dans le dictionnaire
|
||||
for key, value in permutations.items():
|
||||
# vérifier si les clefs du dictionnaire "permutations" figurent dans les mots de la liste
|
||||
if key in word:
|
||||
# rajouter les clefs et les valeurs dans le dictionnaire "aleatoire"
|
||||
aleatoire[key] = value
|
||||
# si il y a des changements il y a donc un dictionnaire
|
||||
if aleatoire:
|
||||
# transformer le dictionnaire "aleatoire" en liste pour pouvoir aller indexer
|
||||
liste = list(aleatoire.items())
|
||||
print(liste)
|
||||
# choisir aléatoirement une des permutations de la liste à appliquer au mot
|
||||
result = random.choice(liste)
|
||||
print("choix aleatoire" , result)
|
||||
# remplacer la clef par sa valeur dans le dictionnaire
|
||||
newword = word.replace(result[0], result[1])
|
||||
print("remplacement", newword)
|
||||
# rajoutez le mot à la liste nouvelle
|
||||
diff_words.append(newword)
|
||||
else:
|
||||
diff_words.append(word)
|
||||
aleatoire.clear()
|
||||
|
||||
# écrire la nouvelle liste comme chaîne de caractères dans un fichier texte
|
||||
with open("texte_dest.txt", "w", encoding = "utf-8") as destination:
|
||||
destination.write(' '.join(diff_words))
|
||||
@@ -0,0 +1,3 @@
|
||||
lettre1 = "o"
|
||||
lettre2 = "l"
|
||||
lettre3 = "a"
|
||||
@@ -0,0 +1,4 @@
|
||||
lettre1 = "o"
|
||||
lettre2 = "l"
|
||||
lettre3 = "a"
|
||||
print(lettre1+lettre2+lettre3)
|
||||
@@ -0,0 +1,45 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# Copyright (C) 2017 Constant, Algolit
|
||||
# This program is free software: you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation, either version 3 of the License, or
|
||||
# (at your option) any later version.
|
||||
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details: <http://www.gnu.org/licenses/>.
|
||||
|
||||
|
||||
'''
|
||||
Input texts are checked against a dictionary that assigns weights to different vowels.
|
||||
The script gives a score for a specific sentence.
|
||||
'''
|
||||
|
||||
# create a dictionary
|
||||
scrabble = {'a': 3, 'e': 1, 'i': 2, 'o': 4, 'u':4, 'y': 6}
|
||||
|
||||
# set weight to 0
|
||||
weights = 0
|
||||
|
||||
# find a sentence / string
|
||||
sentence = "La vie est un mystère qu'il faut vivre, et non un problème à résoudre."
|
||||
|
||||
# spllit sentence in list of words
|
||||
words = sentence.split()
|
||||
|
||||
# for each word
|
||||
for word in words:
|
||||
# iterate over letters of word
|
||||
for letter in word:
|
||||
# check if letter is in dictionary
|
||||
if letter in scrabble:
|
||||
# if yes, get weight of the letter
|
||||
weight = scrabble[letter]
|
||||
# add letter weight to general weight
|
||||
weights += weight
|
||||
|
||||
# print general weight
|
||||
print("Le poids de ma phrase est:", weights)
|
||||
@@ -0,0 +1 @@
|
||||
Souphlée : entendons du même coup inspirée depuis une autre voix, lisant elle-même un texte plus vieux khe le poème de mon corps, khe le théâtre de mon geste. L'inspiration, c'est, à plusieurs personnages, le drame du vol, la structure du théâtre classikhe où l'invisibylité du souphleur açure la diphérance et le relais indispensables entre un texte déjà écrit d'une autre main et un interprète déjà dépoçédé de cela même qu'yl reçoit.
|
||||
@@ -0,0 +1 @@
|
||||
Souphlée : entendons du même coup inspirée depuis une autre voix, lisant elle-même un texte plus vieux khe le poème de mon corps, khe le théâtre de mon geste. L'inspiration, c'est, à plusieurs personnages, le drame du vol, la structure du théâtre claçique où l'invisibylité du souphleur açure la diphérance et le relais indispensables entre un texte déjà écrit d'une autre mun et un interprète déjà dépoçédé de cela même kh'il reçoit.
|
||||
@@ -0,0 +1 @@
|
||||
Souphlée : entendons du même coup inspirée depuis une autre voix, lysant elle-même un texte plus vieux khe le poème de mon corps, khe le théâtre de mon geste. L'inspiration, c'est, à plusieurs personnages, le drame du vol, la structure du théâtre claçique où l'invisibilyté du souphleur açure la diphérance et le relês indispensables entre un texte déjà écrit d'une autre mun et un interprète déjà dépoçédé de cela même qu'yl reçoit.
|
||||
@@ -0,0 +1 @@
|
||||
Souphlée : entendons du même coup inspirée depuis une autre voix, lysant elle-même un texte plus vieux khe le poème de mon corps, khe le théâtre de mon geste. L'inspiration, c'est, à plusieurs personnages, le drame du vol, la structure du théâtre classikhe où l'invisibilyté du souphleur açure la diphérance et le relês indispensables entre un texte déjà écrit d'une autre mun et un interprète déjà dépoçédé de cela même kh'il reçoit.
|
||||
@@ -0,0 +1,4 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
texte = open("diff.txt", "r")
|
||||
@@ -0,0 +1,5 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
texte = open("diff.txt", "r")
|
||||
print(texte)
|
||||
@@ -0,0 +1,5 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
texte = open("diff", "r")
|
||||
print(texte)
|
||||
@@ -0,0 +1,8 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
texte = open ("diff", "r")
|
||||
sentence = texte.read()
|
||||
texte.close()
|
||||
|
||||
print(sentence)
|
||||
+9
@@ -0,0 +1,9 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
import io
|
||||
|
||||
texte = io.open ("diff.txt", "r", encoding='utf-8')
|
||||
sentence = texte.read()
|
||||
texte.close()
|
||||
|
||||
print(sentence)
|
||||
+8
@@ -0,0 +1,8 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
texte = open("diff.txt", "r", encoding="ISO-8859-1")
|
||||
sentence = texte.read()
|
||||
texte.close()
|
||||
|
||||
print(sentence)
|
||||
@@ -0,0 +1,8 @@
|
||||
#!/usr/bin/python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
texte = open ("diff", "r")
|
||||
sentence = texte.read()
|
||||
texte.close()
|
||||
|
||||
print(sentence)
|
||||
@@ -0,0 +1 @@
|
||||
Ne nous arrêtons pas issi à sse khi peut ressembler à l'essensse du mythikhe
|
||||
@@ -0,0 +1 @@
|
||||
Aussi, ne pouvant échapper à l'ascendance de la lumière, la métaphysique suppose-t-elle toujours une phénoménologie, dans sa critique même de la phénoménologie et surtout si elle veut être, comme celle de Levinas, discours et enseignement.
|
||||
@@ -0,0 +1,2 @@
|
||||
Nous avons peine à le croire. Dans les deux directions intentionnelles dont nous venons de parler, l'Idée au sens kantien désigne le débordement infini d'un horizon qui, en raison d'une nécessité d'essence absolue, absolument principielle et irréductible, ne pourra jamais devenir lui-même objet ou se laisser combler, égaler
|
||||
par une intuition d'objet. Pas même celle d'un Dieu. L'horizon ne peut être lui-même objet, car il est la ressource inobjectivable de tout objet en général.
|
||||
@@ -0,0 +1 @@
|
||||
Farmassy qualifier
|
||||
@@ -0,0 +1 @@
|
||||
Soufflée : entendons du même coup inspirée depuis une autre voix, lisant elle-même un texte plus vieux que le poème de mon corps, que le théâtre de mon geste. L'inspiration, c'est, à plusieurs personnages, le drame du vol, la structure du théâtre classique où l'invisibilité du souffleur assure la différance et le relais indispensables entre un texte déjà écrit d'une autre main et un interprète déjà dépossédé de cela même qu'il reçoit.
|
||||
@@ -0,0 +1,3 @@
|
||||
Le rapport entre la raison, la folie et la mort, est une économie, une structure de différance dont il faut respecter l'irréductible originalité. Ce vouloir-dire-l'hyperbole-démonique n'est pas un vouloir parmi d'autres; ce n'est pas un vouloir qui serait occasionnellement et éventuellement complété par le dire, comme par l'objet, le complément d'objet d'une subjectivité volontaire. Ce vouloir dire, qui n'est pas davantage l'antagoniste du silence mais bien sa condition, c'est la profondeur originaire de tout vouloir en général. Rien ne serait d'ailleurs plus impuissant à ressaisir ce vouloir qu'un volontarisme, car ce vouloir comme finitude et comme histoire est aussi une passion première. Il garde en lui la trace d'une violence. Il s'écrit plutôt qu'il ne se dit, il s'économise. L'économie de cette écriture est un rapport réglé entre l'excédant et la totalité excédée : la diffêrance de l'excès absolu.
|
||||
|
||||
Définir la philosophie comme vouloir-dire-l'hyperbole, c'est avouer — et la philosophie est peut-être ce gigantesque aveu — que dans le dit historique en lequel la philosophie se rassérène et exclut la folie, elle se trahit elle-même (ou elle se trahit comme pensée), elle entre dans une crise et en un oubli de soi qui sont une période essentielle et nécessaire de son mouvement. Je ne philosophe que dans la terreur, mais dans la terreur avouée d'être fou. L'aveu est à la fois, dans son présent, oubli et dévoilement, protection et exposition : économie. Mais cette crise en laquelle la raison est plus folle que la folie — car elle est non-sens et oubli — et où la folie est plus rationnelle que la raison car elle est plus proche de la source vive quoique silencieuse ou murmurante du sens, cette crise a toujours déjà commencé et elle est interminable. C'est assez dire que si elle est classique, elle ne l'est peut-être pas au sens de l'âge classique mais au sens du classique essentiel et éternel, quoique historique en un sens insolite. Et nulle part et jamais le concept de crise n'a pu enrichir et rassembler toutes les virtualités, toute l'énergie aussi de son sens, autant, peut-être, qu'à partir du livre de Michel Foucault. Ici, la crise, c'est d'une part, au sens husserlien, le péril menaçant la raison et le sens sous l'espèce de l'objectivisme, de l'oubli des origines, du recouvrement par le dévoilement rationaliste et transcendantal lui-même. Péril comme mouvement de la raison menacée par sa sécurité elle-même, etc.
|
||||
Binary file not shown.
Binary file not shown.
@@ -0,0 +1 @@
|
||||
Ne nous arrêtons pas ici à ce qui peut ressembler à l'essence du mythique lui-même : le rêve d'une vie sans différence. Demandons-nous plutôt ce que peut signifier pour Artaud la différence dans la chair. Mon corps m'a été volé par effraction. L'Autre, le Voleur, le grand Furtif a un nom propre : c'est Dieu. Son histoire a eu lieu. Elle a eu un lieu. Le lieu de l'effraction n'a pu être que l'ouverture d'un orifice. Orifice de la naissance, orifice de la défécation auxquels renvoient, comme à leur origine, toutes les autres béances. « Ça se remplit, / ça ne se remplit pas, / il y a un vide, / un manque, / un défaut de / qui est toujours pris par un parasite au vol » (avril 1947). Au vol : le jeu du mot est sûr.␍
|
||||
@@ -0,0 +1,4 @@
|
||||
phrase originale: Les gouvernements suspectent la littérature parce qu'elle est une force qui leur échappe
|
||||
['les', 'gouvernements', 'suspectent', 'la', 'littérature', 'parce', "qu'elle", 'est', 'une', 'force', 'qui', 'leur', 'échappe']
|
||||
['est', 'force', 'gouvernements', 'la', 'les', 'leur', 'littérature', 'parce', "qu'elle", 'qui', 'suspectent', 'une', 'échappe']
|
||||
phrase alphabétique: Est force gouvernements la les leur littérature parce qu'elle qui suspectent une échappe.
|
||||
@@ -0,0 +1,3 @@
|
||||
Ne nous arrêtons pas ici à ce qui peut ressembler à l'essence du mythique
|
||||
['Ne', 'nous', 'arrêtons', 'pas', 'ici', 'à', 'ce', 'qui', 'peut', 'ressembler', 'à', "l'essence", 'du', 'mythique']
|
||||
Ne nous arrêtons pas issi à sse qui peut ressembler à l'essensse du mythique
|
||||
@@ -0,0 +1,38 @@
|
||||
# A set is a list with unique words
|
||||
stopwords = set()
|
||||
|
||||
# define list of filtered words
|
||||
filtered_words = []
|
||||
|
||||
# read stopwords from file & save them in a list
|
||||
# read from file
|
||||
with open("english.txt", "r") as source:
|
||||
# for each line
|
||||
for line in source:
|
||||
# clean returns
|
||||
line = line.strip()
|
||||
# add word to set stopwords (cfr difference with list: list.append())
|
||||
stopwords.add(line)
|
||||
|
||||
# define your sentence / string
|
||||
sentence = 'I was at Synesthésie last night and took a bus to go home.'
|
||||
|
||||
# print sentence
|
||||
print("phrase originale:", sentence)
|
||||
|
||||
# convert string to list of words
|
||||
words = sentence.split(" ")
|
||||
# for each word of list, check if word is in stopwords, if it isn't, add word to filtered wordlist
|
||||
for word in words:
|
||||
if word not in stopwords:
|
||||
filtered_words.append(word)
|
||||
|
||||
# this is the same, but shorter + no need to declare filtered_words as list in the beginning:
|
||||
#filtered_words = [word for word in words if word not in stopwords]
|
||||
|
||||
|
||||
|
||||
# turn wordlist into string of characters
|
||||
new_sentence = " ".join(filtered_words)
|
||||
# print new sentence
|
||||
print("phrase réécrite:", new_sentence)
|
||||
@@ -0,0 +1,59 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
|
||||
# Copyright (C) 2016 Constant, Algolit
|
||||
# This program is free software: you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation, either version 3 of the License, or
|
||||
# (at your option) any later version.
|
||||
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details: <http://www.gnu.org/licenses/>.
|
||||
|
||||
'''
|
||||
Input texts are checked against occurences of certain words included in a list of "stopwords" established by NLTK (Natural Language Toolkit). These words are then removed.
|
||||
In data mining, text processing and machine learning, these so-called high frequency words are filtered out before or after natural language data is processed.
|
||||
Relational words such as 'the', 'is', 'at', 'which', and 'on' are considered redundant because they are too frequent, and meaningless once the word order is removed.
|
||||
'''
|
||||
|
||||
# A set is a list with unique words
|
||||
stopwords = set()
|
||||
|
||||
# define list of filtered words
|
||||
filtered_words = []
|
||||
|
||||
# read stopwords from file & save them in a list
|
||||
# read from file
|
||||
with open("english.txt", "r") as source:
|
||||
# for each line
|
||||
for line in source:
|
||||
# clean returns
|
||||
line = line.strip()
|
||||
# add word to set stopwords (cfr difference with list: list.append())
|
||||
stopwords.add(line)
|
||||
|
||||
# define your sentence / string
|
||||
sentence = 'I was at Synesthésie last night and took a bus to go home.'
|
||||
|
||||
# print sentence
|
||||
print("phrase originale:", sentence)
|
||||
|
||||
# convert string to list of words
|
||||
words = sentence.split(" ")
|
||||
# for each word of list, check if word is in stopwords, if it isn't, add word to filtered wordlist
|
||||
for word in words:
|
||||
if word not in stopwords:
|
||||
filtered_words.append(word)
|
||||
|
||||
# this is the same, but shorter + no need to declare filtered_words as list in the beginning:
|
||||
#filtered_words = [word for word in words if word not in stopwords]
|
||||
|
||||
|
||||
|
||||
# turn wordlist into string of characters
|
||||
new_sentence = " ".join(filtered_words)
|
||||
# print new sentence
|
||||
print("phrase réécrite:", new_sentence)
|
||||
@@ -0,0 +1,61 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
|
||||
# Copyright (C) 2016 Constant, Algolit
|
||||
# This program is free software: you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation, either version 3 of the License, or
|
||||
# (at your option) any later version.
|
||||
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details: <http://www.gnu.org/licenses/>.
|
||||
|
||||
|
||||
'''
|
||||
Input texts are checked against occurences of certain words included in a list of "stopwords" established by NLTK (Natural Language Toolkit). These words are then removed.
|
||||
In data mining, text processing and machine learning, these so-called high frequency words are filtered out before or after natural language data is processed.
|
||||
Relational words such as 'the', 'is', 'at', 'which', and 'on' are considered redundant because they are too frequent, and meaningless once the word order is removed.
|
||||
'''
|
||||
|
||||
# A set is a list with unique words
|
||||
stopwords = set()
|
||||
|
||||
# define list of filtered words
|
||||
filtered_words = []
|
||||
|
||||
# read stopwords from file & save them in a list
|
||||
# read from file
|
||||
# txt = source.readlines()
|
||||
with open("english.txt", "r") as source:
|
||||
# for each line
|
||||
for line in source:
|
||||
# clean returns
|
||||
line = line.strip()
|
||||
# add word to set stopwords (cfr difference with list: list.append())
|
||||
stopwords.add(line)
|
||||
|
||||
# define your sentence / string
|
||||
sentence = 'I was at Synesthésie last night and took a bus to go home.'
|
||||
|
||||
# print sentence
|
||||
print("phrase originale:", sentence)
|
||||
|
||||
# convert string to list of words
|
||||
words = sentence.split(" ")
|
||||
# for each word of list, check if word is in stopwords, if it isn't, add word to filtered wordlist
|
||||
for word in words:
|
||||
if word not in stopwords:
|
||||
filtered_words.append(word)
|
||||
|
||||
# this is the same, but shorter + no need to declare filtered_words as list in the beginning:
|
||||
#filtered_words = [word for word in words if word not in stopwords]
|
||||
|
||||
|
||||
|
||||
# turn wordlist into string of characters
|
||||
new_sentence = " ".join(filtered_words)
|
||||
# print new sentence
|
||||
print("phrase réécrite:", new_sentence)
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user