APPRENDRE LE PYTHON #4 ? LES LISTES

main.py

from random import shuffle
 
# Générateur de phrases
# demander en console une chaine de la forme "mot1/mot2/mot3/mot4"
chained_words = input("Entrer une chaine de la forme mot1/mot2/mot3/mot4")
 
# transformer cette chaine en liste
words = chained_words.split("/")
 
# la melanger
shuffle(words)
 
# recuperer le nombre d'elements
words_len = len(words)
 
# si le nombre d'élements de cette liste est inferieur à 10
if words_len < 10:
  # afficher les deux premiers mots
  print(words[0], words[1])
  
# si le nombre d'éements est superieur ou égal à 10
else:
  # afficher les 3 derniers
  print(words[words_len - 1], words[words_len - 2], words[words_len - 3])

salut , voici mon code :

from random import shuffle
# /j'ai galérer car j'avais mis la parenthèse après "/mot2/etc.... "" a la fin au lieu de la mettre après la guillemet #
words_list=input("veuillez citer quelques mots sous la forme: mot1/mot2/etc.... ") .split("/")

for loop in range(3):
shuffle(words_list)
print(words_list)

if len(words_list) < 10:
print(words_list[0],
words_list[1],
)
else:
print(words_list[len(words_list)-3],
words_list[len(words_list)-2],
words_list[len(words_list)-1],
)

=============================================================================

Generateur des phrases par Ramanantsoa Ravaka

=============================================================================

texte = input("chaine de caractere(mot1-mot2-mot3-mot4-mot5) : ").split("-")
shuffle(texte)
print(texte)
if len(texte) < 10 :
print(texte[0:2])
else : print(texte[0:3])

voilà mon code, il est je trouve plus simpliste que celui de graven, donc peut-etre plus performant

from random import shuffle

sentence = input("donnez moi des mots de cette façon : mot1/mot2/mot3... ").split("/")
shuffle(sentence)

if len(sentence) < 9:
    print(sentence[0:2])
else:
    print(sentence[0:3])

mon code, j'ai regardé la soluce un peu pour afficher les 2 premiers et 2 derniers mots ^^
`# on importe le module shuffle
from random import shuffle
#on demande une liste de mots et on les sépare en liste par la valeur "espace"
text = input("écrivez une liste de mots séparés d'un espace ").split(" ")

on compte le nombre de mots dans la liste et l'insère dans une variable

nb_word = len(text)
#on mélange les mots dans la liste
shuffle(text)

si le nombre de mots est inférieur à 10 on affiche les deux premiers

if nb_word < 10:
print(text[0], text[1])
#sinon on affiche les deux derniers
else:
print(text[nb_word -1], text[nb_word -2], text[nb_word -3])
`

Voici mon code, je pensais que j'allais bien plus galérer que ça pour cet exercice, c'est que ça commence à rentrer !

from random import shuffle

words_list = input("Ecrivez le nombre de mots que vous souhaitez, séparés par un slash").split("/")
print("Les mots choisis sont : {}".format(words_list))
shuffle(words_list)
print("Le mélange des mots donne : {}".format(words_list))

number_words = len(words_list)
print("Il y a {}".format(number_words) + " mots dans votre liste")

if number_words < 10:
    print(words_list[0])
    print(words_list[1])
else:
    print(words_list[len(words_list) - 3])
    print(words_list[len(words_list) - 2])
    print(words_list[len(words_list) - 1])

from random import shuffle
#generateur de phrases
#demander en cosole une chaine de liste
print("entrer vos mots")
texte = input("mot1-mot 2-mot3-mot4") .split("-")
print("vos mots sont", texte)
shuffle(texte)
print(texte)
shuffle(texte)
print(texte)
text_len = len(texte)
if text_len < 10:
print(texte[0])
print(texte[1])
else:
print(texte[text_len -1], texte[text_len -2], texte[text_len -3])

bonjour Graven ... très agréable á suivre tes formations ... en quelques minutes tu nous offres beaucoup d'informations .
merci un grand bravo pour ta pédagogie et tes présentations très pro .

code

import random
#from random import shuffle

texte = input("entrez une liste de mots séparés par /")

liste = texte.split("/")

random.shuffle(liste)

compteur = len(liste)  

print(liste, "\nVous avez entré", compteur, "mots")  #*\n ds le texte = saut a la ligne*

#liste = (liste[0] + liste[1], liste[-1] + liste[-2] + liste[-3])[compteur >= 10]   #*resultat en format texte collé*

liste = (liste[:2], liste[-3:])[compteur >= 10] #*resultat en format liste ( : 2 car :1  me renvoyait que le premier élément) merci ;)*

print(liste)

Hello, voici mon code pour cet exercice :
from random import shuffle

x = input("Entrez une chaine de caractère sous la forme 'mot1/mot2/mot3/mot4': ")
newlist = []
mot = ""
count=0
count2=0
for i in x:
if i != "/":
mot += i
else:
newlist.append(mot)
mot = ""
newlist.append(mot) # Ajoute le dernier mot à la liste
shuffle(newlist)
print(newlist)
for i in range(len(newlist)):
count=count+1
print(count)

if count<10:
print(newlist[:2])
else:
print(newlist[-3:])

Bonjour !
Voici mon code :

from random import shuffle

#Demander en console une liste de mot sous une certaine forme :
#split pour le récupérer sous forme de liste
text = input("Entrer une chaîne de la forme mot1/mot2/mot3/mot4/..... ").split("/")

#mélanger la liste grâce à la fonction shuffle du module random
shuffle(text)

#si la liste est inférieur à 10 éléments, afficher les 2 premiers éléments de la liste
if len(text) < 10 :
print(text)
print(text[0:2])

#sinon on affiche les 3 derniers éléments
else:
print(text)
n = 3
res= text[-n:]
print("The last N elements of list are : " + str(res))

Salut, voici mon code :

import statistics
import random

def main():
chaine_mot = input("Entrez une chaine de la forme (chaine_mot1/chaine_mot2/chaine_mot3/chaine_mot4...)").split("/")
print(chaine_mot)
random.shuffle(chaine_mot)
print(chaine_mot)
if len(chaine_mot) >= 10:
print(chaine_mot[len(chaine_mot)-1],chaine_mot[len(chaine_mot)-2],chaine_mot[len(chaine_mot)-3])
else:
print(chaine_mot[0],chaine_mot[1])

if name == 'main':
main()

Hey voila mon code

from random import shuffle

def Main():
    mots = input("Veuillez entrez des mots sous la forme : mot1/mot2/mot3 ect... (séparer par un slash) ").split("/")
    shuffle(mots)
    print(mots)

    if len(mots) < 10:
        print(mots[0], mots[1])

    elif len(mots) >= 10:
        print(mots[0], mots[1], mots[2])


if __name__ == "__main__":
    Main()

Voici mon code:

from random import shuffle

mots=input("Veuiilez entrer une chaine des mots en suivant cet exemple (mot1/mot2/mot3/...) ").split("/")

nbre=len(mots)

print("Vous avez ajouté " + str(nbre) + " mots" )

print("Voici la liste des mots avant de mélanger: " + str(mots) )

shuffle(mots)

print("Voici la liste des mots après avoir melangé" + str(mots) )

if nbre < 10:
print("Voici la liste des deux premiers mots: " + str(mots[0:2]))

else:
print("Voici la liste des trois premiers mots: " + str(mots[0:3]))

Bonsoir à tous, voici mon code :

Afin de vérifier mon résultat, je trouvais utile d'affiche la liste une fois mélangée.

# Générateur de phrases
# Demander à l'utilisateur de saisir une phrase de la forme "mot1/mot2/mot3/mot4/..."
sentence = input("Entrez une phrase de la forme (mot1/mot2/mot3/mot4/...) : ")

# Transformer cette phrase en une liste
sentence = sentence.split("/")

# Mélanger les mots de la liste
shuffle(sentence)
print(sentence)

# Si le nombre d'éléments est < à 10 -> afficher les 2 premiers mots
# Si le nombre d'éléments est >= à 10 -> afficher les 3 derniers mots
if len(sentence) < 10:
    print(sentence[0:2])
elif len(sentence) >= 10:
    print(sentence[-3:])

Place de cinema

