यदि डेटाफ़्रेम में स्ट्रिंग का nवां वर्ण एक निश्चित वर्ण है, तो उस पंक्ति को हटा दें

आप apply और बूलियन इंडेक्सिंग का उपयोग कर सकते हैं:

df1 = df1[df1.apply(lambda r: r['seq'][r['a']-1]!='.', axis=1)]

आउटपुट:

             seq  a  b   val
0  (((...))).(.)  1  9  0.01
2     ..(.)..(.)  5  7  0.03

आप प्रत्येक वर्ण को एक नए कॉलम में विभाजित करने के लिए str.split के साथ '' का उपयोग कर सकते हैं, फिर कॉलम a के आधार पर स्थिति पर सही वर्ण प्राप्त करने के लिए अनुक्रमण का उपयोग कर सकते हैं। अंत में जांचें कि कहां != '.' का।

print (df1[df1['seq'].str.split('', expand=True)
                     .to_numpy()[np.arange(len(df1)), df1['a']] #no need of -1 here
           !='.'])
             seq  a  b   val
0  (((...))).(.)  1  9  0.01
2     ..(.)..(.)  5  7  0.03

3 पंक्तियों की एक छोटी डेटाफ़्रेम के लिए, apply यदि तेज़ है, लेकिन यदि आकार बढ़ता है, तो यह विधि दिलचस्प हो जाती है। हालाँकि यदि seq में तार लंबे हैं, तो वे समय पर प्रभाव डाल सकते हैं।

%timeit df1[df1.apply(lambda r: r['seq'][r['a']-1]!='.', axis=1)]
# 1.15 ms ± 23.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit df1[df1['seq'].str.split('', expand=True).to_numpy()[np.arange(len(df1)), df1['a']]!='.']
#1.7 ms ± 95 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

#with 300 rows
df2 = pd.concat([df1]*100)
%timeit df2[df2.apply(lambda r: r['seq'][r['a']-1]!='.', axis=1)]
# 7.45 ms ± 137 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit df2[df2['seq'].str.split('', expand=True).to_numpy()[np.arange(len(df2)), df2['a']]!='.']
#2.58 ms ± 52.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

#with 3000 rows
df3 = pd.concat([df1]*1000)
%timeit df3[df3.apply(lambda r: r['seq'][r['a']-1]!='.', axis=1)]
#67.9 ms ± 3.6 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit df3[df3['seq'].str.split('', expand=True).to_numpy()[np.arange(len(df3)), df3['a']]!='.']
#11.4 ms ± 432 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)