Bibm@th

Forum de mathématiques - Bibm@th.net

Bienvenue dans les forums du site BibM@th, des forums où on dit Bonjour (Bonsoir), Merci, S'il vous plaît...

Vous n'êtes pas identifié(e).

Répondre

Veuillez composer votre message et l'envoyer
Nom (obligatoire)

E-mail (obligatoire)

Message (obligatoire)

Programme anti-spam : Afin de lutter contre le spam, nous vous demandons de bien vouloir répondre à la question suivante. Après inscription sur le site, vous n'aurez plus à répondre à ces questions.

Quel est le résultat de l'opération suivante (donner le résultat en chiffres)?
quatre-vingt sept moins vingt neuf
Système anti-bot

Faites glisser le curseur de gauche à droite pour activer le bouton de confirmation.

Attention : Vous devez activer Javascript dans votre navigateur pour utiliser le système anti-bot.

Retour

Résumé de la discussion (messages les plus récents en premier)

dede
09-04-2018 21:12:43
Bibi974 a écrit :

Bonjour , je cherche à savoir comment tester l'appartenance d'un élément à une liste de liste . En effet "in" fonction pour une liste [1,3,5] (par ex) mais dans mon ex cela ne marche pas et me renvoie non tout le temps ...

A =[[1,5],[3,6]]
n = int(input())
if n in A :
    print("oui")
else:
    print("non")
Merci par avance.


ta liste est compose de sous liste . et ton int(input())  récuper une unique valeur numérique .
si  tu test  a voir si par exemple  n= [3,6] ou n = [1,5] , on if n in A : te retournera Oui.
la comment peux tu penser qu'une valeur numérique soit de quelque façon equivalente à une liste de 2 valeurs??

PGMPGRM
08-01-2017 14:12:03

non je ne suis pas trop d'accord avec vous moi j'ai ça:
list=[0,1];L
random.choice(liste)
n in list(L)
if n=0:
    print("pile")
if n!=0:
    print("face")

yoshi
06-06-2015 20:10:00

Bonsoir,

s'il s'agit de l'appartenance à une liste et non pas une liste de listes, oui c'est facile à faire...

Exemple:

L=[1,4,2,0,9,3,8,7,6,5,11,12,15,20,21,18,17,14,13,16,27,28,36,35]
x=16
print("Liste initiale")
print(L)
if x in L:
    p=L.index(x) # position de x dans L
    L[p]=L[p]*7  # plus court est : L[p]*=7

#vérification
print("Nouvelle liste")
print (L)

Sortie :

Python 3.4.0 (v3.4.0:04f714765c13, Mar 16 2014, 19:24:06) [MSC v.1600 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> ===================================== RESTART =====================================
>>>
Liste initiale
[1, 4, 2, 0, 9, 3, 8, 7, 6, 5, 11, 12, 15, 20, 21, 18, 17, 14, 13, 16, 27, 28, 36, 35]
Nouvelle liste
[1, 4, 2, 0, 9, 3, 8, 7, 6, 5, 11, 12, 15, 20, 21, 18, 17, 14, 13, 112, 27, 28, 36, 35]
>>>

Si tu as une liste composée par ex de tous les nombres de 1 à 100 et que tu veux remplacer par True tous les multiples de 6, il te faut passer par une boucle qui prend chaque élément x, garde sa position i :

L=[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]

print("Liste initiale")
print(L)
for i,x in enumerate(L):
    if x%6==0:
        L[i]=True

#vérification
print("\nNouvelle liste") # \n permet de sauter une ligne
print (L)

Sortie :

Python 3.4.0 (v3.4.0:04f714765c13, Mar 16 2014, 19:24:06) [MSC v.1600 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> ===================================== RESTART =====================================
>>>
Liste initiale
[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]

Nouvelle liste
[1, 2, 3, 4, 5, True, 7, 8, 9, 10, 11, True, 13, 14, 15, 16, 17, True, 19, 20, 21, 22, 23, True, 25, 26, 27, 28, 29, True, 31, 32, 33, 34, 35, True, 37, 38, 39, 40, 41, True, 43, 44, 45, 46, 47, True, 49, 50]
>>>

As-tu d'autres questions ?

@+

evily
06-06-2015 17:46:23
Barbichu a écrit :

Salut,
oui, ça s'appelle "in".
Par ex "3 in [3,4]" te répond "True".
++

peut-on demander au programme de faire un traitement à l'élément demander si la réponse est "true" ?
par exemple x in [3,4] 
si réponse est "true"
x=x*3

Barbichu
06-02-2013 18:16:06

Salut,

Garulfo a écrit :

[...] Pour ta version « impérative », [...]
[...] Le fait que tu les trouves plus lisibles [...]
[...] Maintenant c'est fort possible que ça ne répondait pas exactement à l'exercice de Bibi. [...]

Trois extraits qui m'indiquent que tu as probablement mal lu mon message (ou trop vite) ou mal interprété, ou les deux (ou les trois). Ou alors c'est moi.

Pour le reste de ton message, je reviendrai dessus plus tard.
(J'aime bien ce genre de débat.)

Bonne soirée,

Garulfo
06-02-2013 14:32:22
Barbichu a écrit :

Salut Garulfo,

je suis plutôt d'accord sur le fond, tes programmes sont en effet plus concis, plus abstrait (et plus lisibles pour moi, mais je ne sais pas si ce sera le cas de Bibi ou de totomm, je ne connais pas leur formation) et répondent à la question initiale, mais je dois m'indigner sur la forme.

Déjà, python n'est pas un langage fonctionnel (même si certaines composantes du langages permettent de faire de la programmation fonctionnelle) et les listes n'y sont pas des objets persistants. Je ne vois pas en quoi la structure de la liste python est "récursive" [...]

(Au passage tu avais fait une erreur : l'élément initial pour le reduce doit être False)

Oupss ^^ tu as raison pour le False. Au temps pour moi.

Oui ce n'est pas un langage fonctionnel et il est vrai aussi que les listes ne sont pas (à l'interne) récursive.
Mais de l'externe une liste a une spécification récursive. Son comportement et sa conception est récursive.
Avant d'apprendre à optimiser localement (« la racine du mal » comme disait Dijkstra), il faut "élever" sa vue.
Et c'est pourquoi je pense que c'est une meilleure solution.

Pour ta version « impérative », je n'aime pas les fonctions qui retournent des valeurs booléennes. Ce sont souvent des manques de temps dans l'écriture de la formule sous jacentes. Dans ce cas précis, il est clair que le for rend l'écriture de la formule plus complexe (il faut un forall et je ne sais pas si c'est disponible dans les biblios Python), mais ça se fait quand même bien... — je le ferais après mon cours, je n'ai pas le temps là et j'aimerais éviter un autre True qui devrait être un False

Le fait que tu les trouves plus lisibles "montrent" — je met ça entre guillemets car c'est loin d'être une démonstration — qu'il y a une forme de posture à acquérir pour les plus développeurs expérimentés. Or en général on ne l'acquiert pas si on ne commence pas par l'apprendre et on s'enfarge dans du code détaillé. Ça se retrouve avec des développeurs qui ont quelques années d'expérience et qui ne comprennent toujours pas qu'un itérateur est préférable à une implémentation de cet itérateur.

Maintenant c'est fort possible que ça ne répondait pas exactement à l'exercice de Bibi. Mais je n'ai pas l'habitude de donner des solutions exactes sur les forums.

Sinon personnellement je n'aime pas beaucoup Python... trop de liberté nuit à la propreté du code, à l'abstraction et à la lisibilité... et que dire de la maintenance ><  Mais c'est un avis personnel.

Bonne journée à tous

totomm
05-02-2013 09:21:45

Bonjour,

Lire après 10 mois passés un commentaire sur un exemple de petit programme est un réel plaisir. En souhaitant que Bibi974 en sache profiter...

Merci à Barbichu qui complète le commentaire de Garulfo (qui mérite aussi un merci) :
Le niveau de concision et d'abstraction utilisé en programmation dépend du niveau et de la fréquence des problèmes à traiter.

Nul doute que Python permette un niveau très élaboré en programmation dont chacun peut tirer profit (même utilisateur "occasionnel"), mais certainement une discussion sur l'utilisation, et à fortiori sur l'implémentation de structures itératives versus récursives dépasse largement les réponses simples aux questions simples posées en post #1 et #4.

Cordialement

Barbichu
04-02-2013 22:13:07

Salut Garulfo,

je suis plutôt d'accord sur le fond, tes programmes sont en effet plus concis, plus abstrait (et plus lisibles pour moi, mais je ne sais pas si ce sera le cas de Bibi ou de totomm, je ne connais pas leur formation) et répondent à la question initiale, mais je dois m'indigner sur la forme.

Déjà, python n'est pas un langage fonctionnel (même si certaines composantes du langages permettent de faire de la programmation fonctionnelle) et les listes n'y sont pas des objets persistants. Je ne vois pas en quoi la structure de la liste python est "récursive" : elle s'apparente plus au tableau mutable à longueur variable qu'à un type algébrique. Enfin --- mais c'est un détail de vocabulaire j'imagine --- les solutions que tu proposes n'ont rien de récursives (au mieux map et reduce sont peut-être implantées récursivement, mais ce ne sont pas nos oignons en temps qu'utilisateur).

NB : Par contre, il est vrai qu'il y a quelques structures persistantes en python : tuple et frozenset par exemple.
Il y a aussi la construction lambda en python, alors tant qu'à faire autant réécrire ton programme de manière encore plus concise (et plus élégante à mon goût) :


inL = lambda e, L: reduce(lambda b, l: b or e in l, L, False)
 

(Au passage tu avais fait une erreur : l'élément initial pour le reduce doit être False)

Pour finir sur quelque chose de constructif, voici une fonction récursive (vraiment cette fois-ci) pour tester appartenance à un itérable dont les éléments peuvent être des itérables dont les éléments peuvent être des itérables ... en style impératif :


from collections import Iterable

def inL(e, L):
    if e == L: return True
    if isinstance(L, Iterable):
        for l in L:
            if inL(e, l): return True
    return False
 

ou bien style fonctionnel (qui n'est pas forcement très compréhensible ni élégant, dans ce cas ci) :


from collections import Iterable

def inL(e, L):
    e_in = lambda b, l: b or e == l or \
        (reduce(e_in, l, False) if isinstance(l, Iterable) else False)
    return e_in(False, L)
 

A+

Garulfo
04-02-2013 18:59:23
totomm a écrit :
def inL(e,L,r=None):
    if r==None:
        r=[]
    for i in range(len(L)):
        if e in L[i]:
            r.append(i)
    return r
   
#Utilisation exemple
a =[[1,5],[3,6],[5,4],[5,6]]
b=inL(6,a)
print(b) #imprime [1, 3]

Salut,

je ne vois pas l'intérêt de ton paramètre r. Est-ce dans l'éventualité qu'on désire commencer avec une liste des indices non vides ? Ça me semble moyennement intéressant. Sinon tu ne réponds pas à la question posée par Bibi; ce qui est possiblement volontaire et certainement salutaire. Personnellement, je n'aime pas cette solution qui déconstruit la liste sans se préoccuper qu'il existe déjà des fonctions de haut niveau qui sont abstraites et bien pensées. Utiliser une structure de liste impose de penser en liste. Et une liste est récursive. Donc a priori, la solution la plus « naturelle » est la solution récursive. On peut la détailler, mais il s'avère qu'on peut aussi se rendre compte vide que ce n'est qu'un cumule d'une application (map) et d'un pliage (fold, appelé reduce en python).

Une première solution serait de décomposer en deux étapes le traitement

import operator
#Fonction inL
def inL(e,L):
    def e_in(L) : return (e in L)
    L1 = map (e_in, L)
    return reduce (operator.or_, L1)
#Utilisation exemple
a =[[1,5],[3,6],[5,4],[5,6]]
b=inL(6,a)
print(b) #imprime True

Une deuxième solution serait d'utiliser une fonction qui encapsule le travail du map dans le reduce pour ne faire qu'un passage dans la liste.

import operator
#Fonction inL
def inL(e,L):
    def e_in(b,L1) : return b or (e in L1)
    return reduce (e_in, L, True)
 

Bon ce n'était que mon point de vue à 2 sesterces, mais il me semble qu'un mathématicien devrait penser à une solution récursive de haut niveau avant une solution itérative détaillée. ;)

totomm
06-04-2012 13:56:31

bonjour,

par exemple

def inL(e,L,r=None):
    if r==None:
        r=[]
    for i in range(len(L)):
        if e in L[i]:
            r.append(i)
    return r
   
#Utilisation exemple
a =[[1,5],[3,6],[5,4],[5,6]]
b=inL(6,a)
print(b) #imprime [1, 3]

cordialement

Bibi974
06-04-2012 10:51:11

Bonjour , je cherche à savoir comment tester l'appartenance d'un élément à une liste de liste . En effet "in" fonction pour une liste [1,3,5] (par ex) mais dans mon ex cela ne marche pas et me renvoie non tout le temps ...

A =[[1,5],[3,6]]
n = int(input())
if n in A :
    print("oui")
else:
    print("non")
Merci par avance.

Golgup
23-05-2009 11:32:39

Merci Barbichu

Barbichu
22-05-2009 22:09:27

Salut,
oui, ça s'appelle "in".
Par ex "3 in [3,4]" te répond "True".
++

Golgup
22-05-2009 21:06:13

Bonjour,

Y'a t-il un commande direct qui dise si oui ou non, un element appartient à une liste donnée?

Merci

Pied de page des forums