salut

il est évident que ça ne peut pas marcher ...

comment se notent deux termes consécutifs d'une liste L ?

Les deux termes consécutifs d'une liste L se notent L[n]+L[n+1] ?

Je réponds un peu tard mais je n'arrivais plus à me connecter sur le site.
Donc si j'ai compris :
def liste_pas_ordre(L):
n=abool
for i in range(len(L)):
        if L[n] < L[n+1]:
            return (false)
for i in range(len(L)):
        if L[n] > L[n+1]:
            return (false)
J'ai essayé et cela me marque : list indices must be integeres, not type? Est-ce que je suis bien arrivée au bout?

J'ai fait une erreur de frappe c'est n=bool et non n=abool.

ben oui tu utilises la variable n et pas la variable de boucle ... que tu notes ... ?

et il y a un pb de bornes ...

Je pense qu'il faut changer n par i.   Ensuite, il faut peut-être utiliser if et else au lieu de if seul.

Donc:
def liste_pas_ordre(L):
    for i in range(len(L)):
        if L < L[i+1]:
            return ("false")
        else:
            return ("true")

Dans l'énoncé, il est marqué qu'il faut utiliser "True si deux termes consécutifs ne sont pas rangés dans l'ordre croissant".
C'est ce que j'ai fait mais python me met False au lieu de True au résultat quand les valeurs ne sont pas les premiers chiffres.
Je ne sais pas si je suis assez clair. Par exemple:
>>> (liste_pas_ordre([1,2,3,4,5]))
>>> ('false')
et
>>> (liste_pas_ordre([1,2,3,5,4]))
>>> ('false')    [i]Alors que si j'ai bien compris cela devrait être True.

Alors que
>>> (liste_pas_ordre([2,1,3,4,5]))
>>> ('true')

il est stupide d'utiliser True quand tout est ok !! vu la logique de fonctionnement des opérateurs booléens ...

on peut toujours répondre ce qu'il faut répondre à la fin en utilisant la fonction not ...

3/ si deux termes consécutifs ne sont pas dans l'ordre s'arrêter et sortir en concluant ...

"Tant que" est "while" en python. Pour le reste, je cherche depuis tout à l'heure. Dès que j'ai quelque chose qui me parait correct, je le poste.

Je compare les deux premiers termes consécutifs :
L[i]<L[i+1].

Dans la formule, cela donne :

def liste_pas_ordre(L):
    for i in range(len(L)):
        while L[i] < L[i+1]:
            return ("false")

Après pour continuer avec les termes suivants, je ne ne l'ai pas vu en cours et je ne trouve pas.
Est-ce qu'il faudrait ajouter une variable i=0 et i+1=1 et tant que la liste de i est < à la liste de i+1,
i=1 et i+1 = i+1+1, ce qui donnerait :

def liste_pas_ordre(L):
    i=0
     i+1=1
    for i in range(len(L)):
        while L < L[i+1]:
            i=i+1
            i+1=i+1+1
            return ("false")
        


    

pour les deux premiers termes il n'y a pas de i mais une valeur numérique bien précise

ensuite ça doit être fait dans la fonction !!

rien ne va !!

