reverseපයිතන්ගේ strවස්තුව සඳහා කිසිදු ක්‍රියාකාරීත්වයක් නොමැත . මෙම ක්‍රමය ක්‍රියාත්මක කිරීමේ හොඳම ක්‍රමය කුමක්ද?

ඉතා සංක්ෂිප්ත පිළිතුරක් සපයන්නේ නම්, කරුණාකර එහි කාර්යක්ෂමතාව විස්තර කරන්න. උදාහරණයක් ලෙස, strවස්තුව වෙනත් වස්තුවකට පරිවර්තනය වේද යන්න යනාදිය.

කොහොමද:

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

මෙය දිගු කරන ලද පෙති සින්ටැක්ස් ය. එය ක්‍රියාත්මක කිරීමෙන් [begin:end:step]- ආරම්භයෙන් හා අවසානයෙන් ඉවත් වී -1 පියවරක් නියම කිරීමෙන් එය නූලක් ආපසු හරවයි.

@ පාවුලෝගේ s[::-1]වේගවත්ම; මන්දගාමී ප්‍රවේශයක් (සමහර විට වඩා කියවිය හැකි නමුත් එය විවාදාත්මක ය) ''.join(reversed(s)).

නූල් සඳහා ප්‍රතිලෝම ශ්‍රිතයක් ක්‍රියාත්මක කිරීමේ හොඳම ක්‍රමය කුමක්ද?

මෙම ප්‍රශ්නය පිළිබඳ මගේ අත්දැකීම් ශාස්ත්‍රීය ය. කෙසේ වෙතත්, ඔබ ඉක්මන් පිළිතුර සොයන ගැති අයෙක් නම්, පහත දැක්වෙන පියවරක් භාවිතා කරන්න -1:

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

හෝ වඩා පහසුවෙන් කියවිය හැකිය (නමුත් ක්‍රමයේ නම සෙවීම සහ අනුකාරකයක් ලබා දෙන විට සම්බන්ධ වීම නිසා ලැයිස්තුව මන්දගාමී වේ) , str.join:

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

හෝ කියවීමේ හැකියාව සහ නැවත භාවිතා කිරීම සඳහා, පෙත්තක් ශ්‍රිතයකට දමන්න

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

ඊළගට:

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

දිගු පැහැදිලි කිරීම

ඔබ ශාස්ත්‍රීය ප්‍රදර්ශනය ගැන උනන්දුවක් දක්වන්නේ නම් කරුණාකර කියවන්න.

පයිතන්ගේ str වස්තුව තුළ ප්‍රතිලෝම ශ්‍රිතයක් නොමැත.

ඔබ දැනගත යුතු පයිතන්ගේ නූල් පිළිබඳ කරුණු කිහිපයක් මෙන්න:

1. පයිතන්හිදී, නූල් වෙනස් කළ නොහැක. නූලක් වෙනස් කිරීමෙන් නූල් වෙනස් නොවේ. එය නව එකක් නිර්මාණය කරයි.

2. නූල් පෙති කපයි. නූලක් කැපීමෙන් ඔබට නූල් එකේ එක් ස්ථානයක සිට පසුපසට හෝ ඉදිරියට, තවත් ලක්ෂ්‍යයකට, වර්ධක ලබා දෙනු ඇත. ඔවුන් දායකත්වයක පෙති අංකනය හෝ පෙති වස්තුවක් ගනී:

   string[subscript]

වරහන තුළ මහා බඩවැලක් ඇතුළත් කිරීමෙන් දායකත්වය පෙත්තක් නිර්මාණය කරයි:

    string[start:stop:step]

වරහන් වලින් පිටත පෙත්තක් සෑදීමට, ඔබට පෙති වස්තුවක් සෑදිය යුතුය:

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

කියවිය හැකි ප්‍රවේශයක්:

''.join(reversed('foo'))කියවිය හැකි වුවත් , str.joinඊට සාපේක්ෂව මන්දගාමී විය හැකි තවත් හැඳින්වෙන ශ්‍රිතයක් මත නූල් ක්‍රමයක් ඇමතීම අවශ්‍ය වේ . අපි මෙය ශ්‍රිතයකට ඇතුළත් කරමු - අපි නැවත ඒ වෙත පැමිණෙමු:

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

බොහෝ කාර්ය සාධන ප්‍රවේශය:

ප්‍රතිලෝම පෙත්තක් භාවිතා කිරීම වඩා වේගවත් ය:

'foo'[::-1]

