පයිතන් හි පහත සඳහන් දෑ කරන්නේ කෙසේද?

array = [0, 10, 20, 40]
for (i = array.length() - 1; i >= 0; i--)

මට අරාවෙහි මූලද්රව්ය තිබිය යුතුය, නමුත් අවසානයේ සිට ආරම්භය දක්වා.

මේ සඳහා ඔබට reversedශ්‍රිතය භාවිතා කළ හැකිය :

>>> array=[0,10,20,40]
>>> for i in reversed(array):
...     print(i)

reversed(...)ලැයිස්තුවක් ආපසු නොදෙන සටහන . භාවිතයෙන් ඔබට ප්‍රතිලෝම ලැයිස්තුවක් ලබා ගත හැකිය list(reversed(array)).

>>> L = [0,10,20,40]
>>> L[::-1]
[40, 20, 10, 0]

විස්තාරණය කරන ලද පෙති සින්ටැක්ස් මුදා හැරීම සඳහා පයිතන් වට්ස් හි නව ප්‍රවේශය තුළ හොඳින් විස්තර කර ඇත2.3.5

විවරණයක ඇති විශේෂ ඉල්ලීම අනුව මෙය වඩාත් වර්තමාන පෙති ලේඛනයයි .

>>> L = [0,10,20,40]
>>> L.reverse()
>>> L
[40, 20, 10, 0]

හෝ

>>> L[::-1]
[40, 20, 10, 0]

මෙය ලැයිස්තුව අනුපිටපත් කිරීම සඳහා ය:

L = [0,10,20,40]
p = L[::-1]  #  Here p will be having reversed list

මෙය තැනින් තැන ලැයිස්තුව ආපසු හැරවීමයි:

L.reverse() # Here L will be reversed in-place (no new list made)

පයිතන් හි ලැයිස්තුවක් ආපසු හැරවීමට හොඳම ක්‍රමය මෙය යැයි මම සිතමි.

a = [1,2,3,4]
a = a[::-1]
print(a)
>>> [4,3,2,1]

කාර්යය අවසන් කර ඇති අතර දැන් ඔබට ප්‍රතිලෝම ලැයිස්තුවක් ඇත.

පෙති කැපීම භාවිතා කිරීම, උදා: array = array [:: - 1], ඉතා පිළිවෙලට හා ඉතා පයිතොනික්, නමුත් සමහර විට නවකයින් සඳහා ටිකක් අපැහැදිලි විය හැකිය. ප්‍රතිලෝම () ක්‍රමය භාවිතා කිරීම එදිනෙදා කේතීකරණයට යාමට හොඳ ක්‍රමයක් වන්නේ එය පහසුවෙන් කියවිය හැකි බැවිනි.

කෙසේ වෙතත්, සම්මුඛ පරීක්ෂණ ප්‍රශ්නයක දී මෙන් ඔබට ලැයිස්තුවක් ආපසු හැරවීමට අවශ්‍ය නම්, ඔබට මෙවැනි ක්‍රම වලින් සාදන ලද ඒවා භාවිතා කිරීමට නොහැකි වනු ඇත. සම්මුඛ පරීක්‍ෂකවරයා ඔබ පයිතන් දැනුමේ ගැඹුරට වඩා ගැටලුවට ප්‍රවේශ වන්නේ කෙසේදැයි සොයා බලනු ඇත, ඇල්ගොරිතම ප්‍රවේශයක් අවශ්‍ය වේ. පහත උදාහරණය, ​​සම්භාව්‍ය හුවමාරුවක් භාවිතා කිරීම, එය කිරීමට එක් ක්‍රමයක් විය හැකිය: -

def reverse_in_place(lst):      # Declare a function
    size = len(lst)             # Get the length of the sequence
    hiindex = size - 1
    its = size/2                # Number of iterations required
    for i in xrange(0, its):    # i is the low index pointer
        temp = lst[hiindex]     # Perform a classic swap
        lst[hiindex] = lst[i]
        lst[i] = temp
        hiindex -= 1            # Decrement the high index pointer
    print "Done!"

# Now test it!!
array = [2, 5, 8, 9, 12, 19, 25, 27, 32, 60, 65, 1, 7, 24, 124, 654]

print array                    # Print the original sequence
reverse_in_place(array)        # Call the function passing the list
print array                    # Print reversed list


**The result:**
[2, 5, 8, 9, 12, 19, 25, 27, 32, 60, 65, 1, 7, 24, 124, 654]
Done!
[654, 124, 24, 7, 1, 65, 60, 32, 27, 25, 19, 12, 9, 8, 5, 2]

මෙය ටුපල්ස් හෝ නූල් අනුපිළිවෙලෙහි ක්‍රියා නොකරනු ඇති බව සලකන්න, මන්ද නූල් සහ ටුපල් වෙනස් කළ නොහැකි බැවින් මූලද්‍රව්‍ය වෙනස් කිරීමට ඔබට ඒවා ලිවිය නොහැක.

එකම ලැයිස්තුව ආපසු හැරවීම සඳහා:

array.reverse()

ආපසු හැරවූ ලැයිස්තුව වෙනත් ලැයිස්තුවකට පැවරීමට:

newArray = array[::-1] 

l.reverse()පයිතන් 3 සහ 2 හි දීර් list ලැයිස්තුවක් ආපසු හැරවිය හැකි වේගවත්ම ක්‍රමය එය බව මම සොයා ගතිමි (වෙනත් යෝජනා වලට පටහැනිව) .

l[::-1]එය ආපසු හැරවීමට පෙර ලැයිස්තුව පිටපත් කරන නිසා එය මන්දගාමී වේ. පෙන්වු list()විසින් ඉදිරිපත් කරන ලද iterator පමණ ඇමතුමක් reversed(l)සමහර පොදු කාර්ය එකතු විය යුතුයි. ඇත්ත වශයෙන්ම ඔබට ලැයිස්තුවේ පිටපතක් හෝ අනුකාරකයක් අවශ්‍ය නම් එම ක්‍රම භාවිතා කරන්න, නමුත් ඔබට ලැයිස්තුව ආපසු හැරවීමට අවශ්‍ය නම් l.reverse()වේගවත්ම ක්‍රමය ලෙස පෙනේ.

කාර්යයන්

def rev_list1(l):
    return l[::-1]

def rev_list2(l):
    return list(reversed(l))

def rev_list3(l):
    l.reverse()
    return l

ලැයිස්තුව

l = list(range(1000000))

පයිතන් 3.5 වේලාවන්

timeit(lambda: rev_list1(l), number=1000)
# 6.48
timeit(lambda: rev_list2(l), number=1000)
# 7.13
timeit(lambda: rev_list3(l), number=1000)
# 0.44

පයිතන් 2.7 වේලාව

timeit(lambda: rev_list1(l), number=1000)
# 6.76
timeit(lambda: rev_list2(l), number=1000)
# 9.18
timeit(lambda: rev_list3(l), number=1000)
# 0.46

for x in array[::-1]:
    do stuff

සමඟ reversed සහ list:

>>> list1 = [1,2,3]
>>> reversed_list = list(reversed(list1))
>>> reversed_list
>>> [3, 2, 1]

array=[0,10,20,40]
for e in reversed(array):
  print e

පැහැදිලි කිරීම සහ කාල ප්‍රති .ල සහිත ක්‍රමවල සාරාංශය

හොඳ පිළිතුරු කිහිපයක් ඇත, නමුත් පැතිරී ඇති අතර බොහෝ ඒවා එක් එක් ප්‍රවේශයේ මූලික වෙනස්කම් දක්වන්නේ නැත.

