Comment ajouter des guillemets à une chaîne de caractères à l'aide de python?

Je veux ajouter un ensemble de (double) devis pour une chaîne python si elles sont manquantes, mais la chaîne peut également contenir des guillemets.

Le but de cela est de citer toutes de commande qui ne sont pas déjà cité parce que l'API Windows vous demande de citer l'ensemble de la ligne de commande lors de l'exécution d'un processus à l'aide de _popen().

Voici quelques chaînes qui devrait être cité:

<empty string>
type
"type" /?
"type" "/?"
type "a a" b
type "" b

Voici quelques-uns qui devraient pas être cité:

"type"
""type" /?"

Veuillez prendre le temps de tester tous les exemples; il n'est pas trop facile de détecter si la chaîne besoins les guillemets ou pas.

Quel est le résultat attendu pour ''?
#6 peut aussi être lu comme citation-un-quotedemptystring-b-devis
Ce mec a changé autour de la question tout à fait un peu, surtout pour dire ce que son véritable objectif est. Bon pour clarifier l'objectif, mais les références à tester les nombres sorte de ne plus travailler.
N'est-il pas une fonction de la bibliothèque pour ces? Notez également qu'en Python il y a subprocess.call qui prend ses arguments sous forme d'une liste, os.popen est obsolète.

OriginalL'auteur bogdan | 2010-08-27

python string

Je pense que c'est une question difficile à spécifier de façon précise, mais peut-être cette stratégie se rapprochera de votre objectif.

L'idée de base est de créer une copie de la chaîne d'origine, le retrait de la interne de la cité éléments. Un interne de la cité de l'élément est définie ici, de sorte qu'il doit contenir au moins un caractère non-blanc.

Après l'interne de la cité articles ont été supprimés, puis vérifier si l'ensemble de la chaîne entourant de guillemets ou pas.

import re

tests = [
    # Test data in original question.
    ( '',                '""'                ),
    ( 'a',               '"a"'               ),
    ( '"a"',             '"a"'               ), # No change.
    ( '""a" b"',         '""a" b"'           ), # No change.
    ( '"a" b',           '""a" b"'           ),
    ( '"a" "b"',         '""a" "b""'         ),
    ( 'a "b" c',         '"a "b" c"'         ),

    # Test data in latest edits.
    ( 'type',            '"type"'         ),    # Quote these.
    ( '"type" /?',       '""type" /?"'    ),
    ( '"type" "/?"',     '""type" "/?""'  ),
    ( 'type "a a" b',    '"type "a a" b"' ),
    ( 'type "" b',       '"type "" b"'    ),
    ( '"type"',          '"type"'         ),    # Don't quote.
    ( '""type" /?"',     '""type" /?"'    ),

    # Some more tests.
    ( '"a b" "c d"',     '""a b" "c d""'     ),
    ( '" a " foo " b "', '"" a " foo " b ""' ),
]

Q = '"'
re_quoted_items = re.compile(r'" \s* [^"\s] [^"]* \"', re.VERBOSE)

for orig, expected in tests:
    # The orig string w/o the internally quoted items.
    woqi = re_quoted_items.sub('', orig)

    if len(orig) == 0:
        orig_quoted = Q + orig + Q
    elif len(woqi) > 0 and not (woqi[0] == Q and woqi[-1] == Q):
        orig_quoted = Q + orig + Q    
    else:
        orig_quoted = orig

    print orig_quoted == expected

OriginalL'auteur FMc

8

Votre problème est incohérent.

Considérer les deux cas

""a" b"

"a" "b"

Le premier est interprété comme un pré-cité de la chaîne avec "imbriqués citations", mais ce dernier est interprété comme séparément ces chaînes. Voici quelques exemples qui mettent en évidence le problème.

" "a" "b" "

" "a" b"

"a ""b"

Comment devraient-ils être traités?

Tout le temps, j'ai senti que quelque chose n'allait pas avec cette question... maintenant je sais. +1 pour l'apporter.
Je viens de taper la même chose. Au lieu de cela, je vais upvote votre réponse. Un autre exemple: " a " foo " b ". Des clarifications mineures: pas sûr que la question est incompatible en tant que sous-spécifié.
en supprimant les espaces, respectivement en considérant uniquement les guillemets, les deux sont équivalents.
Eh bien, c'est incompatible avec l'hypothèse que tous les non-citer les personnages sont traités de manière égale. L'ajout de plus les changements de spécification du problème.
malheureusement, cela n'aide pas: les commandes "a "foo" b" et "a" foo "b" semblent impossibles à distinguer, mais nécessitent des règles différentes. Peut-être essayer un et de rattraper l'erreur qui en résulte?

OriginalL'auteur Katriel

J'ai écrit un simple état de la machine pour vérifier si nous sommes dans un mot ou pas. Si la cote de profondeur est jamais à zéro dans la chaîne de caractères, alors nous avons besoin de devis:

def quotify(s):
    if s == "":
        return '""'

    depth = 0
    in_word = False
    needs_quotes = False
    for c in s:
        if c == '"':
            if in_word:
                depth -= 1
            else:
                depth += 1
        else:
            if depth == 0:
                needs_quotes = True
                break
            in_word = not c.isspace()

    if needs_quotes:
        return '"' + s + '"'
    else:
        return s

assert quotify('') == '""'
assert quotify('''type''') == '''"type"'''
assert quotify('''"type" /?''') == '''""type" /?"'''
assert quotify('''"type" "/?"''') == '''""type" "/?""'''
assert quotify('''type "a a" b''') == '''"type "a a" b"'''
assert quotify('''type "" b''') == '''"type "" b"'''
assert quotify('''"type"''') == '''"type"'''
assert quotify('''""type" /?"''') == '''""type" /?"'''

J'aime votre approche, car il ne nécessite pas de re, mais elle ne parviennent pas sur le dernier test réalisé par FM - son re solution ne passer tous les tests.

OriginalL'auteur Ned Batchelder

-1

Vous avez trois cas:
1. Chaîne est à moins de deux caractères: ajouter des guillemets
2. Chaîne a des guillemets à s[0] et s[1]: ne pas ajouter des guillemets
3. Ajouter des guillemets
Et par "ajouter des guillemets" je veux dire tout simplement construire '"'+string+'"' et le retourner.

Traduire de si-états, et vous avez terminé.

Aussi l'échec de l'essai #5

OriginalL'auteur Ian

Vous devez vous connecter pour publier un commentaire.

Votre problème est incohérent.