Geek asks and answers

Creating a reverse method for a python list from scratch

I want to create a reverse method for a list. I know that such a method already exists in python, but I want to try it from scratch. Here is what I have, and it seems to me useful, but it just returns the list in the same order. I understand that lists are mutable, and I can simply reassign the values ​​in a loop.

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
+4
source share
12 answers

You change the list that you iterate over it (data_list) because it does not work, try like this:

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
+4
source 
def reverse(data_list):
    return data_list[::-1]

>> reverse ([1,2,3,4,5])
[5, 4, 3, 2, 1]
+14
source

, , ; , .

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

:

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]
+5

python ( ) [] , ( ):

x = [1, 2 ,3, 4, 5]
newx = []
for i in range(1, len(x)+1):
  newx.append(x[-i])
  print x[-i]

:

def reverse(list)
  newlist = []
  for i in range(1, len(list)+1):
    newlist.append(list[-1])
  return newlist
+3

, . , , . , :

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

, , , "" .

+1
word_reversed = ''

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

, (), (word_reversed).

, , , .reverse word [:: - 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")
+1

- :

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
0

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:

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
0

"" ? , :

reverse_list([a, b, c, d, e]) => [e, d, c, b, a]

, 0 -> n, 1 -> (n - 1), 2 -> (n - 2). , ...

def reverse_list(list):
    i = 0
    while i < (len(list) - 1):
        list.insert(i, list.pop())
        i += 1
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)
0

reversed() , [::-1] . , , .

import queue


s = "abc"
lst = list(s)
iter_ = iter(s)

, reversed():

def reversed_iter(iterable):
    """Yield items in reverse with a queue."""
    stack = queue.LifoQueue()                          # 1
    for x in iterable:                                 # 2
        stack.put(x)
    while not stack.empty():                           # 3
        yield stack.get()


list(reversed_iter(s))
# ['c', 'b', 'a']
list(reversed_iter(lst))
# ['c', 'b', 'a']
list(reversed_iter(iter_))
# ['c', 'b', 'a']

- , . .

       ↓   ↑
    |   "c"   |
    |   "b"   |
    |   "a"   |
    -----------

( ) ( ), , "c".

:

  1. ( , LifoQueue)

The result is the elements obtained in the reverse order.

queuenot required. Alternatively, we can emulate the stack with a simple one list:

def reversed_iter(iterable):
    """Yield items in reverse with a list."""
    stack = []
    for x in iterable:
        stack.append(x)
    while stack:
        yield stack.pop()


list(reversed_iter(s))
# ['c', 'b', 'a']

Emulating an abstract data type is all that is needed in both examples.

0
source 
list = [23, 3, 33, 44, 55, 16, 27 ];

1. more codes

def conver(list):
    list.sort()

    length = len(list)
    s = length

    new_list = [None]*length
    for item in list:
        s = s - 1
        new_list[s] = item

    print(new_list)


conver(list)

output:

[55, 44, 33, 27, 23, 16, 3]

2.easiest

list.sort()

list.reverse()

print(list)

output:

[55, 44, 33, 27, 23, 16, 3]
0
source

More articles:


All Articles