熊猫系列识别连续辅音的数量

Question

Given a Series of strings, I'm trying to calculate a new Series which contains the highest consecutive count of consonants in the original string, ignoring spaces.

For example, given df['names'] , I'd like to determine df['max_consonants'] like below:

In [1]: df
Out[1]:
               names max_consonants
0       will hunting              2
1       sean maguire              1
2     gerald lambeau              2
3   chuckie sullivan              2
4    mike krzyzewski              5

Outside of pandas , I am able to do this using the re module, like so:

In [2]: def max_consonants(s):
             return max(len(i) for i in re.findall(r'[^aeiou ]+', s))

In [3]: max_consonants('mike krzyzewski')
Out[3]: 5

I know I can use pd.Series.apply to use the max_consonants function on a Series , but it is not vectorized. I am working with data containing 2-3mm rows/names, so I am looking for the most efficient solution.

Is there a more elegant solution native to pandas that would allow me to take advantage of vectorization?

Answer 1

You could try this, it should also work for special characters because of the \\W . But please note, that \\W also catches numbers, so if you also want to split on those, you need to add 0-9 to the regex used by split:

df['names'].str.split(r'[AaEeIiOoUu\W]', expand=True).fillna('').applymap(len).max(axis='columns')

With the test data:

raw="""idx             names  max_consonants
0       will hunting              2
1       sean maguire              1
2     gerald lambeau              2
3   chuckie sullivan              2
4    mike krzyzewski              5
5    mike krzyzewski12345678      5
"""
df= pd.read_csv(io.StringIO(raw), sep='\s{2,}', index_col=[0])

This evaluates to:

idx
0    2
1    1
2    2
3    2
4    5
5    8
dtype: int64

The intermediate result before the applymap looks like this btw:

Out[89]: 
      0   1   2      3    4         5  6  7
idx                                        
0     w  ll   h     nt   ng                
1     s       n      m    g            r   
2     g   r  ld      l   mb                
3    ch  ck               s        ll  v  n
4     m   k      krzyz  wsk                
5     m   k      krzyz  wsk  12345678      

Note on the performance: I would expect .mapapply(len) to be translated to efficient C++ operations, but can't verify it with my data. In case you get performance problems with this solution, you can try a variant in which you perform everything up to the applymap , replace the applymap by a loop over the columns and perform .str.len() . Which would roughly look like this:

df_consonant_strings= df['names'].str.split(r'[AaEeIiOoUu\W]', expand=True).fillna('')
ser_max= None
for col in df_consonant_strings.columns:
    ser_col= df_consonant_strings[col].str.len()
    if ser_max is None:
        ser_max= ser_col
    else:
        ser_max= ser_max.where(ser_max>ser_col, ser_col)
# now ser_max contains the desired maximum length of consonant substrings