IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

Problème avec un projet hangman


Sujet :

Python

  1. #1
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Avril 2023
    Messages
    3
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Avril 2023
    Messages : 3
    Par défaut Problème avec un projet hangman
    Bonjour je suis en première spécial NSI et mon professeur nous a donné un projet et j'ai une erreur dans mon programme que je ne comprend pas (Je tiens à préciser que j'ai bien le dossier ressource sur mon ordinateur. Dans ce dossier il y a trois fichier french.lg, english.lg et russian.lg et dans ces fichier six mots de chaque langue sont inscrit dedans)

    Quand je lance mon programme cette erreur apparait:

    Traceback (most recent call last):

    File "/Users/ethan/Desktop/eleveProjet/hangman.py", line 600, in <module>

    dictionary = read_dictionary_file(name_of_dictionaries[language])

    File "/Users/ethan/Desktop/eleveProjet/hangman.py", line 233, in read_dictionary_file

    raise FileNotFoundError("Le fichier "+name_file+" n\'est pas présent dans le répertoire resources/")

    FileNotFoundError: Le fichier english.lg n'est pas présent dans le répertoire resources/

    Que puis je faire ?

    En tout cas merci d'avance pour vos réponses

    Voici mon programme


    # -*- coding: utf-8 -*-

    base (12 ptns)

    IMP1 vérifier que l'utilisateur n'a pas déjà rentré une lettre (2 pnts)

    IMP2 gérer en entrée des minuscules ou des majuscules (==> conversion) (1pnts)

    IMP3 gestion de langues multiples (on leur fournira 3 fichiers: français, anglais et russe) (3pnts)

    Lettres russe : https://www.lexilogos.com/russe_alphabet_cyrillique.htm

    on considère les lettres Е Ё comme une seule et même lettre Е

    'А Б В Г Д Е Ё Ж З И Й К Л М Н О П Р С Т У Ф Х Ц Ч Ш Щ Ъ Ы Ь Э Ю Я'

    'а б в г д е ё ж з и й к л м н о п р с т у ф х ц ч ш щ ъ ы ь э ю я'

    IMP4 utilisation des fréquences de lettres en français puis dans les autres langues pour recommander à l'utilisateur la prochaine lettre

    (4 pnts + 1 pnts si multi langues)

    https://fr.wikipedia.org/wiki/Fr%C3%...on_des_lettres

    https://www.apprendre-en-ligne.net/c...tat/russe.html

    IMP5 dessiner le pendu avec un module graphique (2pnts)

    """

    import os

    import sys

    import random

    # ------------------------------------------------------------------------------------------------------

    # CONSTANTS & GLOBALS

    NOM_ELEVE1 = ""

    CLASSE_ELEVE1 = 100

    NOM_ELEVE2 = ""

    CLASSE_ELEVE2 = 100

    # améliorations implémentées

    IMP1 = True

    IMP2 = True

    IMP3 = True

    IMP4 = True

    IMP5 = True

    NUMBER_OF_ERRORS_MAX = 10

    name_of_dictionaries = {

    "en": "english.lg",

    "fr": "french.lg",

    "ru": "russian.lg"

    }

    # ------------------------------------------------------------------------------------------------------

    # BASIC FONCTIONS

    def isValidLanguage(language):

    """

    Vérifie si la langue donnée en paramètre fait partie de la liste des langues autorisées.

    :param language: la langue à vérifier

    :type language: str

    :return: le résultat du test

    :rtype: bool

    """

    global name_of_dictionaries

    if type(language) != str or len(language) != 2:

    return False

    return language in name_of_dictionaries.keys()

    def is_number_of_errors_correct(nb_errors):

    """

    Vérifie si le nombre d'erreurs passé en paramètre est valide.

    Args:

    nb_errors (int): Le nombre d'erreurs à vérifier.

    Returns:

    bool: True si le nombre d'erreurs est valide, False sinon.

    """

    global NUMBER_OF_ERRORS_MAX

    return 0 <= nb_errors <= NUMBER_OF_ERRORS_MAX

    assert type(nb_errors) == int, "le nombre d'erreurs à tester n'est pas un entier"

    def get_list_of_letters_possibles(language="en"):

    """

    Return a list of possible letters according to the selected language.

    :param language: the name of the language (default is 'en' for English)

    :type language: str

    :return: the list of possible letters

    :rtype: list

    """

    assert isValidLanguage(language), "Invalid language"

    if language == "en":

    letters = "abcdefghijklmnopqrstuvwxyz"

    elif language == "fr":

    letters = "abcdefghijklmnopqrstuvwxyzàâéèêëîïôùûüÿç"

    elif language == "ru":

    letters = "абвгдеёжзийклмнопрстуфхцчшщъыьэюя"

    else:

    letters = ""

    return list(letters)

    def is_letter(variable, language="en"):

    """

    Returns True if the input variable is a valid letter in the given language.

    Args:

    variable (str): The variable to check.

    language (str): The language to use. Currently only supports "en" for English.

    Returns:

    bool: True if the input variable is a valid letter, False otherwise.

    """

    valid_letters = set("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

    if variable in valid_letters:

    return True

    else:

    return False

    """

    Test if a particular letter (string) is correct in a specific language

    :param variable: the variable to check

    :type variable: X

    :param language: the name of the language in which we need to check the letter

    :type language: str

    :return: the result of the test

    :rtype: bool

    """

    assert isValidLanguage(language), "la langue n'est pas valide"

    pass

    def is_a_letter_list(variable, language="en"):

    """

    Returns True if the input variable is a list of valid letters in the given language.

    Args:

    variable (list): The variable to check.

    language (str): The language to use. Currently only supports "en" for English.

    Returns:

    bool: True if the input variable is a list of valid letters, False otherwise.

    """

    for letter in variable:

    if not is_letter(letter, language):

    return False

    return True

    """

    Test if a variable is a list of letters (string) in a specific language

    :param variable:

    :type variable:

    :param language: the name of the language in which we need to check the letter

    :type language: str

    :return:

    :rtype:

    """

    assert isValidLanguage(language), "la langue n'est pas valide"

    pass

    def is_a_mask(variable):

    """

    Vérifie si une variable est un masque valide.

    Args:

    variable (any): la variable à vérifier

    Returns:

    bool: True si la variable est un masque valide, False sinon

    """

    if not isinstance(variable, list): # Vérifie si la variable est une liste

    return False

    for element in variable:

    if not isinstance(element, bool): # Vérifie si chaque élément de la liste est un booléen

    return False

    return True

    """

    Test if a variable is a mask (a list of boolean)

    :param variable: the variable to check

    :type variable: X

    :return: the result of the test

    :rtype: bool

    """

    pass

    def is_a_frequency(variable):

    """

    Test if a variable is a frequency (float between 0.0 and 100.0)

    :param variable: the variable to check

    :type variable: X

    :return: the result of the test

    :rtype: bool

    """

    pass

    def is_a_dictionnary_of_frequencies(variable, language="en"):

    """

    Test if a variable is a dictionnary of frequencies (float between 0.0 and 100.0)

    with as indices the letters

    :param variable: the variable to check

    :type variable: X

    :param language: the name of the language in which we need to check the dictionnary of frequencies

    :type language: str

    :return: the result of the test

    :rtype: bool

    """

    assert isValidLanguage(language), "la langue n'est pas valide"

    pass

    # ------------------------------------------------------------------------------------------------------

    def read_dictionary_file(name_file):

    """

    Read the file name_file and extract each word one per ligne and export it as a list of words

    :param name_file: name of the file with words

    :type name_file: str

    :return: list of string (words)

    :rtype: list

    raise an FileNotFoundError if the file doesn\'t exist

    raise an ValueError if the list of words is empty

    """

    if not os.path.exists("./resources/"+name_file) or not os.path.isfile("./resources/"+name_file):

    raise FileNotFoundError("Le fichier "+name_file+" n\'est pas présent dans le répertoire resources/")

    list_of_words = []

    file = open("./resources/"+name_file, "r", encoding="utf8")

    for ligne in file.readlines():

    word = ligne.split("\n")[0]

    list_of_words.append(word)

    file.close()

    if len(list_of_words) == 0:

    raise ValueError("Le fichier "+name_file+" dans le répertoire resources/ est vide.")

    return list_of_words

    def pick_a_word(list_of_words):

    """

    Choose a random word from a list of words

    :param list_of_words: an not empty list of the words

    :type list_of_words: list<str>

    :return: a word picked randomly from the list

    :rtype: str

    raise an TypeError if list_of_words is not a list of string or if the list is empty

    raise an ValueError if the word picked is empty

    """

    if type(list_of_words) != list or any([type(list_of_words[i]) != str for i in range(len(list_of_words))]):

    raise TypeError("La liste de mots n\'est pas du bon type.")

    if len(list_of_words) == 0:

    raise TypeError("La liste de mots est vide.")

    indice_word = random.randint(0, len(list_of_words)-1)

    word = list_of_words[indice_word]

    if len(word) == 0:

    raise ValueError("Le mot a l\'indice "+str(indice_word)+" est vide.")

    return word

    def convert_string_to_char_list(word):

    """

    Converts a word represented as a string into a list of characters.

    Args:

    word (str): The word to convert.

    Returns:

    list: A list of characters representing the input word.

    Raises:

    ValueError: If the input word is an empty string or contains invalid characters.

    """

    if not isinstance(word, str):

    raise TypeError("Input must be a string")

    if not word:

    raise ValueError("Input string cannot be empty")

    char_list = []

    for i in range(len(word)):

    if not is_letter(word[i]):

    raise ValueError(f"Invalid character '{word[i]}' in input string")

    char_list.append(word[i])

    if not is_a_letter_list(char_list):

    raise ValueError("Input string contains non-letter characters")

    return char_list

    """

    Convert a word to a list of characters

    :param word: the word to convert

    :type word: str

    :return: the list of each characters of the word

    :rtype: list<str>

    """

    pass

    def ask_for_a_letter(language="en"): #base et (IMP2)

    """

    Asks the user to input a valid letter between 'A' and 'Z'.

    Args:

    language (str): The language to use. Currently only supports "en" for English.

    Returns:

    str: The valid letter input by the user.

    Raises:

    ValueError: If the input is not a valid letter between 'A' and 'Z'.

    """

    valid_letters = set("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

    while True:

    letter = input("Please enter a valid letter between A and Z: ").strip().upper()

    if letter in valid_letters:

    return letter

    else:

    raise ValueError("Invalid input. Please enter a valid letter between A and Z.")

    #base et (IMP2)z

    #def ask_for_a_letter(list_of_letters_picked, language="en"): #(IMP1)

    #def ask_for_a_letter(list_of_letters_picked, list_of_letters_possibles, language="en"): #(IMP1, IMP3)

    """

    Ask a letter to the user and check if the letter is valid and not previously asked

    :param list_of_letters_picked:

    :type list_of_letters_picked:

    :param list_of_letters_possibles:

    :type list_of_letters_possibles:

    :param language: the language in which we need to ask the letter to the user

    :type language: str

    :return:

    :rtype:

    """

    assert isValidLanguage(language), "la langue n'est pas valide"

    #(IMP1)

    #assert ...

    #------

    #(IMP3)

    #assert ...

    #------

    pass

    def display_word(word, mask, language="en"):

    # Vérification des pré-conditions

    assert isinstance(word, list) and len(word) > 0, "Le mot doit être une liste non vide"

    assert isinstance(mask, list) and len(mask) == len(word), "Le masque doit être une liste de booléens de même longueur que le mot"

    assert isinstance(language, str) and len(language) == 2, "La langue doit être une chaîne de 2 caractères représentant une langue prise en charge par le programme"

    # Affichage du mot avec le masque

    display_word = ""

    for i in range(len(word)):

    if mask[i]:

    display_word += word[i] + " "

    else:

    display_word += "? "

    print("Mot à trouver : " + display_word)

    """

    Display the word showing only the letters found, in a specific language

    :param word: a list with all the letters to find

    :type word: list<str>

    :param mask: a list with bool indicating if a letter if found or not

    :type mask: list<bool>

    :param language: the language in which we need to display the word

    :type language: str

    :return: -

    :rtype: None

    """

    assert isValidLanguage(language), "la langue n'est pas valide"

    #assert ...

    pass

    def is_letter_in_word(word, letter, language="en"):

    """

    Vérifie si une lettre est présente dans un mot dans une langue donnée.

    Args:

    word (str): le mot dans lequel on cherche la lettre

    letter (str): la lettre à chercher

    language (str): la langue dans laquelle le mot et la lettre sont représentés (par défaut en anglais)

    Returns:

    bool: True si la lettre est présente dans le mot, False sinon

    """

    # Vérifie si le mot et la lettre sont valides

    assert is_a_word(word, language), "Le mot est invalide."

    assert is_a_letter(letter, language), "La lettre est invalide."

    # Recherche la lettre dans le mot

    return letter in word

    """

    :param word:

    :type word:

    :param letter:

    :type letter:

    :param language: the language in which we need to check the letter

    :type language:

    :return:

    :rtype:

    """

    assert isValidLanguage(language), "la langue n'est pas valide"

    #assert ...

    pass

    def get_mask(word, language="en"):

    """

    Retourne le masque associé à un mot dans une langue donnée.

    Args:

    word (str): le mot dont on veut le masque

    language (str): la langue dans laquelle le mot est représenté (par défaut en anglais)

    Returns:

    list: le masque associé au mot

    """

    # Vérifie si le mot est valide

    assert is_a_word(word, language), "Le mot est invalide."

    # Convertit le mot en tableau de caractères

    word_list = convert_string_to_char_list(word)

    # Initialise le masque à False pour chaque lettre du mot

    mask = [False] * len(word_list)

    return mask

    """

    :param word:

    :type word:

    :param language:

    :type language:

    :return:

    :rtype:

    """

    # in the mask if the letter is found the value at the indice i will be True, False if not

    assert isValidLanguage(language), "la langue n'est pas valide"

    pass

    def update_mask(word, mask, letter_to_reveal, language="en"):

    """

    Update the mask for a word in a specific language

    :param word:

    :type word:

    :param mask:

    :type mask:

    :param letter_to_reveal:

    :type letter_to_reveal:

    :param language:

    :type language:

    :return:

    :rtype:

    """

    assert isValidLanguage(language), "la langue n'est pas valide"

    #assert ...

    pass

    def is_game_finished(mask, nb_errors):

    """

    Vérifie si le jeu est terminé en fonction du masque et du nombre d'erreurs.

    Args:

    mask (List[bool]): Le masque représentant les lettres trouvées et manquantes.

    nb_errors (int): Le nombre d'erreurs commises par le joueur.

    Returns:

    bool: True si le jeu est terminé, False sinon.

    """

    assert isinstance(mask, list), "Le masque doit être une liste de booléens."

    assert isinstance(nb_errors, int), "Le nombre d'erreurs doit être un entier."

    assert is_number_of_errors_correct(nb_errors), f"Le nombre d'erreurs doit être compris entre 0 et {NUMBER_OF_ERRORS_MAX}."

    if nb_errors >= NUMBER_OF_ERRORS_MAX:

    return True

    if False not in mask:

    return True

    return False

    #assert

    pass

    # --- IMPROVEMENTS ---

    def menu_choose_a_language(): #(IMP3)

    """

    Show a menu to the user and return the language selected

    :return: the language selected ('fr', 'en', 'ru')

    :rtype: str

    """

    global name_of_dictionaries

    pass

    def change_lowercase_to_uppercase(letter, language="en"): #(IMP2)

    """

    TO DO

    """

    assert isValidLanguage(language), "la langue n'est pas valide"

    pass

    def get_frequencies_of_letters_in_language(language="en"): #(IMP3, IMP4)

    """

    Return a the frequencies of the letters in a particular language given in parameter

    :param language: the language in which we need to generate the frequencies

    :type language: str

    :return: the frequencies of the letters

    :rtype: dict<str, float>

    """

    assert isValidLanguage(language), "la langue n'est pas valide"

    frequence_fr = {}

    frequence_en = {}

    frequence_ru = {}

    #TO COMPLETE

    pass

    def get_values(x):

    """

    Return the second value of a 2-uplets

    :param x: the 2_uplets

    :type x: tuple<X>

    :return: the second value of the 2_uplets

    :rtype: X

    """

    return x[1]

    def recommend_next_letter(frequencies, list_of_letters_picked, language="en"): #(IMP3, IMP4)

    """

    Return the second value of a 2-uplets

    :param frequencies: the frequencies of the letters

    :type frequencies: dict<str, float>

    :param list_of_letters_picked: a list with all the previous letters asked

    :type list_of_letters_picked: list<str>

    :param language: the language in which we need to recommend the letter

    :type language: str

    :return: the letter recommended

    :rtype: str

    """

    #assert ...

    pass

    def display_hanged_man(nb_errors): #(IMP5)

    """

    Display the hanged man in the console

    :param nb_errors: the nb of errors

    :type nb_errors: int

    :return: -

    :rtype: None

    """

    pass

    ##################################################

    if __name__ == "__main__":

    # choice of the language and import of the dictionary

    language = "en" #base

    #language = ...() #(IMP3)

    dictionary = read_dictionary_file(name_of_dictionaries[language])

    # operation with language selected

    #list_of_letters_possibles = get_list_of_letters_possibles(language) #(IMP4)

    #frequencies = get_frequencies_of_letters_in_language(language) #(IMP4)

    # choice of the word

    word = pick_a_word(dictionary)

    list_char = get_list_of_characters(word)

    # initialisation

    mask = initialize_mask(word)

    nb_errors = 0

    # initialisation of letters

    #letters_picked = [] #(IMP1)

    # loop over the game

    while not is_game_finished(mask, nb_errors):

    # display the current word

    display_word(list_char, mask, language)

    # display of the recommended letter (IMP4)

    #recommend_letter = recommend_next_letter(frequencies, letters_picked, \

    # language)

    #print("Nous vous recommandons la lettre suivante :", recommend_letter)

    # get the letter and update the list of letters_picked

    letter = ask_for_a_letter(language) #base & (IMP2)

    #letter = ask_for_a_letter(letters_picked, language) #(IMP1)

    #letter = ask_for_a_letter(letters_picked, list_of_letters_possibles, \

    #language)

    #(IMP1, IMP3)

    # update depending of the result of the test

    isPresent = is_letter_in_word(list_char, letter, language)

    # letters_picked.append(...)

    # update the list of the letters picked #(IMP1)

    if isPresent:

    update_mask(list_char, mask, letter)

    else:

    nb_errors += 1

    # display of the hangman

    print("Il vous reste", NUMBER_OF_ERRORS_MAX - nb_errors, "erreurs disponibles.")

    #display_hanged_man(nb_errors) #(IMP1)

    print()

    # display the current word

    display_word(list_char, mask, language)

    # display final result

    if is_winning(mask):

    print("\nVous avez gagné ")

    else:

    print("\nVous avez perdu !!")

  2. #2
    Membre prolifique
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 830
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 830
    Billets dans le blog
    1
    Par défaut
    Bonjour
    Citation Envoyé par Ethan.K Voir le message
    Que puis je faire ?
    Vérifier le chemin demandé par le programme par rapport au chemin réel du fichier "english.lg". Tu dis qu'il se trouve dans le dossier "ressource" mais est-ce que ton programme va réellement le chercher dans ce dossier? Surtout que le nom "ressource" n'apparait nulle-part dans ton code. Je ne vois pas trop comment Python pourrait savoir qu'il faut donc aller le chercher dans ce dossier en particulier.
    Et à propos de code justement, tu pourrais aussi aller te promener dans le forum (à défaut de ses règles que tu n'as visiblement pas lu) pour voir comment on les poste. Parce que franchement si tu trouves que celui que tu nous as posté est lisible et récupérable... Tu ne t'es pas dit à un certain moment que l'indentation était un élément nécessaire ou bien c'est simplement que tu ne le sais pas?
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  3. #3
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Avril 2023
    Messages
    3
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Avril 2023
    Messages : 3
    Par défaut
    Bonjour merci pour votre réponse je n'avais pas comprit comment la balise marchait voila le code avec la bonne l'indentation. Quant au code le cheminement devrais se trouver ver la ligne 212 (mais ce n'est pas moi qui l'ai fait c'est mon professeur) c'est pourquoi je ne comprend pas pourquoi il y a une erreur. Cette erreur est d'autant plus énervante car elle m'empêchèrent de savoir si mon programme fonctionne dans l'ensemble.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    394
    395
    396
    397
    398
    399
    400
    401
    402
    403
    404
    405
    406
    407
    408
    409
    410
    411
    412
    413
    414
    415
    416
    417
    418
    419
    420
    421
    422
    423
    424
    425
    426
    427
    428
    429
    430
    431
    432
    433
    434
    435
    436
    437
    438
    439
    440
    441
    442
    443
    444
    445
    446
    447
    448
    449
    450
    451
    452
    453
    454
    455
    456
    457
    458
    459
    460
    461
    462
    463
    464
    465
    466
    467
    468
    469
    470
    471
    472
    473
    474
    475
    476
    477
    478
    479
    480
    481
    482
    483
    484
    485
    486
    487
    488
    489
    490
    491
    492
    493
    494
    495
    496
    497
    498
    499
    500
    501
    502
    503
    504
    505
    506
    507
    508
    509
    510
    511
    512
    513
    514
    515
    516
    517
    518
    519
    520
    521
    522
    523
    524
    525
    526
    527
    528
    529
    530
    531
    532
    533
    534
    535
    536
    537
    538
    539
    540
    541
    542
    543
    544
    545
    546
    547
    548
    549
    550
    551
    552
    553
    554
    555
    556
    557
    558
    559
    560
    561
    562
    563
    564
    565
    566
    567
    568
    569
    570
    571
    572
    573
    574
    575
    576
    577
    578
    579
    580
    581
    582
    583
    584
    585
    586
    587
    588
    589
    590
    591
    592
    593
    594
    595
    596
    597
    598
    599
    600
    601
    602
    603
    604
    605
    606
    607
    608
    609
    610
    611
    612
    613
    614
    615
    616
    617
    618
    619
    620
    621
    622
    623
    624
    625
    626
    627
    628
    629
    630
    631
    # -*- coding: utf-8 -
    """
    """
     
    """
        base (12 ptns)
     
        IMP1 vérifier que l'utilisateur n'a pas déjà rentré une lettre (2 pnts)
        IMP2 gérer en entrée des minuscules ou des majuscules (==> conversion) (1pnts)
        IMP3 gestion de langues multiples (on leur fournira 3 fichiers: français, anglais et russe) (3pnts)
            Lettres russe : https://www.lexilogos.com/russe_alphabet_cyrillique.htm
            on considère les lettres Е Ё comme une seule et même lettre Е
            'А Б В Г Д Е Ё Ж З И Й К Л М Н О П Р С Т У Ф Х Ц Ч Ш Щ Ъ Ы Ь Э Ю Я'
            'а б в г д е ё ж з и й к л м н о п р с т у ф х ц ч ш щ ъ ы ь э ю я'
        IMP4 utilisation des fréquences de lettres en français puis dans les autres langues pour recommander à l'utilisateur la prochaine lettre
            (4 pnts + 1 pnts si multi langues)
            https://fr.wikipedia.org/wiki/Fr%C3%A9quence_d%27apparition_des_lettres
            https://www.apprendre-en-ligne.net/crypto/stat/russe.html
        IMP5 dessiner le pendu avec un module graphique (2pnts)
    """
     
    import os
    import sys
    import random
    # ------------------------------------------------------------------------------------------------------
    # CONSTANTS & GLOBALS
    NOM_ELEVE1 = ""
    CLASSE_ELEVE1 = 100
    NOM_ELEVE2 = ""
    CLASSE_ELEVE2 = 100
    # améliorations implémentées
    IMP1 = True
    IMP2 = True
    IMP3 = True
    IMP4 = True
    IMP5 = True
     
    NUMBER_OF_ERRORS_MAX = 10
     
    name_of_dictionaries = {
            "en": "english.lg",
            "fr": "french.lg",
            "ru": "russian.lg"
        }
     
    # ------------------------------------------------------------------------------------------------------
    # BASIC FONCTIONS
    def isValidLanguage(language):
        """
            Vérifie si la langue donnée en paramètre fait partie de la liste des langues autorisées.
     
            :param language: la langue à vérifier
            :type language: str
            :return: le résultat du test
            :rtype: bool
        """
        global name_of_dictionaries
     
        if type(language) != str or len(language) != 2:
            return False
     
        return language in name_of_dictionaries.keys()
     
    def is_number_of_errors_correct(nb_errors):
        """
        Vérifie si le nombre d'erreurs passé en paramètre est valide.
     
        Args:
            nb_errors (int): Le nombre d'erreurs à vérifier.
     
        Returns:
            bool: True si le nombre d'erreurs est valide, False sinon.
        """
        global NUMBER_OF_ERRORS_MAX #we get the constant
        return 0 <= nb_errors <= NUMBER_OF_ERRORS_MAX
     
        assert type(nb_errors) == int, "le nombre d'erreurs à tester n'est pas un entier"
     
    def get_list_of_letters_possibles(language="en"):
        """
        Return a list of possible letters according to the selected language.
     
        :param language: the name of the language (default is 'en' for English)
        :type language: str
        :return: the list of possible letters
        :rtype: list
        """
        assert isValidLanguage(language), "Invalid language"
     
        if language == "en":
            letters = "abcdefghijklmnopqrstuvwxyz"
        elif language == "fr":
            letters = "abcdefghijklmnopqrstuvwxyzàâéèêëîïôùûüÿç"
        elif language == "ru":
            letters = "абвгдеёжзийклмнопрстуфхцчшщъыьэюя"
        else:
            letters = ""
     
        return list(letters)
     
    def is_letter(variable, language="en"):
     
        valid_letters = set("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
        if variable in valid_letters:
            return True
        else:
            return False
        """
            Test if a particular letter (string) is correct in a specific language
     
            :param variable: the variable to check
            :type variable: X
            :param language: the name of the language in which we need to check the letter
            :type language: str
            :return: the result of the test
            :rtype: bool
        """
        assert isValidLanguage(language), "la langue n'est pas valide"
     
        pass
     
    def is_a_letter_list(variable, language="en"):
        for letter in variable:
            if not is_letter(letter, language):
                return False
        return True
        """
            Test if a variable is a list of letters (string) in a specific language
     
            :param variable:The variable to check.
            :type variable: list
            :param language: the name of the language in which we need to check the letter
            :type language: str
            :return:Returns True if the input variable is a list of valid letters, False otherwise.
            :rtype:bool
        """
        assert isValidLanguage(language), "la langue n'est pas valide"
     
        pass
     
    def is_a_mask(variable):
        """
        Vérifie si une variable est un masque valide.
     
        Args:
        variable (any): la variable à vérifier
     
        Returns:
        bool: True si la variable est un masque valide, False sinon
        """
        if not isinstance(variable, list):  # Vérifie si la variable est une liste
            return False
        for element in variable:
            if not isinstance(element, bool):  # Vérifie si chaque élément de la liste est un booléen
                return False
        return True
     
        """
            Test if a variable is a mask (a list of boolean)
     
            :param variable: the variable to check
            :type variable: X
            :return: the result of the test
            :rtype: bool
        """
        pass
     
    def is_a_frequency(variable):
        """
            Test if a variable is a frequency (float between 0.0 and 100.0)
     
            :param variable: the variable to check
            :type variable: X
            :return: the result of the test
            :rtype: bool
        """
        pass
     
    def is_a_dictionnary_of_frequencies(variable, language="en"):
        """
            Test if a variable is a dictionnary of frequencies (float between 0.0 and 100.0)
            with as indices the letters
     
            :param variable: the variable to check
            :type variable: X
            :param language: the name of the language in which we need to check the dictionnary of frequencies
            :type language: str
            :return: the result of the test
            :rtype: bool
        """
        assert isValidLanguage(language), "la langue n'est pas valide"
     
        pass
    # ------------------------------------------------------------------------------------------------------
    def read_dictionary_file(name_file):
        """
            Read the file name_file and extract each word one per ligne and export it as a list of words
     
            :param name_file: name of the file with words
            :type name_file: str
     
            :return: list of string (words)
            :rtype: list
     
            raise an FileNotFoundError if the file doesn\'t exist
            raise an ValueError if the list of words is empty
        """
        if not os.path.exists("./resources/"+name_file) or not os.path.isfile("./resources/"+name_file):
            raise FileNotFoundError("Le fichier "+name_file+" n\'est pas présent dans le répertoire resources/")
     
        list_of_words = []
        file = open("./resources/"+name_file, "r", encoding="utf8")
     
        for ligne in file.readlines():
            word = ligne.split("\n")[0]
            list_of_words.append(word)
     
        file.close()
        if len(list_of_words) == 0:
            raise ValueError("Le fichier "+name_file+" dans le répertoire resources/ est vide.")
     
        return list_of_words
     
    def pick_a_word(list_of_words):
        """
            Choose a random word from a list of words
     
            :param list_of_words: an not empty list of the words
            :type list_of_words: list<str>
     
            :return: a word picked randomly from the list
            :rtype: str
     
            raise an TypeError if list_of_words is not a list of string or if the list is empty
            raise an ValueError if the word picked is empty
        """
        if type(list_of_words) != list or any([type(list_of_words[i]) != str for i in range(len(list_of_words))]):
            raise TypeError("La liste de mots n\'est pas du bon type.")
     
        if len(list_of_words) == 0:
            raise TypeError("La liste de mots est vide.")
     
        indice_word = random.randint(0, len(list_of_words)-1)
     
        word = list_of_words[indice_word]
        if len(word) == 0:
            raise ValueError("Le mot a l\'indice "+str(indice_word)+" est vide.")
     
        return word
     
    def convert_string_to_char_list(word):
        """
        Converts a word represented as a string into a list of characters.
     
        Args:
            word (str): The word to convert.
     
        Returns:
            list: A list of characters representing the input word.
     
        Raises:
            ValueError: If the input word is an empty string or contains invalid characters.
        """
        if not isinstance(word, str):
            raise TypeError("Input must be a string")
     
        if not word:
            raise ValueError("Input string cannot be empty")
     
        char_list = []
        for i in range(len(word)):
            if not is_letter(word[i]):
                raise ValueError(f"Invalid character '{word[i]}' in input string")
            char_list.append(word[i])
     
        if not is_a_letter_list(char_list):
            raise ValueError("Input string contains non-letter characters")
     
        return char_list
        """
            Convert a word to a list of characters
     
            :param word: the word to convert
            :type word: str
     
            :return: the list of each characters of the word
            :rtype: list<str>
        """
        pass
     
    def ask_for_a_letter(language="en"): #base et (IMP2)
        """
        Asks the user to input a valid letter between 'A' and 'Z'.
     
        Args:
            language (str): The language to use. Currently only supports "en" for English.
     
        Returns:
            str: The valid letter input by the user.
     
        Raises:
            ValueError: If the input is not a valid letter between 'A' and 'Z'.
        """
        valid_letters = set("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
        while True:
            letter = input("Please enter a valid letter between A and Z: ").strip().upper()
            if letter in valid_letters:
                return letter
            else:
                raise ValueError("Invalid input. Please enter a valid letter between A and Z.")
     #base et (IMP2)z
    #def ask_for_a_letter(list_of_letters_picked, language="en"): #(IMP1)
    #def ask_for_a_letter(list_of_letters_picked, list_of_letters_possibles, language="en"): #(IMP1, IMP3)
        """
            Ask a letter to the user and check if the letter is valid and not previously asked
     
            :param list_of_letters_picked:
            :type list_of_letters_picked:
            :param list_of_letters_possibles:
            :type list_of_letters_possibles:
            :param language: the language in which we need to ask the letter to the user
            :type language: str
            :return:
            :rtype:
        """
        assert isValidLanguage(language), "la langue n'est pas valide"
     
        #(IMP1)
        #assert ...
        #------
     
        #(IMP3)
        #assert ...
        #------
        pass
     
    def display_word(word, mask, language="en"):
        # Vérification des pré-conditions
        assert isinstance(word, list) and len(word) > 0, "Le mot doit être une liste non vide"
        assert isinstance(mask, list) and len(mask) == len(word), "Le masque doit être une liste de booléens de même longueur que le mot"
        assert isinstance(language, str) and len(language) == 2, "La langue doit être une chaîne de 2 caractères représentant une langue prise en charge par le programme"
     
        # Affichage du mot avec le masque
        display_word = ""
        for i in range(len(word)):
            if mask[i]:
                display_word += word[i] + " "
            else:
                display_word += "? "
        print("Mot à trouver : " + display_word)
     
        """
            Display the word showing only the letters found, in a specific language
     
            :param word: a list with all the letters to find
            :type word: list<str>
            :param mask: a list with bool indicating if a letter if found or not
            :type mask: list<bool>
            :param language: the language in which we need to display the word
            :type language: str
            :return: -
            :rtype: None
        """
        assert isValidLanguage(language), "la langue n'est pas valide"
     
        #assert ...
     
        pass
     
    def is_letter_in_word(word, letter, language="en"):
        """
        Vérifie si une lettre est présente dans un mot dans une langue donnée.
     
        Args:
        word (str): le mot dans lequel on cherche la lettre
        letter (str): la lettre à chercher
        language (str): la langue dans laquelle le mot et la lettre sont représentés (par défaut en anglais)
     
        Returns:
        bool: True si la lettre est présente dans le mot, False sinon
        """
        # Vérifie si le mot et la lettre sont valides
        assert is_a_word(word, language), "Le mot est invalide."
        assert is_a_letter(letter, language), "La lettre est invalide."
        # Recherche la lettre dans le mot
        return letter in word
     
        """
     
     
            :param word:
            :type word:
            :param letter:
            :type letter:
            :param language: the language in which we need to check the letter
            :type language:
            :return:
            :rtype:
        """
        assert isValidLanguage(language), "la langue n'est pas valide"
     
        #assert ...
     
        pass
     
    def get_mask(word, language="en"):
        """
        Retourne le masque associé à un mot dans une langue donnée.
     
        Args:
        word (str): le mot dont on veut le masque
        language (str): la langue dans laquelle le mot est représenté (par défaut en anglais)
     
        Returns:
        list: le masque associé au mot
        """
        # Vérifie si le mot est valide
        assert is_a_word(word, language), "Le mot est invalide."
        # Convertit le mot en tableau de caractères
        word_list = convert_string_to_char_list(word)
        # Initialise le masque à False pour chaque lettre du mot
        mask = [False] * len(word_list)
        return mask
        """
     
     
            :param word:
            :type word:
            :param language:
            :type language:
            :return:
            :rtype:
        """
     
     
        # in the mask if the letter is found the value at the indice i will be True, False if not
        assert isValidLanguage(language), "la langue n'est pas valide"
     
        pass
     
    def update_mask(word, mask, letter_to_reveal, language="en"):
        """
            Update the mask for a word in a specific language
     
            :param word:
            :type word:
            :param mask:
            :type mask:
            :param letter_to_reveal:
            :type letter_to_reveal:
            :param language:
            :type language:
            :return:
            :rtype:
        """
        assert isValidLanguage(language), "la langue n'est pas valide"
     
        #assert ...
     
        pass
     
    def is_game_finished(mask, nb_errors):
        """
        Vérifie si le jeu est terminé en fonction du masque et du nombre d'erreurs.
     
        Args:
            mask (List[bool]): Le masque représentant les lettres trouvées et manquantes.
            nb_errors (int): Le nombre d'erreurs commises par le joueur.
     
        Returns:
            bool: True si le jeu est terminé, False sinon.
        """
        assert isinstance(mask, list), "Le masque doit être une liste de booléens."
        assert isinstance(nb_errors, int), "Le nombre d'erreurs doit être un entier."
        assert is_number_of_errors_correct(nb_errors), f"Le nombre d'erreurs doit être compris entre 0 et {NUMBER_OF_ERRORS_MAX}."
     
        if nb_errors >= NUMBER_OF_ERRORS_MAX:
            return True
     
        if False not in mask:
            return True
     
        return False
     
        #assert
     
        pass
     
    # --- IMPROVEMENTS ---
     
    def menu_choose_a_language(): #(IMP3)
        """
            Show a menu to the user and return the language selected
     
            :return: the language selected ('fr', 'en', 'ru')
            :rtype: str
        """
        global name_of_dictionaries
     
        pass
     
    def change_lowercase_to_uppercase(letter, language="en"): #(IMP2)
        """
            TO DO
        """
     
        assert isValidLanguage(language), "la langue n'est pas valide"
     
        pass
     
     
    def get_frequencies_of_letters_in_language(language="en"): #(IMP3, IMP4)
        """
            Return a the frequencies of the letters in a particular language given in parameter
     
            :param language: the language in which we need to generate the frequencies
            :type language: str
            :return: the frequencies of the letters
            :rtype: dict<str, float>
        """
        assert isValidLanguage(language), "la langue n'est pas valide"
     
        frequence_fr = {}
     
        frequence_en = {}
     
        frequence_ru = {}
     
        #TO COMPLETE
     
        pass
     
    def get_values(x):
        """
            Return the second value of a 2-uplets
     
            :param x: the 2_uplets
            :type x: tuple<X>
            :return: the second value of the 2_uplets
            :rtype: X
        """
        return x[1]
     
    def recommend_next_letter(frequencies, list_of_letters_picked, language="en"): #(IMP3, IMP4)
        """
            Return the second value of a 2-uplets
     
            :param frequencies: the frequencies of the letters
            :type frequencies: dict<str, float>
            :param list_of_letters_picked: a list with all the previous letters asked
            :type list_of_letters_picked: list<str>
            :param language: the language in which we need to recommend the letter
            :type language: str
            :return: the letter recommended
            :rtype: str
        """
        #assert ...
        pass
     
    def display_hanged_man(nb_errors): #(IMP5)
        """
            Display the hanged man in the console
     
            :param nb_errors: the nb of errors
            :type nb_errors: int
            :return: -
            :rtype: None
        """
        pass
    ##################################################
    if __name__ == "__main__":
        #choice of the language and import of the dictionary
        language = "en" # langue par défaut
        #language = english_words() #(IMP3)
        #name_of_dictionaries = {"en": "english_words.txt", "fr": "mots_francais.txt"}
        dictionary = read_dictionary_file(name_of_dictionaries[language])
     
        # operation with language selected
        #list_of_letters_possibles = get_list_of_letters_possibles(language) #(IMP4)
        #frequencies = get_frequencies_of_letters_in_language(language) #(IMP4)
     
        # choice of the word
        word = pick_a_word(dictionary)
        list_char = get_list_of_characters(word)
     
        # initialisation
        mask = is_a_mask(word)
        nb_errors = 0
     
        # initialisation des lettres
        #letters_picked = [] (IMP1)
     
        # boucle de jeu
        while not is_game_finished(mask, nb_errors):
            # affichage du mot courant
            display_word(list_char, mask, language)
     
            # affichage de la lettre recommandée (IMP4)
            #recommend_letter = recommend_next_letter(frequencies, letters_picked, \# language)
            #print("Nous vous recommandons la lettre suivante :", recommend_letter)
     
        # get the letter and update the list of letters_picked
        letter = ask_for_a_letter(language) #base & (IMP2)
        #letter = ask_for_a_letter(letters_picked, language) #(IMP1)
        letter = ask_for_a_letter(letters_picked, list_of_letters_possibles, \
        language)
        #(IMP1, IMP3)
     
        # update depending of the result of the test
        isPresent = is_letter_in_word(list_char, letter, language)
        letters_picked.append(letter)
        # update the list of the letters picked #(IMP1)
        if isPresent:
            update_mask(list_char, mask, letter)
        else:
            nb_errors += 1
     
            # affichage du pendu
            print("Il vous reste", NUMBER_OF_ERRORS_MAX - nb_errors, "erreurs disponibles.")
            #display_hanged_man(nb_errors)
     
            print()
     
        # affichage du mot courant
        display_word(list_char, mask, language)
     
        # affichage du résultat final
        if is_winning(mask):
            print("\nVous avez gagné :)")
        else:
            print("\nVous avez perdu !!")

  4. #4
    Membre prolifique
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 830
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 830
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par Ethan.K Voir le message
    Je tiens à préciser que j'ai bien le dossier ressource sur mon ordinateur
    Quant au code le cheminement devrais se trouver ver la ligne 212
    En effet. Ligne 211 (parce que l'exception est en ligne 212 mais elle est issue de l'ereur de la ligne 211): if not os.path.exists("./resources/"+name_file) or not os.path.isfile("./resources/"+name_file).
    Je crois que c'est clair pour quiconque ouvre un peu les yeux (et je comprends aussi pourquoi, quand j'ai fait "rechercher ressource" avec mon navigateur, je n'ai rien trouvé)...

    Citation Envoyé par Ethan.K Voir le message
    Cette erreur est d'autant plus énervante car elle m'empêchèrent de savoir si mon programme fonctionne dans l'ensemble.
    Ah ben oui, c'est le principe des erreurs: elles empêchent le code de continuer...
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  5. #5
    Expert éminent
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 726
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 726
    Par défaut
    Citation Envoyé par Ethan.K Voir le message
    Cette erreur est d'autant plus énervante car elle m'empêchèrent de savoir si mon programme fonctionne dans l'ensemble.
    "./resources/"+name_file est un chemin relatif par rapport au répertoire de travail par défaut (le working directory).
    Il y a plein de chose à comprendre et à regarder mais tout cela est relativement bien expliqué dans n'importe quel tuto qui des chapitres sur les fichiers (qu'on ne va pas recopier ici).

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  6. #6
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Avril 2023
    Messages
    3
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Avril 2023
    Messages : 3
    Par défaut
    Citation Envoyé par Sve@r Voir le message
    Bonjour

    Vérifier le chemin demandé par le programme par rapport au chemin réel du fichier "english.lg". Tu dis qu'il se trouve dans le dossier "ressource" mais est-ce que ton programme va réellement le chercher dans ce dossier? Surtout que le nom "ressource" n'apparait nulle-part dans ton code. Je ne vois pas trop comment Python pourrait savoir qu'il faut donc aller le chercher dans ce dossier en particulier.
    Et à propos de code justement, tu pourrais aussi aller te promener dans le forum (à défaut de ses règles que tu n'as visiblement pas lu) pour voir comment on les poste. Parce que franchement si tu trouves que celui que tu nous as posté est lisible et récupérable... Tu ne t'es pas dit à un certain moment que l'indentation était un élément nécessaire ou bien c'est simplement que tu ne le sais pas?
    Comment je peux faire pour le modifier ?

  7. #7
    Membre prolifique
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 830
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 830
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par Ethan.K Voir le message
    Comment je peux faire pour le modifier ?
    Modifier quoi? Si c'est modifier ton code pour qu'il corresponde au chemin prévu alors tu l'ouvres avec un éditeur de code et tu tapes avec tes doigts. Et si c'est modifier le chemin pour qu'il corresponde au code tel qu'il est écrit ben tu dois savoir renommer des dossiers...
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

Discussions similaires

  1. Divers problèmes avec un projet MFC
    Par Altpua dans le forum MFC
    Réponses: 5
    Dernier message: 15/07/2010, 12h40
  2. Problème avec mon projet JEE
    Par Ammouna1204 dans le forum Servlets/JSP
    Réponses: 18
    Dernier message: 20/04/2010, 22h50
  3. Probléme avec mon Projet VB.net
    Par inter_amine dans le forum Windows Forms
    Réponses: 2
    Dernier message: 06/11/2008, 10h07
  4. Problème avec un projet
    Par josef24 dans le forum C
    Réponses: 12
    Dernier message: 24/09/2007, 13h31
  5. Import problème avec le projet d'import
    Par IM007 dans le forum 4D
    Réponses: 3
    Dernier message: 22/05/2007, 13h29

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo