From the docs:

str.split([sep[, maxsplit]])

Return a list of the words in the string, using sep as the delimiter string. If maxsplit is given, at most maxsplit splits are done (thus, the list will have at most maxsplit+1 elements).

s.split('mango', 1)[1]

I would favor using the re module for this because the expression for splitting on multiple arbitrary characters is very simple:

r'[,*;/]'

The brackets create a character class that matches anything inside of them. The code is like this:

import re

results = re.split(r'[,*;/]', my_string, maxsplit=1)

The maxsplit argument makes it so that the split only occurs once.

If you are doing the same split many times, you can compile the regex and search on that same expression a little bit faster (but see Jon Clements' comment below):

c = re.compile(r'[,*;/]')
results = c.split(my_string)

If this speed up is important (it probably isn't) you can use the compiled version in a function instead of having it re compile every time. Then make a separate function that stores the actual compiled expression:

def split_chars(chars, maxsplit=0, flags=0, string=None):
    # see note about the + symbol below
    c = re.compile('[{}]+'.format(''.join(chars)), flags=flags)
    def f(string, maxsplit=maxsplit):
        return c.split(string, maxsplit=maxsplit)
    return f if string is None else f(string)

Then:

special_split = split_chars(',*;/', maxsplit=1)
result = special_split(my_string)

But also:

result = split_chars(',*;/', my_string, maxsplit=1)

The purpose of the + character is to treat multiple delimiters as one if that is desired (thank you Jon Clements). If this is not desired, you can just use re.compile('[{}]'.format(''.join(chars))) above. Note that with maxsplit=1, this will not have any effect.

Finally: have a look at this talk for a quick introduction to regular expressions in Python, and this one for a much more information packed journey.

Using re.search:

import re

strs = ["71 1 * abwhf", "8 askg", "*14 snbsb", "00ab"]


def split_on_letter(s):
    match = re.compile("[^\W\d]").search(s)
    return [s[:match.start()], s[match.start():]]


for s in strs:
    print split_on_letter(s)

The regex [^\W\d] matches all alphabetical characters.

\W matches all non-alphanumeric characters and \d matches all numeric characters. ^ at the beginning of the set inverts the selection to match everything that is not (non-alphanumeric or numeric), which corresponds to all letters.

match searches the string to find the index of the first occurrence of the matching expression. You can slice the original string based on the location of the match to get two lists.

str.split takes a maxsplit argument, pass 1 to only split on the first -:

print components[i].rstrip().split('-',1)

To store the output in two variables:

In [7]: s = "console-3.45.1-0"

In [8]: a,b = s.split("-",1)

In [9]: a
Out[9]: 'console'

In [10]: b
Out[10]: '3.45.1-0'

This is what str.partition is for:

>>> 'jvm.args= -Dappdynamics.com=true, -Dsomeotherparam=false,'.partition('=')
('jvm.args', '=', ' -Dappdynamics.com=true, -Dsomeotherparam=false,')

From the docs:

str.partition(sep)

Split the string at the first occurrence of sep, and return a 3-tuple containing the part before the separator, the separator itself, and the part after the separator. If the separator is not found, return a 3-tuple containing the string itself, followed by two empty strings.

New in version 2.5.