Regex will do

import re

strings = '''
Hi my name is hazza 50 test test test

Hi hazza 60 test test test

hazza 50 test test test

hazza test test test
'''

for s in re.findall('([a-zA-Z ]*)\d*.*',strings):
    print(s)

Gives

Hi my name is hazza 

Hi hazza 

hazza 

hazza test test test

You may use a simple (\d+)M regex (1+ digit(s) followed with M where the digits are captured into a capture group) with re.findall.

See IDEONE demo:

import re
s = "107S33M15H\n33M100S\n12M100H33M"
print(re.findall(r"(\d+)M", s))

And here is a regex demo

Regular expressions to the rescue!

I see you are already on the right path, by using a regular expression. But you could try using a regular expression with a capture in order to capture the digits following the string "Episode".

Here is a small example to get you going:

import re
m = re.search('Episode (\d+)', 'series[Episode 37]-03th_July_2010-YouTube', re.IGNORECASE)
m.group(1)

The last statement, m.group(1), returns the contents of the first group (what's inside the parentheses in the regular expression). In this case it will be the string '37', which is the digits that follows the string "Episode ".

Also notice I'm using the IGNORECASE flag, so this will work regardless of the casing of the string "Episode". So "episode" and even "ePISODE" will work too.

Use one expression for all of them:

\b[A-Z]?\d[/\d]*\b(?:\s+days)?

See a demo on regex101.com.
You'd need to precisize the "account number" format here.

Assuming:

• You know there is a comma in the string, so you don't have to search the entire string to find out if there is or not.
• You know the pattern is 'many_not_digits,few_digits' so there is a big imbalance between the size of the left/right parts either side of the comma.
• You can get to the end of the string without walking it, which you can in Python because string indexing is constant time

Then you could start from the end and walk backwards looking for the comma, which would be less overall work for your examples than walking from the left looking for the comma.

Doing work in Python code is way slower than using Python engine code written in C, right? So would it really be faster?

1. Make a string "aaaaa....,12"
2. use the timeit module to compare each approach - split, or right-walk.
3. Timeit does a million runs of some code.
4. Extend the length of "aaaaaaaaaaaaaaaa....,12" to make it extreme.

How do they compare?

• String split: 1400 "a"'s run a million times took 1 second.
• String split: 4000 "a"'s run a million times took 2 seconds.
• Right walk: 1400 "a"'s run a million times took 0.4 seconds.
• Right walk: 999,999 "a"'s run a million times took ... 0.4 seconds.

!

from timeit import timeit

_split = """num = x.split(',')[-1]"""

_rwalk = """
i=-1
while x[i] != ',':
    i-=1
num = x[i+1:]
"""

print(timeit(_split, setup='x="a"*1400 + ",12"'))
print(timeit(_rwalk, setup='x="a"*999999 + ",12"'))

e.g.

1.0063155219977489     # "aaa...,12" for 1400 chars, string split
0.4027107510046335     # "aaa...,12" for 999999 chars, rwalked. Faster.

Try it online at repl.it

I don't think this is algorithmically better than O(n), but with the constraints of the assumptions I made you have more knowledge than str.split() has, and can leverage that to skip walking most of the string and beat it in practise - and the longer the text part, and shorter the digit part, the more you benefit.

You want to look into regular expressions (regex) and Python's re module.

import re

string = "CORSAIR VENGEANCE RGB 16GB (2X8GB) DDR4 3200MHZ CL 16"

matches = re.findall("(\d+)", string)
print(matches)

Output: ['16', '2', '8', '4', '3200', '16']

The regex pattern \d+ matches 1 or more numerical characters in sequence. By putting it in brackets ( ) it captures each occurrence of that pattern as a group. And the re.findall method returns those groups in a list. Note that they are still strings, not numbers.

I'd use a regexp:

>>> import re
>>> re.findall(r'\d+', "hello 42 I'm a 32 string 30")
['42', '32', '30']

This would also match 42 from bla42bla. If you only want numbers delimited by word boundaries (space, period, comma), you can use \b:

>>> re.findall(r'\b\d+\b', "he33llo 42 I'm a 32 string 30")
['42', '32', '30']

To end up with a list of numbers instead of a list of strings:

>>> [int(s) for s in re.findall(r'\b\d+\b', "he33llo 42 I'm a 32 string 30")]
[42, 32, 30]

NOTE: this does not work for negative integers

Assuming that you are looking for positive numbers, as it looks like you are extracting address elements.

Run a field calculate on Name_Num field.

Put this in the pre-logic Script Code (make sure Parser is Python):

def extract_from_number_to_end(input_string):
    output = input_string # return input if no number found
    for char in input_string:
        if char.isdigit():
            pos = input_string.find(char)
            output = input_string[pos:]
            break #stop as we have found the first number
    return output

And call it in the Name_Num = part like:

extract_from_number_to_end(!MyField!)

It defaults to returning the original string if no number is found.

Just use re.search which stops matching once it finds a match.

re.search(r'\d+', headline).group()

or

You must remove the forward slashes present in your regex.

re.findall(r'^\D*(\d+)', headline)