Bien le bonjour à tous et toutes.

Une question me gène depuis un bon moment.
Dans du code que je vois, je trouve très souvent la mise en forme de chaine de caractères de la forme :
buf = "".join(("/Title (", title, ")\n"))
f.write(buf) # f étant un descripteur de fichier (ouvert en écriture).

Ma question maintenant :
Quel est l'interêt de ce
buf = "".join(...)
par rapport à un
buf = "/Title (", title, ")\n" ?

Voire éventuellement en question subsidiaire par rapport à un bon vieux
buf = "/Title (%s)\n" % title ?

Si quelqu'un à une réponse autre que 42 à me fournir, je lui en serais reconnaissant.
Merci d'avance
Fouff

> Ma question maintenant :
> Quel est l'interêt de ce
> buf = "".join(...)
> par rapport à un
> buf = "/Title (", title, ")\n" ?

A mon humble avis, c'est réservé à ceux qui fument...

> Ma question maintenant :
> Quel est l'interêt de ce
> buf = "".join(...)
> par rapport à un
> buf = "/Title (", title, ")\n" ?

A mon humble avis, c'est réservé à ceux qui fument...

Fouff a écrit :
> Bien le bonjour à tous et toutes.
>
> Une question me gène depuis un bon moment.
> Dans du code que je vois, je trouve très souvent la mise en forme de
> chaine de caractères de la forme :
> buf = "".join(("/Title (", title, ")\n"))
> f.write(buf) # f étant un descripteur de fichier (ouvert en écriture).
>
> Ma question maintenant :
> Quel est l'interêt de ce
> buf = "".join(...)
> par rapport à un
> buf = "/Title (", title, ")\n" ?
>
> Voire éventuellement en question subsidiaire par rapport à un bon vieux
> buf = "/Title (%s)\n" % title ?

A part rendre le code imbitable, je ne vois pas bien.

Fouff a écrit :
> Bien le bonjour à tous et toutes.
>
> Une question me gène depuis un bon moment.
> Dans du code que je vois, je trouve très souvent la mise en forme de
> chaine de caractères de la forme :
> buf = "".join(("/Title (", title, ")\n"))
> f.write(buf) # f étant un descripteur de fichier (ouvert en écriture).
>
> Ma question maintenant :
> Quel est l'interêt de ce
> buf = "".join(...)
> par rapport à un
> buf = "/Title (", title, ")\n" ?
>
> Voire éventuellement en question subsidiaire par rapport à un bon vieux
> buf = "/Title (%s)\n" % title ?

A part rendre le code imbitable, je ne vois pas bien.

Fouff wrote:
> Bien le bonjour à tous et toutes.

> Quel est l'interêt de ce
> buf = "".join(...)

un gus qui a mal lu ou plutôt pas relu, et encore moin compris les questions
concernant l'inneficacité de la concaténation des chaines qui affectaient les
version postérieures de python.


> par rapport à un
> buf = "/Title (", title, ")\n" ?

pas pareil tu vas introduire un espace entre title et les parenth?ses
encadrantes

> Voire éventuellement en question subsidiaire par rapport à un bon vieux
> buf = "/Title (%s)\n" % title ?

propre, clair et concis
quoi que la forme canonique soit plutôt
buf = "/Title (%s)\n" % ( title )
mais je chipote

> Si quelqu'un à une réponse autre que 42 à me fournir, je lui en serais reconnaissant.

autre hypoth?se, l'auteur du code qui t'interpelles veux rendre son code abscon
et il y a arrive

Eric

Fouff wrote:
> Bien le bonjour à tous et toutes.

> Quel est l'interêt de ce
> buf = "".join(...)

un gus qui a mal lu ou plutôt pas relu, et encore moin compris les questions
concernant l'inneficacité de la concaténation des chaines qui affectaient les
version postérieures de python.


> par rapport à un
> buf = "/Title (", title, ")\n" ?