පෙති හෝ මුල් කතුවරයාගේ අභිප්‍රාය අඩු හුරුපුරුදු කෙනෙකුට මෙය වඩාත් කියවිය හැකි සහ තේරුම් ගත හැකි වන්නේ කෙසේද? අපි දායකත්ව අංකනයෙන් පිටත පෙති වස්තුවක් සාදමු, එයට විස්තරාත්මක නමක් ලබා දී එය ග්‍රාහක අංකනය වෙත යවමු.

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

කාර්යයක් ලෙස ක්‍රියාත්මක කරන්න

මෙය ශ්‍රිතයක් ලෙස සැබවින්ම ක්‍රියාත්මක කිරීම සඳහා, විස්තරාත්මක නමක් භාවිතා කිරීමට තරම් අර්ථාන්විත ලෙස පැහැදිලි යැයි මම සිතමි:

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

භාවිතය සරලව:

reversed_string('foo')

ඔබේ ගුරුවරයාට බොහෝ විට අවශ්‍ය දේ:

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

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

මෙය න්‍යායාත්මකව නරක ය, මන්ද, මතක තබා ගන්න, නූල් වෙනස් කළ නොහැකි ය - එබැවින් ඔබ ඔබේ චරිතයක් එකතු කරන බවක් පෙනෙන සෑම අවස්ථාවකම new_stringඑය න්‍යායාත්මකව සෑම විටම නව නූලක් නිර්මාණය කරයි! කෙසේ වෙතත්, සමහර අවස්ථාවල මෙය ප්‍රශස්තිකරණය කරන්නේ කෙසේදැයි CPython දනී, මෙම සුළු කාරණය එකකි.

හොඳම පුහුණුව

න්‍යායාත්මකව වඩා හොඳ වන්නේ ඔබේ උපස්ථර ලැයිස්තුවකට එකතු කර පසුව ඒවා සමඟ සම්බන්ධ වීමයි:

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)

කෙසේ වෙතත්, අපි පහත දැක්වෙන වේලාවන්හි CPython සඳහා දකින පරිදි, මෙය සැබවින්ම වැඩි කාලයක් ගතවේ, මන්ද CPython හට නූල් සම්මුතිය ප්‍රශස්ත කළ හැකි බැවිනි.

වේලාව

මෙන්න වේලාවන්:

>>> 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 නූල් සමෝච්ඡකරණය ප්‍රශස්ත කරයි, අනෙක් ක්‍රියාත්මක කිරීම් එසේ නොවිය හැක :

... + + b හෝ a = a + b ස්වරූපයෙන් ප්‍රකාශ සඳහා සීපයිතන් විසින් ස්ථානීය නූල් සම්මුතිය කාර්යක්ෂමව ක්‍රියාත්මක කිරීම මත රඳා නොසිටින්න. මෙම ප්‍රශස්තිකරණය CPython හි පවා බිඳෙන සුළුය (එය ක්‍රියාත්මක වන්නේ සමහර වර්ග සඳහා පමණි) සහ නැවත ගණනය කිරීම් භාවිතා නොකරන ක්‍රියාත්මක කිරීම් වලදී කිසිසේත්ම නොපවතී. පුස්තකාලයේ කාර්ය සාධන සංවේදී කොටස් වලදී, ඒ වෙනුවට '' .ජොයින් () පෝරමය භාවිතා කළ යුතුය. විවිධ ක්‍රියාත්මක කිරීම් හරහා රේඛීය වේලාවට සමෝච්ඡය ඇතිවීම මෙයින් සහතික කෙරේ.

ඉක්මන් පිළිතුර (TL; DR)

උදාහරණයක්

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

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

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

සවිස්තරාත්මක පිළිතුර

පසුබිම

මෙම පිළිතුර සපයනු ලබන්නේ පහත දැක්වෙන උත්සුකතාවයන් සඳහා ය.

වොව්. පාවුලෝ යෝජනා කළ විසඳුම ගැන මා මුලින් භීතියට පත් වූ නමුත්, පළමු ප්‍රකාශය කියවීමෙන් මට දැනුණු භීතියට එය පිටුපස අසුනක් ගත්තේය: "එය ඉතා පයිතොනික් ය. හොඳ රැකියාවක්!" එවැනි දීප්තිමත් ප්‍රජාවක් මෙතරම් මූලික දෙයක් සඳහා එවැනි ගුප්ත ක්‍රම භාවිතා කිරීම හොඳ අදහසක් යැයි මම සිතමි. එය s.reverse () පමණක් නොවන්නේ ඇයි?

ගැටලුව

• සන්දර්භය
  • පයිතන් 2.x
  • පයිතන් 3.x