prix_pop_corn = 7
prix_mineur = 15
prix_majeur = 20
Obedi = int (input("Quel est votre âge : "))
if Obedi < 18 :
pop_corn = input("Souhaitez-vous du pop corn ? (Oui, Non)")
if pop_corn == "Oui" :
price = prix_pop_corn + prix_mineur
else :
price = prix_mineur
else :
pop_corn = input("Souhaitez-vous du pop corn ? (Oui, Non)")
if pop_corn == "Oui" :
price = prix_pop_corn + prix_majeur
else :
price = prix_majeur
print("Vous devez payer " ,price, "euro")

# Generateur de phrases
# demander en console une chaine de la forme mot1/mot2/....
# transformer la chaine en une liste
# la melanger
# si le nb d'element est inf à 10 afficher les 2 premiers mots
# si le nb d'element est sup ou egal à 10 afficher les 3 derniers mots
from random import shuffle

words = input("Entrez plusieurs mots de la forme mot1/mot2/...").split("/")
print("La liste des mots est : {}".format(words))
shuffle(words)
print("La liste mélangée est : {}".format(words))

if len(words) >= 10:
    print("La liste est superieur à 10 donc : {}".format(words[-3:]))
else:
    print("La liste est inferieur à 10 donc : {}".format(words[0:2]))

Voila le miens, je suis peut être pas très opti mais j'aime bien
from random import shuffle
chain_word = input("Ecrire une chaine de mot sous la forme : mot1/mot2/mot3...").split("/")
print(chain_word)
shuffle(chain_word)
print(chain_word)
lenght = len(chain_word)
print(lenght)
if lenght < 10 :
print(chain_word [0],chain_word [1] )
elif lenght >= lenght:
print(chain_word[-3], chain_word[-2], chain_word[-1])

VOICI MA CONTRIBUTION

from random import shuffle
#demander en console une chaine de la forme "mot1/mot2/mot3/mot4"
generateur = input("Entrer une chaine de caractère de la forme(mot1/mot2/mot3/mot4...)").split("/")

#la melanger
shuffle (generateur)
print(generateur)

#recuperation de nombres des élément de la liste
compte = len(generateur)
#de dire si le nombre d'éléments de cette liste est inférieur à 10
#afficher les deux premiers mots
if compte < 10 :
print("{}, {}".format(generateur[0], generateur[1]))

#si le nombres d'élément est superieur ou égale à 10
#afficher les 3 derniers mots
elif compte > 10 :
print(generateur[len(generateur) -3])
print(generateur[len(generateur) -2])
print(generateur[len(generateur) -1])