pas pareil tu vas introduire un espace entre title et les parenth?ses
encadrantes

> Voire éventuellement en question subsidiaire par rapport à un bon vieux
> buf = "/Title (%s)\n" % title ?

propre, clair et concis
quoi que la forme canonique soit plutôt
buf = "/Title (%s)\n" % ( title )
mais je chipote

> Si quelqu'un à une réponse autre que 42 à me fournir, je lui en serais reconnaissant.

autre hypoth?se, l'auteur du code qui t'interpelles veux rendre son code abscon
et il y a arrive

Eric

Eric Deveaud a écrit :
>> Quel est l'interêt de ce
>> buf = "".join(...)
>
> un gus qui a mal lu ou plutôt pas relu, et encore moin compris les questions
> concernant l'inneficacité de la concaténation des chaines qui affectaient les
> version postérieures de python.
>

Même s'il est établi que les nouvelles versions gêrent mieux la
concaténation des chaînes avec "+", je continue toujours à préférer les
"".join(maliste) selon les bonnes vieilles recommandations, sachant
qu'un string est immuable.

C'est maintenant hors-propos où cela a été optimisé pour que la
différence ne se "voit" plus trop ?

Kib.

Eric Deveaud a écrit :
>> Quel est l'interêt de ce
>> buf = "".join(...)
>
> un gus qui a mal lu ou plutôt pas relu, et encore moin compris les questions
> concernant l'inneficacité de la concaténation des chaines qui affectaient les
> version postérieures de python.
>

Même s'il est établi que les nouvelles versions gêrent mieux la
concaténation des chaînes avec "+", je continue toujours à préférer les
"".join(maliste) selon les bonnes vieilles recommandations, sachant
qu'un string est immuable.

C'est maintenant hors-propos où cela a été optimisé pour que la
différence ne se "voit" plus trop ?

Kib.

Eric Deveaud a écrit :

> propre, clair et concis
> quoi que la forme canonique soit plutôt
> buf = "/Title (%s)\n" % ( title )
> mais je chipote

uf = "/Title (%(title)s)\n" % {'title': title }

--
Encolpe DEGOUTE
http://encolpe.degoute.free.fr/
Logiciels libres, hockey sur glace et autres activités cérébrales

Eric Deveaud a écrit :

> propre, clair et concis
> quoi que la forme canonique soit plutôt
> buf = "/Title (%s)\n" % ( title )
> mais je chipote

uf = "/Title (%(title)s)\n" % {'title': title }

--
Encolpe DEGOUTE
http://encolpe.degoute.free.fr/
Logiciels libres, hockey sur glace et autres activités cérébrales

Eric Deveaud a écrit :
> Fouff wrote:
(snip)
>> Voire éventuellement en question subsidiaire par rapport à un bon vieux
>> buf = "/Title (%s)\n" % title ?
>
> propre, clair et concis
> quoi que la forme canonique soit plutôt
> buf = "/Title (%s)\n" % ( title )

buf = "/Title (%s)\n" % (title,)

Hormis le cas de la notation littérale pour le tuple vide, c'est la
virgule qui fait le tuple, pas les parenthèses.

> mais je chipote

!-)

Eric Deveaud a écrit :
> Fouff wrote:
(snip)
>> Voire éventuellement en question subsidiaire par rapport à un bon vieux
>> buf = "/Title (%s)\n" % title ?
>
> propre, clair et concis
> quoi que la forme canonique soit plutôt
> buf = "/Title (%s)\n" % ( title )

buf = "/Title (%s)\n" % (title,)

Hormis le cas de la notation littérale pour le tuple vide, c'est la
virgule qui fait le tuple, pas les parenthèses.

> mais je chipote

!-)

Encolpe Degoute a écrit :
> Eric Deveaud a écrit :
>
>> propre, clair et concis
>> quoi que la forme canonique soit plutôt
>> buf = "/Title (%s)\n" % ( title )
>> mais je chipote
>
> uf = "/Title (%(title)s)\n" % {'title': title }
>