• සිදුවීම:
  • සංවර්ධකයාට නූලක් පරිවර්තනය කිරීමට අවශ්‍යයි
  • පරිවර්තනය යනු සියලුම අක්ෂරවල අනුපිළිවෙල ආපසු හැරවීමයි

විසඳුමක්

• example01 දීර් extended පෙති අංකනය භාවිතා කරමින් අපේක්ෂිත ප්‍රති result ලය ලබා දෙයි .

අන්තරායන්

• සංවර්ධකයා එවැනි දෙයක් බලාපොරොත්තු විය හැකිය string.reverse()
• ස්වදේශීය idiomatic (aka " pythonic ") විසඳුම නව සංවර්ධකයින්ට කියවිය නොහැක
• string.reverse()පෙති අංකනය කිරීමෙන් වැළකීම සඳහා සංවර්ධකයා තමාගේ හෝ ඇයගේ අනුවාදය ක්‍රියාත්මක කිරීමට පෙළඹවිය හැකිය .
• පෙති අංකනයෙහි ප්‍රතිදානය සමහර අවස්ථාවල ප්‍රති-බුද්ධිමත් විය හැකිය:
  • උදා: උදාහරණ 02 බලන්න
    • print 'coup_ate_grouping'[-4:] ## => 'ping'
    • සසඳන විට
    • print 'coup_ate_grouping'[-4:-1] ## => 'pin'
    • සසඳන විට
    • print 'coup_ate_grouping'[-1] ## => 'g'
  • සුචිගත කිරීමේ විවිධ ප්‍රති come ල [-1]සමහර සංවර්ධකයින් ඉවතට විසි කළ හැකිය

තාර්කිකත්වය

දැනුවත්ව සිටීමට පයිතන්ට විශේෂ තත්වයක් ඇත: නූලක් යනු නැවත ක්‍රියාත්මක කළ හැකි වර්ගයකි.

string.reverse()ක්‍රමවේදයක් බැහැර කිරීම සඳහා වන එක් තර්කයක් නම්, මෙම විශේෂ තත්වයේ බලය උත්තේජනය කිරීම සඳහා පයිතන් සංවර්ධකයින්ට දිරි දීමනා ලබා දීමයි.

සරල වචන වලින් කිවහොත්, මෙයින් අදහස් කරන්නේ වෙනත් ක්‍රමලේඛන භාෂාවල අරා මෙන්, නූලක ඇති එක් එක් අක්ෂර අනුක්‍රමික අනුපිළිවෙලක කොටසක් ලෙස පහසුවෙන් ක්‍රියාත්මක කළ හැකි බවයි.

මෙය ක්‍රියාත්මක වන ආකාරය තේරුම් ගැනීමට, example02 සමාලෝචනය කිරීමෙන් හොඳ දළ විශ්ලේෂණයක් ලබා ගත හැකිය.

උදාහරණ 02

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

නිගමනය

මෙම ප්රජානන බර පෙත්තක් අංකනය පිඹුරා ක්රියාත්මක වන ආකාරය තේරුම් සම්බන්ධ සැබවින්ම භාෂාව ඉගෙන වැඩි කාලයක් ආයෝජනය කිරීමට අපේක්ෂා නොකරන ඇතැම් ගන්නේ කාගෙන්ද සහ සංවර්ධකයන් සඳහා ඕනෑවට වඩා විය හැක.

එසේ වුවද, මූලික මූලධර්ම තේරුම් ගත් පසු, ස්ථාවර නූල් හැසිරවීමේ ක්‍රමවලට වඩා මෙම ප්‍රවේශයේ බලය තරමක් වාසිදායක විය හැකිය.

වෙනත් ආකාරයකින් සිතන අය සඳහා, ලැම්බඩා ශ්‍රිත, ඉරේටර හෝ සරල එක්-ක්‍රියා ශ්‍රිත ප්‍රකාශ වැනි විකල්ප ප්‍රවේශයන් ඇත.

අවශ්‍ය නම්, සංවර්ධකයෙකුට ඇගේම string.reverse () ක්‍රමය ක්‍රියාත්මක කළ හැකිය, කෙසේ වෙතත් පයිතන්හි මෙම අංගය පිටුපස ඇති තාර්කිකත්වය තේරුම් ගැනීම හොඳය.

මෙයද බලන්න

• විකල්ප සරල ප්‍රවේශය
• විකල්ප සරල ප්‍රවේශය
• පෙති අංකනය පිළිබඳ විකල්ප පැහැදිලි කිරීම

