Non esiste una reversefunzione integrata per l' stroggetto di Python . Qual è il modo migliore di implementare questo metodo?

Se fornisci una risposta molto concisa, ti preghiamo di approfondire la sua efficienza. Ad esempio, se l' stroggetto viene convertito in un oggetto diverso, ecc.

Che ne dite di:

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

Questa è sintassi della sezione estesa . Funziona facendo [begin:end:step]: lasciando l'inizio e la fine e specificando un passaggio di -1, inverte una stringa.

@ Paolo's s[::-1]è il più veloce; è un approccio più lento (forse più leggibile, ma è discutibile) ''.join(reversed(s)).

Qual è il modo migliore di implementare una funzione inversa per le stringhe?

La mia esperienza con questa domanda è accademica. Tuttavia, se sei un professionista alla ricerca della risposta rapida, usa una sezione che passi da -1:

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

o più facilmente (ma più lentamente a causa delle ricerche dei nomi dei metodi e del fatto che il join forma un elenco quando viene assegnato un iteratore) str.join:

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

o per leggibilità e riusabilità, inserire la sezione in una funzione

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

e poi:

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

Spiegazione più lunga

Se sei interessato all'esposizione accademica, continua a leggere.

Non esiste alcuna funzione inversa incorporata nell'oggetto str di Python.

Ecco un paio di cose sulle stringhe di Python che dovresti sapere:

1. In Python, le stringhe sono immutabili . La modifica di una stringa non modifica la stringa. Ne crea uno nuovo.

2. Le stringhe sono affettabili. Affettare una stringa ti dà una nuova stringa da un punto della stringa, avanti o indietro, a un altro punto, con incrementi dati. Prendono la notazione delle sezioni o un oggetto delle sezioni in un pedice:

   string[subscript]

Il pedice crea una sezione includendo i due punti tra parentesi graffe:

    string[start:stop:step]

Per creare una sezione al di fuori delle parentesi graffe, è necessario creare un oggetto sezione:

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

Un approccio leggibile:

Sebbene ''.join(reversed('foo'))sia leggibile, richiede la chiamata di un metodo stringa str.join, su un'altra funzione chiamata, che può essere piuttosto lento. Mettiamolo in una funzione - torneremo ad esso:

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

Approccio più performante:

Molto più veloce sta usando una porzione inversa:

'foo'[::-1]

Ma come possiamo renderlo più leggibile e comprensibile a qualcuno che non ha familiarità con le sezioni o l'intento dell'autore originale? Creiamo un oggetto slice al di fuori della notazione dei pedici, assegniamo un nome descrittivo e passiamo alla notazione dei pedici.

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

Implementare come funzione

Per implementarlo effettivamente come una funzione, penso che sia semanticamente abbastanza chiaro da usare semplicemente un nome descrittivo:

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

E l'uso è semplicemente:

reversed_string('foo')

Ciò che il tuo insegnante probabilmente vuole:

Se hai un istruttore, probabilmente vogliono che tu inizi con una stringa vuota e costruisca una nuova stringa da quella precedente. Puoi farlo con pura sintassi e valori letterali usando un ciclo 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

Questo è teoricamente negativo perché, ricorda, le stringhe sono immutabili - quindi ogni volta che sembra che tu stia aggiungendo un carattere al tuo new_string, teoricamente crea sempre una nuova stringa! Tuttavia, CPython sa come ottimizzare questo in alcuni casi, di cui questo caso banale è uno.

La migliore pratica

Teoricamente è meglio raccogliere le sottostringhe in un elenco e unirle in un secondo momento:

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)

Tuttavia, come vedremo nei tempi seguenti per CPython, questo in realtà richiede più tempo, poiché CPython può ottimizzare la concatenazione di stringhe.

Tempi

Ecco i tempi:

>>> 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 ottimizza la concatenazione di stringhe, mentre altre implementazioni potrebbero non :

... non fare affidamento sull'implementazione efficiente di CPython della concatenazione di stringhe sul posto per le istruzioni nella forma a + = b o a = a + b. Questa ottimizzazione è fragile anche in CPython (funziona solo per alcuni tipi) e non è presente affatto nelle implementazioni che non usano il conteggio. In parti della libreria sensibili alle prestazioni, è invece necessario utilizzare il modulo '' .join (). Ciò garantirà che la concatenazione si verifichi in tempo lineare attraverso varie implementazioni.

Risposta rapida (TL; DR)

Esempio

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

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

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

Risposta dettagliata

sfondo

Questa risposta viene fornita per rispondere alla seguente preoccupazione di @odigity:

Wow. All'inizio ero inorridito dalla soluzione proposta da Paolo, ma questo ha fatto un passo indietro rispetto all'orrore che ho provato leggendo il primo commento: "È molto pitonico. Ottimo lavoro!" Sono così turbato che una comunità così brillante pensa di usare metodi così criptici per qualcosa di così basilare è una buona idea. Perché non è solo s.reverse ()?

Problema

• Contesto
  • Python 2.x
  • Python 3.x
• Scenario:
  • Lo sviluppatore vuole trasformare una stringa
  • La trasformazione è di invertire l'ordine di tutti i personaggi

Soluzione

• esempio01 produce il risultato desiderato, usando la notazione di sezione estesa .

insidie

• Lo sviluppatore potrebbe aspettarsi qualcosa di simile string.reverse()
• L' idioma nativo (alias " pitonico ") potrebbe non essere leggibile per gli sviluppatori più recenti
• Lo sviluppatore può essere tentato di implementare la propria versione di string.reverse() per evitare la notazione delle sezioni.
• L'output della notazione di sezioni può essere contro-intuitivo in alcuni casi:
  • vedi ad esempio esempio02
    • print 'coup_ate_grouping'[-4:] ## => 'ping'
    • rispetto a
    • print 'coup_ate_grouping'[-4:-1] ## => 'pin'
    • rispetto a
    • print 'coup_ate_grouping'[-1] ## => 'g'
  • i diversi risultati dell'indicizzazione [-1]possono far cadere alcuni sviluppatori