සමස්තයක් ලෙස, ඕනෑම ශ්‍රිතයක් මෙන්, ආපසු හැරවීම සඳහා සාදන ලද ශ්‍රිත / ක්‍රම භාවිතා කිරීම වඩා හොඳය. මෙම අවස්ථාවෙහිදී, ඒවා කෙටි ලැයිස්තු (අයිතම 10) මත දළ වශයෙන් 2 සිට 8 ගුණයක් වේගවත් වන අතර, අතින් සාදන ලද සුචිගත කිරීමේ මාධ්‍යයක් සමඟ සසඳන විට දිගු ලැයිස්තු වල ~ 300 + ගුණයක් වේගවත් වේ. විශේෂ experts යන් ඒවා නිර්මාණය කිරීම, සෝදිසි කිරීම සහ ප්‍රශස්තකරණය කිරීම නිසා මෙය අර්ථවත් කරයි. ඔවුන් අඩුපාඩු වලට ගොදුරු වීමේ අවදානම අඩු වන අතර දාර සහ කෙළවරේ සිදුවීම් හැසිරවීමට වැඩි ඉඩක් ඇත.

ඔබට අවශ්‍ය දැයි සලකා බලන්න:

1. පවතින ලැයිස්තුවක් ආපසු හරවන්න
   • හොඳම විසඳුම object.reverse()ක්‍රමයයි
2. ලැයිස්තුවේ පිටුපස පැත්තෙහි අනුකාරකයක් සාදන්න (ඔබ එය ලූපයක්, උත්පාදක යන්ත්‍රයක් ආදිය සඳහා පෝෂණය කිරීමට යන නිසා)
   • හොඳම විසඳුම වන්නේ reversed(object)අනුකාරකය නිර්මාණය කිරීමයි
3. හෝ ප්‍රතිලෝම අනුපිළිවෙලට ඇති සම්පූර්ණ පිටපතක් සාදන්න
   • හොඳම විසඳුම වන්නේ පියවර -1 ක ප්‍රමාණයක් සහිත පෙති භාවිතා කිරීමයි: object[::-1]

පරීක්ෂණ පිටපත

ආවරණය කරන ලද ක්‍රම සඳහා මගේ පරීක්ෂණ පිටපතෙහි ආරම්භය මෙන්න. මෙම පිළිතුරේ ඇති සියලුම කේත ස්නිපෙට් එකට දමා ලැයිස්තුවක් ආපසු හැරවීමේ විවිධ ක්‍රම ක්‍රියාත්මක කරන ස්ක්‍රිප්ට් එකක් සහ වේලාව එක් එක් කාලය (අවසාන කොටසේ ප්‍රතිදානය).

from timeit import timeit
from copy import copy

def time_str_ms(t):
    return '{0:8.2f} ms'.format(t * 1000)

ක්රමය 1: obj.reverse () සමඟ ප්රතිවිකුණුම් කරන්න

ඉලක්කය හුදෙක් පවත්නා ලැයිස්තුවක ඇති අයිතමවල අනුපිළිවෙල ආපසු හැරවීම නම්, ඒවා ලිහිල් නොකර හෝ වැඩ කිරීමට පිටපතක් ලබා නොගෙන, භාවිතා කරන්න <list>.reverse() ශ්‍රිතය . ලැයිස්තු වස්තුවක් මත මෙය කෙලින්ම ධාවනය කරන්න, එවිට සියලු අයිතමවල අනුපිළිවෙල ආපසු හරවනු ලැබේ:

පහත දැක්වෙන්නේ ආපසු හරවන ලද ලැයිස්තුව ආපසු ලබා දුන්නද, ලබා දී ඇති මුල් විචල්‍යය ආපසු හරවන බවයි. එනම් ඔබට මෙම ශ්‍රිත ප්‍රතිදානය භාවිතා කර පිටපතක් සෑදිය හැකිය. සාමාන්‍යයෙන්, ඔබ මේ සඳහා ශ්‍රිතයක් නොකරනු ඇත, නමුත් අවසානයේ දී කාල කේතය භාවිතා කිරීමට මම එසේ කළෙමි.

අපි මෙම ක්‍රම දෙකෙහි ක්‍රියාකාරිත්වය පරීක්ෂා කර බලමු - පළමුව තැනින් තැන ලැයිස්තුවක් ආපසු හරවන්න (මුල් ලැයිස්තුව වෙනස් කරන්න), ඉන්පසු ලැයිස්තුව පිටපත් කර පසුව ආපසු හරවන්න.

def rev_in_place(mylist):
    mylist.reverse()
    return mylist