Voici ma version !
Je suis un peu habitué à la programmation, donc je me suis dit qu'il y avait forcément moyen d'intégrer une boucle for dans le else qui lit les 3 derniers éléments de la liste, et j'ai réussi en lisant un peu la doc de l'AFPY. J'imagine que si c'était noté j'aurais quelques points en moins, mais on est entre nous, donc j'imagine que tu ne m'en tiendra pas rigueur.
(je me suis aussi permis de créer un dépôt GitHub où je partage mes essais de réalisation de tes TP.

# Tuto 04 de Graven : générateur de phrases

from random import shuffle

# Demander en console une chaine de la forme mot1/mot2/mot3/mot4
chaine = input("Entrez une chaine de la forme mot1/mot2/mot3/mot4.... : ")

# Transformer cette chaine en une liste
chaineListed = chaine.split("/")
print("Chaine avant de la mélanger : ")
print(chaineListed)

# la mélanger
shuffle(chaineListed)
print("Chaine mélangée : ")
print(chaineListed)

# si le nombre d'éléments de cette liste est inférieur à 10
# -> afficher les deux premiers mots
# si le nombre d'éléments est supérieur ou égal à 10
# -> afficher les 3 derniers mots 

nombreElements = len(chaineListed)

if nombreElements < 10:
    print(chaineListed[0])
    print(chaineListed[1])
else:
    for key in range(nombreElements-3, nombreElements):
        print(chaineListed[key])

Voici mon TP
from random import shuffle
text = input("Entrer des mots de la forme (mot1/mot2/mot3/mot4/mot5)").split("/")
print(text)
shuffle(text)
print(text)
text_size = len(text)
if text_size< 10:
print(text[0])
print(text[1])
else:
print(text[len(text) - 1])
print(text[len(text) - 2])

import random
mot_préféré = input ("Entre les 3 mots que tu préféres en format : mot 1/mot 2/mot3/mot 4/ mot 5 ").split("/")
print (mot_préféré)
random.shuffle(mot_préféré)
print (mot_préféré)
if len(mot_préféré) < 10 :
print(mot_préféré[0:2])
else :
print(mot_préféré[2:])

Je m'en suis sorti comme ça pour ma part :

import random

text = input("Entre une chaine de la forme mot1/mot2/mot3/mot4 etc...").split("/")
print(text)
random.shuffle(text)
print(text)
if len(text) < 10 :
print(text[0:2])
else :
print(text[-3:])

from random import shuffle

liste_de_mots = input("Entrez une liste de mots séparés par des /")
print(liste_de_mots)
mots = liste_de_mots.split('/')
print(mots)
shuffle(mots)
print(mots)

mots_len = len(mots)
print("Il y a", len(mots), "mots dans la liste")

if len(mots)<10 :
print(mots[0], mots[1])

if len(mots)>=10 :
print(mots[mots_len -1], mots[mots_len -2], mots[mots_len -3])

Moi j'aurais changé le dernier print dans la condition si supérieur ou égal à 10 en :

print(list_de_mot[len(list_de_mot) - 3:len(list_de_mot)])

Comment ça c'est plus court et t'es sûr que ça prend que les trois dernières mots de la liste en te basant sur la taille de la liste et en retirant 3 pour faire le début de la fin de la liste 😉👍 Coeur sur vous ❤️👍🤔

Voilà comment j'aurais fait car c'est plus court et plus esthétique 😉👍

Voici mon exercice si vous avez des conseils n'hésiter pas from random import shuffle

genp = input("Taper des mot sous la forme (mot1/mot2/mot3......)").split("/")
print(genp)
shuffle(genp)
if len(genp) < 10 :
print(genp[0])
print(genp[1])
elif len(genp) >= 10 :
print(genp[7])
print(genp[8])
print(genp[9])

Voila :

from random import shuffle

text = input("Entrer une chaine de la forme (mot1/mot2/mot3/mot4/mot5/etc...): ").split("/")
print(text)
shuffle(text)
print(text)

if len(text)<10:
print(text[0],text[1])
else:
print(text[len(text)-3], text[len(text)-2],text[len(text)-1])

gen_test = input("enter your strings: str1/str2/str3........ ").split("/")
print(gen_test)
import random
random.shuffle(gen_test)
print(gen_test)
if len(gen_test) < 10:
print(gen_test[:2])
elif len(gen_test) >= 10:
print(gen_test[-4:-1])

#Generateur de phrase
#demander en console une chaine de la forme "mots1/mots2/mots3..."
#melanger ses mots
#si le nombre d'élément de cette liste est inférieur à 10
#--> afficher les deux premiers mots

si le nombre d'élément est superieur ou égale à 10

#--> afficher les 3 derniers
import random

Entree= input("entrée votre mots de la forme (mots1/mots2/mots3)").split("/")
melanger=random.shuffle(Entree)
print(Entree)
element=len(Entree)
print(element)
if element<10:
print (Entree[0],Entree[1])
else:
print(Entree[element-1], Entree[element-2], Entree[element-3])

import random

Demander en console une chaine de la forme "mot1/mot2/mot3..."

entree = input("Entrez vos mots séparés par des '/': ").split("/")

Mélanger les mots

random.shuffle(entree)

Afficher la liste mélangée et le nombre d'éléments

print(entree)
nombre_elements = len(entree)
print("Nombre d'éléments:", nombre_elements)

Afficher les mots selon le nombre d'éléments

if nombre_elements < 10:
# Vérifier s'il y a au moins deux éléments pour éviter une erreur d'indexation
if nombre_elements >= 2:
print(entree[0], entree[1])
elif nombre_elements == 1:
print(entree[0])
else:
print("La liste est vide.")
else:
# Afficher les 3 derniers mots
print(entree[-3], entree[-2], entree[-1])

Personne n'a fait comme moi pour les deux premiers et les trois derniers mots...