Il n'y a pas de reversefonction intégrée pour l' strobjet Python . Quelle est la meilleure façon de mettre en œuvre cette méthode?

Si vous fournissez une réponse très concise, veuillez préciser son efficacité. Par exemple, si l' strobjet est converti en un autre objet, etc.

Que diriez-vous:

>>> 'hello world'[::-1]
'dlrow olleh'

Il s'agit d' une syntaxe de tranche étendue . Cela fonctionne en faisant [begin:end:step]- en laissant début et fin et en spécifiant une étape de -1, il inverse une chaîne.

@ Paolo s[::-1]est le plus rapide; une approche plus lente (peut-être plus lisible, mais c'est discutable) est ''.join(reversed(s)).

Quelle est la meilleure façon d'implémenter une fonction inverse pour les chaînes?

Ma propre expérience avec cette question est académique. Cependant, si vous êtes un professionnel à la recherche de la réponse rapide, utilisez une tranche qui passe par -1:

>>> 'a string'[::-1]
'gnirts a'

ou plus lisiblement (mais plus lent en raison de la recherche de nom de la méthode et le fait qui se joignent forme une liste quand ils reçoivent une iterator), str.join:

>>> ''.join(reversed('a string'))
'gnirts a'

ou pour la lisibilité et la réutilisabilité, mettez la tranche dans une fonction

def reversed_string(a_string):
    return a_string[::-1]

et alors:

>>> reversed_string('a_string')
'gnirts_a'

Explication plus longue

Si vous êtes intéressé par l'exposition académique, veuillez continuer à lire.

Il n'y a pas de fonction inverse intégrée dans l'objet str de Python.

Voici quelques informations sur les chaînes de Python que vous devez savoir:

1. En Python, les chaînes sont immuables . La modification d'une chaîne ne modifie pas la chaîne. Il en crée un nouveau.

2. Les cordes sont tranchables. Le découpage d'une chaîne vous donne une nouvelle chaîne d'un point de la chaîne, vers l'arrière ou vers l'avant, vers un autre point, par incréments donnés. Ils prennent la notation de tranche ou un objet tranche dans un indice:

   string[subscript]

L'indice crée une tranche en incluant un deux-points entre les accolades:

    string[start:stop:step]

Pour créer une tranche en dehors des accolades, vous devrez créer un objet tranche:

    slice_obj = slice(start, stop, step)
    string[slice_obj]

Une approche lisible:

Bien qu'il ''.join(reversed('foo'))soit lisible, il nécessite d'appeler une méthode de chaîne str.join, sur une autre fonction appelée, qui peut être relativement lente. Mettons cela dans une fonction - nous y reviendrons:

def reverse_string_readable_answer(string):
    return ''.join(reversed(string))

Approche la plus performante:

Beaucoup plus rapide utilise une tranche inverse:

'foo'[::-1]

Mais comment pouvons-nous rendre cela plus lisible et compréhensible pour quelqu'un de moins familier avec les tranches ou l'intention de l'auteur original? Créons un objet tranche en dehors de la notation en indice, donnons-lui un nom descriptif et passons-le à la notation en indice.

start = stop = None
step = -1
reverse_slice = slice(start, stop, step)
'foo'[reverse_slice]

Mettre en œuvre en tant que fonction

Pour réellement implémenter cela en tant que fonction, je pense qu'il est suffisamment clair sur le plan sémantique d'utiliser simplement un nom descriptif:

def reversed_string(a_string):
    return a_string[::-1]

Et l'utilisation est tout simplement:

reversed_string('foo')

Ce que votre professeur veut probablement:

Si vous avez un instructeur, il voudra probablement que vous commenciez avec une chaîne vide et que vous construisiez une nouvelle chaîne à partir de l'ancienne. Vous pouvez le faire avec une syntaxe pure et des littéraux en utilisant une boucle while:

def reverse_a_string_slowly(a_string):
    new_string = ''
    index = len(a_string)
    while index:
        index -= 1                    # index = index - 1
        new_string += a_string[index] # new_string = new_string + character
    return new_string

C'est théoriquement mauvais parce que, rappelez-vous, les chaînes sont immuables - donc à chaque fois qu'il semble que vous ajoutiez un caractère à votre new_string, cela crée théoriquement une nouvelle chaîne à chaque fois! Cependant, CPython sait comment optimiser cela dans certains cas, dont ce cas trivial en est un.

Meilleur entrainement

Théoriquement, il est préférable de rassembler vos sous-chaînes dans une liste et de les rejoindre plus tard:

def reverse_a_string_more_slowly(a_string):
    new_strings = []
    index = len(a_string)
    while index:
        index -= 1                       
        new_strings.append(a_string[index])
    return ''.join(new_strings)

Cependant, comme nous le verrons dans les timings ci-dessous pour CPython, cela prend en fait plus de temps, car CPython peut optimiser la concaténation des chaînes.

Timings

Voici les horaires:

>>> a_string = 'amanaplanacanalpanama' * 10
>>> min(timeit.repeat(lambda: reverse_string_readable_answer(a_string)))
10.38789987564087
>>> min(timeit.repeat(lambda: reversed_string(a_string)))
0.6622700691223145
>>> min(timeit.repeat(lambda: reverse_a_string_slowly(a_string)))
25.756799936294556
>>> min(timeit.repeat(lambda: reverse_a_string_more_slowly(a_string)))
38.73570013046265

CPython optimise la concaténation de chaînes, tandis que d'autres implémentations peuvent ne pas :

... ne comptez pas sur l'implémentation efficace de CPython de la concaténation de chaîne sur place pour les instructions sous la forme a + = b ou a = a + b. Cette optimisation est fragile même dans CPython (elle ne fonctionne que pour certains types) et n'est pas présente du tout dans les implémentations qui n'utilisent pas le recomptage. Dans les parties sensibles aux performances de la bibliothèque, le formulaire '' .join () doit être utilisé à la place. Cela garantira que la concaténation se produit en temps linéaire sur différentes implémentations.

Réponse rapide (TL; DR)

Exemple

### example01 -------------------
mystring  =   'coup_ate_grouping'
backwards =   mystring[::-1]
print backwards

### ... or even ...
mystring  =   'coup_ate_grouping'[::-1]
print mystring

### result01 -------------------
'''
gnipuorg_eta_puoc
'''

Réponse détaillée

Contexte

Cette réponse est fournie pour répondre à la préoccupation suivante de @odigity:

Sensationnel. J'ai été horrifié au début par la solution proposée par Paolo, mais cela a laissé un siège à l'horreur que j'ai ressentie en lisant le premier commentaire: "C'est très pythonique. Bon travail!" Je suis tellement troublé qu'une communauté aussi brillante pense que l'utilisation de telles méthodes cryptiques pour quelque chose d'aussi basique est une bonne idée. Pourquoi n'est-ce pas juste à l'inverse ()?

Problème

• Le contexte
  • Python 2.x
  • Python 3.x
• Scénario:
  • Le développeur veut transformer une chaîne
  • La transformation consiste à inverser l'ordre de tous les caractères

Solution

• example01 produit le résultat souhaité, en utilisant la notation de tranche étendue .

Pièges

• Le développeur peut s'attendre à quelque chose comme string.reverse()
• La solution native idiomatique (aka " pythonic ") peut ne pas être lisible par les nouveaux développeurs
• Le développeur peut être tenté d'implémenter sa propre version de string.reverse()pour éviter la notation par tranche.
• La sortie de la notation de tranche peut être contre-intuitive dans certains cas:
  • voir par exemple, example02
    • print 'coup_ate_grouping'[-4:] ## => 'ping'
    • par rapport à
    • print 'coup_ate_grouping'[-4:-1] ## => 'pin'
    • par rapport à
    • print 'coup_ate_grouping'[-1] ## => 'g'
  • les différents résultats de l'indexation [-1]peuvent décourager certains développeurs

Raisonnement

Python a une circonstance particulière à connaître: une chaîne est un type itérable .

Une justification de l'exclusion d'une string.reverse()méthode est d'inciter les développeurs de python à tirer parti de la puissance de cette circonstance particulière.

En termes simplifiés, cela signifie simplement que chaque caractère individuel d'une chaîne peut être facilement exploité en tant que partie d'un arrangement séquentiel d'éléments, tout comme les tableaux dans d'autres langages de programmation.

Pour comprendre comment cela fonctionne, l'examen de example02 peut fournir un bon aperçu.

Exemple02

### example02 -------------------
## start (with positive integers)
print 'coup_ate_grouping'[0]  ## => 'c'
print 'coup_ate_grouping'[1]  ## => 'o' 
print 'coup_ate_grouping'[2]  ## => 'u' 

## start (with negative integers)
print 'coup_ate_grouping'[-1]  ## => 'g'
print 'coup_ate_grouping'[-2]  ## => 'n' 
print 'coup_ate_grouping'[-3]  ## => 'i' 

## start:end 
print 'coup_ate_grouping'[0:4]    ## => 'coup'    
print 'coup_ate_grouping'[4:8]    ## => '_ate'    
print 'coup_ate_grouping'[8:12]   ## => '_gro'    

## start:end 
print 'coup_ate_grouping'[-4:]    ## => 'ping' (counter-intuitive)
print 'coup_ate_grouping'[-4:-1]  ## => 'pin'
print 'coup_ate_grouping'[-4:-2]  ## => 'pi'
print 'coup_ate_grouping'[-4:-3]  ## => 'p'
print 'coup_ate_grouping'[-4:-4]  ## => ''
print 'coup_ate_grouping'[0:-1]   ## => 'coup_ate_groupin'
print 'coup_ate_grouping'[0:]     ## => 'coup_ate_grouping' (counter-intuitive)

## start:end:step (or start:end:stride)
print 'coup_ate_grouping'[-1::1]  ## => 'g'   
print 'coup_ate_grouping'[-1::-1] ## => 'gnipuorg_eta_puoc'

## combinations
print 'coup_ate_grouping'[-1::-1][-4:] ## => 'puoc'

Conclusion

La charge cognitive associée à la compréhension du fonctionnement de la notation par tranche en python peut en effet être trop lourde pour certains adoptants et développeurs qui ne souhaitent pas investir beaucoup de temps dans l'apprentissage du langage.

Néanmoins, une fois les principes de base compris, la puissance de cette approche sur les méthodes de manipulation de chaînes fixes peut être très favorable.

Pour ceux qui pensent le contraire, il existe des approches alternatives, telles que les fonctions lambda, les itérateurs ou les simples déclarations de fonctions uniques.

Si vous le souhaitez, un développeur peut implémenter sa propre méthode string.reverse (), mais il est bon de comprendre la raison d'être de cet aspect de python.

Voir également

• approche simple alternative
• approche simple alternative
• explication alternative de la notation de tranche

Les réponses existantes ne sont correctes que si les modificateurs Unicode / grappes de graphèmes sont ignorés. J'y reviendrai plus tard, mais jetons d'abord un coup d'œil à la vitesse de certains algorithmes d'inversion:

list_comprehension  : min:   0.6μs, mean:   0.6μs, max:    2.2μs
reverse_func        : min:   1.9μs, mean:   2.0μs, max:    7.9μs
reverse_reduce      : min:   5.7μs, mean:   5.9μs, max:   10.2μs
reverse_loop        : min:   3.0μs, mean:   3.1μs, max:    6.8μs

list_comprehension  : min:   4.2μs, mean:   4.5μs, max:   31.7μs
reverse_func        : min:  75.4μs, mean:  76.6μs, max:  109.5μs
reverse_reduce      : min: 749.2μs, mean: 882.4μs, max: 2310.4μs
reverse_loop        : min: 469.7μs, mean: 577.2μs, max: 1227.6μs

Vous pouvez voir que le temps pour la liste comprehension ( reversed = string[::-1]) est dans tous les cas de loin le plus bas (même après avoir corrigé ma faute de frappe).

Inversion de chaîne

Si vous voulez vraiment inverser une chaîne dans le bon sens, c'est BEAUCOUP plus compliqué. Par exemple, prenez la chaîne suivante ( doigt brun pointant vers la gauche , doigt jaune pointant vers le haut ). Ce sont deux graphèmes, mais 3 points de code unicode. Le second est un modificateur de skin .

example = "👈🏾👆"

Mais si vous l'inversez avec l'une des méthodes indiquées, vous obtenez un doigt brun pointant vers le haut , un doigt jaune pointant vers la gauche . La raison en est que le modificateur de couleur "marron" est toujours au milieu et appliqué à tout ce qui le précède. Donc nous avons

• U: doigt pointé vers le haut
• M: modificateur marron
• L: doigt pointé vers la gauche

et

original: LMU
reversed: UML (above solutions)
reversed: ULM (correct reversal)

Les grappes de graphèmes Unicode sont un peu plus compliquées que les simples points de code de modificateur. Heureusement, il existe une bibliothèque pour gérer les graphèmes :

>>> import grapheme
>>> g = grapheme.graphemes("👈🏾👆")
>>> list(g)
['👈🏾', '👆']

et donc la bonne réponse serait

def reverse_graphemes(string):
    g = list(grapheme.graphemes(string))
    return ''.join(g[::-1])

qui est aussi de loin le plus lent:

list_comprehension  : min:    0.5μs, mean:    0.5μs, max:    2.1μs
reverse_func        : min:   68.9μs, mean:   70.3μs, max:  111.4μs
reverse_reduce      : min:  742.7μs, mean:  810.1μs, max: 1821.9μs
reverse_loop        : min:  513.7μs, mean:  552.6μs, max: 1125.8μs
reverse_graphemes   : min: 3882.4μs, mean: 4130.9μs, max: 6416.2μs

Le code

#!/usr/bin/env python

import numpy as np
import random
import timeit
from functools import reduce
random.seed(0)


def main():
    longstring = ''.join(random.choices("ABCDEFGHIJKLM", k=2000))
    functions = [(list_comprehension, 'list_comprehension', longstring),
                 (reverse_func, 'reverse_func', longstring),
                 (reverse_reduce, 'reverse_reduce', longstring),
                 (reverse_loop, 'reverse_loop', longstring)
                 ]
    duration_list = {}
    for func, name, params in functions:
        durations = timeit.repeat(lambda: func(params), repeat=100, number=3)
        duration_list[name] = list(np.array(durations) * 1000)
        print('{func:<20}: '
              'min: {min:5.1f}μs, mean: {mean:5.1f}μs, max: {max:6.1f}μs'
              .format(func=name,
                      min=min(durations) * 10**6,
                      mean=np.mean(durations) * 10**6,
                      max=max(durations) * 10**6,
                      ))
        create_boxplot('Reversing a string of length {}'.format(len(longstring)),
                       duration_list)


def list_comprehension(string):
    return string[::-1]


def reverse_func(string):
    return ''.join(reversed(string))


def reverse_reduce(string):
    return reduce(lambda x, y: y + x, string)


def reverse_loop(string):
    reversed_str = ""
    for i in string:
        reversed_str = i + reversed_str
    return reversed_str


def create_boxplot(title, duration_list, showfliers=False):
    import seaborn as sns
    import matplotlib.pyplot as plt
    import operator
    plt.figure(num=None, figsize=(8, 4), dpi=300,
               facecolor='w', edgecolor='k')
    sns.set(style="whitegrid")
    sorted_keys, sorted_vals = zip(*sorted(duration_list.items(),
                                           key=operator.itemgetter(1)))
    flierprops = dict(markerfacecolor='0.75', markersize=1,
                      linestyle='none')
    ax = sns.boxplot(data=sorted_vals, width=.3, orient='h',
                     flierprops=flierprops,
                     showfliers=showfliers)
    ax.set(xlabel="Time in ms", ylabel="")
    plt.yticks(plt.yticks()[0], sorted_keys)
    ax.set_title(title)
    plt.tight_layout()
    plt.savefig("output-string.png")


if __name__ == '__main__':
    main()

1. en utilisant la notation de tranche

def rev_string(s): 
    return s[::-1]

2. en utilisant la fonction reverse ()

def rev_string(s): 
    return ''.join(reversed(s))

3. utiliser la récursivité

def rev_string(s): 
    if len(s) == 1:
        return s

    return s[-1] + rev_string(s[:-1])

Une façon moins troublante de voir les choses serait:

string = 'happy'
print(string)

'heureux'

string_reversed = string[-1::-1]
print(string_reversed)

'yppah'

En anglais [-1 :: - 1] se lit comme suit:

"À partir de -1, allez jusqu'au bout, en faisant des pas de -1"

Inverse une chaîne en python sans utiliser reverse () ou [:: - 1]

def reverse(test):
    n = len(test)
    x=""
    for i in range(n-1,-1,-1):
        x += test[i]
    return x

C'est aussi une façon intéressante:

def reverse_words_1(s):
    rev = ''
    for i in range(len(s)):
        j = ~i  # equivalent to j = -(i + 1)
        rev += s[j]
    return rev

ou similaire:

def reverse_words_2(s):
    rev = ''
    for i in reversed(range(len(s)):
        rev += s[i]
    return rev

Une autre façon plus «exotique» en utilisant byterarray qui prend en charge .reverse ()

b = bytearray('Reverse this!', 'UTF-8')
b.reverse()
b.decode('UTF-8')

produira:

'!siht esreveR'

def reverse(input):
    return reduce(lambda x,y : y+x, input)

original = "string"

rev_index = original[::-1]
rev_func = list(reversed(list(original))) #nsfw

print(original)
print(rev_index)
print(''.join(rev_func))

def reverse_string(string):
    length = len(string)
    temp = ''
    for i in range(length):
        temp += string[length - i - 1]
    return temp

print(reverse_string('foo')) #prints "oof"

Cela fonctionne en parcourant une chaîne et en affectant ses valeurs dans l'ordre inverse à une autre chaîne.

Voici un pas de fantaisie:

def reverse(text):
    r_text = ''
    index = len(text) - 1

    while index >= 0:
        r_text += text[index] #string canbe concatenated
        index -= 1

    return r_text

print reverse("hello, world!")

En voici un sans [::-1]ou reversed(à des fins d'apprentissage):

def reverse(text):
    new_string = []
    n = len(text)
    while (n > 0):
        new_string.append(text[n-1])
        n -= 1
    return ''.join(new_string)
print reverse("abcd")

vous pouvez utiliser +=pour concaténer des chaînes, mais join()c'est plus rapide.

Méthode récursive:

def reverse(s): return s[0] if len(s)==1 else s[len(s)-1] + reverse(s[0:len(s)-1])

exemple:

print(reverse("Hello!"))    #!olleH

Toutes les solutions ci-dessus sont parfaites, mais si nous essayons d'inverser une chaîne à l'aide de la boucle for en python, cela deviendra un peu délicat, alors voici comment inverser une chaîne à l'aide de la boucle for

string ="hello,world"
for i in range(-1,-len(string)-1,-1):
    print (string[i],end=(" ")) 

J'espère que celui-ci sera utile à quelqu'un.

C'est ma façon:

def reverse_string(string):
    character_list = []
    for char in string:
        character_list.append(char)
    reversed_string = ""
    for char in reversed(character_list):
        reversed_string += char
    return reversed_string

Il existe de nombreuses façons d'inverser une chaîne, mais j'en ai également créé une autre juste pour le plaisir. Je pense que cette approche n'est pas si mauvaise.

def reverse(_str):
    list_char = list(_str) # Create a hypothetical list. because string is immutable

    for i in range(len(list_char)/2): # just t(n/2) to reverse a big string
        list_char[i], list_char[-i - 1] = list_char[-i - 1], list_char[i]

    return ''.join(list_char)

print(reverse("Ehsan"))

Cette classe utilise des fonctions magiques python pour inverser une chaîne:

class Reverse(object):
    """ Builds a reverse method using magic methods """

    def __init__(self, data):
        self.data = data
        self.index = len(data)


    def __iter__(self):
        return self

    def __next__(self):
        if self.index == 0:
            raise StopIteration

        self.index = self.index - 1
        return self.data[self.index]


REV_INSTANCE = Reverse('hello world')

iter(REV_INSTANCE)

rev_str = ''
for char in REV_INSTANCE:
    rev_str += char

print(rev_str)  

Production

dlrow olleh

Référence

Pour résoudre ce problème de manière programmée pour l'entretien

def reverse_a_string(string: str) -> str:
    """
    This method is used to reverse a string.
    Args:
        string: a string to reverse

    Returns: a reversed string
    """
    if type(string) != str:
        raise TypeError("{0} This not a string, Please provide a string!".format(type(string)))
    string_place_holder = ""
    start = 0
    end = len(string) - 1
    if end >= 1:
        while start <= end:
            string_place_holder = string_place_holder + string[end]
            end -= 1
        return string_place_holder
    else:
        return string


a = "hello world"
rev = reverse_a_string(a)
print(rev)

Production:

dlrow olleh

Avec python 3, vous pouvez inverser la chaîne sur place, ce qui signifie qu'elle ne sera pas affectée à une autre variable. Vous devez d'abord convertir la chaîne en liste, puis tirer parti de la reverse()fonction.

https://docs.python.org/3/tutorial/datastructures.html

   def main():
        my_string = ["h","e","l","l","o"]
        print(reverseString(my_string))

    def reverseString(s):
      print(s)
      s.reverse()
      return s

    if __name__ == "__main__":
        main()

C'est une fonction inverse simple et significative, facile à comprendre et à coder

def reverse_sentence(text):
    words = text.split(" ")
    reverse =""
    for word in reversed(words):
        reverse += word+ " "
    return reverse

Voici simplement:

imprimer "loremipsum" [- 1 :: - 1]

et certains logiquement:

def str_reverse_fun():
    empty_list = []
    new_str = 'loremipsum'
    index = len(new_str)
    while index:
        index = index - 1
        empty_list.append(new_str[index])
    return ''.join(empty_list)
print str_reverse_fun()

production:

muspimérol

Inverse une chaîne sans magie python.

>>> def reversest(st):
    a=len(st)-1
    for i in st:
        print(st[a],end="")
        a=a-1

Bien sûr, en Python, vous pouvez faire des trucs d'une ligne très sophistiqués. :)
Voici une solution simple et polyvalente qui pourrait fonctionner dans n'importe quel langage de programmation.

def reverse_string(phrase):
    reversed = ""
    length = len(phrase)
    for i in range(length):
        reversed += phrase[length-1-i]
    return reversed

phrase = raw_input("Provide a string: ")
print reverse_string(phrase)

s = 'hello'
ln = len(s)
i = 1
while True:
    rev = s[ln-i]
    print rev,
    i = i + 1
    if i == ln + 1 :
        break

PRODUCTION :

o l l e h

Vous pouvez utiliser la fonction inversée avec une liste exhaustive. Mais je ne comprends pas pourquoi cette méthode a été éliminée en python 3, était inutilement.

string = [ char for char in reversed(string)]