uf = "/Title (%(title)s)\n" % locals()

!-)

Encolpe Degoute a écrit :
> Eric Deveaud a écrit :
>
>> propre, clair et concis
>> quoi que la forme canonique soit plutôt
>> buf = "/Title (%s)\n" % ( title )
>> mais je chipote
>
> uf = "/Title (%(title)s)\n" % {'title': title }
>

uf = "/Title (%(title)s)\n" % locals()

!-)

kib a écrit :
> Eric Deveaud a écrit :
> >> Quel est l'interêt de ce
>>> buf = "".join(...)
>>
>> un gus qui a mal lu ou plutôt pas relu, et encore moin compris les
>> questions
>> concernant l'inneficacité de la concaténation des chaines qui
>> affectaient les
>> version postérieures de python.
>>
>
> Même s'il est établi que les nouvelles versions gêrent mieux la
> concaténation des chaînes avec "+", je continue toujours à préférer les
> "".join(maliste) selon les bonnes vieilles recommandations, sachant
> qu'un string est immuable.
>
> C'est maintenant hors-propos où cela a été optimisé pour que la
> différence ne se "voit" plus trop ?

Pour autant que je sache, on a maintenant, au moins dans certains cas,
de meilleures perfs avec la concaténation.

L'intérêt de la liste est surtout les manipulations qu'elle permet
*avant* la construction du résultat final (tris, filtres etc).

kib a écrit :
> Eric Deveaud a écrit :
> >> Quel est l'interêt de ce
>>> buf = "".join(...)
>>
>> un gus qui a mal lu ou plutôt pas relu, et encore moin compris les
>> questions
>> concernant l'inneficacité de la concaténation des chaines qui
>> affectaient les
>> version postérieures de python.
>>
>
> Même s'il est établi que les nouvelles versions gêrent mieux la
> concaténation des chaînes avec "+", je continue toujours à préférer les
> "".join(maliste) selon les bonnes vieilles recommandations, sachant
> qu'un string est immuable.
>
> C'est maintenant hors-propos où cela a été optimisé pour que la
> différence ne se "voit" plus trop ?

Pour autant que je sache, on a maintenant, au moins dans certains cas,
de meilleures perfs avec la concaténation.

L'intérêt de la liste est surtout les manipulations qu'elle permet
*avant* la construction du résultat final (tris, filtres etc).

Bruno Desthuilliers wrote:
> Eric Deveaud a écrit :
> > buf = "/Title (%s)\n" % ( title )
>
> buf = "/Title (%s)\n" % (title,)
>
> Hormis le cas de la notation littérale pour le tuple vide, c'est la
> virgule qui fait le tuple, pas les parenthèses.
>
> > mais je chipote
>
> !-)

? chipoteur, chipoteur et demi, mais mercide cette remarque tr?s pertinente.

Eric qui part se mettre des baffes ;-)

Bruno Desthuilliers wrote:
> Eric Deveaud a écrit :
> > buf = "/Title (%s)\n" % ( title )
>
> buf = "/Title (%s)\n" % (title,)
>
> Hormis le cas de la notation littérale pour le tuple vide, c'est la
> virgule qui fait le tuple, pas les parenthèses.
>
> > mais je chipote
>
> !-)

? chipoteur, chipoteur et demi, mais mercide cette remarque tr?s pertinente.

Eric qui part se mettre des baffes ;-)

Bonsoir !

Perso, je vois une explication possible : Le développeur ne sait pas,
au moment où il écrit le code, quel délimiteur il (devra) utiliser(a).
Dès lors, avec le code cité, il pourra très facilement modifier.

Exemples :

buf = ";".join(("/Title (", title, ")\n"))
buf = "\t".join(("/Title (", title, ")\n"))
buf = " - ".join(("/Title (", title, ")\n"))
buf = "|".join(("/Title (", title, ")\n"))