def rev_copy_reverse(mylist):
    a = copy(mylist)
    a.reverse()
    return a

ක්රමය 2: පෙති භාවිතයෙන් ලැයිස්තුවක් ආපසු හරවන්න obj[::-1]

සාදන ලද දර්ශක පෙති කපන ක්‍රමය මඟින් ඕනෑම සුචිගත කරන ලද වස්තුවක කොටසක පිටපතක් සෑදීමට ඔබට ඉඩ සලසයි.

• එය මුල් වස්තුවට බලපාන්නේ නැත
• එය සම්පූර්ණ ලැයිස්තුවක් සාදයි, අනුකාරකයක් නොවේ

සාමාන්‍ය වාක්‍ය ඛණ්ඩය : <object>[first_index:last_index:step]. සරල ප්‍රතිලෝම ලැයිස්තුවක් නිර්මාණය කිරීම සඳහා පෙති කැපීම සූරාකෑමට, භාවිතා කරන්න : <list>[::-1]. විකල්පයක් හිස්ව තබන විට, එය ඒවා වස්තුවේ පළමු හා අවසාන මූලද්‍රව්‍යයේ පෙරනිමි ලෙස සකසයි (පියවරේ ප්‍රමාණය .ණ නම් ආපසු හරවනු ලැබේ).

සුචිගත කිරීම මඟින් කෙනෙකුට negative ණ සංඛ්‍යා භාවිතා කිරීමට ඉඩ ලබා දේ, එය වස්තුවේ දර්ශකයේ අවසානයේ සිට පසුපසට ගණන් කරයි (එනම් -2 යනු අවසාන අයිතමයේ දෙවැන්නයි). පියවර ප්‍රමාණය negative ණ වන විට, එය අවසාන අයිතමය සමඟ ආරම්භ වන අතර එම ප්‍රමාණයෙන් දර්ශකය පසුපසට යනු ඇත. මේ සමඟ සම්බන්ධිත ආරම්භක තර්කනයක් ප්‍රශස්තිකරණය කර ඇත.

def rev_slice(mylist):
    a = mylist[::-1]
    return a

ක්රමය 3: reversed(obj)iterator ශ්‍රිතය සමඟ ලැයිස්තුවක් ආපසු හරවන්න

ඒ නිසා එය reversed(indexed_object)ක්රියාව:

• මෙය ප්‍රතිලෝම දර්ශක අනුකාරකයක් නිර්මාණය කරයි, ලැයිස්තුවක් නොවේ. විශාල ලැයිස්තු වල වඩා හොඳ ක්‍රියාකාරිත්වය සඳහා ඔබ එය ලූපයකට පෝෂණය කරන්නේ නම් නියමයි
• මෙය පිටපතක් නිර්මාණය කරන අතර මුල් වස්තුවට බලපාන්නේ නැත

අමු අනුකාරකයක් සමඟ පරීක්ෂා කරන්න, සහ අනුකාරකයෙන් ලැයිස්තුවක් සාදන්න.

def reversed_iterator(mylist):
    a = reversed(mylist)
    return a

def reversed_with_list(mylist):
    a = list(reversed(mylist))
    return a

ක්රමය 4: අභිරුචි / අත්පොත සුචිගත කිරීම සමඟ ප්රතිලෝම ලැයිස්තුව

වේලාව පෙන්වන පරිදි, ඔබේම සුචිගත කිරීමේ ක්‍රම නිර්මාණය කිරීම නරක අදහසකි. ඔබට සැබවින්ම අභිරුචි යමක් කිරීමට අවශ්‍ය නම් මිස, සාදන ලද ක්‍රම භාවිතා කරන්න.

එයින් කියැවෙන්නේ කුඩා ලැයිස්තු ප්‍රමාණ සහිත විශාල ද penalty ුවමක් නොමැති නමුත් ඔබ පරිමාණය වැඩි කළ විට ද penalty ුවම අති විශාල වන බවයි. පහත දැක්වෙන මගේ කේතය ප්‍රශස්තිකරණය කළ හැකි බව මට විශ්වාසයි, නමුත් මම සාදන ලද ක්‍රම සමඟ බැඳී සිටිමි.

