Discussion :

[Silent-Fart]

Bonjour à tous,

Je suis un débutant en programmation et je suis arrivé à un gros blocage à un de mes projets. Dans mon programme, j'ai une liste. Dans cette liste, il y a plusieurs objets avec un attribut de valeur booléenne qui ont la valeur par défaut False. Il faudra que je change la valeur booléenne d'un objet à la fois, tant qu'une condition n'est pas remplie (en reprenant à chaque fois un différent bien sûr). Il peut y avoir un nombre d'objets à valeur True quelconque dans cette liste, je ne vois vraiment pas comment faire ça ! Auriez-vous l'amabilité de m'aider en me donnant des pistes, s'il vous plaît?

Merci d'avance

[josmiley]

je pense que les listes comprehension feront ton bonheur, si j'ai bien comprite ton problème.
se serait plus clair si tu donnais un exemple.

[Silent-Fart]

Listes compréhension?

Pour les exemples, c'est pas facile, j'ai 400 lignes de code qui sont en fait pour résoudre un jeu logique et je ne veux pas m'abstiner à vous faire apprendre les règles du jeu pour que vous compreniez ce que je fais. Si ce n'est pas assez concret, je ne vois pas quoi dire de plus....

[eyquem]

Bienvenue sur ce forum,


Ta question n’est pas tout à fait claire pour moi aussi.

Si les objets dans ta listes ont des attributs, ce sont donc des instances de classe ?
S’agit-il de classe définie par toi ? Ou d’objets du langage ayant déjà des attributs ?
D’une seule et même classe ? Ou de plusieurs différentes ?
Selon la nature des objets contenus dans la liste, on peut penser à différentes techniques (enfin, peut être, c'est encore à voir).

Il faudra que je change la valeur booléenne d'un objet à la fois, tant qu'une condition n'est pas remplie (en reprenant à chaque fois un différent bien sûr).

D’après ceci, je comprends que tu veux prendre les éléments de la liste l’un après l’autre et changer l’attribut booléen de chacun tant qu’une certaine condition, qui, je présume, n’a rien à voir avec la valeur booléenne en question, n’est pas vérifiée et arréter l’itération et les changements dans la liste dès que cette condition devient True.
Est-ce bien ce que tu as voulu dire ?

Soit dit en passant, le changement de valeur de l’attribut booléen est-il automatiquement le passage à l’inverse ( True-> False si l’attribut est True, et False->True si l’attribut est False)? Ou est-ce plus compliqué?



En tous cas je pense alors à

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
from itertools import takewhile
 
class A:
    def __init__(cap,q,w):
        cap.x = q
        cap.y = w
 
a = A(False,'orange')
b = A(False,'mangouste')
c = A(False,'verre')
d = A(True,'kilogramme')
e = A(True,'plein')
f = A(False,'chequier')
g = A(True,'chevalier')
h = A(False,'')
i = A(True,'miroir')
j = A(True,'cloche')
k = A(False,'compas')
 
li = [a,b,c,d,e,f,g,h,i,j,k]
 
print [ u.x for u in li]
 
for u in takewhile(lambda r:len(r.y)>0,li):
    u.x = not u.x
 
print [ u.x for u in li]

Mais ensuite

Il peut y avoir un nombre d'objets à valeur True quelconque dans cette liste,

je ne comprends vraiment pas quelle conséquence cela entraîne.
Explique toi mieux.




Une list comprehension ne me semble pas adaptée dans la mesure où pour changer la valeur booléenne de l’attribut, il faut faire une affectation ( un signe = , quoi) et que les list comprehension n’acceptent pas d’affectation.

[Silent-Fart]

bon je vais essayer de faire un petit exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
class lapin:
    def __init__(self, carrote = True):
        self.carrote = carrote
 
lapin1 = lapin()
lapin2 = lapin()
lapin3 = lapin()
 
liste_de_lapins = [lapin1, lapin2, lapin3]

Ici, il y a au total 3 instances de classe lapin(). Ils ont chacun un attribut carrote. S'ils ont une carrote, la valeur lapin.carrote sera True. Dans le cas contraire, False. Chaque lapin peut avoir une carrote ou ne pas avoir de carrote. Il y a donc plein de possibilités entre ceux qui ont une carrote et ceux qui n'en ont pas. Le but serait de générer toutes les solutions possibles.

Je me suis dit que visualiser ce problème comme une sorte de code binaire (1=True et 0= False) pourrait aider pour trouver les solutions (les solutions ici seraient : "000","100","010","001","110","101","011","111" si je ne m'abuse). Mon problème est qu'il me faudrait une fonction qui puisse générer ces solutions avec comme seul argument la longueur de la liste de lapins (vu que celui-ci peut-être variable).

Vous me suivez? :-)

[tyrtamos]

Bonjour,

S'il s'agit de lister toutes les solutions possibles sur la base d'un comptage binaire, c'est facile!

Avec Python 2.6, la fonction bin(n) donne la représentation binaire du nombre entier n.

Voilà un petit code qui va donner la liste des comptages binaires sous forme de chaine:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
lg = len(liste_de_lapins)
 
for i in xrange(0,2**lg):
    print i, str(bin(i))[2:].zfill(lg)
 
0 000
1 001
2 010
3 011
4 100
5 101
6 110
7 111

Comme lg est la longueur de la liste, il y a 2**lg cas possibles, numérotés de 0 à 2**lg-1 (ici, de 0 à 7).

On peut vouloir disposer de cette liste pour manipuler son contenu. Par exemple, si on préfère, pour le trier en inverse:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
L = []
for i in xrange(0,2**lg):
    L.append(str(bin(i))[2:].zfill(lg))
 
print L
['000', '001', '010', '011', '100', '101', '110', '111']
 
L.reverse()
print L
['111', '110', '101', '100', '011', '010', '001', '000']

Pour une valeur donnée, b='010' par exemple, si on prend '0' pour False et '1' pour True, on peut tester avec:

b[0]=='0' donc lapin1.carotte==False
b[1]=='1' donc lapin2.carotte==True
b[2]=='0' donc lapin3.carotte==False

Tyrtamos

[nardo47]

Salut !

Marrant ça, j'avais exactement la même méthode et le même code que Tyrtamos, mais je les ai trouvé trop moches pour les conseiller.

Surtout quand on a ceci :

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
 
In [132]: import itertools
 
In [133]: nbrelapins = 3
 
In [134]: valeurs = [True, False]
 
In [135]: list(itertools.product(valeurs, repeat=nbrelapins))
Out[135]:
[(True, True, True),
 (True, True, False),
 (True, False, True),
 (True, False, False),
 (False, True, True),
 (False, True, False),
 (False, False, True),
 (False, False, False)]

Plus simple et plus compréhensible, non ?

[tyrtamos]

mais je les ai trouvé trop moches pour les conseiller.

Ça, ce n'est pas gentil...

Plus simple et plus compréhensible, non ?

Pas pour moi: l'utilisation du module itertools ne clarifie rien quand on ne ne connait pas. Mais bon. Ce n'est pas pour moi que ça doit être plus clair...

Tyrtamos

[tyrtamos]

Je peux simplifier un peu la formule puisque bin(i) renvoie déjà un string:

str(bin(i))[2:].zfill(lg) devient donc:

bin(i)[2:].zfill(lg)

Par exemple, si i=2, alors:

bin(i) donne la chaine '0b10'
[2:] donne la chaine '10' (=découpe la chaine en éliminant les 2 premiers caractères)
.zfill(lg) donne '010' (=complète en ajoutant autant de '0' à gauche pour que la chaine fasse lg caractères)

Tyrtamos

[nardo47]

Ça, ce n'est pas gentil...

Je suis désolé, je ne voulais pas t'offenser, mais je trouve que :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
str(bin(x))[2:].zfill(n)

c'est loin d'être compréhensible, surtout 3 mois après l'avoir écrit (Je rappelle juste que j'y avais pensé, je l'avais même écrit moi aussi avant d'aller fouiller du côté d'itertools).

l'utilisation du module itertools ne clarifie rien quand on ne le connait pas.

Certes, mais c'est alors le cas pour tous les modules. math.sqrt n'est évident qu'une fois qu'on le connait (même si cette connaissance vient de loin et a pu être transférée depuis un autre langage que Python).
Et puis, un module de la bibliothèque de base est maintenu, généralement + rapide et évolué que ce à quoi on aurait pu arriver (mais je m'avance peut-être en généralisant mon cas) et il est surtout documenté avec des exemples.

Après, c'est juste mon opinion, j'essaie de proposer des solutions simples mais je n'impose à personne de les utiliser (de quel droit le ferais-je ?).

Enfin, je dois avouer que ma solution consiste à dire "regardez, y'a déjà une implémentation pour ça. Si vous fouillez un peu dans la bibliothèque standard, vous trouverez sûrement une réponse à votre problème".
Nulle part je ne propose de réflexion sur le sujet, d'idée d'algorithme, de conseils sur les connaissances à avoir (ici, l'analyse combinatoire).

Finalement (vu que tu as écrit un autre post pendant que je rédige laborieusement celui-ci), bien vu, le passage à la trappe de str.

[tyrtamos]

@nardo47

Si tu avais proposé ta solution comme alternative, ça m'aurait paru naturel, et je n'aurais pas pris la peine de répondre. Je l'aurais même examiné avec intérêt (personne n'a le monopole des bonnes idées). Problème clos pour moi.

Mais il est vrai, je m'en aperçois souvent, que j'essaye de n'utiliser que les fonctions de base et le moins possible les modules complémentaires et les "astuces" spécifiques Python. Et ce pour au moins pour les raisons suivantes:

- 3 mois plus tard, je les comprends plus facilement
- je n'aime pas utiliser les fonctions que je ne comprends pas bien
- je peux convertir plus facilement mon code dans un autre langage

Pour le dernier point: j'ai déjà travaillé avec de nombreux langages, comme C, C++, pascal, basic, etc... y compris des langages exotiques comme forth, lisp ou prolog. Et en pratiquant comme je le fais, je peux récupérer plus facilement les algorithmes que j'ai déjà mis au point.

Mais je ne dis pas que j'ai raison...

Pour finir, voilà la solution pour les fans des listes compréhension :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
L = [bin(i)[2:].zfill(lg) for i in xrange(0,2**lg)]
print L
['000', '001', '010', '011', '100', '101', '110', '111']

Tyrtamos

Edit: On peut même créer une fonction lambda avec ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
listebin = lambda lg: [bin(i)[2:].zfill(lg) for i in xrange(0,2**lg)]
 
print listebin(2)
['00', '01', '10', '11']
 
print listebin(3)
['000', '001', '010', '011', '100', '101', '110', '111']
 
print listebin(4)
['0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111', '1000', '1001', '1010', '1011', '1100', '1101', '1110', '1111']

[eyquem]

Je suis ébahi.

- Mon post est-il invisible ?

- On peut à la limite considérer que

Il faudra que je change la valeur booléenne d'un objet à la fois

est une façon maladroite d’exprimer

Le but serait de générer toutes les solutions possibles.

Mais ajouter

tant qu'une condition n'est pas remplie

c’est bien totalement contradictoire avec

toutes les solutions possibles.

non ?
Ou bien suis-je idiot ?

- tyrtamos et nardo47, vous vous engagez sur la nouvelle piste sans faire remarquer sa rupture avec la première

- Premier post

Dans cette liste, il y a plusieurs objets avec un attribut de valeur booléenne qui ont la valeur par défaut False.

Puis

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

def __init__(self, carrote = True)

Ce que je veux dire, c’est que ce genre de ruptures dans la logique d’échange de ce forum est un peu désagréable. Mais y a eu pire.







Concernant la petite controverse,

sans trouver que la solution avec bin() soit foncièrement moche, je lui trouve même de l’astuce, il est vrai qu’elle a un petit air plan plan alors qu’une fonction du module itertools exploite mieux l’abstraction élevée du langage Python.

Je veux dire qu’il me semble que Python a été conçu et évolue pour fournir au développeur des outils qui soient les plus proches possibles de sa façon naturelle de penser: le langage, un code, doivent être le moins possible un rideau déformant entre l’algorithme et la pensée.

Une fonction product() du module itertools répond d'après moi à ce souci. Il est vrai que

l'utilisation du module itertools ne clarifie rien quand on ne ne connait pas

mais c’est aussi le cas de bin() quand on ne connaît pas, ce qui était mon cas avant que tu l’introduises , tyrtamos. En fin, disons que je l’avais vue un jour mais qu’elle n’est pas parmi les choses auxquelles je pense le plus rapidement. J’avoue d’ailleurs aussi qu’il en est un peu de même pour les fonctions du modules itertools: je ne les connais pas suffisamment bien pour pouvoir me passer d’aller regarder la doc chaque fois que je pense à une de ses fonctions; la seule différence avec bin() c’est qu’elle sont un peu moins profondément enfouies dans mes neurones. C’est une question d’habitude et d’expérience de chacun. Mais il est vrai, je pense, que les solutions ont aussi une valeur dans l’absolu, c’est à dire indépendamment du crâne qui les pense.









Ce que tu dis, tyrtamos, concernant ton utilisation préférentielle des fonctions de base pour pouvoir convertir plus facilement un code dans un autre langage pose un débat de fond: que permet Python, dans quel esprit et pour quel objectif l’utiliser ?

Pour ma part , je trouve dommage de se brider dans l’utilisation de ses possibilités au motif qu’on veut pouvoir adapter l’algorithme trouvé à un autre langage. Quel intérêt foncier de procéder ainsi ?

Est-ce profiter de la facilité de développer en Python pour mettre au point un algorithme, et passer ensuite l’algorithme dans un autre langage parce que, je présume, on trouve que ce sera plus rapide ou je ne sais quelle autre raison , en Java ou C++ ?
C’est un peu ce que je faisais au début: j’ai pris conscience un jour que je codais en Python en pensant sans cesse aux processsus impliqués dans la mémoire par telle ou telle manière de faire, j’utilisais Python comme on le fait du langage C d’après ce que j’ai compris, un peu obsédé par la recherche de la plus grande vitesse.
Mais c’est nier je trouve l’intérêt fondamental de Python, c’est en faire un serviteur d’autres langages.

De plus , c’est faire dans l’autre sens ce qu’on reproche parfois à certains forumeurs qui arrivent ici en voulant adapter un code écrit dans un autre langage. Il y a des différences ténues ou grosses entre langages qui font que ce n’est pas vraiment bon de procéder ainsi. Pour moi, un algorithme dépend pour partie du langage utilisé.

Ces questions sont un peu théoriques et même “philosophiques“, mais elles sont essentielles pour éviter de “mouler“ inconsciemment ceux à qui ont répond dans une tournure d’esprit ou une autre.







Enfin bref, il reste quand même un problème:

vos réponses ne sont pas des solutions au problème numéro 2 posé par Silent-Fart, qui est me semble-t-il d’obtenir plusieurs listes d’instances lapins représentant toutes les combinaisons possibles de leur attribut carotte.

Soit dit en passant, carotte s’ecrit ainsi.

Alors je propose:

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
class lapin:
    def __init__(self, carotte = False):
        self.carotte = carotte
 
nbrelapins = 3
from itertools import product
combis = list(product([True, False], repeat=nbrelapins))
for i in xrange(2**nbrelapins):
    globals()['liste_de_lapins_'+str(i)] = [ lapin(u) for u in combis[i] ]
 
 
print liste_de_lapins_0
print liste_de_lapins_1 
print liste_de_lapins_2 
print liste_de_lapins_3 
print liste_de_lapins_4 
print liste_de_lapins_5 
print liste_de_lapins_6 
print liste_de_lapins_7 
 
print [ instance.carotte for instance in liste_de_lapins_0 ]
print [ instance.carotte for instance in liste_de_lapins_1 ]
print [ instance.carotte for instance in liste_de_lapins_2 ]
print [ instance.carotte for instance in liste_de_lapins_3 ]
print [ instance.carotte for instance in liste_de_lapins_4 ]
print [ instance.carotte for instance in liste_de_lapins_5 ]
print [ instance.carotte for instance in liste_de_lapins_6 ]
print [ instance.carotte for instance in liste_de_lapins_7 ]

J’ai fixé la valeur par défaut de l’attribut carotte à False parce qu’en ces temps de crise, les lapins doivent participer aux restrictions. Et surtout, un lapin ne naît pas avec une carotte dans la bouche, sauf dans le XVIème peut être, mais il ne doit pas y avoir beaucoup de lapins dans le XVIème.


Je trouve que c’est dingue comme c’est condensé. J’aimerais bien voir ce que ça donne en C++.
Et j’ai éçrit ça en 5 minutes ( un peu surpris quand même )

Maintenant je n'ai peut être encore une fois rien compris au problème, où alors je l’ai bien compris mais il a déjà changé encore une fois......

[eyquem]

Pour éviter le sentiment d’étrangeté lié à globals() , on peut aussi faire

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
class lapin:
    def __init__(self, carotte = False):
        self.carotte = carotte
 
nbrelapins = 3
from itertools import product
combis = list(product([True, False], repeat=nbrelapins))
liste_de_lapins = []
for i in xrange(2**nbrelapins):
    liste_de_lapins.append( [ lapin(u) for u in combis[i] ] )
 
for li in liste_de_lapins:
    print li
 
for li in liste_de_lapins:
    print [ instance.carotte for instance in li ]

et en condensant

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
class lapin:
    def __init__(self, carotte = False):
        self.carotte = carotte
 
nbrelapins = 3
from itertools import product
combis = list(product([True, False], repeat=nbrelapins))
 
liste_de_lapins = [ [ lapin(u) for u in combis[i] ] for i in xrange(2**nbrelapins) ]
 
for li in liste_de_lapins:
    print li
 
for li in liste_de_lapins:
    print [ instance.carotte for instance in li ]

Temps d'exécution équivalents, mais perso j'aime la limpidité de list comprehension

[tyrtamos]

Bonjour eyquem,

En ce qui me concerne, je n'ai répondu qu'à partir du moment où j'ai cru comprendre une partie de la question: celle figurant dans le dernier paragraphe du message #5. Et ma réponse ne concerne que cette partie.

Par ailleurs, je réponds directement à celui qui pose la question du fil de discussion, et je ne tiens pas forcément compte des autres messages.

Pour le reste, chacun a son style de codage.

Ma priorité est que ça marche, que je comprenne bien ce que j'ai fait, et que je puisse récupérer facilement plus tard les investissements que je fais en codage.

La beauté du code, l'exploitation maximale de toutes les ressources du langage et le gain en microsecondes ne sont pas mes priorités.

Mais je n'impose rien à personne!

Tyrtamos

[eyquem]

Salut tyrtamos

dernier paragraphe du message #5. Et ma réponse ne concerne que cette partie.

Ah oui oui, d’accord. À question mal posée, on répond comme on peut, effectivement. Je me casse peut être trop la tête des fois pour essayer de répondre.



S’il y a un reproche dans ma question narquoise sur l’invisibilité de mon code, il s’adresse uniquement à Silent-Fart. Qu’il n’y ait pas de malentendu. Autrement, c'est de l'étonnement.

Ma priorité est que ça marche

La force de Python me semble être là: ça marche rapidement. Et si ça marche rapidement c’est parce que Python est clair (je ne dirais pas simple), désencombré et puissant. Dans d’autres langages, ce n’est pas le cas, et c’est si long avant d’atteindre un code qui marche qu’on peut dire qu’en prenant de la hauteur de vue, ça ne marche en fait pas: c’est comme si on devait passer une semaine à faire soi-même tous les réglages d’une voiture neuve qu’on vient d’acheter avant de pouvoir partir avec.

La beauté du code, l'exploitation maximale de toutes les ressources du langage et le gain en microsecondes ne sont pas mes priorités.

Moi aussi.
beauté du code: notion très relative
exploiter au maximum: pas un but en soi
microsecondes: on finit par s’en ficher un peu, quand la réactivité n’est pas essentielle

Ce qui m’intéresse dans Python: aisance à concevoir les algorithmes, rapidité d’écriture du code, clarté du code (donc facilité de relecture et de compréhension par autrui, d’où maintenabilité)

que je puisse récupérer facilement plus tard les investissements que je fais en codage.

C'est là que ce me semble être une distortion qui ne convient pas à tout le monde.

[tyrtamos]

Citation: "que je puisse récupérer facilement plus tard les investissements que je fais en codage."

C'est là que ce me semble être une distortion qui ne convient pas à tout le monde.

En fait, quand j'ai passé plusieurs heures ou plusieurs jours à paufiner le code d'un algorithme, je ne veux pas être obligé de repartir d'une page blanche 6 mois plus tard, dans le même langage ou dans un autre.

Ce qui est amusant, c'est qu'il doit y avoir à la base de la pure fainéantise, mais que celle-ci est souvent une excellente motivation pour les bonnes méthodes de travail. On appelle cela aussi de la "productivité" dans l'industrie...

J'ajoute que, dans l'industrie, un "informaticien génial" (le type de gars qui travaille tout seul et qui fabrique un code tellement travaillé et tellement concis que personne ne le comprend) est considéré comme dangereux! En particulier parce son code n'est pas maintenable dans le temps. Et s'il quitte son entreprise, c'est la cata... J'ai pu assister à de méchantes gamelles de projets importants à cause de cela.

Tyrtamos

[Silent-Fart]

Bonjour,

Tout d'abord je tiens à vous faire part d'un grand merci! Je me sens bête de ne pas avoir pu trouver ça par moi-même... Pour ma part, je trouve le code à tyrtamos nettement plus compréhensible.

Je m'excuse de n'avoir pas été clair (du tout) et oui, j'ai fait une erreur dans le code que je vous ai mis (default True au lieu de False) et je m'en excuse. Mais je le répète : Je suis un débutant en programmation (ce qui a été prouvé par la simplicité de ce programme). Oui cela n'excuse pas le fait que je fasse une erreur autant moche. Je m'excuse aussi pour vous avoir fait perdre votre temps, surtout eyquem. Mais sérieusement, qui t'as obligé d'essayer de m'aider? Quand t'as vu que mes deux posts étaient contradictoires et non clairs, t'aurais pu juste partir et faire ce que tu veux, mais tu ne l'as pas fait... Quand on aide quelqu'un, c'est de bonne volonté, alors agresse-moi pas!

Merci encore

[eyquem]

C'est là que ce me semble être une distortion
eyquem

distorsion, pas distortion !
Entre le français et l’anglais je m’emmêle.


--------------------------


Ce que tu dis sur les bonnes pratiques et la productivité est fort intéressant, tyrtamos. D’ailleurs cela me rappelle quelque chose, tu en déjà parlé une fois, je crois bien. Mais je crains bien de devoir dire que je ne suis pas d’accord avec toi, dans la faible étendue de mes connaissances en programmation.
Cependant, à lire beaucoup de débats sur developpez.com, j’en arrive à avoir une micro idée du paysage de la programmation et à oser proférer quelque avis modeste.

dans l'industrie, un "informaticien génial" (le type de gars qui travaille tout seul et qui fabrique un code tellement travaillé et tellement concis que personne ne le comprend) est considéré comme dangereux! En particulier parce son code n'est pas maintenable dans le temps. Et s'il quitte son entreprise, c'est la cata...

* Un informaticien véritablement "génial", je ne crois pas que ça existe en de nombreux exemplaires.

Si tu emploies par contre ce terme pour signifier quelqu’un de suffisamment puissant intellectuellement pour arriver à dompter les difficultés intrinséques présentés par un langage donné compliqué et qui est obligé de développer seul parce que les autres ne suivent pas, alors il faut peut être plutôt critiquer

- soit le langage qui est intrinséquement trop tarabiscoté pour des programmeurs moyens,
(je pense à C++)

- soit les capacités des dits programmeurs à maîtriser un langage pas facile. pas assez bons en clair.

Avec le Java, le programmeur moderne peut être moins compétent, et c'est exactement la raison pour laquelle le Java est apparu: les besoins ont explosés par rapport aux nombre d'informaticiens compétents disponibles

http://www.developpez.net/forums/d85...y/#post4901690

(il se trouve que malgré cet objectif fixé à Java, plusieurs années de son évolution s’atreignant à la rétro-compatibilité l’ont rendu presqu’aussi profus et peu facile que du C++ pour les développeurs les moins doués, mais c’est une autre histoire)


En tous les cas, je serais fort intéressé de voir un code d’informaticien "génial" que personne ne comprendrait, même avec des explications.





* Car le problème est peut être aussi là:

si en parlant de gars qui travaille tout seul , tu veux dire que non seulement personne n'arrive à travailler avec lui mais qu'en plus personne d'autre que lui ne peut comprendre son code fini, c’est sans doute parce que ce code n’est pas documenté.

Je ne vois pas comment dans une science aussi rigoureuse que la programmation, on peut ne pas arriver à comprendre un code correctement documenté. On doit toujours pouvoir au moins comprendre que le code est écrit n’importe comment, mais pas rester devant comme une poule devant un couteau.

Si un code n’est pas documenté, le développeur est pour moi plus responsable de cela que d’avoir conçu un algorithme d’extra-terrestre. La mauvaise pratique en l’occurence est là: mauvaise doc, plutôt que dans le niveau de complexité des fonctions et algos impliqués dans le code.






* Quant à la qualification de dangereux, c’est le genre de défense qui ne doit pas étonner de la part de personnes quand leur compétence est trop remise en question par l’existence d’in “informaticien déclaré génial“. C’est vrai dans toutes les disciplines: Ceux que Jupiter veut perdre, il commence par leur ôter la raison. Les responsables de services et de sociétés feraient mieux de s’efforcer eu-mêmes à plus de compétence pour diriger. J’ai lu sur cet excellent site des quantités de relations sur ce qui ne va pas dans le monde des sociétés d’informatique, quand les auteurs ont assez d’honnêteté pour s’exprimer avec franchise.
Regardez par exemple ceci

Pour le produit dont j'ai ravi la gestion et la direction à mon supérieur hiérarchique (....) Seul hic pour cette société, ils m'ont licencié et n'ont pas jugé bon de me laissé former un autre développeur (nettement moins payé, mais nettement moins compétent) a reprendre l'applicatif et à en comprendre l'architecture au demeurant malheureusement complexe.
Résultat, cette société qui n'a appréciée que je les oblige à passer au modernisme, est aujourd'hui en faillite, (...)
http://www.developpez.net/forums/d85...y/#post4899680

Et aussi ceci

Mais pour revenir a merise, oui il y a une autre approche possible pour la conception de système d'information. J'ais develloper une approche neuronal permetant de concevoir un système d'information sur une base matriciel de relation entre les differente table et les jointures. J'ais eu l'occasion de faire la démonstration de cette outil a une grande entreprise française et au directeur du service de la maintenance des sytèmes d'information.

Je me rappel de sa tête lorsque je lui est montrer qu'il était possible de representer et de remodeliser une ancienne database en moins de 5 minutes, grace a un petit automate que j'ais créer. Fini les doublon et fini les relation combinant la même information de base.

Il n'as pas aimé, que l'on puisse mettre en doute plus de 40 années d'expérience, par un petit autodidacte, sortie de la banlieue.
http://www.developpez.net/forums/d85...y/#post4899103

* Un code pas maintenable dans le temps, même s’il est bien documenté ?

Est-ce qu’il ne faut pas plutôt se demander si ce n’est pas le propre du langage utilisé de rendre la maintenance compliquée ?

- soit parce que sa complexité se traduit par une complexité intrinsèque de recours à des trucs et astuces non naturels

Les languages et standards ne sont pas encore au point qu'on a déjà poussé leur utilisation largement au-delà de ce qui était prévu initialement. Auparavant, un programmeur génial était quelqu'un qui trouvait des solutions nouvelles à des limitations nouvelles. Je prend comme exemple l'invention de UNIX suite au plafonnement de Multics. Maintenant, on louange le programmeur qui excelle dans les trucs et astuces pour accomplir l'impossible. Les webmasters sont passés maître dans l'art.
http://www.developpez.net/forums/d85...y/#post4901690

- soit parce ses possibilités ne sont pas adaptées à l’objectif, les responsables étant souvent les décideurs non connaisseurs:

Une fois, j'ai refroidi un client en lui expliquant comment sa requête était impossible avec la technologie utilisée. (....) Où je travaille, c'est plutôt rare que les décideurs viennent s'assoir à notre table pour discuter des choix qu'ils s'apprêtent à faire. Ils feront leurs choix en dépit de nous, et nous devrons trouver le moyen de les mettre en oeuvre dans des délais raisonnables. Bien peu sont intéressés de savoir qu'en développant à la hâte, l'étude de faisabilité, les commentaires dans le code, la documentation et les tests sont négligés. Ils ne le réalisent que lorque nous éprouvons des problèmes sérieux (coûteux) en production.
http://www.developpez.net/forums/d85...y/#post4901690

* Quant au développeur qui se casse d’une entreprise sans laisser à ses collègues les moyens de reprendre le flambeau, cela relève pour moi de la faute morale. C’est comme si un chercheur en génétique moléculaire quittait son labo sans permettre à son successeur de comprendre rapidement l’avancée des travaux, les sondes ADN utilisées et dans quel but, les gènes clonés d’un organisme à l’autre, les souches obtenues, etc. Le suivant devrait y passer 3 mois.






- Enfin, tout ça pour dire que je ne vois aucun argument valable à se forcer soi-même à se brider dans l’usage de Python sous prétexte que dans les entreprises, avec des langages plus compliqués à maîtriser, des développeurs qui ne sont pas tous des lumières et des décideurs qui ne savent pas décider, il se passe des problèmes quand un type arrive à faire avec du C++ ou du Java ce qu’on fait facilement avec Python, c’est à dire travailler à un niveau d’abstraction élevé. Tout simplement parce qu’à la base, il est difficile de faire de l’abstraction avec un langage qui n’est pas prévu pour.

Il n’y a qu’à voir les réactions d’émerveillement de développeurs découvrant le haut niveau voilé dans C++ par les contraintes de gestion permanente du bas-niveau, (du moins c’est ce que j’ai compris) à l’adresse suivante:
http://bartoszmilewski.wordpress.com...-to-do-with-c/
si quelqu’un trouve la file dans un forum de developpez.com où il est discuté de cet article avec le même enthousiasme, merci de donner son lien car je ne la retrouve pas)


Je trouve même contradictoire et malencontreux d’ utiliser un langage évolué en se disant «je me bride aux fonctions basiques pour mettre mes codes à égalité avec les ceux écrits dans les autres langages moins évolués». C’est écrire du code Python en pensant C++, Java ou je ne sais quoi d’autre. Si on y est forcé, bon d’accord (un décideur par là dessous ?) mais sinon ça conduit à demander: mais pourquoi utiliser Python dans ce cas ?





Nota bene: merci pour ces échanges de vues, tyrtamos, c’est mieux que les non-réponses de Silent-Fart le bien nommé.

[tyrtamos]

@eyquem,

Je crois qu'on s'arrêtera là, à la constatation de notre amical désaccord. Et excuses à Silent-Fart pour avoir squatter son fil.

Les anomalies que tu cites font malheureusement partie de la vie normale. Et les refuser conduit à imaginer un monde idéal, conforme aux livres et à la logique, mais qui n'existe pas.

Pour ne reprendre qu'un petit exemple: la documentation des programmes. Désolé, mais s'il y a une chose que les programmeurs ne font pas suffisamment, c'est bien ça! Et on le voit malheureusement tous les jours... Comme le temps manque (toujours), une fois le code terminé, on passe au suivant. Pour qu'une doc suffisante soit établie, il faut une impérieuse obligation, vigoureusement contrôlée.

A + sur un autre fil!

Tyrtamos.

[eyquem]

@ Silent-Fart

Tiens, je n’avais pas vu que tu avais fini de farter . Et l’entendre je ne pouvais pas

Y a rien de grave dans tes erreurs, rassure toi ! Pas la peine de t’épandre en mille excuses, on comprend.

TU ne m’as pas fait perdre mon temps, J’AI bien voulu m’intéresser à ton problème et persévérer, tu as tout à fait raison.

Ma réaction est due à la frustration d’un esprit logique qui voit un problème changer de direction comme une girouette au vent + la sensation de participer à un jeu de devinettes sans avoir de réponse sur une solution proposée.

Oui c’est juste un peu agaçant. Si je ne peux pas le dire sans que tu te sentes agressé, c’est peut être parce que TU es un peu susceptible alors que JE n'ai pas voulu t'agresser.

Si un propos est ressenti comme agressif dès que son taux de sucre est trop bas ( qu’il n'est pas assez sirupeux je veux dire, hein...) , comment des débats peuvent ils se tenir ?







@ tyrtamos


ok, ok

Quoique je regrette de ne pas savoir pourquoi s’attacher à utiliser Python.
Je remarquai d’aillurs tout à l’heure une pub en bandeau de ce site, sur Windows 7 (je crois) qui disait quelque chose du genre «Utilisez les ressources d’un OS au maximum». Vrai pour un OS et pas pour un langage ?

Les anomalies que tu cites font malheureusement partie de la vie normale.

ce ne sont donc pas des anomalies.



Mais bon..... A+