Maintenant, est-ce que cette hypothèse est la bonne ?






--
@-salutations

Michel Claveau

Bonsoir !

Perso, je vois une explication possible : Le développeur ne sait pas,
au moment où il écrit le code, quel délimiteur il (devra) utiliser(a).
Dès lors, avec le code cité, il pourra très facilement modifier.

Exemples :

buf = ";".join(("/Title (", title, ")\n"))
buf = "\t".join(("/Title (", title, ")\n"))
buf = " - ".join(("/Title (", title, ")\n"))
buf = "|".join(("/Title (", title, ")\n"))

Maintenant, est-ce que cette hypothèse est la bonne ?






--
@-salutations

Michel Claveau

Bruno Desthuilliers wrote:
> Encolpe Degoute a écrit :
> > Eric Deveaud a écrit :
> >
> >> propre, clair et concis
> >> quoi que la forme canonique soit plutôt
> >> buf = "/Title (%s)\n" % ( title )
> >> mais je chipote
> >
> > uf = "/Title (%(title)s)\n" % {'title': title }
> >
>
> uf = "/Title (%(title)s)\n" % locals()

J'aime déja pas trop (question de gout personel) les formes avec les
dictionnaires, qui sont pourtant beaucoup plus lisibles qu'une succession de
variables qu'il faut suivre dnas le bon ordre je n'avait pas pensé au locals(),
va falloir que je m'habitue.

merci

Bruno Desthuilliers wrote:
> Encolpe Degoute a écrit :
> > Eric Deveaud a écrit :
> >
> >> propre, clair et concis
> >> quoi que la forme canonique soit plutôt
> >> buf = "/Title (%s)\n" % ( title )
> >> mais je chipote
> >
> > uf = "/Title (%(title)s)\n" % {'title': title }
> >
>
> uf = "/Title (%(title)s)\n" % locals()

J'aime déja pas trop (question de gout personel) les formes avec les
dictionnaires, qui sont pourtant beaucoup plus lisibles qu'une succession de
variables qu'il faut suivre dnas le bon ordre je n'avait pas pensé au locals(),
va falloir que je m'habitue.

merci

MC a écrit :
> Bonsoir !
>
> Perso, je vois une explication possible : Le développeur ne sait pas, au
> moment où il écrit le code, quel délimiteur il (devra) utiliser(a). Dès
> lors, avec le code cité, il pourra très facilement modifier.
>
> Exemples :
>
> buf = ";".join(("/Title (", title, ")\n"))
> buf = "\t".join(("/Title (", title, ")\n"))
> buf = " - ".join(("/Title (", title, ")\n"))
> buf = "|".join(("/Title (", title, ")\n"))
>
> Maintenant, est-ce que cette hypothèse est la bonne ?
>
>
>
>
>
>
Je ne pense pas car alors on pourrait tout aussi bien faire ça par
concaténation et changer DELIM en ce qu'on veut:

DELIM = ";"
bug = "/Title (" + DELIM + title + DELIM + ")\n"

MC a écrit :
> Bonsoir !
>
> Perso, je vois une explication possible : Le développeur ne sait pas, au
> moment où il écrit le code, quel délimiteur il (devra) utiliser(a). Dès
> lors, avec le code cité, il pourra très facilement modifier.
>
> Exemples :
>
> buf = ";".join(("/Title (", title, ")\n"))
> buf = "\t".join(("/Title (", title, ")\n"))
> buf = " - ".join(("/Title (", title, ")\n"))
> buf = "|".join(("/Title (", title, ")\n"))
>
> Maintenant, est-ce que cette hypothèse est la bonne ?
>
>
>
>
>
>
Je ne pense pas car alors on pourrait tout aussi bien faire ça par
concaténation et changer DELIM en ce qu'on veut:

DELIM = ";"
bug = "/Title (" + DELIM + title + DELIM + ")\n"