def rev_manual_pos_gen(mylist):
    max_index = len(mylist) - 1
    return [ mylist[max_index - index] for index in range(len(mylist)) ]

def rev_manual_neg_gen(mylist):
    ## index is 0 to 9, but we need -1 to -10
    return [ mylist[-index-1] for index in range(len(mylist)) ]

def rev_manual_index_loop(mylist):
    a = []
    reverse_index = len(mylist) - 1
    for index in range(len(mylist)):
        a.append(mylist[reverse_index - index])
    return a

def rev_manual_loop(mylist):
    a = []
    reverse_index = len(mylist)
    for index, _ in enumerate(mylist):
        reverse_index -= 1
        a.append(mylist[reverse_index])
    return a

එක් එක් ක්රමය වේලාව

ආපසු හැරවීමේ සෑම ක්‍රමයක්ම වරින් වර ඉතිරි පිටපත පහත දැක්වේ. එය ප්‍රතිවර්තනය obj.reverse()හා තැනීම පෙන්වයිreversed(obj) ප්‍රතිනිර්මාණය සෑදීම සැමවිටම වේගවත් වන අතර පෙති භාවිතා කිරීම පිටපතක් නිර්මාණය කිරීමේ වේගවත්ම ක්‍රමයයි.

ඔබට එය කළ යුතු නම් මිස එය තනිවම කිරීමට ක්‍රමයක් නිර්මාණය නොකිරීමටද එය ඔප්පු කරයි!

loops_to_test = 100000
number_of_items = 10
list_to_reverse = list(range(number_of_items))
if number_of_items < 15:
    print("a: {}".format(list_to_reverse))
print('Loops: {:,}'.format(loops_to_test))
# List of the functions we want to test with the timer, in print order
fcns = [rev_in_place, reversed_iterator, rev_slice, rev_copy_reverse,
        reversed_with_list, rev_manual_pos_gen, rev_manual_neg_gen,
        rev_manual_index_loop, rev_manual_loop]
max_name_string = max([ len(fcn.__name__) for fcn in fcns ])
for fcn in fcns:
    a = copy(list_to_reverse) # copy to start fresh each loop
    out_str = ' | out = {}'.format(fcn(a)) if number_of_items < 15 else ''
    # Time in ms for the given # of loops on this fcn
    time_str = time_str_ms(timeit(lambda: fcn(a), number=loops_to_test))
    # Get the output string for this function
    fcn_str = '{}(a):'.format(fcn.__name__)
    # Add the correct string length to accommodate the maximum fcn name
    format_str = '{{fx:{}s}} {{time}}{{rev}}'.format(max_name_string + 4)
    print(format_str.format(fx=fcn_str, time=time_str, rev=out_str))

කාල ප්‍රති .ල

ප්‍රති task ල වලින් පෙනී යන්නේ යම් කාර්යයක් සඳහා වඩාත් සුදුසු බිල්ට් ක්‍රම සමඟ පරිමාණය වඩාත් හොඳින් ක්‍රියාත්මක වන බවයි. වෙනත් වචන වලින් කිවහොත්, වස්තු මූලද්‍රව්‍ය ගණන වැඩි වන විට, සාදන ලද ක්‍රමවලට වඩා ඉහළ කාර්ය සාධන ප්‍රති .ල ලැබීමට පටන් ගනී.

දේවල් එකට ගැටීමට වඩා ඔබට අවශ්‍ය දේ කෙලින්ම සාක්ෂාත් කරගත හැකි හොඳම බිල්ට් ක්‍රමය භාවිතා කිරීම වඩා හොඳය. ඔබට ආපසු හරවන ලද ලැයිස්තුවේ පිටපතක් අවශ්‍ය නම් පෙති කැපීම වඩාත් සුදුසුය - එය ශ්‍රිතයෙන් ලැයිස්තුවක් reversed()සෑදීමට වඩා වේගවත් වන අතර ලැයිස්තුවේ පිටපතක් සාදා තැන තැනට වඩා වේගවත් වේobj.reverse() . නමුත් එම ක්‍රමවලින් එකක් ඔබට සැබවින්ම අවශ්‍ය නම් ඒවා වේගවත් නමුත් කිසි විටෙකත් වේගයට වඩා දෙගුණයකින් වැඩි නොවේ. මේ අතර - අභිරුචි, අතින් ක්‍රමවේදයන්ට විශාල ප්‍රමාණයේ ඇණවුම් ගත හැකිය, විශේෂයෙන් ඉතා විශාල ලැයිස්තු සමඟ.

