Ich habe 1-12 Zahlen in der Spalte SAMPLE und für jede Zahl versuche ich, Mutationsnummern zu zählen (A: T, C: G usw.). Dieser Code funktioniert, aber wie kann ich diesen Code ändern, um alle 12 Bedingungen für jede Mutation zu erhalten, anstatt 12 Mal denselben Code und auch für jede Mutation zu schreiben?

In diesem Beispiel; AT gibt mir die Nummer während SAMPLE=1. Ich versuche, die AT-Nummer für jede Probennummer (1,2, .. 12) zu ermitteln. Wie kann dieser Code dafür geändert werden? Ich werde mich über jede Hilfe freuen. Vielen Dank.

         SAMPLE                                        MUT
0          11                                 chr1:100154376:G:A
1           2                                 chr1:100177723:C:T
2           9                                 chr1:100177723:C:T
3           1                                chr1:100194200:-:AA
4           8                                  chr1:10032249:A:G
5           2                                 chr1:100340787:G:A
6           1                                 chr1:100349757:A:G
7           3                                  chr1:10041186:C:A
8          10                                 chr1:100476986:G:C
9           4                                 chr1:100572459:C:T
10          5                                 chr1:100572459:C:T
...        ...                                    ...

d= df["SAMPLE", "MUT" ]
chars1 = "TGC-"
number = {}
for item in chars1:
    dm= d[(d["MUT"].str.contains("A:" + item)) & (d["SAMPLE"].isin([1]))]
    num1 = dm.count()
    number[item] = num1

AT=number["T"]
AG=number["G"]
AC=number["C"]
A_=number["-"]
4
kant 12 Aug. 2015 im 00:21

3 Antworten

Beste Antwort

Ich würde die nativen String-Extraktionsmethoden in Pandas verwenden

df.MUT.str.extract('A:(T)|A:(G)|A:(C)|A:(-)')

Welches gibt die Übereinstimmungen der verschiedenen Gruppen zurück:

      0    1    2    3
0   NaN  NaN  NaN  NaN
1   NaN  NaN  NaN  NaN
2   NaN  NaN  NaN  NaN
3   NaN  NaN  NaN  NaN
4   NaN    G  NaN  NaN
5   NaN  NaN  NaN  NaN
6   NaN    G  NaN  NaN
7   NaN  NaN  NaN  NaN
8   NaN  NaN  NaN  NaN
9   NaN  NaN  NaN  NaN
10  NaN  NaN  NaN  NaN

Dann würde ich dies mit pd.isnull in True oder False konvertieren und mit ~ invertieren. Dadurch wird wahr, wo es eine Übereinstimmung ist, und falsch, wo es keine gibt.

~pd.isnull(df.MUT.str.extract('A:(T)|A:(G)|A:(C)|A:(-)'))
        0      1      2      3
0   False  False  False  False
1   False  False  False  False
2   False  False  False  False
3   False  False  False  False
4   False   True  False  False
5   False  False  False  False
6   False   True  False  False
7   False  False  False  False
8   False  False  False  False
9   False  False  False  False
10  False  False  False  False

Weisen Sie dies dann dem Datenrahmen zu

df[["T","G","C","-"]] = ~pd.isnull(df.MUT.str.extract('A:(T)|A:(G)|A:(C)|A:(-)'))

    SAMPLE                  MUT      T      G      C      -
0       11   chr1:100154376:G:A  False  False  False  False
1        2   chr1:100177723:C:T  False  False  False  False
2        9   chr1:100177723:C:T  False  False  False  False
3        1  chr1:100194200:-:AA  False  False  False  False
4        8    chr1:10032249:A:G  False   True  False  False
5        2   chr1:100340787:G:A  False  False  False  False
6        1   chr1:100349757:A:G  False   True  False  False
7        3    chr1:10041186:C:A  False  False  False  False
8       10   chr1:100476986:G:C  False  False  False  False
9        4   chr1:100572459:C:T  False  False  False  False
10       5   chr1:100572459:C:T  False  False  False  False

Jetzt können wir einfach die Spalten summieren:

df[["T","G","C","-"]].sum()
T    0
G    2
C    0
-    0

Aber warte, wir haben das nicht nur dort gemacht, wo SAMPLE == 1

Wir können dies sehr einfach mit einer Maske tun:

sample_one_mask = df.SAMPLE == 1
df[sample_one_mask][["T","G","C","-"]].sum()
T    0
G    1
C    0
-    0

Wenn Sie möchten, dass dies stattdessen pro BEISPIEL zählt, können Sie die Funktion groupby verwenden:

df[["SAMPLE","T","G","C","-"]].groupby("SAMPLE").agg(sum).astype(int)

        T  G  C  -
SAMPLE            
1       0  1  0  0
2       0  0  0  0
3       0  0  0  0
4       0  0  0  0
5       0  0  0  0
8       0  1  0  0
9       0  0  0  0
10      0  0  0  0
11      0  0  0  0

TLDR;

Mach das:

df[["T","G","C","-"]] = ~pd.isnull(df.MUT.str.extract('A:(T)|A:(G)|A:(C)|A:(-)'))
df[["SAMPLE","T","G","C","-"]].groupby("SAMPLE").agg(sum).astype(int)
2
firelynx 12 Aug. 2015 im 11:24

Sie können eine Spalte mit dem Mutationstyp (A-> T, G-> C) mit einer Substitution durch reguläre Ausdrücke erstellen und dann pandas groupby anwenden, um zu zählen.

import pandas as pd
import re
df = pd.read_table('df.tsv')
df['mutation_type'] = df['MUT'].apply(lambda x: re.sub(r'^.*?:([^:]+:[^:]+)$', r'\1', x))
df.groupby(['SAMPLE','mutation_type']).agg('count')['MUT']

Die Ausgabe für Ihre Daten ist wie folgt:

SAMPLE  mutation_type
1       -:AA             1
        A:G              1
2       C:T              1
        G:A              1
3       C:A              1
4       C:T              1
5       C:T              1
8       A:G              1
9       C:T              1
10      G:C              1
11      G:A              1
Name: MUT, dtype: int64
1
A.P. 11 Aug. 2015 im 22:08

Ich hatte eine ähnliche Antwort auf A.P.

import pandas as pd
df = pd.DataFrame(data={'SAMPLE': [11,2,9,1,8,2,1,3,10,4,5], 'MUT': ['chr1:100154376:G:A', 'chr1:100177723:C:T', 'chr1:100177723:C:T', 'chr1:100194200:-:AA', 'chr1:10032249:A:G', 'chr1:100340787:G:A', 'chr1:100349757:A:G', 'chr1:10041186:C:A', 'chr1:100476986:G:C', 'chr1:100572459:C:T', 'chr1:100572459:C:T']}, columns=['SAMPLE', 'MUT'])
df['Sequence'] = df['MUT'].str.replace(r'\w+:\d+:', '\1')
df.groupby(['SAMPLE', 'Sequence']).count()

Produziert

                 MUT
SAMPLE Sequence     
1      -:AA       1
       A:G        1
2      C:T        1
       G:A        1
3      C:A        1
4      C:T        1
5      C:T        1
8      A:G        1
9      C:T        1
10     G:C        1
11     G:A        1
1
Jarad 11 Aug. 2015 im 22:19