Pourquoi les chaînes vides sont-elles renvoyées dans les résultats de split ()?

Quel est le point de '/segment/segment/'.split('/')revenir ['', 'segment', 'segment', '']?

Remarquez les éléments vides. Si vous divisez sur un délimiteur qui se trouve à la position un et à la toute fin d'une chaîne, quelle valeur supplémentaire cela vous donne-t-il pour avoir la chaîne vide renvoyée de chaque extrémité?

str.splitcompléments str.join, donc

"/".join(['', 'segment', 'segment', ''])

vous récupère la chaîne d'origine.

Si les chaînes vides n'étaient pas là, la première et la dernière '/'seraient manquantes après lejoin()

Plus généralement, pour supprimer les chaînes vides renvoyées dans les split()résultats, vous souhaiterez peut-être examiner la filterfonction.

Exemple:

filter(None, '/segment/segment/'.split('/'))

Retour

['segment', 'segment']

Il y a deux points principaux à considérer ici:

• Il est raisonnable de s'attendre à ce que le résultat de '/segment/segment/'.split('/')soit égal à ['segment', 'segment'], mais cela perd alors des informations. Si cela split()fonctionnait comme vous le souhaitiez, si je vous dis cela a.split('/') == ['segment', 'segment'], vous ne pouvez pas me dire ce que ac'était.
• Quel devrait être le résultat 'a//b'.split()? ['a', 'b']?, ou ['a', '', 'b']? Par exemple, faut-il split()fusionner les délimiteurs adjacents? Si tel est le cas, il sera très difficile d'analyser les données délimitées par un caractère, et certains champs peuvent être vides. Je suis assez sûr qu'il ya beaucoup de gens qui font veulent les valeurs vides dans le résultat pour le cas ci - dessus!

Au final, cela se résume à deux choses:

Cohérence: si j'ai des ndélimiteurs, dans a, je récupère les n+1valeurs après le split().

Il devrait être possible de faire des choses complexes, et faciles de faire des choses simples: si vous voulez ignorer les chaînes vides à la suite de split(), vous pouvez toujours faire:

def mysplit(s, delim=None):
    return [x for x in s.split(delim) if x]

mais si on ne veut pas ignorer les valeurs vides, on devrait pouvoir le faire.

Le langage doit choisir une définition de: split()il y a trop de cas d'utilisation différents pour satisfaire les exigences de chacun par défaut. Je pense que le choix de Python est bon, et le plus logique. (En passant, l'une des raisons pour lesquelles je n'aime pas C strtok()est parce qu'il fusionne les délimiteurs adjacents, ce qui rend extrêmement difficile de faire une analyse / tokenisation sérieuse avec lui.)

Il y a une exception: a.split()sans argument, serre les espaces blancs consécutifs, mais on peut affirmer que c'est la bonne chose à faire dans ce cas. Si vous ne voulez pas le comportement, vous pouvez toujours le faire a.split(' ').

Avoir x.split(y)toujours renvoyer une liste d' 1 + x.count(y)éléments est une régularité précieuse - comme @ gnibbler l'a déjà souligné, il fait splitet joinexact inverses les uns des autres (comme ils devraient évidemment l'être), il cartographie aussi précisément la sémantique de toutes sortes d'enregistrements joints par des délimiteurs ( comme csvles lignes de fichiers [[net de problèmes de citations]], les lignes d' /etc/groupUnix, etc.), il permet (comme la réponse de @ Roman l'a mentionné) de vérifier facilement (par exemple) les chemins absolus ou relatifs (dans les chemins de fichiers et les URL), et ainsi de suite.

Une autre façon de voir les choses est que vous ne devriez pas jeter des informations par la fenêtre sans aucun gain. Que gagnerait-on à faire l' x.split(y)équivalent x.strip(y).split(y)? Rien, bien sûr - il est facile d'utiliser la deuxième forme quand c'est ce que vous voulez dire, mais si la première forme a été arbitrairement comme signifiant le second, vous auriez beaucoup de travail à faire lorsque vous ne voulez que le premier ( ce qui est loin d'être rare, comme le souligne le paragraphe précédent).

Mais vraiment, penser en termes de régularité mathématique est le moyen le plus simple et le plus général de vous apprendre à concevoir des API praticables. Pour prendre un exemple différent, il est très important que, pour toute valeur xet y x == x[:y] + x[y:]- qui indique immédiatement pourquoi un extrême d'un découpage doit être exclu. Plus l'assertion invariante que vous pouvez formuler est simple, plus il est probable que la sémantique résultante soit ce dont vous avez besoin dans les utilisations réelles - une partie du fait mystique que les mathématiques sont très utiles pour traiter l'univers.

Essayez la formulation de l'invariant pour un splitdialecte dans lequel d' attaque et de fuite sont délimiteurs-cas spéciaux ... contre-exemple: les méthodes de chaînes telles que isspacene sont pas au maximum simple - x.isspace()est équivalent à x and all(c in string.whitespace for c in x)- ce leader stupide x andest la raison pour laquelle vous vous trouvez ainsi souvent vous codage not x or x.isspace(), pour revenir à la simplicité qui aurait dû être conçue dans les is...méthodes de chaîne (où une chaîne vide "est" tout ce que vous voulez - contrairement au sens du cheval de l'homme dans la rue, peut-être [[ensembles vides, comme zéro & c, ont toujours dérouté la plupart des gens ;-)]], mais se conformant pleinement au bon sens mathématique évident et raffiné ! -).

Je ne sais pas quel type de réponse vous recherchez? Vous obtenez trois correspondances parce que vous avez trois délimiteurs. Si vous ne voulez pas celui-là vide, utilisez simplement:

'/segment/segment/'.strip('/').split('/')

Eh bien, cela vous permet de savoir qu'il y avait un délimiteur là-bas. Ainsi, voir 4 résultats vous permet de savoir que vous avez 3 délimiteurs. Cela vous donne le pouvoir de faire ce que vous voulez avec ces informations, plutôt que de laisser Python supprimer les éléments vides, puis de vous faire vérifier manuellement les délimiteurs de début ou de fin si vous avez besoin de le savoir.

Exemple simple: Supposons que vous souhaitiez vérifier les noms de fichiers absolus et relatifs. De cette façon, vous pouvez tout faire avec le fractionnement, sans avoir à vérifier également quel est le premier caractère de votre nom de fichier.

Considérez cet exemple minimal:

>>> '/'.split('/')
['', '']

splitdoit vous donner ce qui est avant et après le délimiteur '/', mais il n'y a pas d'autres caractères. Il doit donc vous donner la chaîne vide, qui précède et suit techniquement le '/', car '' + '/' + '' == '/'.