පරිමාණය සඳහා, අයිතම 1000 ක ලැයිස්තුවක් සමඟ, reversed(<list>)ක්‍රියාකාරී ඇමතුම නැවත සැකසීමට ms 30 ms ගත වේ, ස්ථානය ආපසු හැරවීමට ms 55 ms ගත වේ, පෙති ක්‍රමය භාවිතා කර සම්පූර්ණ ප්‍රතිලෝම ලැයිස්තුවේ පිටපතක් සෑදීමට ~ 210 ms ගත වේ, නමුත් මම සෑදූ වේගවත්ම අත්පොත ක්‍රමය ඩොලර් 8400 ක් විය !!

ලැයිස්තුවේ අයිතම 2 ක් සමඟ:

a: [0, 1]
Loops: 100,000
rev_in_place(a):             24.70 ms | out = [1, 0]
reversed_iterator(a):        30.48 ms | out = <list_reverseiterator object at 0x0000020242580408>
rev_slice(a):                31.65 ms | out = [1, 0]
rev_copy_reverse(a):         63.42 ms | out = [1, 0]
reversed_with_list(a):       48.65 ms | out = [1, 0]
rev_manual_pos_gen(a):       98.94 ms | out = [1, 0]
rev_manual_neg_gen(a):       88.11 ms | out = [1, 0]
rev_manual_index_loop(a):    87.23 ms | out = [1, 0]
rev_manual_loop(a):          79.24 ms | out = [1, 0]

ලැයිස්තුවේ අයිතම 10 ක් සමඟ:

rev_in_place(a):             23.39 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
reversed_iterator(a):        30.23 ms | out = <list_reverseiterator object at 0x00000290A3CB0388>
rev_slice(a):                36.01 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_copy_reverse(a):         64.67 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
reversed_with_list(a):       50.77 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_pos_gen(a):      162.83 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_neg_gen(a):      167.43 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_index_loop(a):   152.04 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_loop(a):         183.01 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

ලැයිස්තුවේ අයිතම 1000 ක් සමඟ:

rev_in_place(a):             56.37 ms
reversed_iterator(a):        30.47 ms
rev_slice(a):               211.42 ms
rev_copy_reverse(a):        295.74 ms
reversed_with_list(a):      418.45 ms
rev_manual_pos_gen(a):     8410.01 ms
rev_manual_neg_gen(a):    11054.84 ms
rev_manual_index_loop(a): 10543.11 ms
rev_manual_loop(a):       15472.66 ms

ආපසු හැරවූ (අරාව) භාවිතා කිරීම හොඳම මාර්ගය වනු ඇත.

>>> array = [1,2,3,4]
>>> for item in reversed(array):
>>>     print item

ඔබ ඉදි භාවිතයෙන් තොරව මෙය ක්රියාත්මක කිරීම හැක්කේ කෙසේද? යන්න වටහා ගැනීම අවශ්ය reversed.

def reverse(a):
    midpoint = len(a)/2
    for item in a[:midpoint]:
        otherside = (len(a) - a.index(item)) - 1
        temp = a[otherside]
        a[otherside] = a[a.index(item)]
        a[a.index(item)] = temp
    return a

මේ සඳහා O (N) කාලය ගත යුතුය.

ඔබ සමහර වෙනත් විචල්ය දී ආපස්සට ලැයිස්තුව මූලද්රව්ය ගබඩා කිරීමට අවශ්ය නම්, ඔබ භාවිතා කළ හැකිය revArray = array[::-1]හෝ revArray = list(reversed(array)).