finalement ma méthode ne va pas (enfin elle va mais pénible à t'expliquer) donc on va continuer avec du (plus) classique

def liste_pas_l'ordre (L) :
  T = False
  for i in range (len(L)) :
     if L[i] ... L[i + 1] :
         ...
   return T

J 'ai peut-être trouvé la solution mais la flèche exécution sur python n'apparaît plus. Savez-vous quelle manipulation dois-je faire pour récupérer la flèche?

Sinon voici ce que j'ai fait:
def liste_pas_l'ordre (L) :
  T = "False"
  for i in range (len(L)) :
    while L[i] < L[i + 1] :
         T="True"
   return T

alors là je ne sais pas de quoi tu parles ...

ok pour ton algo, c'est l'idée mais il y a des pb :

1/ encore et toujours un pb de borne    (*)
2/ il faut un test pour changer T en True   (*)
3/ T est un booléen et pas un alphanumérique donc il ne faut pas de guillemet

(*) imagine que tu vas jusqu'au bout ...

et il faut incrémenter i à chaque tour

Mon problème de borne serait "for i in range (len(L)) :" que je ne dois pas mettre?
Par contre il faudrait rajouter L=[]
J'enlève les guillemets à False et True.
Et j'incrémente i en créant une variable i=0
Donc

def liste_pas_l'ordre (L) :
  T = False
   L=[]
   i=0
    while L[i] < L[i + 1] :
         T=False         (je change True par False) jusqu'à ce qu'il detecte
          i=1
          if L[i+1]<L[i]       et ensuite il faudrait qu'il renvoie True.  A la fin
          T=True
    return T

regarde ce qui se passe dans ton script quand len (L) = 5 par exemple

tout ce qui est dans la boucle while ne va pas :

i est constant et égal à 1
tu fais deux tests contraires sans intérêt

D'accord donc
def liste_pas_l'ordre (L) :
  T = False
   L=[]
   i =1                             ( et non i=0 du coup )

puis
while  L[i] < L[i + 1] :
        T=True
         return (T)

j'ai essayé plein d'autres possibilités et c'est celle qui me parait la plus cohérente....

Sinon faut-il que j'utilise if et else?

D'accord, je rectifie mes erreurs :
L=[i]
et
i=0  car les indices de listes commencent à 0

Je continue à chercher pour la boucle while....

def liste_blabla (L) :
  T = true
  i = 0
  while L(i) <= L(i + 1) and i < ... :   pour le pb de la borne !!
    i = i + 1
  if i = ... :
    T = ...
  return T

def liste_blabla (L) :
  T = false
  for i in range (...) :
     if L[i] ... L[i + 1] :
       T = 
  return T

pardon : il faut mettre des crochets pour la liste dans le premier script

@ Franca26

En réponse à ta question :

Erreur fâcheuse....
La combinaison de touches est CTRL + F2 pour arrêter un script parti en vrille !

On obtient alors  la fenêtre ci dessous qui permet un temps de réflexion... avant d'agir.

Merci beaucoup pour les renseignements techniques que je vais noter pour pouvoir utiliser si cela se reproduit.

Pour ce qui est du script
def liste_blabla (L) :
  T = false
  for i in range (...) :
     if L[i] ... L[i + 1] :
       T =
  return T


Voilà ce que j'ai trouvé :
def liste_pas_ordre (L):
    L = False
    for i in range (L):
        if L[i]>L[i+1]:
            L = True
    return (L)

J'arrive à un résultat par contre si je prends un exemple :
les deux derniers chiffres sont inversés, cela me donne False au lieu de True
(:>>> (liste_pas_ordre([1,2,3,4,5]))
False
>>> (liste_pas_ordre([1,2,3,5,4]))
False)

Pour
def liste_blabla (L) :
  T = true
  i = 0
  while L(i) <= L(i + 1) and i < ... :
    i = i + 1
  if i = ... :
    T = ...
  return T

voilà ce que j'ai fait:

def liste_pas_ordre (L):
    T= True
    i=0
    while L[i]<=L[i+1] and i<=i+1:
        i=i+1
        i<i+1
        T= False
    return (T)

J'ai le même résultat si je prends un exemple ..... :
console de Python:
>>> (liste_pas_ordre([1,2,3,5,4]))
False
>>> (liste_pas_ordre([2,1,3,4,5]))
False

Pardon, il est vrai que j'avais mis L à la place du T parce que Python mettait list index out of range.
En modifiant for i in range cela donne :

def liste_pas_ordre (L):
    T = False
    for i in range (len(L)):
        if L[i]>L[i+1]:
            T = True
    return (T)

console de python:
list index out of range

et ben enfin : je te dis qu'il y a un pb de borne dans le range et la liste

prenons ta liste : L = [1, 2, 4, 5, 3] ou ce que tu veux

maintenant déroule le programme à la main sur une feuille et regarde ce qui se passe...

Avec while, j'ai oublié effectivement le "if" que vous aviez écrit.
Je modifie :
def liste_pas_ordre (L) :
  T = true
  i = 0
  while L(i) <= L(i + 1) and i < i+1 :
    i = i + 1
  if i = i+1 :
    T = False
  return T

Si on prend liste : L = [1, 2, 4, 5, 3], chaque étape est fausse sauf la dernière qui est donc True.

je m'en fous !!

je veux que

def liste_pas_ordre (L) :
  T = true
  i = 0
  while L(i) <= L(i + 1) and i < 0   :
    i = i + 1
  if i = = i+1 :
    T = False
  return T

Je pensais qu'il s'agissait d'une boucle non bornée car nous ne savons pas combien de fois la boucle va se répéter mais en fait d'après ce que vous voulez me faire comprendre, il s'agirait d'une boucle bornée?

Y a t il un terme en Python qui veut dire "jusqu'à"? C'est peut être de cela que j'ai besoin.

quel que soit le script les boucles sont bornées soit parce que range l'est soit parce que je prend mes précautions dans la boucle while

mais à chaque fois tu ne traduis pas parle bon test parce que tu ne fais pas ce que je te demande  et trouver le pb de bornes

et tes tests sont donc faux ou inutiles

A priori,  je ne comprends pas ce qu'il m'est demandé de faire puisque je réponds à côté. Ce que j'ai fait ne convient pas, certainement parce que je ne saisis pas correctement ce qu'il faut. Quand vous parlez de problèmes de bornes, cela veut bien dire qu'il y a un problème dans la formule en général?

Je reprends et détaille :
1/ prendre les 2 premiers termes et les comparer :
Cela revient à utiliser les signes <=, >=
L[i] <= L[i+1] ou L[i]>=L[i+1]  

2/ J'utilise while L[i] <=L[i+1] ou L[i]>=L[i+1]  
Pour parcourir la liste j'utilise (len(L) -1)  et non (len(L)) comme j'avais mis

En rajoutant -1, python peut accéder à toutes les valeurs car
list index out of range signifie que Python essaie d'accéder à une valeur qui n'est pas présente dans la formule

3/ Je peux aller jusqu'à ce que le programme tombe sur deux nombres inversés

je t'ai dit de le faire avec le pgm que je t'ai dit à 14h19

non la traduction est fausse

mais comme tu ne comprends pas je vais te le faire avec la liste L = [1,3,2,4, 5] et

Si i= 0
L[0] > L[0 + 1] , c'est faux
Si i = 1
L[1] > L[1 + 1], c'est faux
Si i = 3
L[3] > L[3 + 1], c'est faux
Si i = 2
L[2] > L[2 + 1], c'est faux
Si i = 4
L[4] > L[4 + 1], c'est faux
Si i = 5
L[5] > L[5 + 1], c'est faux

Du coup, il faudrait faire plusieurs comparaisons en commençant par la première valeur et en finissant par la dernière jusqu'à atteindre le résultat soit juste, ce qui reviendrait à comparer :
L[0,1,3,2,4,5]
L[0]<L[1] => faux
L[1]<L[3] => faux
L[3]>L[2] => vrai
Le programme s'arrêterait à ce niveau.

on se moque de savoir si c'est faux ou vrai : pour l'instant c'est sans intérêt

l'important c'est ce qu'on compare !!!

peux-tu recommencer en me calculant les sommes entre crochet ?


et sans tout ce qui suit le "du coup" qui n'a rien à voir avec la question ...

Si i= 0
L[0] < L[1] ,
Si i = 1
L[1] < L[2],
Si i = 3
L[3] < L[4],
Si i = 2
L[2] < L[3],
Si i = 4
L[4] < L[5],
Si i = 5
L[5] < L[6].

En attendant que Carpediem soit disponible :