Fondamento logico

Python ha una circostanza speciale da tenere presente: una stringa è iterabile tipo .

Una motivazione per escludere a string.reverse() metodo è quello di dare agli sviluppatori di Python l'incentivo a sfruttare il potere di questa circostanza speciale.

In termini semplificati, ciò significa semplicemente che ogni singolo carattere in una stringa può essere facilmente utilizzato come parte di una disposizione sequenziale di elementi, proprio come le matrici in altri linguaggi di programmazione.

Per capire come funziona, la revisione di esempio02 può fornire una buona panoramica.

Example02

### 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'

Conclusione

Il carico cognitivo associato alla comprensione di come funziona la notazione delle sezioni in Python potrebbe effettivamente essere troppo per alcuni adottanti e sviluppatori che non desiderano investire molto tempo nell'apprendimento della lingua.

Tuttavia, una volta compresi i principi di base, il potere di questo approccio rispetto ai metodi di manipolazione di stringhe fisse può essere abbastanza favorevole.

Per coloro che la pensano diversamente, esistono approcci alternativi, come funzioni lambda, iteratori o semplici dichiarazioni di funzioni una tantum.

Se lo si desidera, uno sviluppatore può implementare il proprio metodo string.reverse (), tuttavia è bene comprendere la logica alla base di questo aspetto di Python.

Guarda anche

• approccio semplice alternativo
• approccio semplice alternativo
• spiegazione alternativa della notazione delle sezioni

Le risposte esistenti sono corrette solo se i modificatori Unicode / i cluster grapheme vengono ignorati. Ci penserò più avanti, ma prima diamo un'occhiata alla velocità di alcuni algoritmi di inversione:

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

Potete vedere che il tempo per la comprensione dell'elenco ( reversed = string[::-1]) è in ogni caso di gran lunga il più basso (anche dopo aver corretto il mio errore di battitura).

Inversione di stringa

Se vuoi davvero invertire una stringa nel senso comune, è MODO più complicato. Ad esempio, prendi la seguente stringa ( dito marrone che punta a sinistra , dito giallo che punta in alto ). Questi sono due grafemi, ma 3 punti di codice unicode. Quello aggiuntivo è un modificatore di skin .

example = "👈🏾👆"

Ma se lo inverti con uno dei metodi indicati, ottieni il dito marrone rivolto verso l'alto , il dito giallo che punta a sinistra . La ragione di ciò è che il modificatore di colore "marrone" è ancora nel mezzo e viene applicato a tutto ciò che lo precede. Quindi abbiamo

• U: dito rivolto verso l'alto
• M: modificatore marrone
• L: dito puntato a sinistra

e

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

I cluster Unicode Grapheme sono un po 'più complicati dei semplici punti di codice modificatore. Fortunatamente, esiste una libreria per la gestione dei grafemi :

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

e quindi la risposta corretta sarebbe

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

che è anche di gran lunga il più lento:

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

Il codice

#!/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. usando la notazione delle sezioni

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

2. utilizzando la funzione inversa ()

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

3. utilizzo della ricorsione

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

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

Un modo meno imbarazzante di vederlo sarebbe:

string = 'happy'
print(string)

'contento'

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

'Yppah'

In inglese [-1 :: - 1] si legge come:

"A partire da -1, vai fino in fondo, facendo i passi di -1"

Invertire una stringa in Python senza usare reversed () o [:: - 1]

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

Questo è anche un modo interessante:

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

o simili:

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

Un altro modo più "esotico" che usa byterarray che supporta .reverse ()

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

produrrà:

'!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"

Funziona eseguendo il looping di una stringa e assegnandone i valori in ordine inverso a un'altra stringa.

Eccone uno di fantasia:

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!")

Eccone uno senza [::-1]o reversed(a fini di apprendimento):

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")

puoi usare +=per concatenare le stringhe ma join()è più veloce.

Metodo ricorsivo:

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

esempio:

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

Tutte le soluzioni di cui sopra sono perfette ma se stiamo cercando di invertire una stringa usando for loop in python diventerà un po 'complicato, quindi ecco come possiamo invertire una stringa usando for loop

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

Spero che questo sia utile per qualcuno.

Questo è il mio modo:

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

Esistono molti modi per invertire una stringa, ma ne ho anche creata un'altra solo per divertimento. Penso che questo approccio non sia poi così male.

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"))

Questa classe utilizza le funzioni magiche di Python per invertire una stringa:

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)  

Produzione

dlrow olleh

Riferimento

Per risolvere questo problema in modo programmatico per l'intervista

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)

Produzione:

dlrow olleh

Con python 3 puoi invertire la stringa sul posto, il che significa che non verrà assegnata a un'altra variabile. Per prima cosa devi convertire la stringa in un elenco e quindi sfruttare la reverse()funzione.

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()

Questa è una funzione inversa semplice e significativa, facile da capire e codificare

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

Ecco semplicemente:

stampa "loremipsum" [- 1 :: - 1]

e alcuni logicamente:

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()

produzione:

muspimerol

Invertire una stringa senza magia pitone.

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

Certo, in Python puoi fare cose molto fantasiose a 1 riga. :)
Ecco una soluzione semplice e versatile che potrebbe funzionare in qualsiasi linguaggio di programmazione.

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

PRODUZIONE :

o l l e h

È possibile utilizzare la funzione invertita con un elenco comprensivo. Ma non capisco perché questo metodo sia stato eliminato in Python 3, non è stato necessario.

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