නමුත් පළමු ප්‍රභේදය තරමක් වේගවත් ය:

z = range(1000000)
startTimeTic = time.time()
y = z[::-1]
print("Time: %s s" % (time.time() - startTimeTic))

f = range(1000000)
startTimeTic = time.time()
g = list(reversed(f))
print("Time: %s s" % (time.time() - startTimeTic))

ප්‍රතිදානය:

Time: 0.00489711761475 s
Time: 0.00609302520752 s

සංවිධානාත්මක වටිනාකම්:

පයිතන් හි, ලැයිස්තු අනුපිළිවෙල ද හැසිරවිය හැකිය වර්ග කිරීම ඔබේ විචල්‍යයන් සංඛ්‍යාත්මක / අකාරාදී පිළිවෙලට සංවිධානය කරයි:

තාවකාලිකව:

print(sorted(my_list))

ස්ථිර:

my_list.sort(), print(my_list)

ඔබට "ප්‍රතිලෝම = සත්‍ය" ධජය සමඟ වර්ග කළ හැකිය :

print(sorted(my_list, reverse=True))

හෝ

my_list.sort(reverse=True), print(my_list)

සංවිධානය කිරීමකින් තොරව

සමහර විට ඔබට අගයන් වර්ග කිරීමට අවශ්‍ය නොවනු ඇත, නමුත් අගයන් ආපසු හැරවීම පමණි. එවිට අපට එය මේ ආකාරයෙන් කළ හැකිය:

print(list(reversed(my_list)))

** ලැයිස්තු අනුපිළිවෙලට අක්ෂරවලට වඩා අංකවලට ප්‍රමුඛතාවයක් ඇත. පයිතන් සාරධර්ම සංවිධානය නියමයි.

යම් තර්කනයක් භාවිතා කිරීම

සම්මුඛ පරීක්ෂණ සඳහා පුහුණුවීම සඳහා පැරණි පාසල් තර්කනයක් භාවිතා කිරීම.

ඉදිරිපස සිට පසුපසට අංක මාරු කිරීම. දර්ශක දෙකක් භාවිතා කිරීමindex[0] and index[last]

def reverse(array):
    n = array
    first = 0
    last = len(array) - 1
    while first < last:
      holder = n[first]
      n[first] = n[last]
      n[last] = holder
      first += 1
      last -= 1
    return n

input -> [-1 ,1, 2, 3, 4, 5, 6]
output -> [6, 1, 2, 3, 4, 5, -1]

ප්‍රතිලෝමව අරාව හරහා ගමන් කිරීමට ඔබට අරාව දර්ශකයේ බිට්වයිස් අනුපූරකය භාවිතා කළ හැකිය :

>>> array = [0, 10, 20, 40]
>>> [array[~i] for i, _ in enumerate(array)]
[40, 20, 10, 0]

ඔබ කුමක් කළත්, මේ ආකාරයෙන් එය නොකරන්න.

ලැයිස්තු අවබෝධය භාවිතා කරන්න:

[array[n] for n in range(len(array)-1, -1, -1)]

තවත් විසඳුමක් භාවිතා කිරීමට වනු ඇත numpy.flip මේ සඳහා

import numpy as np
array = [0, 10, 20, 40]
list(np.flip(array))
[40, 20, 10, 0]

නිශ්චිතවම කිවහොත්, ප්‍රශ්නය වන්නේ ලැයිස්තුවක් ආපසු හරවා යැවීම නොව උදාහරණ ලැයිස්තු නාමයක් සහිත ලැයිස්තුවක් ආපසු හරවා ගන්නේ කෙසේද යන්නයි array .

"array"භාවිතය නම් ලැයිස්තුවක් ආපසු හැරවීමට array.reverse().

විස්තර කර ඇති පරිදි ඇදහිය නොහැකි තරම් ප්‍රයෝජනවත් පෙති ක්‍රමය මඟින් ලැයිස්තුවක් ආපසු හැරවීමට භාවිතා කළ හැකිය array = array[::-1].

def reverse(text):
    output = []
    for i in range(len(text)-1, -1, -1):
        output.append(text[i])
    return output

