Tirer parti de chaque lettre dans une chaîne de caractères en Python?

J'ai essayé de définir une fonction qui permettra de tirer parti de toutes les autres lettres et aussi prendre de l'espace en accout par exemple:

print function_name("Hello world") doit imprimer "HeLlO wOrLd" plutôt que "HeLlO WoRlD"

J'espère que cela a du sens. Toute aide est appréciée.

Merci, Oli

Quel est la différence entre vos exemples?
Désolé, j'ai tapé dans l'erreur. J'ai édité maintenant. Merci
montre-nous ton code
Pouvez-vous élaborer sur "prendre de l'espace en accouut" ?
Je pense qu'il veut dire les espaces ne devraient pas compter lors de l'alternance entre les minuscules et en majuscules.
Dans cet exemple, l'espace ne semble pas compter. Si "Bonjour" se termine dans la capitale, l'espace serait "non-capital" et le W serait capital. Donc aparently ce que vous voulez est pour le programme d'éviter de compter les espaces, droit?
Pouvez-vous nous montrer ce que vous avez essayé jusqu'à présent?

InformationsquelleAutor Perceptic | 2013-07-25

python

def foo(s):
    ret = ""
    i = True  # capitalize
    for char in s:
        if i:
            ret += char.upper()
        else:
            ret += char.lower()
        if char != ' ':
            i = not i
    return ret

>>> print foo("hello world")
HeLlO wOrLd'

Merci! Cela fonctionne très bien. Merci à tout le monde pour votre aide aussi.

InformationsquelleAutor vik

3

Je pense que c'est un de ces cas où un régulier forboucle est la meilleure idée:
```
>>> def f(s):
...     r = ''
...     b = True
...     for c in s:
...         r += c.upper() if b else c.lower()
...         if c.isalpha():
...             b = not b
...     return r
...
>>> f('Hello world')
'HeLlO wOrLd'
```
- Merci de ne pas créer des chaînes à plusieurs reprises par l'ajout d'un personnage (+=). La performance est moche. Par exemple, essayez d'appliquer ce la Guerre et de la Paix.
- Vous ne comprenez pas le but de ma réponse; il n'est là que pour montrer la façon dont ce que l'OP demande peut être atteint. Si l'OP est de travailler avec le code de sorte que les performances sensibles tels que la concaténation de chaîne est hors de question (un cas très rare en fait), alors il peut regarder dans quelque chose comme les cordes mutables. Cependant, l'approche décrite ci-dessus, resteront les mêmes.
InformationsquelleAutor arshajii
3

Ici est une version qui utilise des expressions régulières:
```
import re

def alternate_case(s):
    cap = [False]
    def repl(m):
        cap[0] = not cap[0]
        return m.group(0).upper() if cap[0] else m.group(0).lower()
    return re.sub(r'[A-Za-z]', repl, s)
```
Exemple:
```
>>> alternate_case('Hello world')
'HeLlO wOrLd'
```
- Pourquoi est - cap une liste?
- Je suppose que c'est une liste pour éviter global ou nonlocal.
- Si le code est en Python 3.x je voudrais aller avec nonlocal à la place. Il a une liste ici car quelque chose comme cap = not cap dans le repl() fonction serait de vous donner une "variable locale référencée avant affectation" erreur, à moins que nonlocal cap ou global cap ont d'abord été utilisés. Je n'aime pas utiliser global et nonlocal n'est pas disponible sur Python 2.x. Voir stackoverflow.com/a/8934902/505154
- Vous pouvez également utiliser une fonction d'attribut ici, entre les repl définition et la return re.sub(...) vous mettez repl.cap = False, et puis changer chaque cap[0] de référence à l'intérieur de repl à repl.cap.
InformationsquelleAutor Andrew Clark

Cela devrait faire l'affaire:

def function_name(input_string):
    should_capitalize = True
    chars = []
    for single_char in input_string:
        if not single_char.isalpha():
            chars.append(single_char)
            continue

        if should_capitalize:
            chars.append(single_char.upper())
        else:
            chars.append(single_char.lower())

        should_capitalize = not should_capitalize

    return ''.join(chars)

InformationsquelleAutor Maciej Gol

Un (je l'espère élégante) approche récursive:

def funky_cap(s, use_lower=False):
    if s == '':
        return s
    elif not s[0].isalpha():
        return s[0] + funky_cap(s[1:], use_lower)
    elif use_lower:
        return s[0].lower() + funky_cap(s[1:], not use_lower)
    else: # when we need an uppercase letter
        return s[0].upper() + funky_cap(s[1:], not use_lower)

InformationsquelleAutor Micah Walter

Vous devez vous connecter pour publier un commentaire.