la création d'une méthode inverse pour une liste python à partir de zéro

Je veux créer une méthode inverse pour une liste. Je sais qu'il y a déjà une méthode de ce type construit en python, mais je veux l'essayer à partir de zéro. Voici ce que j'ai et il semble avoir du sens pour moi, mais elle retourne la liste dans le même ordre. Ma compréhension est que les listes sont mutables et je pouvais juste réaffecter les valeurs dans la boucle.

def reverse(data_list):
    length = len(data_list)
    s = length

    for item in data_list:
        s = s - 1
        data_list[s] = item
    return data_list

OriginalL'auteur | 2011-03-09

4

Vous êtes à la modification de la liste que vous itérer sur elle (data_list) parce qu'il ne fonctionne pas , essayez comme ceci:
```
def reverse(data_list):
    length = len(data_list)
    s = length

    new_list = [None]*length

    for item in data_list:
        s = s - 1
        new_list[s] = item
    return new_list
```
Merci! Qui ne fonctionne pas mais ma question est: qu'est-ce que [None]*longueur? Pourquoi ne pas travailler si je fais new_list égale à []?
[None]*length permettra de créer une liste de ce genre [None, None ...] longueur de temps, et de new_list = [] ne fonctionnera pas parce que ce créer une liste d'élément 0 de sorte lorsque vous essayez de faire new_lits[1] = .. il donnera un indice d'erreur car il n'y a pas d'indice 1 dans la liste, essentiellement new_lits[1] = .. modifier la valeur de l'indice de l'un avec la nouvelle valeur, il n'ajoutez pas. espérons que ce sens 🙂
Ce n'est pas faute de "parce que vous êtes la modification de la liste que vous itérer sur"; c'est seulement un problème si vous ajoutez ou supprimez des éléments de la liste. C'est défaillante car chaque swap fonctionne sur deux lieux (ce de l'élément et de sa jumelle) donc, le temps que vous traitez l'ensemble de la liste, vous avez opéré sur chaque élément deux fois - en échange, puis échange de revenir en arrière. De sorte que chaque élément se termine là où il a commencé.

OriginalL'auteur mouad

def reverse(data_list):
    return data_list[::-1]

>> inverse([1,2,3,4,5]) 
[5, 4, 3, 2, 1]

Hourra pour le python!

OriginalL'auteur BlueRaja - Danny Pflughoeft

Par le temps que vous êtes à mi-chemin par le biais de la liste, vous avez échangé tous les éléments; comme vous continuez à travers la seconde moitié, vous échangez-les à leur emplacement d'origine à nouveau.

Au lieu d'essayer

def reverse(lst):
    i = 0            # first item
    j = len(lst)-1   # last item
    while i<j:
        lst[i],lst[j] = lst[j],lst[i]
        i += 1
        j -= 1
    return lst

Cela peut être utilisé de deux façons:

a = [1,2,3,4,5]
reverse(a)        # in-place
print a           # -> [5,4,3,2,1]

b = reverse(a[:]) # return the result of reversing a copy of a
print a           # -> [5,4,3,2,1]
print b           # -> [1,2,3,4,5]

OriginalL'auteur Hugh Bothwell

3