පවතින පිළිතුරු නිවැරදි වන්නේ යුනිකෝඩ් විකරණකාරක / ග්‍රැෆේම් පොකුරු නොසලකා හැරියහොත් පමණි. මම පසුව එය සමඟ ගනුදෙනු කරන්නෙමි, නමුත් පළමුව ආපසු හැරවීමේ ඇල්ගොරිතම වල වේගය දෙස බලන්න:

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

ලැයිස්තු අවබෝධ කර ගැනීමේ කාලය ( reversed = string[::-1]) සෑම අවස්ථාවකම අවම මට්ටමක පවතින බව ඔබට පෙනේ (මගේ යතුරු ලියනය සවි කිරීමෙන් පසුව පවා).

නූල් ආපසු හැරවීම

සාමාන්‍ය අර්ථයෙන් ඔබට නූලක් ආපසු හැරවීමට අවශ්‍ය නම්, එය වඩාත් සංකීර්ණ වේ. නිදසුනක් ලෙස, පහත දැක්වෙන නූල ගන්න ( දුඹුරු ඇඟිල්ල වමට යොමු කිරීම , කහ ඇඟිල්ල ඉහළට යොමු කිරීම ). ඒවා ග්‍රැෆීම් දෙකක්, නමුත් යුනිකෝඩ් කේත ලකුණු 3 කි. අතිරේක එක සම වෙනස් කිරීමකි .

example = "👈🏾👆"

නමුත් ඔබ ලබා දී ඇති ඕනෑම ක්‍රමයකින් එය ආපසු හරවන්නේ නම්, ඔබට දුඹුරු ඇඟිල්ල ඉහළට , කහ ඇඟිල්ල වමට යොමු වේ. එයට හේතුව නම් “දුඹුරු” වර්ණ විකරණකාරකය තවමත් මැද පිහිටා ඇති අතර එයට පෙර ඇති ඕනෑම දෙයකට යොමුවීමයි. ඉතින් අපිට තියෙනවා

• යූ: ඇඟිල්ල දිගු කිරීම
• එම්: දුඹුරු විකරණකාරකය
• එල්: ඇඟිල්ල වමට යොමු කිරීම

සහ

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

යුනිකෝඩ් ග්‍රැෆීම් පොකුරු නවීකරණ කේත ලක්ෂ්‍යවලට වඩා ටිකක් සංකීර්ණයි. වාසනාවකට මෙන්, ග්‍රැෆිම් හැසිරවීම සඳහා පුස්තකාලයක් ඇත :

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

එබැවින් නිවැරදි පිළිතුර වනු ඇත

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

එය ද මන්දගාමී වේ:

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

කේතය

#!/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. පෙති අංකනය භාවිතා කිරීම

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

2. ප්‍රතිලෝම () ශ්‍රිතය භාවිතා කිරීම

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

3. පුනරාවර්තනය භාවිතා කිරීම

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

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

එය බැලීමට අඩු ව්‍යාකූල ක්‍රමයක් වනුයේ:

string = 'happy'
print(string)

'සතුටු'

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

'යප්පා'

ඉංග්‍රීසියෙන් [-1 :: - 1] මෙසේ කියවේ:

"-1 සිට ආරම්භ කර, පියවරෙන් පියවර -1 වෙත යන්න."

ප්‍රතිලෝම () හෝ [:: - 1] භාවිතා නොකර පයිතන්හි නූලක් ආපසු හරවන්න.

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

මෙය ද සිත්ගන්නා ක්‍රමයකි:

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

හෝ ඊට සමාන:

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

.Reverse () සඳහා සහය දක්වන බයිටාරේ භාවිතා කරන තවත් 'විදේශීය' ක්‍රමයක්

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

නිෂ්පාදනය කරනු ඇත:

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

මෙය ක්‍රියාත්මක වන්නේ නූලක් හරහා ලූපයක් තබා එහි අගයන් ප්‍රතිලෝම අනුපිළිවෙලින් වෙනත් නූලකට පැවරීමෙනි.

 a=input()
 print(a[::-1])

ඉහත කේතය පරිශීලකයාගෙන් ආදානය ලබා ගන්නා අතර [:: - 1] එකතු කිරීමෙන් ආදානයේ ප්‍රතිලෝමයට සමාන ප්‍රතිදානයක් මුද්‍රණය කරයි.

නිමැවුම්:

>>> Happy 
>>> yppaH

නමුත් වාක්‍ය සම්බන්ධයෙන් ගත් විට, කේත ප්‍රතිදානය පහත බලන්න:

>>> Have a happy day
>>> yad yppah a evaH

නමුත් ඔබට අවශ්‍ය වන්නේ නූල්වල අක්ෂර පමණක් ආපසු හැරවීමට මිස නූල් අනුක්‍රමයට නොවේ නම්, මෙය උත්සාහ කරන්න:

