Je vais vous expliquer comment utiliser map et lambda en python en utilisant le fichier fastq.
Le fichier de test suivant est un fichier du résultat de l'analyse du séquenceur d'ADN appelé fichier fastq, qui est familier en bioinformatique. La ligne @ est l'en-tête, la ligne suivante est la séquence de base d'ADN, la 3ème ligne est la 4ème ligne avec + entre les deux. Est la valeur d'évaluation de la qualité pour chaque caractère de la séquence de base d'ADN sur la deuxième ligne, et la valeur obtenue en ajoutant 33 à la valeur d'évaluation de la qualité est le nombre converti avec des caractères ASCII.
test.fastq
@test1
GAGCACACGTCTNNANNCNAGTCANNANNNANNNNNNNNNNANNCNNNNNNTNNNNNNNNANNNNTGTCCATTGCNNNCACATCATTGTTTACTTGCGCNT
+
;<<:?@9<?############################################################################################
Je souhaite corriger la valeur d'évaluation de la qualité à la valeur d'origine. J'ai donc essayé d'écrire dans un désordre avec python, mais je suis tombé sur une combinaison très pratique de map et de lambda, donc je vais l'écrire. Au fait, l'environnement est python2. Remarque: les différences d'utilisation des fonctions d'ordre supérieur entre les versions de Python.
Par exemple, pour convertir une valeur d'évaluation de qualité de A en un nombre, python utilise une fonction intégrée appelée ** ord (en face de chr) ** pour convertir le code ASCII en un nombre, puis soustrayez 33 pour obtenir l'original. Sera la valeur de.
> python -c 'print ord("A")-33'
32
Pour convertir les 101 caractères de la ligne de valeur de qualité du fichier de test, utilisez l'instruction for.
convert_asci.py
asci_string = ";<<:?@9<?############################################################################################"
for baseq in asci_string:
score = ord(baseq) - 33
print score,
Peut être écrit comme.
convert_asci.résultat d'exécution py
26 27 27 25 30 31 24 27 30 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
Plus cette valeur est élevée, meilleure est la qualité, vous pouvez donc voir que la base de la valeur de qualité de «#» est de très mauvaise qualité. À propos, ce programme de conversion de code ASCI utilise une instruction for, et il est difficile pour le code de devenir verticalement long à mesure que le programme s'allonge et que la vitesse d'exécution semble lente. Alors, exprimons-le en utilisant map.
py:convert_asci.2.py
asci_string = ";<<:?@9<?############################################################################################"
def convert_func(x):
score = ord(x) - 33
return score
res_score = map(convert_func, asci_string)
print res_score
text:convert_asci.2.résultat d'exécution py
[26, 27, 27, 25, 30, 31, 24, 27, 30, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
Même si vous évitez l'instruction for de cette manière, l'instruction sur la ligne qui définit la fonction sera longue. J'ai donc appris que vous pouvez utiliser une fonction anonyme ** appelée ** lambda pour écrire un processus équivalent à la fonction "convert_func" dans une carte (le saviez-vous jamais!). Ce sera comme suit.
py:convert_asci.3.script modifié par py
asci_string = ";<<:?@9<?############################################################################################"
res_score = map(lambda x:ord(x) - 33, asci_string)
print res_score
** La chaîne de caractères est divisée en un seul caractère et itérée dans l'instruction for et la map. J'ai reçu l'information. Merci, je l'ai corrigé. ** **
py:convert_asci.3.Script avant modification py
asci_string = ";<<:?@9<?############################################################################################"
asci_list = list(asci_string) #Il n'était pas nécessaire de faire cela (listage).
res_score = map(lambda x:ord(x) - 33, asci_list)
print res_score
Comment c'est? Je l'ai appelé en une seule ligne. Le résultat est le même car map renvoie une liste. Les fonctions anonymes sont des fonctions jetables qui ne sont utilisées qu'une seule fois. Elle est appelée fonction anonyme car elle n'est utilisée qu'une seule fois et n'a pas besoin d'être nommée. Le format de création d'une fonction anonyme à l'aide d'une expression lambda est le suivant.
argument lambda(Dans l'exemple x):Valeur de retour(Dans l'exemple, ord(x) - 33)
Dans l'exemple, x est un argument qui reçoit la valeur de asci_list de la carte une par une, exécute le processus spécifié, puis renvoie la valeur de retour. C'est très pratique!
Recommended Posts