python:有没有实现substring截取子字符串的方法?


有没有一种方法可以让Python中的字符串子字符串，从第三个字符到字符串的末尾得到一个新的字符串?

也许喜欢myString[2:end]吗?

如果离开第二部分的意思是"直到结束"，如果你离开第一部分，它是从开始吗?

相关讨论

1
2
3
4
5
6
7
8
9
10
11
>>> x ="Hello World!"
>>> x[2:]
'llo World!'
>>> x[:2]
'He'
>>> x[:-2]
'Hello Worl'
>>> x[-2:]
'd!'
>>> x[2:-2]
'llo Worl'

Python将这个概念称为"切片"，它不仅可以处理字符串。这里有一个全面的介绍。

只是为了完整，因为没有人提到过。数组切片的第三个参数是一个步骤。因此，反转字符串非常简单:

1
some_string[::-1]

或者选择其他字符:

1
"H-e-l-l-o- -W-o-r-l-d"[::2] # outputs"Hello World"

在字符串中向前和向后单步执行的能力与从头到尾排列切片的能力保持一致。

相关讨论

Substr()通常(即PHP和Perl)是这样工作的:

1
s = Substr(s, beginning, LENGTH)

所以参数是beginning和LENGTH。

但是Python的行为是不同的;它期望开始和结束后各有一个(!)。初学者很难发现这一点。所以Substr(s，起始，长度)的正确替换是

1
s = s[ beginning : beginning + LENGTH]
相关讨论

实现这一点的一种常见方法是字符串切片。

MyString[a:b]给出一个从索引a到(b - 1)的子字符串。

Is there a way to substring a string in Python, to get a new string from the 3rd character to the end of the string?

Maybe like myString[2:end]?

是的，如果将名称end赋值或绑定到常量singleton None，这实际上是可行的:

1
2
3
4
>>> end = None
>>> myString = '1234567890'
>>> myString[2:end]
'34567890'

切片表示法有三个重要的参数:

开始停止一步

它们的默认值是None，但我们可以显式地传递它们:

1
2
3
4
>>> stop = step = None
>>> start = 2
>>> myString[start:stop:step]
'34567890'

If leaving the second part means 'till the end', if you leave the first part, does it start from the start?

是的,例如:

1
2
3
4
>>> start = None
>>> stop = 2
>>> myString[start:stop:step]
'12'

注意，我们在切片中包含start，但是我们只向上到stop，而不包含stop。

当步骤是None时，默认情况下切片将对该步骤使用1。如果使用一个负整数，Python足够聪明，可以从头到尾执行。

1
2
>>> myString[::-1]
'0987654321'

我在解释切片表示法问题的答案中详细解释了切片表示法。

这里似乎缺少一个示例:完整(浅)副本。

1
2
3
4
5
6
7
8
>>> x ="Hello World!"
>>> x
'Hello World!'
>>> x[:]
'Hello World!'
>>> x==x[:]
True
>>>

这是一个用于创建序列类型(而不是中间字符串)拷贝的常用习惯用法，[:]。浅复制一个列表，请参阅Python列表切片语法使用的原因并不明显。

相关讨论

除了"end"，你都写对了。它叫做切片表示法。你的例子应该是:

1
new_sub_string = myString[2:]

如果省略第二个参数，它将隐式地作为字符串的结束。

我想在讨论中补充两点:

你可以用None代替空格来指定"from the start"或"to the end":

1
'abcde'[2:None] == 'abcde'[2:] == 'cde'

这在函数中特别有用，在函数中你不能提供一个空的空格作为参数:

1
2
3
4
5
6
7
8
9
10
11
12
def substring(s, start, end):
   """Remove `start` characters from the beginning and `end`
    characters from the end of string `s`.

    Examples
    --------
    >>> substring('abcde', 0, 3)
    'abc'
    >>> substring('abcde', 1, None)
    'bcde'
   """
    return s[start:end]

Python有切片对象:

1
2
idx = slice(2, None)
'abcde'[idx] == 'abcde'[2:] == 'cde'

这很简单:

1
2
3
4
5
s = 'Hello, World!'
print(s[:]) # prints"Hello, World!"
print(s[:5]) # prints Hello
print(s[5:]) # prints , World!
print(s[3:7]) # prints"lo,"

也许我错过了，但是我不能在这一页找到原始问题的完整答案，因为变量在这里没有进一步讨论。所以我不得不继续寻找。

既然我还不能发表评论，让我在这里加上我的结论。我相信我不是唯一一个对它感兴趣的人，当访问这个页面:

1
2
3
4
5
 >>>myString = 'Hello World'
 >>>end = 5

 >>>myString[2:end]
 'llo'

如果你离开第一部分，你会得到

1
2
 >>>myString[:end]
 'Hello'

如果你把:也放在中间，你得到了最简单的子字符串，也就是第5个字符(count从0开始，所以在这个例子中是空的):

1
2
 >>>myString[end]
 ' '

如果myString包含一个从偏移量6开始，长度为9的帐号。然后您可以这样提取账号:acct = myString[6:][:9]。

如果OP接受了这一点，他们可能会尝试，以一种实验性的方式，

1
myString[2:][:999999]

它工作-没有错误被提出，没有默认的"字符串填充"发生。

相关讨论

基于@CopyPastelt答案，如果你想要基于偏移量和长度的子字符串:

1
2
def substring(s, offset=None, length=None):
    return s[offset:][:length]

使用的例子:

1
2
3
4
5
string = 'Hello Beautiful World'
substring(string) #returns 'Hello Beautiful World'
substring(string,length=5) #returns 'Hello'
substring(string,6,9) #returns 'Beautiful'
substring(string,16) #returns 'World'

使用硬编码索引本身就是一件很糟糕的事情。

为了避免这种情况，Python提供了一个内置对象slice()。

1
string ="my company has 1000$ on profit, but I lost 500$ gambling."

如果我们想知道我还剩多少钱。

正常的解决方案:

1
2
3
final = int(string[15:19]) - int(string[43:46])
print(final)
>>>500

使用切片:

1
2
3
4
5
EARNINGS = slice(15, 19)
LOSSES = slice(43, 46)
final = int(string[EARNINGS]) - int(string[LOSSES])
print(final)
>>>500

使用slice可以提高可读性。

相关讨论