【问题标题】:Understanding string reversal via slicing通过切片了解字符串反转
【发布时间】:2010-10-20 10:48:47
【问题描述】:

我一直在寻找一种向后打印字符串的方法,在google上快速搜索后,我找到了这个方法:

假设a 是一个字符串变量。这将向后返回 a 字符串:

a[::-1]

谁能解释一下它是如何工作的?

【问题讨论】:

标签: python string slice


【解决方案1】:

前两个边界默认为 0 和序列的长度,和以前一样,-1 的步幅表示切片应该从右到左而不是通常的从左到右。因此,效果是颠倒顺序。

name="ravi"
print(name[::-1]) #ivar

【讨论】:

    【解决方案2】:

    您可以使用 reversed() 函数。 例如

    x = "abcd"
    for i in reversed(x):
            print(i, end="")
    print("\n")
    L = [1,2,3]
    for i in reversed(L):
            print(i, end="")
    

    打印dcba321

    【讨论】:

      【解决方案3】:

      使用扩展切片语法

      word = input ("Type a word which you want to reverse: ")
      def reverse(word):
        word = word[::-1]
        return word
      print (reverse(word))
      

      【讨论】:

        【解决方案4】:

        不使用 reversed 或 [::-1],这是一个基于递归的简单版本,我认为是最易读的:

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

        【讨论】:

          【解决方案5】:

          这是基本的步进符号,请考虑以下功能:

          一个[2:4:2]

          索引在位置 2 和 4 之间被分割,第三个变量的作用是从第一个值开始设置步长。在这种情况下,它将返回 a[2],因为 a[4] 是一个上限,因此只返回两个值,并且不进行第二步。 (-) 减号运算符只是反转步骤输出。

          【讨论】:

            【解决方案6】:

            当然,[::]extended slice 运算符。它允许您获取子字符串。基本上,它通过将您想要的元素指定为 [begin:end:step] 来工作,并且它适用于所有序列。关于它的两件事:

            • 您可以省略一个或多个元素,它会做“正确的事情”
            • begin、end 和 step 的负数有意义

            对于begin和end,如果你给一个负数,表示从序列的末尾开始计数。例如,如果我有一个列表:

            l = [1,2,3]
            

            那么l[-1]是3,l[-2]是2,l[-3]是1。

            对于step 参数,负数表示通过序列向后工作。所以对于一个列表::

            l = [1,2,3,4,5,6,7,8,9,10]
            

            你可以写l[::-1] 这基本上意味着在阅读列表时使用 -1 的步长。 Python 在填写 start 和 stop 时会“做正确的事”,因此它会向后遍历列表并为您提供[10,9,8,7,6,5,4,3,2,1]

            我已经给出了带有列表的示例,但字符串只是另一个序列并且以相同的方式工作。所以a[::-1] 的意思是通过加入你通过向后遍历字符串获得的字符来构建一个字符串。

            【讨论】:

            • “正确的事情”在使用负步幅/步幅时可能会有些混乱。 Example here.
            【解决方案7】:

            这是extended slice notation

            sequence[start:end:step]
            

            在这种情况下,步骤 -1 表示向后,省略开头和结尾表示您想要整个字符串。

            【讨论】:

              【解决方案8】:

              我们可以使用 append 和 pop 来做到这一点

              def rev(s):
                  i = list(s)
                  o = list()
                  while len(i) > 0:
                      o.append(t.pop())
              
                  return ''.join(o)
              

              【讨论】:

              • 当 OP 明确想知道为什么 a[::-1] 有效时,您为什么要建议一种替代方法来反转字符串?
              • 这不是相关答案,请重新阅读问题。
              【解决方案9】:

              考虑下面的列表

              l=[12,23,345,456,67,7,945,467]
              

              另一个反转列表的技巧可能是:

              l[len(l):-len(l)-1:-1] [467, 945, 7, 67, 456, 345, 23, 12]
              
              l[:-len(l)-1:-1] [467, 945, 7, 67, 456, 345, 23, 12]
              
              l[len(l)::-1] [467, 945, 7, 67, 456, 345, 23, 12]
              

              【讨论】:

                【解决方案10】:

                我会这样做:

                variable = "string"
                message = ""
                for b in variable:
                    message = b+message
                print (message)
                

                它会打印:gnirts

                【讨论】:

                  【解决方案11】:

                  我认为以下对于反向打印字符串更有意义,但也许这只是我:

                  for char in reversed( myString ):  
                    print( char, end = "" )
                  

                  【讨论】:

                  • 这是 python 3 在每次打印结束时不换行的方式。在 python 2.x 中,你可以只写 print(char, )
                  • 当然,这会打印出字符串;它不会创建一个将旧字符串反转的新字符串(但是,''.join(reversed(myString)) 会这样做)。
                  • 确实如此。但是,OP 只要求“打印”。因此是“打印”解决方案。
                  • 你总是可以这样做:''.join(reversed(myString0)) 来获取字符串。
                  【解决方案12】:

                  字符串本质上是一个字符序列,因此切片操作对其进行。你所做的其实是:

                  -> 从头到尾以 1 的步长向后获取 'a' 的切片。

                  【讨论】:

                    【解决方案13】:

                    [::-1] 给出字符串 a 的切片。完整的语法是a[begin:end:step] 它给出了 a[begin], a[begin+step], ... a[end-1]。当 step 为负数时,您从 end 开始并移动到 begin。

                    最后,begin 默认为序列的开头,end 到结尾,step 到-1。

                    【讨论】:

                      【解决方案14】:

                      它使用扩展切片——字符串在 Python 中是一个序列,并与其他序列(即列表和元组)共享一些方法。切片分为三个部分 - 开始、停止和步进。它们都有默认值 - start 默认为 0,stop 默认为 len(sequence),step 默认为 1。通过指定 [::-1] 你是说“序列 a 中的所有元素,从头开始, 直到最后一次倒退。

                      此功能是在 Python 2.3.5 中引入的,您可以在What's New docs 中阅读更多内容。

                      【讨论】:

                        【解决方案15】:

                        “-1”部分表示切片的“步长”部分——在这种情况下,它一次遍历字符串 1 个字符,但向后(负步长表示从字符串末尾开始)。例如,如果您将 step 指定为 2,您将获得字符串的所有其他字符,从第一个字符开始。如果您指定的步长为 -2,那么您将获取字符串的所有其他字符,从最后一个字符开始并向后工作。

                        所以,简而言之,如果a = '12345'

                        • a[::2] 变为 135
                        • a[::-1] 变为 54321
                        • a[::-2] 变为 531

                        【讨论】:

                          【解决方案16】:

                          它在 Python 中称为 Slice Notation,您可以在这里阅读更多关于它的工作原理:

                          Explain Python's slice notation

                          【讨论】:

                            猜你喜欢
                            • 2014-01-30
                            • 2017-03-08
                            • 2015-08-15
                            • 2019-05-08
                            • 2017-11-07
                            • 2020-11-27
                            • 2018-09-15
                            • 2021-03-02
                            • 2020-03-26
                            相关资源
                            最近更新 更多