සම්මුඛ පරීක්ෂණ සැකසුම් යැයි උපකල්පනය කරමින් අවම වශයෙන් ගොඩනංවන ලද කාර්යයන් සමඟ

array = [1, 2, 3, 4, 5, 6,7, 8]
inverse = [] #create container for inverse array
length = len(array)  #to iterate later, returns 8 
counter = length - 1  #because the 8th element is on position 7 (as python starts from 0)

for i in range(length): 
   inverse.append(array[counter])
   counter -= 1
print(inverse)

භාවිත

print(reversed(list_name))

ආපසු හැරවූ ලැයිස්තුව ලබා ගැනීමට ක්‍රම 3 ක් ඇත:

1. පෙති කැපීමේ ක්‍රමය 1: reversed_array = array[-1::-1]

2. පෙති කැපීමේ ක්‍රමය 2: reversed_array2 = array[::-1]

3. බිල්ඩින් ශ්‍රිතය භාවිතා කිරීම: reversed_array = array.reverse()

තෙවන ශ්‍රිතය ඇත්ත වශයෙන්ම ලැයිස්තුගත වස්තුව ප්‍රතිස්ථාපනය කළේය. ඒ කියන්නේ නියම දත්තවල පිටපතක් පවත්වාගෙන යන්නේ නැහැ. පැරණි අනුවාදය පවත්වා ගැනීමට ඔබට අවශ්‍ය නැතිනම් මෙය හොඳ ප්‍රවේශයකි. නමුත් ඔබට පැරණි හා ප්‍රතිලෝම අනුවාදය අවශ්‍ය නම් විසඳුමක් ලෙස නොපෙනේ.

ඔබේ අවශ්‍යතාව පයිතන් වෙත වඩාත් සෘජුවම පරිවර්තනය කිරීම මෙම forප්‍රකාශයයි:

for i in xrange(len(array) - 1, -1, -1):
   print i, array[i]

මෙය තරමක් ගුප්ත නමුත් ප්‍රයෝජනවත් විය හැකිය.

def reverse(my_list):
  L = len(my_list)
  for i in range(L/2):
    my_list[i], my_list[L-i - 1] = my_list[L-i-1], my_list[i]
  return my_list

ඔබට සෑම විටම ලැයිස්තුවේ පිටුපස කෙළවරේ සිට මූලද්‍රව්‍ය ඉහළට ඔසවා තැබීම වැනි ලැයිස්තුවක් ලෙස සැලකිය හැකිය. එමඟින් ඔබ තොගයක අවසාන ලක්ෂණ වලින් පළමුව ප්‍රයෝජන ගන්න. ඇත්ත වශයෙන්ම ඔබ 1 වන අරාව පරිභෝජනය කරයි. මම මෙම ක්‍රමයට කැමතියි එය ඉතා බුද්ධිමත් බැවින් එක් ලැයිස්තුවක් පිටුපස කෙළවරේ සිට පරිභෝජනය කරන අතර අනෙක් අන්තය ඉදිරිපස කෙළවරේ සිට ඉදිකරනු ලැබේ.

>>> l = [1,2,3,4,5,6]; nl=[]
>>> while l:
        nl.append(l.pop())  
>>> print nl
[6, 5, 4, 3, 2, 1]

list_data = [1,2,3,4,5]
l = len(list_data)
i=l+1
rev_data = []
while l>0:
  j=i-l
  l-=1
  rev_data.append(list_data[-j])
print "After Rev:- %s" %rev_data 

>>> l = [1, 2, 3, 4, 5]
>>> print(reduce(lambda acc, x: [x] + acc, l, []))
[5, 4, 3, 2, 1]

ප්‍රතිවිරුද්ධ දර්ශකවල යොමු මාරු කිරීමෙන් තැනින් තැන ආපසු හැරවීම:

>>> l = [1,2,3,4,5,6,7]    
>>> for i in range(len(l)//2):
...     l[i], l[-1-i] = l[-1-i], l[i]
...
>>> l
[7, 6, 5, 4, 3, 2, 1]