If you are worried about using split from the left because of lots of unwanted characters in the beginning, use rsplit.

s = "abcdef,12"
s.rsplit(",", 1)[-1]

Here, rsplit will start splitting the string from the right and the optional second argument we used will stop rsplit to proceed further than the first comma operator it encountered.

(eg):
s = "abc,def,12"
s.rsplit(",", 1)[-1]
# Outputs 12
s = "abcdef12"
s.rsplit(",", 1)[-1]
# Outputs abcdef12

This will be lot simpler and cleaner to get the string of numbers in the end rather than doing anything manually.

Not to mention, it will be lot easier if we wish to check whether we get only numbers with this. Even if it is a list of strings.

def get_numbers(string_list, skip_on_error=True):
    numbers_list = []
    for input_string in string_list:
        the_number = input_string.rsplit(",", 1)[-1]
        if the_number.isdigit():
            numbers_list.append(the_number)
        elif skip_on_error:
            numbers_list.append("")
        else:
            raise Exception("Wrong Format occurred: %s" % (input_string))
    return numbers_list

And if you are looking for even further optimization and sure that most(if not all) strings will be of the correct format, you can even use try except if you are going to go with an integer list instead of string list. Like this:

# Instead of the if.. elif.. else construct
try:
    numbers_list.append(int(the_number))
except ValueError:
    if skip_on_error:
        numbers_list.append(0)
    else:
        raise Exception("Wrong Format occurred: %s" % (input_string))

But always remember the Zen Of Python and using split/rsplit follows these:

1. Beautiful is better than ugly
2. Explicit is better than implicit
3. Simple is better than complex
4. Readability counts
5. There should be one-- and preferably only one --obvious way to do it

And also remember Donald Knuth:

We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil. Yet we should not pass up our opportunities in that critical 3%

Kind of broad, pulling from a text file, but will do for many applications of getting both integers and floats out of strings.

The file, commaseperated.txt has a row looking like this:

Input: (0, 1, 2.4), 1, 5, 8, 99.7, 0.1), (, )()!@!#, 9

    import re


    # a function to pull the numbers from many lists of strings
    def func(a, z, c):
        # -- Read .txt -- #
        filename = 'commaseperated.txt'
        f1 = open(filename, 'r')  # open the file for reading
        data = f1.readlines()  # read the entire file as a list of strings
        f1.close()
        #
        for line in data:
            cells = line.strip().split(',')
            # empty string
            b = ""
            # range through cells of from a text file split by commas
            for i in range(a, len(cells[z:c])+a):
                # no commas in the cells so make dummy commas for new string
                b += cells[i] + ','
            # find all the numbers
            z = re.findall(r'\d+(?:\.\d+)?', b)
            # return a list of floated values from the text string
            return [float(z[s]) for s in range(len(z))]

    Output: [0, 1, 2.4, 1, 5, 8, 99.7, 0.1, 9]

In complement to cs95's answer, since str.extract only captures what is inside capturing groups, a lookbehind is not needed.

It's possible to use directly q(\d+):

df['AmountPaid'] = (df['Product'].str.extract(r'q(\d+)', expand=False)
                                 .fillna(0).astype(int)
                    )

Output:

    Product AmountPaid
0      none          0
1        q1          1
2      q123        123
3  q12_a123         12

This is not just shorter in terms of syntax but also more efficient:

• regex demo with lookbehind
• regex demo without lookbehind

You can use regex:

>>> import re
>>> re.findall('[0-9]+', 'CORSAIR VENGEANCE RGB 16GB (2X8GB) DDR4 3200MHZ CL 16')
['16', '2', '8', '4', '3200', '16']

If you only want to extract only positive integers, try the following:

>>> txt = "h3110 23 cat 444.4 rabbit 11 2 dog"
>>> [int(s) for s in txt.split() if s.isdigit()]
[23, 11, 2]

I would argue that this is better than the regex example because you don't need another module and it's more readable because you don't need to parse (and learn) the regex mini-language.

This will not recognize floats, negative integers, or integers in hexadecimal format. If you can't accept these limitations, jmnas's answer below will do the trick.

\d{0,3} matches from zero upto three digits. $ asserts that we are at the end of a line.

re.search(r'/\d{0,3}$', st).group()

Example:

>>> re.search(r'/\d{0,3}$', 'Titile Something/17').group()
'/17'
>>> re.search(r'/\d{0,3}$', 'Titile Something/1').group()
'/1'