un moyen facile en python (sans l'aide de la fonction reverse) est à l'aide de [] l'opérateur d'accès avec des valeurs négatives telles que (impression et de créer une nouvelle liste dans l'ordre inverse):
```
x = [1, 2 ,3, 4, 5]
newx = []
for i in range(1, len(x)+1):
  newx.append(x[-i])
  print x[-i]
```
la fonction serait:
```
def reverse(list)
  newlist = []
  for i in range(1, len(list)+1):
    newlist.append(list[-1])
  return newlist
```
OriginalL'auteur tiagoboldt
1

Je n'obtiens pas la même liste lorsque j'essaie d'exécuter votre code. Mais j'ai aussi ne pas l'inversion de la liste parce que la liste est de passer à travers la liste de l'état qui est en train de changer à partir de l'extrémité arrière. Je pense que la façon dont vous êtes à la recherche de le faire est:
```
def reverse(data_set):
  length = len(data_set)

  for i in range(0, length / 2):
    length = length - 1
    hold = data_set[i]
    data_set[i] = data_set[length]
    data_set[length] = hold
  return data_set
```
ici, nous avons fait marche arrière dans la moitié de la itérations et nous memoize la valeur de l'indice, nous sommes en train de changer ainsi, nous pouvons définir le "renversement" de la même étape.

OriginalL'auteur Gabriel

word_reversed = ''

    for i in range(len(word) -1, -1, -1):
        word_reversed += word[i]

Qui va inverser une chaîne de caractères de longueur inconnue appelée (word) et de l'appeler (word_reversed).

Je suis à l'aide de vérifier pour voir si un mot est un palindrome et je ne suis pas autorisé à l'utiliser .inverse ou le mot[::-1].

# Tyler G
# April 10, 2018
# Palindromes

import re

word = input("Palindromes are words that spell the same thing forwars or backwards, enter a word and see if its one!: ")
word = word.lower()
word = re.sub("[^a-zA-Z]+", "", word)
# count the number of characters in the string
# make a if <string>[0] = <string[counted char -1]
# repeat that over and over
# make a else print("not a ...")
word_reversed = ''

for i in range(len(word) - 1, -1, -1):
    word_reversed += word[i]

itis = 0
if len(word) > 12:
    print("It is not a Palindrome")

else:
    for i in range(0, len(word)):
        if word[i] == word_reversed[i]:
            itis = itis + 1
        else:
            itis = itis - len(word)
    if itis > 0:
        print("It is a palindrome")
    else:
        print("It is NOT a Palindrome")

itis = 0
if len(word) > 12:
    print("It is not a Palindrome")

OriginalL'auteur Tyler G

Quelque chose comme cela devrait fonctionner:

mylist = [1,2,3,4,5]
def reverse(orig_list):
    data_list = orig_list[:]
    length = len(data_list)
    for i in xrange(0, length/2):
        tmp = data_list[length-i-1]
        data_list[length-i-1] = data_list[i]
        data_list[i] = tmp
    return data_list

reverse(mylist)
mylist

OriginalL'auteur Dolan Antenucci

Il y a deux façons de le faire

Pythonic Swap:

def Reverse_Function(item):
    for i in range(len(item)/2):
        item[i], item[-(i+1)] = item[-(i+1)], item[i]
    return item

XOR application:

def Reverse_Function(item):
    for i in range(len(item)/2):
        item[i] = item[i] ^ item[-(i+1)]
        item[-(i+1)] = item[i] ^ item[-(i+1)]
        item[i] = item[i] ^ item[-(i+1)]
    return item

OriginalL'auteur Gagan

0
```
from array import *

x=array('i',[1,2,3,98,5,6,7,8])

y=array('i',[])

for i in x:

     y.insert(0,i)

print(y)
```
Pouvez-vous expliquer pourquoi ce code résout la question?
Lorsque vous fournir une réponse sous la forme d'un fragment de code, vous aussi, idéalement, devrait expliquer dans le texte (ou au moins dans les commentaires dans le code) comment le fragment de code résout les OPs problème. Aussi, il peut être vaut la peine d'expliquer pourquoi votre fragment de code utilise entier tableaux où, comme l'OP demande une solution pour une liste générale. Il est probable que votre pour la boucle serait travailler pour une liste générale - mais il n'est pas clair pourquoi vous avez fait le choix que vous avez fait.

OriginalL'auteur prakx
-1

Ne cherche pas à créer une nouvelle liste de tenir votre "temp" de données?
Sa simple si vous regardez le schéma:
```
reverse_list([a, b, c, d, e]) => [e, d, c, b, a]
```
Cela signifie que la position 0 -> n, 1 -> (n - 1), 2 -> (n - 2). Ce qui signifie que vous pouvez apparaître le dernier élément et de le mettre dans l'index en cours...
```
def reverse_list(list):
    i = 0
    while i < (len(list) - 1):
        list.insert(i, list.pop())
        i += 1
```
Votre réponse doit être une réponse, mais, votre post commence par se poser une question. Si vous êtes à la fourniture d'une solution, proposer une explication pour votre réponse. Si vous avez une question, post que comme un commentaire en dessous de la question d'origine.

OriginalL'auteur kanarelo

Vous devez vous connecter pour publier un commentaire.