在pythond中识别特定数字格式中的随机输入字符

Question

我不得不清理带有成员身份的列，但是，有很多随机输入值，如'0000000'、'99999'、'*'、'na'。你知道吗

会员id是序列号。成员ID的格式从4位到12位，其中：

4位数字-9位数字从任何非零数字开始，10到12位数字从1000xxxxxxxx开始。你知道吗

对不起，没有描述清楚的格式在开始，我刚刚发现的ID未能满足这一标准是一个无效的。我想把这些非会员身份证格式全部区分为0，谢谢帮助。你知道吗

         member_id
 1      176828287         
 2      176841791         
 3      202142958         
 4      222539874         
 5      223565464         
 6      224721631         
 7      227675081         
 8      30235355118       
 9        %                  
10      ---                
11      .                  
12      .215694985         
13      0                  
14      00                 
15      000                
16      00000000000000     
17      99999999999999     
18      999999999999999    
19      : 211066980        
20      D5146159           
21      JulieGreen         
22      N/a                
23      NONE               
24      None               
25      PP - Premium Pr    
26      T0000              
27      T0000019           
28      T0000022           

Answer 1

如果我理解正确，使用regex表达式=\A((1000\d{8})|([1-9]\d{3,10}))\Z将满足您的要求。你知道吗

上面的正则表达式与下面的匹配：

1. 以1000

2. 4到11位，必须以1

下面是一个演示：

import pandas as pd
import re

df = pd.DataFrame(['176828287','176841791','202142958','222539874','223565464','224721631','227675081','30235355118',
  '%',' -','.','.215694985','0','00','000','00000000000000','99999999999999','999999999999999',':211066980',
  'D5146159','JulieGreen','N/a','NONE','None','PP - PremiumPr','T0000','T0000019','T0000022'], columns=['member_id'])

r = re.compile(r'\A((1000\d{8})|([1-9]\d{3,10}))\Z')
df['valid'] = df['member_id'].apply(lambda x: bool(r.match(x)))
#you can use df['member_id'] = df['member_id'].apply(lambda x: x if bool(r.match(x)) else 0) to replace invalid id with 0
print(df)

输出：

          member_id  valid
0         176828287   True
1         176841791   True
2         202142958   True
3         222539874   True
4         223565464   True
5         224721631   True
6         227675081   True
7       30235355118   True
8                 %  False
9                -  False
10                .  False
11       .215694985  False
12                0  False
13               00  False
14              000  False
15   00000000000000  False
16   99999999999999  False
17  999999999999999  False
18       :211066980  False
19         D5146159  False
20       JulieGreen  False
21              N/a  False
22             NONE  False
23             None  False
24   PP - PremiumPr  False
25            T0000  False
26         T0000019  False
27         T0000022  False

Answer 2

pandas有内置的字符串函数，其中包括模式匹配算法。
因此，您可以轻松创建一个布尔掩码，以区分有效id和无效id：

pattern = r'1000\d{6,8}$|[1-9]\d{3,8}$'
mask = df.member_id.str.match(pattern)

要仅打印有效行，只需使用掩码作为索引：

print(df[mask])

    member_id
1  176828287                                                
2  176841791                                                
3  202142958                                                
4  222539874                                                
5  223565464                                                
6  224721631                                                
7  227675081                                                    

要将无效数据设置为0，只需使用掩码的补码：

df.loc[~mask] = 0
print(df)

    member_id                                               
1   176828287                                               
2   176841791                                              
3   202142958                                               
4   222539874                                               
5   223565464                                             
6   224721631                                               
7   227675081                                             
8           0                                             
9           0                                           
10          0                                            
11          0                                             
12          0
13          0
14          0
15          0
16          0
17          0
18          0
19          0
20          0
21          0
22          0
23          0
24          0
25          0
26          0
27          0
28          0

Answer 3

是否已经生成了一个正则表达式，该正则表达式满足要用0替换的数据的条件？如果没有，就必须创建一个，或者为要替换的单个项创建一个字典terms = {'N/a':0, ' -':0}，然后对序列调用.map(terms)。你知道吗