Je galère depuis une semaine sur un code en python , une partie de mon programme ou je dois transformer mon fichier .txt en chaine de caractère .
J'ai essayé avec un exemple mais ça n'a marche pas ,
exemple :
Voici mon fichier . txt (il s'apelle "Essai") , quand vous l'ouvrez ça donner ça :
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Et je veux le tranformer en chaine de caractère sans le "\n " ! , (il ma rendu fou ) , j'ai cherché dans des forums , mais je n'ai pas trouvé de réponses à ces satisfaisantes.
Voici mon programme:
f= open('C:/Users/F/Desktop/Essai.txt', 'r') # Essai est mon fichier.txt que vous pouvez voir juste au dessus )
F5 =f.readlines()
print(F5)
F7 = F5.read()
f.close
F8 = F7.replace('\n', '')
print (F8)
Ta ligne 4 (ta variable F7) ne te renverrai t-elle pas une erreur??? Normalement si, car F5 (t'es sérieux avec ces noms de variables!!! Essaie plutôt d'utiliser des noms explicites ) est une liste. Et les listes non pas de méthode read.
Je ne sais pas s'il y a une manière plus propre de le faire, mais voici ce que j'ai fait:
with open("C:/Users/F/Desktop/Essai.txt", "r") as f_obj:
chn = f_obj.read().replace("\n", "")
PS: C'est à peu près la même chose que toi, sauf que je n'utilises pas readlines (qui va mettre chaque ligne comme élément d'une liste) mais j'utilises directement read sur le fichier, ce qui va mettre tout son contenu dans une chaîne de caractères. Et la syntaxe du with, c'est juste une bonne façon d'ouvrir un fichier
Bonsoir (C'est URGENT je dois fini& mon programme pour demain apres-midi) , je n'arrive pas comprendre pour quoi mon programme m'affiche des lettres et non des mots . Ce serait juste par rapport au mots = chn , faites pas trop attention au reste ). Faites vite s.v.p j'en peu plus
Le voici:
with open("C:/Users/F/Desktop/DICO.txt", "r") as f_obj:
chn = f_obj.read().replace("\n", "")
from random import randrange
MAJUSCULES = "ABCDEFHIJKLMNOPQRSTUVWXYZ"
mots = chn
dessins = [
"""
---------
| |
| o
|
|
|
|""",
"""
---------
| |
| O
| -+-
|
|
|""",
"""
---------
| |
| O
| /-+-
|
|
|""",
"""
---------
| |
| O
| /-+-/
|
|
|""",
"""
---------
| |
| O
| /-+-/
| |
|
|""",
"""
---------
| |
| O
| /-+-/
| | |
|
|"""]
max_erreurs = len(dessins) - 1
def lire_lettre(propositions):
#########################################################################
"""
Demande une lettre à l'utilisateur en s'assurant qu'elle n'a pas déjà
été proposée, puis ajoute cette lettre à la liste des lettres déjà
proposées.
>>> liste=['a', 'b', 'c']
>>> lire_lettre(liste)
Entrez une proposition de lettre : A
Une seule lettre en minuscule, s'il vous plaît.
Entrez une proposition de lettre : a
Cette lettre a déjà été proposée.
Entrez une proposition de lettre : qsdf
Une seule lettre en minuscule, s'il vous plaît.
Entrez une proposition de lettre : e
'e'
>>> print(liste)
['a', 'b', 'c', 'e']
"""
#########################################################################
while True:
lettre = input("Entrez une proposition de lettre : ")
if lettre in propositions:
print("Cette lettre a déjà été proposée.")
elif lettre not in MAJUSCULES or len(lettre) != 1:
print("Une seule lettre en MAJUSCULES, s'il vous plaît.")
else:
break;
propositions.append(lettre)
return lettre
def mot_avec_tirets(mot, propositions):
#########################################################################
"""
Renvoie un mot dont les lettres inconnues sont remplacées par des tirets
>>> mot_avec_tirets('tirets', ['t', 'i'])
'ti--t-'
"""
#########################################################################
m = ''
for lettre in mot:
if lettre in propositions:
m = m + lettre
else:
m = m + '-'
return m
def partie():
#########################################################################
"""
Joue une partie de pendu
retourne True si gagné, False si perdu
"""
#########################################################################
#
# Initialisations
#
erreurs = 0
mot = mots[randrange(len(mots))]
propositions = []
#
# Boucle d'interrogation de l'utilisateur
#
print(dessins[erreurs])
while True:
print("Lettres déjà proposées :", propositions)
print("Réponse courante :", mot_avec_tirets(mot, propositions))
lettre = lire_lettre(propositions)
if lettre in mot:
if mot_avec_tirets(mot, propositions) == mot:
print("Bravo, vous avez gagné. Le mot était :", mot)
print("Nombre d'erreurs:", erreurs)
return True
else:
erreurs = erreurs + 1
print(dessins[erreurs])
if erreurs >= max_erreurs:
print("vous êtes pendu, le mot était :", mot)
return False
#############################################################################
# Programme principal
#############################################################################
print("bonjour, merci de jouer à notre pendu en python")
parties = 0
victoires = 0
while True:
parties = parties + 1
if partie():
victoires = victoires + 1
while True:
cont = input("C pour continuer, a pour arrêter : ")
if cont == 'C' or cont == 'a':
break;
if cont == 'A':
break;
print("Vous avez joué", parties, "partie(s)")
print("Vous en avez gagné", victoires)
print("Au revoir et merci")
Mon programme marche presque :/ , il faudrait que je réussi à mettre des crochets pour chaque mots (crochets à l'extérieur des guillemets bien sur ) .
Et rajouter la première lettre du mot quand je fais tourner le programme . Autant pour les guillemets je sais faire , mais là je vois pas trop :/
C'est URGENT parce que j'ai négoncier avec mon prof hier pour rendre le programme cet apres-midi .
Voilà le programme modifier :
with open("C:/Users/F/Desktop/DIC.txt", "r") as f_obj:
DICO = f_obj.read().splitlines()
from random import randrange
MAJUSCULES = DICO
mots = DICO
dessins = [
"""
---------
| |
|
|
|
|
|"""
"VOUS AVEZ 6 ESSAIE" ,
"""
---------
| |
| o
|
|
|
|"""
"VOUS AVEZ 5 ESSAIE" ,
"""
---------
| |
| O
| -+-
|
|
|"""
"IL VOUS RESTE 4 ESSAIES",
"""
---------
| |
| O
| /-+-
|
|
|"""
"IL VOUS RESTE 3 ESSAIES",
"""
---------
| |
| O
| /-+-/
|
|
|"""
"IL VOUS RESTE 2 ESSAIES",
"""
---------
| |
| O
| /-+-/
| |
|
|"""
"IL VOUS RESTE 1 ESSAIES",
"""
---------
| |
| O
| /-+-/
| | |
|
|"""
"IL VOUS RESTE 0 ESSAIES"]
max_erreurs = len(dessins) - 1
def lire_lettre(propositions):
#########################################################################
"""
Demande une lettre à l'utilisateur en s'assurant qu'elle n'a pas déjà
été proposée, puis ajoute cette lettre à la liste des lettres déjà
proposées.
>>> liste=['a', 'b', 'c']
>>> lire_lettre(liste)
Entrez une proposition de lettre : A
Une seule lettre en minuscule, s'il vous plaît.
Entrez une proposition de lettre : a
Cette lettre a déjà été proposée.
Entrez une proposition de lettre : qsdf
Une seule lettre en minuscule, s'il vous plaît.
Entrez une proposition de lettre : e
'e'
>>> print(liste)
['a', 'b', 'c', 'e']
"""
#########################################################################
while True:
lettre = input("Entrez une proposition de lettre : ")
if lettre in propositions:
print("Cette lettre a déjà été proposée.")
elif lettre not in MAJUSCULES or len(lettre) != 1:
print("Une seule lettre en MAJUSCULES, s'il vous plaît.")
else:
break;
propositions.append(lettre)
return lettre
def mot_avec_tirets(mot, propositions):
#########################################################################
"""
Renvoie un mot dont les lettres inconnues sont remplacées par des tirets
>>> mot_avec_tirets('tirets', ['t', 'i'])
'ti--t-'
"""
#########################################################################
m = ''
for lettre in mot:
if lettre in propositions:
m = m + lettre
else:
m = m + '-'
return m
def partie():
#########################################################################
"""
Joue une partie de pendu
retourne True si gagné, False si perdu
"""
#########################################################################
#
# Initialisations
#
erreurs = 0
mot = mots[randrange(len(mots))]
propositions = []
#
# Boucle d'interrogation de l'utilisateur
#
print(dessins[erreurs])
while True:
print("Lettres déjà proposées :", propositions)
print("Réponse courante :", mot_avec_tirets(mot, propositions))
lettre = lire_lettre(propositions)
if lettre in mot:
if mot_avec_tirets(mot, propositions) == mot:
print("Bravo, vous avez gagné. Le mot était :", mot)
print("Nombre d'erreurs:", erreurs)
return True
else:
erreurs = erreurs + 1
print(dessins[erreurs])
if erreurs >= max_erreurs:
print("vous êtes pendu, le mot était :", mot)
return False
#############################################################################
# Programme principal
#############################################################################
print("bonjour, merci de jouer à notre pendu en python")
parties = 0
victoires = 0
while True:
parties = parties + 1
if partie():
victoires = victoires + 1
while True:
cont = input("C pour continuer, a pour arrêter : ")
if cont == 'C' or cont == 'A':
break;
if cont == 'A':
break;
print("Vous avez joué", parties, "partie(s)")
print("Vous en avez gagné", victoires)
print("Au revoir et merci")
Je comprends rien à ce que tu racontes . Le plus simple serait de donner un exemple de ce que tu as, et de ce que tu souhaites.
Le vocabulaire est aussi important (je sais que tu débutes ce n'est donc pas une critique à proprement parler, mais un conseil ), aussi essaie d'utiliser les bons mots pour les objets que tu souhaites obtenir (liste? chaine? tuple?)
#Une chaine (caractérisée par des guillemets)
chn = "Hello World!!!"
#Une liste (caractérisée par des crochets)
lst_1 = ["Hello World"]
lst_2 = ['h', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!', '!', '!']
Pour la liste, c'est quelque chose comme la 1ère forme ou la seconde que tu aimerais (ou aucune des deux)??
Olygrim ce n'est pas vraiment ça :\ désolé je n'ai pas pu répondre plus tôt (classe prépa ) , je voudrais mettre tous mes mots de ma liste entre crochets,
S.V.P si il y a quelqu'un pour me dire que je pourrai poser ma commande pour que mon pendu n'affiche que les mots de 6 lettres , qu'il n'affiche que les mots de 6 lettres . Comme je l'ai dit je pense qu'on doit utilisé len() mais je vois pas trop comment là poser .
Bonsoir , je comprend pas le problème de mon code .
with open("C:/Users/F/Desktop/DIC.txt", "r") as f_obj:
DICO = f_obj.read().splitlines()
DICO = [[mot] for mot in DICO]
L6 = []
for mot in DICO:
if len(mot)==6 :
L6.append(mot)
from random import randrange
MAJUSCULES = L6
mots = L6
dessins = [
"VOUS AVEZ 6 ESSAIE" ,
"IL VOUS RESTE 5 ESSAIE" ,
"IL VOUS RESTE 4 ESSAIES",
"IL VOUS RESTE 3 ESSAIES",
"IL VOUS RESTE 2 ESSAIES",
"IL VOUS RESTE 1 ESSAIES",
"IL VOUS RESTE 0 ESSAIES"]
max_erreurs = len(dessins) - 1
def lire_lettre(propositions):
#########################################################################
"""
Demande une lettre à l'utilisateur en s'assurant qu'elle n'a pas déjà
été proposée, puis ajoute cette lettre à la liste des lettres déjà
proposées.
>>> liste=['a', 'b', 'c']
>>> lire_lettre(liste)
Entrez une proposition de lettre : A
Une seule lettre en minuscule, s'il vous plaît.
Entrez une proposition de lettre : a
Cette lettre a déjà été proposée.
Entrez une proposition de lettre : qsdf
Une seule lettre en minuscule, s'il vous plaît.
Entrez une proposition de lettre : e
'e'
>>> print(liste)
['a', 'b', 'c', 'e']
"""
#########################################################################
while True:
lettre = input("Entrez une proposition de lettre : ")
if lettre in propositions:
print("Cette lettre a déjà été proposée.")
elif lettre not in MAJUSCULES or len(lettre) != 1:
print("Une seule lettre en MAJUSCULES, s'il vous plaît.")
else:
break;
propositions.append(lettre)
return lettre
def mot_avec_tirets(mot, propositions):
#########################################################################
"""
Renvoie un mot dont les lettres inconnues sont remplacées par des tirets
>>> mot_avec_tirets('tirets', ['t', 'i'])
'ti--t-'
"""
#########################################################################
m = ''
for lettre in mot:
if lettre in propositions:
m = m + lettre
else:
m = m + '-'
return m
def partie():
#########################################################################
"""
Joue une partie de pendu
retourne True si gagné, False si perdu
"""
#########################################################################
#
# Initialisations
#
erreurs = 0
mot = mots[randrange(len(mots))]
propositions = []
#
# Boucle d'interrogation de l'utilisateur
#
print(dessins[erreurs])
while True:
print("Lettres déjà proposées :", propositions)
print("Réponse courante :", mot_avec_tirets(mot, propositions))
lettre = lire_lettre(propositions)
if lettre in mot:
if mot_avec_tirets(mot, propositions) == mot:
print("Bravo, vous avez gagné. Le mot était :", mot)
print("Nombre d'erreurs:", erreurs)
return True
else:
erreurs = erreurs + 1
print(dessins[erreurs])
if erreurs >= max_erreurs:
print("vous êtes pendu, le mot était :", mot)
return False
#############################################################################
# Programme principal
#############################################################################
print("bonjour, merci de jouer à notre pendu en python")
parties = 0
victoires = 0
while True:
parties = parties + 1
if partie():
victoires = victoires + 1
while True:
cont = input("C pour continuer, a pour arrêter : ")
if cont == 'C' or cont == 'A':
break;
if cont == 'A':
break;
print("Vous avez joué", parties, "partie(s)")
print("Vous en avez gagné", victoires)
print("Au revoir et merci")
Il m'affiche cà ,
bonjour, merci de jouer à notre pendu en python
Traceback (most recent call last):
File "C:\Users\F\Desktop\test.py", line 131, in <module>
if partie():
File "C:\Users\F\Desktop\test.py", line 94, in partie
mot = mots[randrange(len(mots))]
File "C:\Users\F\AppData\Local\Programs\Python\Python35\lib\random.py", line 186, in randrange
raise ValueError("empty range for randrange()")
ValueError: empty range for randrange()
>>>
Visiblement ton programme considère que la liste de mots "mots" est vide, dont t'as un problème dans la boucle au début de ton code. Mets des prints pour trouver pourquoi L6 est vide.
with open("C:/Users/F/Desktop/DIC.txt", "r") as f_obj:
DICO = f_obj.read().splitlines()
DICO = [[mot] for mot in DICO]
L6 = DICO
for mot in DICO:
if len(mot)==6 :
L6.append(mot)
print(L6)
from random import randrange
MAJUSCULES = "A,B,C,D,E,F,G,H"
mots = L6
, mais je comprends toujours pas quand il m'affiche les mots pour le motus , il m'affiche qu'une lettre inconnue . ???
Comme ceci :
bonjour, merci de jouer à notre pendu en python
VOUS AVEZ 6 ESSAIE
Lettres déjà proposées : []
Réponse courante : -
Entrez une proposition de lettre :
DICO est une liste de listes de mots, où les sous-listes ne contiennent qu'un élément (cf ligne 3 de ton dernier extrait de code).
La condition qui teste la taille échoue donc, puisque tes sous-listes sont toujours de taille 1, jamais 6.
Comme je te l'ai également dit (et qu'entwanne a également souligné), ta variable DICO (choix pas judicieux de nom de variable) est une LISTE DE LISTES. Autrement dit la condition que tu as écrit dans le code suivant ne sera jamais atteinte:
for mot in DICO:
if len(mot)==6:
car mot est une liste (et non une chaîne de caractère). Le conseil qui t'a été donné (et que tu n'as pas suivi) c'est de mettre des print pour voir ce qui se passe (c'est l'une des façon de faire du débogging en python). Ainsi, en faisant simplement:
for mot in DICO:
print(mot, len(mot))
if len(mot)==6:
ça t'aurais permis de te rendre compte que mot est une liste et qu'elle ne contient qu'un seul élément
Pour rappel, c'est toi qui a insisté pour mettre avoir une liste de listes (que j'avais souligné comme un problème de conception) (ligne 4):
DICO = [[mot] for mot in DICO]
Donc pour résumé, mot est une liste et non une chaîne de caractère (ce qui change bien évidemment tout ). Je te rappelle que pour accéder à un élément d'une liste on utilise l'indexation (ça fait partie de la base de la base de python):
lst = ["A", "B", "C", "D"]
print(lst[0]) #va afficher "A"
Ainsi, toi ce qui t'intéresse ce n'est pas la liste, MAIS la chaîne de caractère. Donc:
soit tu modifies ton code pour récupérer la chaîne (grâce à l'indexation):
for mot in DICO:
if len(mot[0])==6 :
L6.append(mot[0])
soit tu reviens à quelque chose de plus logique en supprimant la ligne suivante:
DICO = [[mot] for mot in DICO]
Et là ta condition fonctionnera.
Une autre remarque IMPORTANTE (tiens en compte stp pour une fois ). Quand tu fais:
MAJUSCULES = L6
mots = L6
Tu NE FAIS PAS une copie de la liste, mais tu ne fais qu'ajouter une nouvelle étiquette vers la liste. Autrement dit, si tu modifies MAJUSCULES (par exemple), ça va également modifier mots et L6 (car les 3 RÉFÉRENCENT LE MÊME OBJET). Regarde par toi-même (teste le code pour t'en rendre compte):
L6 = [1, 2, 3]
MAJUSCULES = L6
mots = L6
print(L6, MAJUSCULES, mots)
MAJUSCULES.append(4)
print(L6, MAJUSCULES, mots) #Les 3 vont être affectés
Pour corriger ça, il faut faire une copie explicite (une shallow copie suffira je pense):
L6 = [1, 2, 3]
MAJUSCULES = list(L6) #shallow copie de L6
mots = list(L6) #shallow copie de L6
print(L6, MAJUSCULES, mots)
MAJUSCULES.append(4)
print(L6, MAJUSCULES, mots) #Seul MAJUSCULES est affecté
Tes problèmes sont vraiment dus au fait qu'il te manque le minimum syndical pour faire du python. L'indexation fait partie des pré-requis, tout comme la distinction (et la compréhension) entre une liste et une chaîne de caractère. C'est pour ça que tu butes au moindre pas alors que les problèmes sont assez triviaux (sauf les étiquettes qui sont un poil plus complexe ).
PS: Et encore une fois, essaies d'utiliser des variables explicites (L6 ???)
Parce que mot n'est pas une chaîne de caractères, c'est une liste qui contient une unique chaîne de caractères. Donc len(mot) vaut toujours 1, jamais 6.
with open("C:/Users/F/Desktop/DIC.txt", "r") as f_obj:
DICO = f_obj.read().splitlines()
DICO = [[mot] for mot in DICO]
"""
Ouverture du dictionnaire
Création d'un tableau de mot appelé DICO
"""
L6 = []
for mot in DICO:
if len(mot[0])==6 :
L6.append(mot[0])
"Selectionne les mots de 6 lettres"
"Rempli un tableau nommé L6 avec les mots de 6 lettres"
print(L6)
from random import randrange
mots = L6
dessins = [
"VOUS AVEZ 6 ESSAIS" ,
"IL VOUS RESTE 5 ESSAIS" ,
"IL VOUS RESTE 4 ESSAIS",
"IL VOUS RESTE 3 ESSAIS",
"IL VOUS RESTE 2 ESSAIS",
"IL VOUS RESTE 1 ESSAIS",
"IL VOUS RESTE 0 ESSAIS"]
max_erreurs = len(dessins) - 1
def lire_lettre(propositions):
#########################################################################
"""
Demande une lettre à l'utilisateur en s'assurant qu'elle n'a pas déjà
été proposée, puis ajoute cette lettre à la liste des lettres déjà
proposées.
>>> liste=['a', 'b', 'c']
>>> lire_lettre(liste)
Entrez une proposition de lettre : A
Une seule lettre en minuscule, s'il vous plaît.
Entrez une proposition de lettre : a
Cette lettre a déjà été proposée.
Entrez une proposition de lettre : qsdf
Une seule lettre en minuscule, s'il vous plaît.
Entrez une proposition de lettre : e
'e'
>>> print(liste)
['a', 'b', 'c', 'e']
"""
#########################################################################
while True:
mot = input("Entrez une proposition de mot : ")
if mot == propositions:
print("C'est le bon mot !")
for mot
break;
print("incorrect")
return mot
def mot_avec_tirets(mot, propositions):
#########################################################################
"""
Renvoie un mot dont les lettres inconnues sont remplacées par des tirets
>>> mot_avec_tirets('tirets', ['t', 'i'])
'ti--t-'
"""
#########################################################################
m = ''
for lettre in mot:
if lettre in propositions:
m = m + lettre
else:
m = m + '-'
return m
def partie():
#########################################################################
"""
Joue une partie de pendu
retourne True si gagné, False si perdu
"""
#########################################################################
#
# Initialisations
#
erreurs = 0
mot = mots[randrange(len(mots))]
propositions = []
print(mot)
#
# Boucle d'interrogation de l'utilisateur
#
print(dessins[erreurs])
while True:
print("Mots déjà proposés :", propositions)
print("Réponse courante :", mot_avec_tirets(mot, propositions))
lettre = lire_lettre(mot)
if lettre == mot:
print("Bravo, vous avez gagné. Le mot était :", mot)
print("Nombre d'erreurs:", erreurs)
return True
else:
erreurs = erreurs + 1
print(dessins[erreurs])
if erreurs >= max_erreurs:
print("vous êtes pendu, le mot était :", mot)
return False
#############################################################################
# Programme principal
#############################################################################
print("bonjour, merci de jouer à motus en python")
parties = 0
victoires = 0
while True:
parties = parties + 1
if partie():
victoires = victoires + 1
while True:
cont = input("C pour continuer, a pour arrêter : ")
if cont == 'C' or cont == 'A':
break;
if cont == 'A':
break;
print("Vous avez joué", parties, "partie(s)")
print("Vous en avez gagné", victoires)
print("Au revoir et merci")
Mais j'ai toujours un problème dans le sens ou le mot je veux quand je n'ai mais pas le bon moment il n'affiche pas "incorrect" , mais il garde les lettres du mots . J'espère avoir été compréhensible .
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique