Si quelqu'un a quelques minutes à perdre pour corriger un petit truc.
J'apprends à l'envers, je code d'abord, et lis la littérature ensuite.
Là, je sors de la phase du Ctrl-C / Ctrl-V depuis internet. L'exercice
est de transformer ça:
Je préfère la dernière version, mais j'intuite qu'on peut faire plus
léger, au moins diminuer le nombre de ''.join()
Puisque j'en suis aux questions béates, je ressors un petit bout du
tout début qui m'avait embêté:
condition_ext = val and (type(val) == type('')) and (val != '_lock')
Je pense qu'il y a plus logique pour tester un type que (type(val) ==
type('')), mais je ne suis depuis pas tombé sur la réponse. Comment
doit-on faire ?
Allez, une petite dernière pour la route: serait-il mieux d'écrire :
Je préfère la dernière version, mais j'intuite qu'on peut faire plus léger, au moins diminuer le nombre de ''.join()
Franchement gangner un *print* pour ça c'est pas terrible, mais bon il ya quand mêm plus simple :
print " Titre :n" + 'n'.join("%s (%s)" % (e, f) for e, f in dico.items())
condition_ext = val and (type(val) == type('')) and (val != '_lock')
Je pense qu'il y a plus logique pour tester un type que (type(val) = > type('')), mais je ne suis depuis pas tombé sur la réponse. Comment doit-on faire ?
isinstance(val, str) # pour une version assez récente, >= 2.3 de mémoire isinstance(val, type('')) # sinon
isinstance(val, basestr) # dans le cas où l'on veut aussi gérer des chaînes unicode
isinstance(val, type_) retourne True si val est de type type_ ou d'un sous-type de type_.
Si on veut tester strictement le type alors : type(val) is str est la meilleure solution (is est le bon opérateur ici, == peut provoquer certaines erreurs, bien que peu probables dans ce cas).
isinstance(val, str) est sémantiquement équivalent à : issubclass(type(val), str)
Allez, une petite dernière pour la route: serait-il mieux d'écrire :
Je préfère la dernière version, mais j'intuite qu'on peut faire plus
léger, au moins diminuer le nombre de ''.join()
Franchement gangner un *print* pour ça c'est pas terrible, mais bon il ya
quand mêm plus simple :
print " Titre :n" + 'n'.join("%s (%s)" % (e, f) for e, f in dico.items())
condition_ext = val and (type(val) == type('')) and (val != '_lock')
Je pense qu'il y a plus logique pour tester un type que (type(val) = > type('')), mais je ne suis depuis pas tombé sur la réponse. Comment
doit-on faire ?
isinstance(val, str) # pour une version assez récente, >= 2.3 de mémoire
isinstance(val, type('')) # sinon
isinstance(val, basestr) # dans le cas où l'on veut aussi gérer des chaînes
unicode
isinstance(val, type_) retourne True si val est de type type_ ou d'un
sous-type de type_.
Si on veut tester strictement le type alors :
type(val) is str
est la meilleure solution (is est le bon opérateur ici, == peut provoquer
certaines erreurs, bien que peu probables dans ce cas).
isinstance(val, str)
est sémantiquement équivalent à :
issubclass(type(val), str)
Allez, une petite dernière pour la route: serait-il mieux d'écrire :
Je préfère la dernière version, mais j'intuite qu'on peut faire plus léger, au moins diminuer le nombre de ''.join()
Franchement gangner un *print* pour ça c'est pas terrible, mais bon il ya quand mêm plus simple :
print " Titre :n" + 'n'.join("%s (%s)" % (e, f) for e, f in dico.items())
condition_ext = val and (type(val) == type('')) and (val != '_lock')
Je pense qu'il y a plus logique pour tester un type que (type(val) = > type('')), mais je ne suis depuis pas tombé sur la réponse. Comment doit-on faire ?
isinstance(val, str) # pour une version assez récente, >= 2.3 de mémoire isinstance(val, type('')) # sinon
isinstance(val, basestr) # dans le cas où l'on veut aussi gérer des chaînes unicode
isinstance(val, type_) retourne True si val est de type type_ ou d'un sous-type de type_.
Si on veut tester strictement le type alors : type(val) is str est la meilleure solution (is est le bon opérateur ici, == peut provoquer certaines erreurs, bien que peu probables dans ce cas).
isinstance(val, str) est sémantiquement équivalent à : issubclass(type(val), str)
Allez, une petite dernière pour la route: serait-il mieux d'écrire :
Comprends pas, tous les objets en Python se comparent à une string, il n'y
aura jamais d'exception levée pour ce test.
_____________
Maric Michaud _____________
Aristote - www.aristote.info 3 place des tapis 69004 Lyon Tel: +33 426 880 097
Bruno Desthuilliers
Bonjour,
Si quelqu'un a quelques minutes à perdre pour corriger un petit truc. J'apprends à l'envers, je code d'abord, et lis la littérature ensuite. Là, je sors de la phase du Ctrl-C / Ctrl-V depuis internet. L'exercice est de transformer ça:
print 'n Titre :' for key in dico: print key, ' (', dico[key], ')'
de façon à n'avoir qu'un seul print (peu importe la pertinence de ce choix, disons qu'il s'agit d'obtenir une chaîne de façon pythonistienne).
print "nTitre :n%s" % "n".join("%s : %s" % item for item in dico.items())
Puisque j'en suis aux questions béates, je ressors un petit bout du tout début qui m'avait embêté:
condition_ext = val and (type(val) == type('')) and (val != '_lock')
Je pense qu'il y a plus logique pour tester un type que (type(val) == type('')), mais je ne suis depuis pas tombé sur la réponse. Comment doit-on faire ?
condition_ext = isinstance(val, basestring) and val != 'lock'
Allez, une petite dernière pour la route: serait-il mieux d'écrire :
try: condition_ext = (val != '_lock')
Vire donc ces parenthèses inutiles.
except: condition_ext = False
Evite ce genre de catch-all comme la peste. C'est un truc à perdre des journées entières quand il faut débugger.
En l'occurrence, tu ne risque guère d'avoir une exception. D'une manière générale, si tu sais à peu près quels types d'exception peuvent être levées dans le try:
Si quelqu'un a quelques minutes à perdre pour corriger un petit truc.
J'apprends à l'envers, je code d'abord, et lis la littérature ensuite.
Là, je sors de la phase du Ctrl-C / Ctrl-V depuis internet. L'exercice
est de transformer ça:
print 'n Titre :'
for key in dico:
print key, ' (', dico[key], ')'
de façon à n'avoir qu'un seul print (peu importe la pertinence de ce
choix, disons qu'il s'agit d'obtenir une chaîne de façon pythonistienne).
print "nTitre :n%s" % "n".join("%s : %s" % item
for item in dico.items())
Puisque j'en suis aux questions béates, je ressors un petit bout du tout
début qui m'avait embêté:
condition_ext = val and (type(val) == type('')) and (val != '_lock')
Je pense qu'il y a plus logique pour tester un type que (type(val) ==
type('')), mais je ne suis depuis pas tombé sur la réponse. Comment
doit-on faire ?
condition_ext = isinstance(val, basestring) and val != 'lock'
Allez, une petite dernière pour la route: serait-il mieux d'écrire :
try:
condition_ext = (val != '_lock')
Vire donc ces parenthèses inutiles.
except:
condition_ext = False
Evite ce genre de catch-all comme la peste. C'est un truc à perdre des
journées entières quand il faut débugger.
En l'occurrence, tu ne risque guère d'avoir une exception. D'une manière
générale, si tu sais à peu près quels types d'exception peuvent être
levées dans le try:
Si quelqu'un a quelques minutes à perdre pour corriger un petit truc. J'apprends à l'envers, je code d'abord, et lis la littérature ensuite. Là, je sors de la phase du Ctrl-C / Ctrl-V depuis internet. L'exercice est de transformer ça:
print 'n Titre :' for key in dico: print key, ' (', dico[key], ')'
de façon à n'avoir qu'un seul print (peu importe la pertinence de ce choix, disons qu'il s'agit d'obtenir une chaîne de façon pythonistienne).
print "nTitre :n%s" % "n".join("%s : %s" % item for item in dico.items())
Puisque j'en suis aux questions béates, je ressors un petit bout du tout début qui m'avait embêté:
condition_ext = val and (type(val) == type('')) and (val != '_lock')
Je pense qu'il y a plus logique pour tester un type que (type(val) == type('')), mais je ne suis depuis pas tombé sur la réponse. Comment doit-on faire ?
condition_ext = isinstance(val, basestring) and val != 'lock'
Allez, une petite dernière pour la route: serait-il mieux d'écrire :
try: condition_ext = (val != '_lock')
Vire donc ces parenthèses inutiles.
except: condition_ext = False
Evite ce genre de catch-all comme la peste. C'est un truc à perdre des journées entières quand il faut débugger.
En l'occurrence, tu ne risque guère d'avoir une exception. D'une manière générale, si tu sais à peu près quels types d'exception peuvent être levées dans le try:
Je préfère la dernière version, mais j'intuite qu'on peut faire plus léger, au moins diminuer le nombre de ''.join()
Franchement gangner un *print* pour ça c'est pas terrible, mais bon il ya quand mêm plus simple :
print " Titre :n" + 'n'.join("%s (%s)" % (e, f) for e, f in dico.items())
condition_ext = val and (type(val) == type('')) and (val != '_lock')
Je pense qu'il y a plus logique pour tester un type que (type(val) = >> type('')), mais je ne suis depuis pas tombé sur la réponse. Comment doit-on faire ?
isinstance(val, str) # pour une version assez récente, >= 2.3 de mémoire isinstance(val, type('')) # sinon
isinstance(val, basestr) # dans le cas où l'on veut aussi gérer des chaînes unicode
isinstance(val, type_) retourne True si val est de type type_ ou d'un sous-type de type_.
Si on veut tester strictement le type alors : type(val) is str est la meilleure solution (is est le bon opérateur ici, == peut provoquer certaines erreurs, bien que peu probables dans ce cas).
isinstance(val, str) est sémantiquement équivalent à : issubclass(type(val), str)
Allez, une petite dernière pour la route: serait-il mieux d'écrire :
Je préfère la dernière version, mais j'intuite qu'on peut faire plus
léger, au moins diminuer le nombre de ''.join()
Franchement gangner un *print* pour ça c'est pas terrible, mais bon il ya
quand mêm plus simple :
print " Titre :n" + 'n'.join("%s (%s)" % (e, f) for e, f in dico.items())
condition_ext = val and (type(val) == type('')) and (val != '_lock')
Je pense qu'il y a plus logique pour tester un type que (type(val) = >> type('')), mais je ne suis depuis pas tombé sur la réponse. Comment
doit-on faire ?
isinstance(val, str) # pour une version assez récente, >= 2.3 de mémoire
isinstance(val, type('')) # sinon
isinstance(val, basestr) # dans le cas où l'on veut aussi gérer des chaînes
unicode
isinstance(val, type_) retourne True si val est de type type_ ou d'un
sous-type de type_.
Si on veut tester strictement le type alors :
type(val) is str
est la meilleure solution (is est le bon opérateur ici, == peut provoquer
certaines erreurs, bien que peu probables dans ce cas).
isinstance(val, str)
est sémantiquement équivalent à :
issubclass(type(val), str)
Allez, une petite dernière pour la route: serait-il mieux d'écrire :
Je préfère la dernière version, mais j'intuite qu'on peut faire plus léger, au moins diminuer le nombre de ''.join()
Franchement gangner un *print* pour ça c'est pas terrible, mais bon il ya quand mêm plus simple :
print " Titre :n" + 'n'.join("%s (%s)" % (e, f) for e, f in dico.items())
condition_ext = val and (type(val) == type('')) and (val != '_lock')
Je pense qu'il y a plus logique pour tester un type que (type(val) = >> type('')), mais je ne suis depuis pas tombé sur la réponse. Comment doit-on faire ?
isinstance(val, str) # pour une version assez récente, >= 2.3 de mémoire isinstance(val, type('')) # sinon
isinstance(val, basestr) # dans le cas où l'on veut aussi gérer des chaînes unicode
isinstance(val, type_) retourne True si val est de type type_ ou d'un sous-type de type_.
Si on veut tester strictement le type alors : type(val) is str est la meilleure solution (is est le bon opérateur ici, == peut provoquer certaines erreurs, bien que peu probables dans ce cas).
isinstance(val, str) est sémantiquement équivalent à : issubclass(type(val), str)
Allez, une petite dernière pour la route: serait-il mieux d'écrire :
Comprends pas, tous les objets en Python se comparent à une string, il n'y
aura jamais d'exception levée pour ce test.
Merci beaucoup.
-- Pierre Maurette
Pierre Maurette
Bonjour,
Si quelqu'un a quelques minutes à perdre pour corriger un petit truc. J'apprends à l'envers, je code d'abord, et lis la littérature ensuite. Là, je sors de la phase du Ctrl-C / Ctrl-V depuis internet. L'exercice est de transformer ça:
print 'n Titre :' for key in dico: print key, ' (', dico[key], ')'
de façon à n'avoir qu'un seul print (peu importe la pertinence de ce choix, disons qu'il s'agit d'obtenir une chaîne de façon pythonistienne).
print "nTitre :n%s" % "n".join("%s : %s" % item for item in dico.items())
Puisque j'en suis aux questions béates, je ressors un petit bout du tout début qui m'avait embêté:
condition_ext = val and (type(val) == type('')) and (val != '_lock')
Je pense qu'il y a plus logique pour tester un type que (type(val) == type('')), mais je ne suis depuis pas tombé sur la réponse. Comment doit-on faire ?
condition_ext = isinstance(val, basestring) and val != 'lock'
Allez, une petite dernière pour la route: serait-il mieux d'écrire :
try: condition_ext = (val != '_lock')
Vire donc ces parenthèses inutiles.
Ce n'est sans doute pas bien, mais je vais persister dans cette erreur.
except: condition_ext = False
Evite ce genre de catch-all comme la peste. C'est un truc à perdre des journées entières quand il faut débugger.
En l'occurrence, tu ne risque guère d'avoir une exception. D'une manière générale, si tu sais à peu près quels types d'exception peuvent être levées dans le try:
Merci beaucoup. Pour l'instant je suis sur les exceptions, ensuite je regarderai le join dans les deux formes proposées par vous et Maric.
-- Pierre Maurette
Bonjour,
Si quelqu'un a quelques minutes à perdre pour corriger un petit truc.
J'apprends à l'envers, je code d'abord, et lis la littérature ensuite. Là,
je sors de la phase du Ctrl-C / Ctrl-V depuis internet. L'exercice est de
transformer ça:
print 'n Titre :'
for key in dico:
print key, ' (', dico[key], ')'
de façon à n'avoir qu'un seul print (peu importe la pertinence de ce choix,
disons qu'il s'agit d'obtenir une chaîne de façon pythonistienne).
print "nTitre :n%s" % "n".join("%s : %s" % item
for item in dico.items())
Puisque j'en suis aux questions béates, je ressors un petit bout du tout
début qui m'avait embêté:
condition_ext = val and (type(val) == type('')) and (val != '_lock')
Je pense qu'il y a plus logique pour tester un type que (type(val) ==
type('')), mais je ne suis depuis pas tombé sur la réponse. Comment doit-on
faire ?
condition_ext = isinstance(val, basestring) and val != 'lock'
Allez, une petite dernière pour la route: serait-il mieux d'écrire :
try:
condition_ext = (val != '_lock')
Vire donc ces parenthèses inutiles.
Ce n'est sans doute pas bien, mais je vais persister dans cette erreur.
except:
condition_ext = False
Evite ce genre de catch-all comme la peste. C'est un truc à perdre des
journées entières quand il faut débugger.
En l'occurrence, tu ne risque guère d'avoir une exception. D'une manière
générale, si tu sais à peu près quels types d'exception peuvent être levées
dans le try:
Si quelqu'un a quelques minutes à perdre pour corriger un petit truc. J'apprends à l'envers, je code d'abord, et lis la littérature ensuite. Là, je sors de la phase du Ctrl-C / Ctrl-V depuis internet. L'exercice est de transformer ça:
print 'n Titre :' for key in dico: print key, ' (', dico[key], ')'
de façon à n'avoir qu'un seul print (peu importe la pertinence de ce choix, disons qu'il s'agit d'obtenir une chaîne de façon pythonistienne).
print "nTitre :n%s" % "n".join("%s : %s" % item for item in dico.items())
Puisque j'en suis aux questions béates, je ressors un petit bout du tout début qui m'avait embêté:
condition_ext = val and (type(val) == type('')) and (val != '_lock')
Je pense qu'il y a plus logique pour tester un type que (type(val) == type('')), mais je ne suis depuis pas tombé sur la réponse. Comment doit-on faire ?
condition_ext = isinstance(val, basestring) and val != 'lock'
Allez, une petite dernière pour la route: serait-il mieux d'écrire :
try: condition_ext = (val != '_lock')
Vire donc ces parenthèses inutiles.
Ce n'est sans doute pas bien, mais je vais persister dans cette erreur.
except: condition_ext = False
Evite ce genre de catch-all comme la peste. C'est un truc à perdre des journées entières quand il faut débugger.
En l'occurrence, tu ne risque guère d'avoir une exception. D'une manière générale, si tu sais à peu près quels types d'exception peuvent être levées dans le try:
Merci beaucoup. Pour l'instant je suis sur les exceptions, ensuite je regarderai le join dans les deux formes proposées par vous et Maric.
-- Pierre Maurette
Bruno Desthuilliers
(snip)
condition_ext = val and (type(val) == type('')) and (val != '_lock')
Je pense qu'il y a plus logique pour tester un type que (type(val) == type('')), mais je ne suis depuis pas tombé sur la réponse. Comment doit-on faire ?
condition_ext = isinstance(val, basestring) and val != 'lock'
NB : ceci étant, on évite autant que possible de tester sur un type (ou sous-type). Bon, là on est possiblement dans un cas où ça a du sens (difficile à dire hors contexte), mais ça reste un truc à éviter dans un langage à typage dynamique.
Allez, une petite dernière pour la route: serait-il mieux d'écrire :
try: condition_ext = (val != '_lock')
Vire donc ces parenthèses inutiles.
Ce n'est sans doute pas bien,
C'est surtout inutile.
mais je vais persister dans cette erreur.
Tant que je n'ai pas à maintenir ton code, hein... !-)
(snip)
condition_ext = val and (type(val) == type('')) and (val != '_lock')
Je pense qu'il y a plus logique pour tester un type que (type(val) ==
type('')), mais je ne suis depuis pas tombé sur la réponse. Comment
doit-on faire ?
condition_ext = isinstance(val, basestring) and val != 'lock'
NB : ceci étant, on évite autant que possible de tester sur un type (ou
sous-type). Bon, là on est possiblement dans un cas où ça a du sens
(difficile à dire hors contexte), mais ça reste un truc à éviter dans un
langage à typage dynamique.
Allez, une petite dernière pour la route: serait-il mieux d'écrire :
try:
condition_ext = (val != '_lock')
Vire donc ces parenthèses inutiles.
Ce n'est sans doute pas bien,
C'est surtout inutile.
mais je vais persister dans cette erreur.
Tant que je n'ai pas à maintenir ton code, hein... !-)
condition_ext = val and (type(val) == type('')) and (val != '_lock')
Je pense qu'il y a plus logique pour tester un type que (type(val) == type('')), mais je ne suis depuis pas tombé sur la réponse. Comment doit-on faire ?
condition_ext = isinstance(val, basestring) and val != 'lock'
NB : ceci étant, on évite autant que possible de tester sur un type (ou sous-type). Bon, là on est possiblement dans un cas où ça a du sens (difficile à dire hors contexte), mais ça reste un truc à éviter dans un langage à typage dynamique.
Allez, une petite dernière pour la route: serait-il mieux d'écrire :
try: condition_ext = (val != '_lock')
Vire donc ces parenthèses inutiles.
Ce n'est sans doute pas bien,
C'est surtout inutile.
mais je vais persister dans cette erreur.
Tant que je n'ai pas à maintenir ton code, hein... !-)