a=input().split() #Splits the input on the basis of space (" ")
for b in a: #declares that var (b) is any value in the list (a)
    print(b[::-1], end=" ") #End declares to print the character in its quotes (" ") without a new line.

ඉහත කේතයේ 2 වන පේළියේ ** විචල්ය b යනු ලැයිස්තුවේ ඕනෑම අගයක් බව මම පැවසුවෙමි (අ) ** මම var a ලැයිස්තුවක් යැයි කීවෙමි, මන්ද ඔබ ආදානයක භේදය භාවිතා කරන විට ආදානයේ විචල්‍යය ලැයිස්තුවක් බවට පත්වේ . Int (ආදාන ()) සම්බන්ධයෙන් භේදය භාවිතා කළ නොහැකි බව මතක තබා ගන්න

නිමැවුම්:

>>> Have a happy day
>>> evaH a yppah yad

අපි ඉහත කේතයේ අවසානය ("") එකතු නොකළහොත් එය පහත පරිදි මුද්‍රණය වේ:

>>> Have a happy day
>>> evaH
>>> a
>>> yppah
>>> yad

අවසානය () තේරුම් ගැනීමට උදාහරණයක් පහත දැක්වේ:

කේතය:

for i in range(1,6):
     print(i) #Without end()

නිමැවුම්:

>>> 1
>>> 2
>>> 3
>>> 4
>>> 5

දැන් අවසානය () සමඟ කේතය කරන්න:

for i in range(1,6):
    print(i, end=" || ")

නිමැවුම්:

>>> 1 || 2 || 3 || 4 || 5 ||

මෙන්න විසිතුරු එකක් නොවේ:

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

මෙන්න නැති එකක් [::-1]හෝ reversed(ඉගෙනුම් අරමුණු සඳහා):

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

ඔබට +=නූල් සංයුක්ත කිරීමට භාවිතා කළ හැකි නමුත් join()වේගවත් වේ.

පුනරාවර්තන ක්‍රමය:

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

උදාහරණයක්:

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

ඉහත විසඳුම් සියල්ලම පරිපූර්ණ නමුත් අපි පයිතන් හි ලූප් සඳහා නූලක් ආපසු හැරවීමට උත්සාහ කරන්නේ නම් එය ටිකක් උපක්‍රමශීලී වනු ඇත, එබැවින් මෙහි දැක්වෙන්නේ අපට ලූප් සඳහා නූලක් ආපසු හැරවිය හැකි ආකාරයයි

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

මෙය යමෙකුට ප්‍රයෝජනවත් වනු ඇතැයි මම බලාපොරොත්තු වෙමි.

මගේ මාර්ගය එයයි:

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

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

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

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

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)  

ප්‍රතිදානය

dlrow olleh

යොමුව

සම්මුඛ පරීක්ෂණ සඳහා ක්‍රමලේඛන ආකාරයෙන් මෙය විසඳීම

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)

ප්‍රතිදානය:

dlrow olleh

පයිතන් 3 සමඟින් ඔබට වෙනත් ස්ථානයකට නූල ආපසු හැරවිය හැකිය. පළමුවෙන්ම ඔබට නූල ලැයිස්තුවක් බවට පරිවර්තනය කර reverse()ශ්‍රිතය උත්තේජනය කළ යුතුය.

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

මෙය සරල හා අර්ථවත් ප්‍රතිලෝම ශ්‍රිතයකි, තේරුම් ගැනීමට පහසු සහ කේත කරන්න

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

මෙන්න සරලවම:

"loremipsum" මුද්‍රණය කරන්න [- 1 :: - 1]

සහ සමහරක් තර්කානුකූලව:

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

ප්‍රතිදානය:

muspimerol

පයිතන් මැජික් නොමැතිව නූලක් ආපසු හරවන්න.

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

ෂුවර්, පයිතන්හි ඔබට ඉතා විසිතුරු 1-පේළි දේවල් කළ හැකිය. :)
ඕනෑම ක්‍රමලේඛන භාෂාවකින් ක්‍රියා කළ හැකි සරල, සියලු වටකුරු විසඳුමක් මෙන්න.

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

නිමැවුම්:

o l l e h

ලැයිස්තු සංසන්දනාත්මකව ඔබට ආපසු හරවන ලද ශ්‍රිතය භාවිතා කළ හැකිය. නමුත් මෙම ක්‍රමය පයිතන් 3 හි ඉවත් කළේ ඇයිදැයි මට නොතේරේ.

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