Copyright HébergementWebs.com - License GPL

Biopython - Guide rapide

Tutoriel biopython   2020-11-16 15:33:22

Biopython - Guide rapide Biopython - Introduction Biopython est le plus grand et package de bioinformatique le plus populaire pour Python. Il contient un certain nombre de sous-modules différents pour les tâches bioinformatiques courantes. Il est développé par Chapman et Chang, principalement écrit en Python. Il contient également du code C pour optimiser la partie calcul complexe du logiciel. Il fonctionne sous Windows, Linux, Mac OS X, etc. Fondamentalement, Biopython est une collection de modules python qui fournissent des fonctions permettant de gérer les opérations de séquence d"ADN, d"ARN et de protéines telles que la complémentation inverse d"une chaîne d"ADN , trouver des motifs dans des séquences de protéines, etc. Il fournit de nombreux analyseurs pour lire toutes les principales bases de données génétiques telles que GenBank, SwissPort, FASTA, etc., ainsi que des wrappers / interfaces pour exécuter d"autres logiciels / outils de bioinformatique populaires tels que NCBI BLASTN, Entrez, etc., dans l"environnement python. Il a des projets frères comme BioPerl, BioJava et BioRuby. Caractéristiques Biopython est portable, clair et a une syntaxe facile à apprendre. Certaines des principales caractéristiques sont énumérées ci-dessous - Interprétée, interactive et orientée objet. Prend en charge les formats FASTA, PDB, GenBank, Blast, SCOP, PubMed / Medline, ExPASy. Option pour gérer les formats de séquence. Outils pour gérer les structures des protéines. BioSQL - Ensemble standard de tables SQL pour stocker des séquences ainsi que des fonctionnalités et des annotations. Accès aux services en ligne et à la base de données, y compris les services NCBI (Blast, Entrez, PubMed) et ExPASY (SwissProt, Prosite). Accès aux services locaux, y compris Blast, Clustalw, EMBOSS. Objectifs Le but de Biopython est de fournir un accès simple, standard et étendu à la bioinformatique via le langage python. Les objectifs spécifiques du Biopython sont listés ci-dessous - Fournir un accès standardisé aux ressources bioinformatiques . Modules et s réutilisables de haute qualité. Manipulation rapide des tableaux pouvant être utilisée dans le code de cluster, PDB , NaiveBayes et Markov Model. Analyse des données génomiques. Avantages Biopython nécessite très moins de code et présente les avantages suivants - Fournit le type de données de microarray utilisé dans le clustering. Lit et écrit des fichiers de type Tree-View. Prend en charge les données de structure utilisées pour l"analyse, la représentation et l"analyse PDB. Prend en charge les données de journaux utilisées dans les applications Medline. Prend en charge la base de données BioSQL, qui est une base de données standard largement utilisée parmi tous les projets de bioinformatique. Prend en charge le développement d"analyseurs en fournissant des modules pour analyser un fichier bioinformatique dans un objet d"enregistrement spécifique au format ou une class générique de séquence plus des fonctionnalités. Effacer documentation basée sur le style livre de cuisine. Exemple de cas Étude Vérifions quelques cas d"utilisation (génétique des populations, structure de l"ARN, etc.,) et essayons de comprendre comment Biopython joue un rôle important dans ce domaine - Génétique des populations La génétique des populations est l"étude de la variation génétique au sein d"une population, et implique l"examen et la modélisation des changements dans les fréquences des gènes et des allèles dans les populations dans l"espace et le temps. Biopython fournit Module Bio.PopGen pour la génétique des populations. Ce module contient toutes les fonctions nécessaires pour rassembler des informations sur la génétique classique des populations. Structure de l"ARN Trois macromolécules biologiques majeures qui sont essentielles à notre vie sont l"ADN, l"ARN et les protéines. Les protéines sont les bêtes de somme de la cellule et jouent un rôle important en tant qu"enzymes. L"ADN (acide désoxyribonucléique) est considéré comme le «modèle» de la cellule. Il contient toutes les informations génétiques nécessaires à la croissance, à l"absorption des nutriments et à la propagation de la cellule. L"ARN (acide ribonucléique) agit comme «ADN ph otocopy "dans la cellule. Biopython fournit des objets Bio.Sequence qui représentent des nucléotides, des blocs de construction d"ADN et d"ARN. Biopython - Installation Cette section explique comment installer Biopython sur votre machine. Il est très facile à installer et cela ne prendra pas plus de cinq minutes. Étape 1 - Vérification de l"installation de Python Biopython est conçu pour fonctionner avec Python 2.5 ou versions supérieures. Il est donc obligatoire que python soit d"abord installé. Exécutez la commande ci-dessous dans votre invite de commande - > python --version Il est défini ci-dessous - Il montre la version de python , s"il est installé correctement. Sinon, téléchargez la dernière version du python, installez-le puis exécutez à nouveau la commande. Étape 2 - Installer Biopython avec pip C"est facile pour installer Biopython à l"aide de pip depuis la ligne de commande sur toutes les plateformes. Tapez la commande ci-dessous - > pip install biopython La réponse suivante apparaîtra sur votre écran - Pour mettre à jour une ancienne version de Biopython - > pip install biopython –-upgrade La réponse suivante sera visible sur votre écran - Après avoir exécuté cette commande , les anciennes versions de Biopython et NumPy (Biopython en dépend) seront supprimées avant d"installer les versions récentes. Étape 3 - Vérification de l"installation de Biopython Maintenant, vous avez installé avec succès Biopython sur votre machine. Pour vérifier que Biopython est correctement installé, tapez le commande ci-dessous sur votre console python - Il montre la version de Biopython. Autre façon - Installer Biopython en utilisant Source Pour installer Biopython en utilisant source code, suivez les instructions ci-dessous - Téléchargez la version récente de Biopython à partir du lien suivant - https://biopython.org/wiki/Download" À partir de maintenant, la dernière version est biopython-1.72 . Téléchargez le fichier et décompressez le fichier d"archive compressé, déplacez-vous dans le dossier du code source et tapez la commande ci-dessous - > python setup.py build Cela construira Biopython à partir du code source comme indiqué ci-dessous - Maintenant, testez le code en utilisant la commande ci-dessous - > python setup.py test Enfin, installez en utilisant la commande ci-dessous - > python setup.py install Biopython - Création d"une application simple Créons une application Biopython simple pour analyser un fichier bioinformatique et imprimer le contenu. Cela nous aidera à comprendre le concept général du Biopython et comment il aide dans le domaine de la bioinformatique. Étape 1 - Commencez par créer un exemple de fichier de séquence, "example.fasta »Et mettez-y le contenu ci-dessous. > sp | P25730 | FMS1_ECOLI CS1 sous-unité fimbriale A précurseur (CS1 piline) MK LKKTIGAMALATLFATMGASAVEKTISVTASVDPTVDLLQSDGSALPNSVALTYSPAV NNFEAHTINTVVHTNDSDKGVVVKLSADPVLSNVLNPTLQIPVSVNFAGKPLSTTGITID p> sp | P15488 | FMS3_ECOLI CS3 fimbriae sous-unité A précurseur (CS3 piline) MLKIKYLLIGLSLSAMSSYSLAAAGPTLTKELALNVLSPAALDATWAPQDNLTLSNTGVS NTLVGVLTLSNTSIDTVSIASTNVSDTSKNGTVTFAHETNNSASFATTISTDNANITLDK NAGNTIVKTTNGSQLPTNLPLKFITTEGNEHLVSGNYRANITITSTIKGGGTKKGTTDKK L"extension, FASTA se réfère au format de fichier du fichier de séquence. FASTA provient du logiciel de bioinformatique, FASTA, d"où son nom. Le format FASTA a plusieurs séquences organisées une par une et chaque séquence aura son propre identifiant, son nom, sa deion et les données de séquence réelles. Étape 2 - Créer un nouveau python, * simple_example.py "et entrez le code ci-dessous et enregistrez-le. depuis Bio.SeqIO import parse depuis Bio.SeqRecord import SeqRecord depuis Bio.Seq import Seq file = open ( "example.fasta ") records = parse (file, "fasta ") pour enregistrer dans les enregistrements: print ( "Id:% s "% record.id) print ( "Nom:% s "% record.name) print (" Deion:% s "% record.deion) print (" Annotations:% s "% record.annotations) print (" Sequence Data:% s "% record .seq) print ( "Alphabet de séquence:% s "% record.seq.alphabet) Examinons un peu plus en détail le code - Ligne 1 importe la class d"analyse disponible dans le module Bio.SeqIO. Le module Bio.SeqIO est utilisé pour lire et écrire le fichier de séquence dans un format différent et la class `parse "est utilisée pour analyser le contenu du s equence. Line 2 importe la class SeqRecord disponible dans le module Bio.SeqRecord. Ce module est utilisé pour manipuler les enregistrements de séquence et la class SeqRecord est utilisée pour représenter une séquence particulière disponible dans le fichier de séquence. * Line 3 " importe la class Seq disponible dans la Bio Module .Seq. Ce module est utilisé pour manipuler les données de séquence et la class Seq est utilisée pour représenter a envoyé les données de séquence d"un enregistrement de séquence particulier disponible dans le fichier de séquence. La ligne 5 ouvre le fichier «example.fasta» en utilisant la fonction python ordinaire, ouvrez. Ligne 7 analyse le contenu du fichier de séquence et renvoie le contenu sous forme de liste d’objet SeqRecord. La ligne 9-15 fait une boucle les enregistrements utilisant python for boucle et imprime les attributs de l"enregistrement de séquence (SqlRecord) tels que id, nom, deion, données de séquence, etc. La ligne 15 imprime le type de la séquence en utilisant la class Alphabet. Étape 3 - Ouvrez une invite de commande et accédez au dossier contenant le fichier de séquence, "example.fasta" et exécutez la commande ci-dessous - > python simple_example.py Étape 4 - Python exécute le et imprime toutes les données de séquence disponibles dans le fichier d"exemple, "exemple .fasta ». La sortie sera similaire au contenu suivant. Id: sp | P25730 | FMS1_ECOLI Nom: sp | P25730 | FMS1_ECOLI Decription: sp | P25730 | FMS1_ECOLI CS1 sous-unité fimbriale A précurseur (CS1 piline) Annotations: {} séquence de données: MKLKKTIGAMALATLFATMGASAVEKTISVTASVDPTVDLLQSDGSALPNSVALTYSPAVNNFEAHTINTVVHTNDSD KGVVVKLSADPVLSNVLNPTLQIPVSVNFAGKPLSTTGITIDSNDLNFASSGVNKVSSTQKLSIHADATRVTGGALTA GQYQGLVSIILTKSTTTTTTTKGT séquence Alphabet: SingleLetterAlphabet () Id: sp | P15488 | FMS3_ECOLI Nom: sp | P15488 | FMS3_ECOLI decription: sp | P15488 | FMS3_ECOLI CS3 flmbrial sous-unité précurseur (CS3 pilin ) Annotations: {} données de séquence: MLKIKYLLIGLSLSAMSSYSLAAAGPTLTKELALNVLSPAALDATWAPQDNLTLSNTGVSNTLVGVLTLSNTSIDTVS IASTNVSDTSKNGTVTFAHETNNSASFATTISTDNANITLDKNAGNTIVKTTNGSQLPTNLPLKFITTEGNEHLVSGN YRANITITSTIKGGGTKKGTTDKK séquence Alphabet: SingleLetterAlphabet () Nous avons vu trois classs, analyse syntaxique, SeqRecord et Seq dans cet exemple. Ces trois classs fournissent la plupart des fonctionnalités et nous apprendrons ces classs dans la section suivante. Biopython - Séquence Une séquence est une série de lettres utilisées pour représentent la protéine, l’ADN ou l’ARN d’un organisme. Il est représenté par la class Seq. La class Seq est définie dans le module Bio.Seq. Créons une séquence simple en Biopython comme indiqué ci-dessous - >>> de Bio.Seq import Seq >>> seq = Seq ( "AGCT ") >>> seq Seq ( "AGCT ") >>> print (seq) AGCT Ici, nous avons créé une protéine simple séquence AGCT et chaque lettre représente A lanine, G lycine, C ysteine ​​et T hreonine. Chaque objet Seq a deux attributs importants - data - la chaîne de séquence réelle (AGCT) alphabet - utilisé pour représenter le type de séquence. par exemple. Séquence d"ADN, séquence d"ARN, etc. Par défaut, elle ne représente aucune séquence et est de nature générique. Module Alphabet Les objets Seq contiennent Attribut alphabet pour spécifier le type de séquence, les lettres et les opérations possibles. Il est défini dans le module Bio.Alphabet. L"alphabet peut être défini comme ci-dessous - >>> from Bio.Seq import Seq >>> myseq = Seq ( "AGCT ") >>> myseq Seq ( "AGCT ") >>> myseq.alphabet Alphabet () Le module Alphabet fournit ci-dessous des classs pour représenter différents types de séquences. Alphabet - class de base pour tous les types d"alphabets. SingleLetterAlphabet - Alphabet générique avec des lettres de taille un. Il dérive de Alphabet et tous les autres types d"alphabets en dérivent. >>> de Bio.Seq import Seq >>> de Bio.Alphabet import single_letter_alphabet >>> test_seq = Seq ( "AGTACACTGGT ", single_letter_alphabet) >>> test_seq Seq ( "AGTACACTGGT ", SingleLetterAlphabet ()) ProteinAlphabet - Alphabet générique de protéines à une seule lettre. >>> from Bio.Seq import Seq >>> from Bio.Alphabet import generic_protein >>> test_seq = Seq ( "AGTACACTGGT ", generic_protein) >>> test_seq Seq ( "AGTACACTGGT ", ProteinAlphabet ()) NucleotideAlphabet - Générique alphabet nucléotidique à une seule lettre. >>> de Bio.Seq import Seq >>> de Bio.Alphabet import generic_nucleotide >>> test_seq = Seq ( "AGTACACTGGT " , generic_nucleotide) >>> test_seq Seq ( "AGTACACTGGT ", NucleotideAlphabet ()) DNAAlphabet - Alphabet générique d"ADN à une seule lettre. > >> depuis Bio.Seq import Seq >>> depuis Bio.Alphabet import generic_dna >>> test_seq = Seq ( "AGTACACTGGT ", generic_dna) >>> test_seq Seq ( "AGTACACTGGT ", DNAAlphabet ()) RNAAlphabet - Alphabet générique d"ARN à une lettre. >>> de Bio.Seq import Seq >>> de Bio.Alphabet import generic_rna >>> test_seq = Seq ( "AGTACACTGGT ", generic_rna) >>> test_seq Seq ( "AGTACACTGGT ", RNAAlphabet ()) Module Biopython, Bio.Alphabet.IUPAC fournit des types de séquence de base tels que définis par l"IUPAC communauté. Il contient les classs suivantes - IUPACProtein (protein) - Alphabet protéique IUPAC de 20 acides aminés standard. ExtendedIUPACProtein (extended_protein) - Alphabet d"une seule lettre de protéine IUPAC majuscule, y compris X. IUPACAmbiguousDNA (ambiguous_dna) - ADN ambigu IUPAC en majuscules. IUPACUnambiguousDNA (unambiguous_dna) - ADN non ambigu IUPAC en majuscules (GATC). ExtendedIUPACDNA (extended_dna) - Alphabet ADN IUPAC étendu. IUPACAmbiguousRNA (ambiguous_rna) - ARN ambigu IUPAC majuscule. ARNIUPACUnambiguousRNA (unambiguous_rna) - ARN non ambigu IUPAC majuscule (GAUC). Prenons un exemple simple pour la class IUPACProtein comme indiqué ci-dessous - >>> de Bio.Alphabet import IUPAC >>> protein_seq = Seq ( "AGCT ", IUPAC.protein) >>> protein_seq Seq ( "AGCT ", IUPACProtein ()) >>> protein_seq.alphabet De plus, Biopython expose toutes les bioinformatiques liées d données de configuration via le module Bio.Data. Par exemple, IUPACData.protein_letters a les lettres possibles de l"alphabet IUPACProtein. >>> from Bio.Data import IUPACData >>> IUPACData.protein_letters "ACDEFGHIKLMNPQRSTVWY " Opérations de base Cette section explique brièvement toutes les opérations de base disponibles dans la class Seq. Les séquences sont similaires aux chaînes python. Nous pouvons effectuer des opérations de chaîne python comme le découpage, le comptage, la concaténation, la recherche, le fractionnement et le décapage en séquences. Utilisez les codes ci-dessous pour obtenir Pour obtenir le première valeur de la séquence. >>> seq_string = Seq ( "AGCTAGCT ") >>> seq_string [0] "A " Pour imprimer les deux premières valeurs. >>> seq_string [0: 2] Seq ( "AG ") Pour imprimer toutes les valeurs. >>> seq_string [:] Seq (" AGCTAGCT ") Pour effectuer des opérations de longueur et de comptage. >>> len (seq_string) 8 >>> seq_string .count ( "A ") 2 Pour ajouter deux séquences. >>> de Bio. Alphabet import generic_dna, generic_protein >>> seq1 = Seq ( "AGCT ", generic_dna) >>> seq2 = Seq ( "TCGA ", generic_dna) >>> seq1 + seq2 Seq ( "AGCTTCGA ", DNAAlphabet ()) Ici, le tw ci-dessus o les objets de séquence, seq1, seq2 sont des séquences génériques d"ADN et vous pouvez donc les ajouter et produire une nouvelle séquence. Vous ne pouvez pas ajouter de séquences avec des alphabets incompatibles, comme une séquence protéique et une séquence ADN comme spécifié ci-dessous - >>> dna_seq = Seq ( "AGTACACTGGT " , generic_dna) >>> protein_seq = Seq ( "AGUACACUGGU ", generic_protein) >>> dna_seq + protein_seq ..... ..... TypeError: Alphabets incompatibles DNAAlphabet () et ProteinAlphabet () >>> Pour ajouter deux séquences ou plus, stockez-les d"abord dans une liste python, puis retr ieve-le en utilisant "for loop" et enfin ajoutez-le comme indiqué ci-dessous - >>> from Bio.Alphabet import generic_dna >>> list = [Seq ( " AGCT ", generic_dna), Seq (" TCGA ", generic_dna), Seq (" AAA ", generic_dna)] >>> pour s dans la liste: ... print (s) ... AGCT TCGA AAA >>> final_seq = Seq ( ", generic_dna) >>> pour s dans la liste: ... final_seq = final_seq + s ... >>> final_seq Seq ( "AGCTTCGAAAA ", DNAAlphabet ()) Dans la section ci-dessous, Pour changer la casse de la séquence. >>> from Bio.Alphabet import generic_rna >>> rna = Seq ( "agct ", generic_rna) >>> rna.upper () Seq ( "AGCT ", RNAAlphabet ()) Pour vérifier l"appartenance à python et l"opérateur d"identité. >>> rna = Seq ( "agct ", generic_rna) >>> "a " in rna True >>> "A " in rna False >>> rna1 = Seq (" AGCT ", generic_dna) >>> rna est rna1 False < / pré> Pour trouver une seule lettre ou une séquence de lettres dans la séquence donnée. >>> protein_seq = Seq ( "AGUACACUGGU " , generic_protein) >>> protein_seq.find ( "G ") 1 >>> protein_seq.find ( "GG ") 8 Pour effectuer une opération de fractionnement. >>> protein_seq = Seq ( "AGUACACUGGU ", generic_protein) >>> protein_seq.split ( "A ") [Seq ( "" , ProteinAlphabet ()), Seq ( "GU ", ProteinAlphabet ()), Seq ( "C ", ProteinAlphabet ()), Seq ( "CUGGU ", ProteinAlphabet ())] Pour effectuer des opérations de strip dans la séquence. >>> strip_seq = Seq ( "AGCT ") >>> strip_seq Seq ( "AGCT ") >>> strip_seq.strip () Seq ( "AGCT ") Biopython - Opérations de séquence avancées Dans ce chapitre, nous allons discuter de quelques des fonctionnalités de séquence avancées fournies par Biopython. Complément et complément inverse La séquence nucléotidique peut être complétée en obtenir une nouvelle séquence. En outre, la séquence complémentée peut être complémentée en sens inverse pour obtenir la séquence d"origine. Biopython fournit deux méthodes pour faire cette fonctionnalité - complément et reverse_complement . Le code pour cela est donné ci-dessous - >>> from Bio.Alphabet import IUPAC >>> nucleotide = Seq ( "TCGAAGTCAGTC ", IUPAC.ambiguous_dna)> >> nucleotide.complement () Seq ( "AGCTTCAGTCAG ", IUPACAmbiguousDNA ()) >>> Ici, la méthode complément () permet de compléter une séquence d"ADN ou d"ARN. La méthode reverse_complement () complète et inverse la séquence résultante de gauche à droite. Il est montré ci-dessous - >>> nucleotide.reverse_complement () Seq ( "GACTGACTTCGA ", IUPACAmbiguousDNA ()) Biopython utilise le ambiguous_dna_complement variable fournie par Bio.Data.IUPACData pour effectuer l"opération de complément. >>> depuis Bio.Data import IUPACData >>> import pprint >>> pprint.pprint (IUPACData.ambiguous_dna_complement) { "A ": "T ", "B ": "V ", "C ": "G ", "D ": " H ", " G ": " C ", " H ": " D ", " K ": " M ", " M ": " K ", " N ": " N ", " R ": " Y ", " S ": " S ", " T ": " A ", "V ": "B ", "W ": "W ", "X ": "X ", "Y ": "R "} >> > Contenu GC La composition de base de l"ADN génomique (contenu GC) devrait affecter de manière significative le fonctionnement du génome et l"écologie des espèces. Le contenu GC est le nombre de nucléotides GC par le total des nucléotides. Pour obtenir le contenu des nucléotides GC, importez le module suivant et effectuez les étapes suivantes - >>> depuis Bio.SeqUtils import GC >>> nucleotide = Seq (" GACTGACTTCGA ", IUPAC.unambiguous_dna) >>> GC (nucléotide) 50.0 Tranion La tranion est le processus de changement de séquence d"ADN en séquence d"ARN. Le processus de tranion biologique proprement dit effectue un complément inverse (TCAG → CUGA) pour obtenir l"ARNm con sider l"ADN comme brin matrice. Cependant, en bioinformatique et donc en Biopython, nous travaillons généralement directement avec le brin codant et nous pouvons obtenir la séquence d"ARNm en changeant la lettre T en U. Un exemple simple pour ce qui précède est le suivant - >>> depuis Bio.Seq import Seq >>> depuis Bio.Seq import transcrire >>> depuis Bio.Alphabet import IUPAC >>> dna_seq = Seq ( "ATGCCGATCGTAT ", IUPAC.unambiguous_dna) >>> transcrire (dna_seq) Seq ( "AUGCCGAUCGUAU ", IUPACUnambiguousRNA ()) >>> Pour inverser la tranion, T est changé en U comme indiqué dans le code ci-dessous - >>> rna_seq = transcribe (dna_seq) >>> rna_seq.back_transcribe () Seq ( "ATGCCGATCGTAT ", IUPACUnambiguousDNA ()) Pour obtenir le brin modèle d"ADN, reverse_complémenter l"ARN retranscrit comme indiqué ci-dessous - >>> rna_seq.back_transcribe (). reverse_complement () Seq ( "ATACGATCGGCAT ", IUPACUnambiguousDNA ()) Translation Tra La nslation est un processus de traduction de la séquence d"ARN en séquence protéique. Considérez une séquence d"ARN comme indiqué ci-dessous - >>> rna_seq = Seq ( "AUGGCCAUUGUAAU ", IUPAC.unambiguous_rna) >>> rna_seq Seq ( "AUGGCCAUUGUAAUGGAUGCCGCUGAAAGGCCC ", IUPACUnambiguousRNA ()) Maintenant, appliquez la fonction translate () au code ci-dessus - >>> rna_seq.translate () Seq ( "MAIV ", IUPACProtein ()) La séquence d"ARN ci-dessus est simple. Considérez la séquence d"ARN, AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGA et appliquez translate () - >>> rna = Seq ( "AUGGCCAUUGUAAUGGGCCGCUGAAAGGUGCCCGA ", IUPAC.unambiguousate () ) Seq ( "MAIVMGR * KGAR ", HasStopCodon (IUPACProtein (), "* ")) Ici, les codons d"arrêt sont indiqués par un astérisque "*". Il est possible dans la méthode translate () de s"arrêter au premier codon d"arrêt. Pour ce faire, vous pouvez attribuer à_ stop = True dans translate () comme suit - >>> rna.translate (to_stop = True) Seq ( "MAIVMGR ", IUPACProtein ()) Ici, le codon stop n"est pas inclus dans la séquence résultante car il n"en contient pas. Table de traduction La page des codes génétiques du NCBI fournit la liste complète des tables de traduction utilisées par Biopython. Voyons un exemple de table standard pour visualiser le code - >>> from Bio.Data import CodonTable >>> table = CodonTable.unambiguous_dna_by_name [ "Standard "] >>> imprimer (tableau) Tableau 1 Standard, SGC0 | T | C | A | G | - + --------- + --------- + --------- + --------- + - T | TTT F | TCT S | TAT Y | TGT C | T T | TTC F | TCC S | TAC Y | TGC C | C T | TTA L | TCA S | TAA Stop | TGA Stop | A T | TTG L (s) | TCG S | TAG Stop | TGG W | G - + --------- + --------- + --------- + --------- + - C | CTT L | CCT P | CAT H | CGT R | T C | CTC L | CCC P | CAC H | CGC R | C C | CTA L | CCA P | CAA Q | CGA R | A C | CTG L (s) | CCG P | CAG Q | CGG R | G - + --------- + --------- + --------- + --------- + - A | ATT I | ACT T | AAT N | AGT S | T A | ATC I | ACC T | AAC N | AGC S | C A | ATA I | ACA T | AAA K | AGA R | A A | ATG M (s) | ACG T | AAG K | AGG R | G - + --------- + --------- + --------- + --------- + - G | GTT V | GCT A | GAT D | GGT G | T G | GTC V | GCC A | GAC D | GGC G | C G | GTA V | GCA A | GAA E | GGA G | A G | GTG V | GCG A | GAG E | GGG G | G - + --------- + --------- + --------- + --------- + - >>> Biopython utilise cette table pour traduire l"ADN en protéine ainsi que pour trouver le codon Stop. Biopython - Opérations d"E / S de séquence Biopython fournit un module , Bio.SeqIO pour lire et écrire des séquences depuis et vers un fichier (n"importe quel flux) respectivement. Il prend en charge presque tous les formats de fichiers disponibles en bioinformatique. La plupart des logiciels fournissent des approche t pour différents formats de fichiers. Mais, Biopython suit consciemment une approche unique pour présenter les données de séquence analysées à l"utilisateur via son objet SeqRecord. Apprenons-en plus sur SeqRecord dans la section suivante. SeqRecord Le module Bio.SeqRecord fournit SeqRecord pour contenir les méta-informations de la séquence ainsi que les données de la séquence elles-mêmes comme indiqué ci-dessous - seq - C"est une séquence réelle. id - C"est l"identifiant principal de la séquence donnée. Le type par défaut est chaîne. nom - C"est le nom de la séquence. Le type par défaut est une chaîne. deion - Il affiche des informations lisibles par l"homme sur la séquence. annotations - C"est un dictionnaire d"informations supplémentaires sur la séquence. Le SeqRecord peut être importé comme spécifié ci-dessous from Bio.SeqRecord import SeqRecord Comprenons les nuances de l"analyse du fichier de séquence en utilisant un fichier de séquence réel dans les sections à venir. Analyse Formats de fichier de séquence Cette section explique comment analyser deux des formats de fichier de séquence les plus courants, FASTA et GenBank . FASTA FASTA est le format de fichier le plus basique pour stocker des données de séquence. À l"origine, FASTA est un logiciel pour l"alignement de séquences d"ADN et de protéines développé au début de l"évolution de la bioinformatique et utilisé principalement pour rechercher la similitude de séquence. Biopython fournit un exemple de fichier FASTA et il est accessible à l"adresse https:// github .com / biopython / biopython / blob / master / Doc / examples / ls_orchid.fasta. Téléchargez et enregistrez ce fichier dans votre répertoire d"exemples Biopython sous "orchid.fasta" . Le module Bio.SeqIO fournit la méthode parse () pour traiter séquenc e fichiers et peuvent être importés comme suit - à partir de l"analyse d"importation Bio.SeqIO la méthode parse () contient deux arguments, le premier est le deeur de fichier et le second est le format de fichier. >>> file = open ( "path / to / biopython / sample / orchid.fasta ") >>> pour enregistrer dans parse (file, "fasta "): ... print (record.id) ... gi | 2765658 | emb | Z78533.1 | CIZ78533 gi | 2765657 | emb | Z78532.1 | CCZ78532 ..... ..... .......... gi | 2765565 | emb | Z78440.1 | PPZ78440 gi | 2765564 | emb | Z78439.1 | PBZ78439 >>> Ici, le parse () renvoie un objet itérable qui renvoie SeqRecord à chaque itération. Étant itérable, il fournit de nombreuses méthodes sophistiquées et simples et nous permet de voir quelques-unes des fonctionnalités. next () next () La méthode renvoie la élément suivant disponible dans l"objet itérable, que nous pouvons utiliser pour obtenir la première séquence comme indiqué ci-dessous - >>> first_seq_record = next (SeqIO.parse (open ( "chemin / vers / biopython / sample / orchid.fasta "), "fasta ")) >>> first_seq_record.id "gi | 2765658 | emb | Z78533.1 | CIZ78533 " >>> first_seq_record. name "gi | 2765658 | emb | Z78533.1 | CIZ78533 " >>> first_seq_record.seq Seq ( "CGTAACAAGGTTTCCGTAGGTGAACCTGCGGAAGGATCATTGATGAGACCGTGG ... CGC ", SingleLetterAlphabet. emb | Z78533.1 | CIZ78533 Gène d"ARNr C.irapeanum 5.8S et ADN ITS1 et ITS2 ">>> first_seq_record.annotations {} >>> Ici, seq_record.annotations est vide car le format FASTA ne prend pas en charge les annotations de séquence. compréhension de liste Nous pouvons convertir l"objet itérable en liste u chanter la compréhension de la liste comme indiqué ci-dessous >>> seq_iter = SeqIO.parse (open ( "path / to / biopython / sample / orchid.fasta "), "fasta ") >>> all_seq = [seq_record pour seq_record dans seq_iter] >>> len (all_seq) 94 >>> Ici, nous avons utilisé la méthode len pour obtenir le nombre total. Nous pouvons obtenir une séquence de longueur maximale comme suit - >>> seq_iter = SeqIO.parse (open ( "path / to / biopython / sample / orchid.fasta "), "fasta ") >>> max_seq = max (len (seq_record.seq) pour seq_record dans seq_iter) >>> max_seq 789 >>> Nous pouvons également filtrer la séquence en utilisant le code ci-dessous - >>> seq_iter = SeqIO.parse (open ( "path / to / biopython / sample / orchid.fasta "), "fasta ") >>> seq_under_600 = [ seq_record pour seq_record dans seq_iter if len (seq_record.seq) >> pour seq dans seq_under_600: ... print (seq.id) ... gi | 2765606 | emb | Z78481.1 | PIZ78481 gi | 2765605 | emb | Z78480.1 | PGZ78480 gi | 2765601 | emb | Z78476.1 | PGZ78476 gi | 2765595 | emb | Z78470.1 | PPZ78470 gi | 2765594 | emb | Z78469.1 | PHZ78469 gi | 2765564 | emb | Z78439.1 | PBZ78439 >>> Ecrire une collection d"objets SqlRecord (données analysées) dans un fichier est aussi simple que d"appeler la méthode SeqIO.write comme ci-dessous - file = open ( "converti.fasta ", "w) SeqIO.write (seq_record, fichier , "fasta ") Cette méthode peut être utilisée efficacement pour convertir le format comme spécifié ci-dessous - file = open ( "converti .gbk ", " w) SeqIO.write (seq_record, file, "genbank ") GenBank C"est un format de séquence plus riche pour les gènes et comprend des champs pour https://github.com/biopython/biopython/blob/master/Doc/examples/ls_orchid.fasta." Téléchargez et enregistrez le fichier dans votre Biopython exemple de répertoire comme "orchid.gbk" Depuis, Biopython fournit une fonction unique, analyser pour analyser tous les formats bioinformatiques. L"analyse du format GenBank est aussi simple que de changer l"option de format dans la méthode d"analyse. Le code correspondant a été donné ci-dessous - >> > de Bio import SeqIO >>> depuis Bio.SeqIO import parse >>> seq_record = next (parse (open ( "path / to / biopython / sample / orchid.gbk "), "genbank ")) >>> seq_record .id "Z78533.1 " >>> seq_record.name "Z78533 " >>> seq_record.seq Seq ( "CGTAACAAGGTTTCCGTAGGTGAACCTGCGGAAGGATCATTGATGAGACCGTGG ... CGC ", IUPACAmbiguousDNA () C.irapeanum 5.8S rRNA et ADN ITS1 et ITS2 ">>> seq_record.annotations {" molecule_type ": " DNA ", " topology ": " linear ", " data_file_division " : "PLN ", "date ": "30 -NOV-2006 ", " accessions ": [" Z78533 "], " sequence_version ": 1, " gi " : "2765658 ", "keywords ": [ "ARN ribosomal 5.8S ", "Gène ARNr 5.8S ", "espaceur transcrit interne ", "ITS1 ", "ITS2 "], " source ": " Cypripedium irapeanum ", " organisme ": " Cypripedium irapeanum ", " taxonomie ": [" Eukaryota ", " Viridiplantae ", " Streptophyta ", " Embryophyta ", " Tracheophyta ", " Spermatophyta ", " Magnoliophyta ", " Liliopsida ", " Asparagales ", " Orchidaceae ", " Cypripedio ideae ", " Cypripedium "], " references ": [Reference (title = " Phylogenetics of the slipper orchids (Cypripedioideae: Orchidaceae): Nucléaire ADNr Séquences ITS ", ...), Reference (title = "Soumission directe ", ...)]} Biopython - Alignements de séquences L"alignement de séquences est le processus consistant à organiser deux séquences ou plus (de séquences d"ADN, d"ARN ou de protéines) dans un ordre spécifique pour identifier la région de similitude entre elles. L"identification de la région similaire nous permet de déduire de nombreuses informations telles que quels caractères sont conservés entre les espèces, comment proches des différentes espèces génétiquement, comment les espèces évoluent, etc. Biopython fournit un support étendu pour l"alignement de séquences. Apprenons quelques-unes des fonctionnalités importantes fournies par Biopython dans ce chapitre - Analyse Alignement de séquence Biopython fournit un module, Bio.AlignIO pour lire et écrire des alignements de séquence. En bioinformatique, il existe de nombreux formats disponibles pour spécifier la séquence al Ignorer les données similaires aux données de séquence apprises précédentes. Bio.AlignIO fournit une API similaire à Bio.SeqIO sauf que Bio.SeqIO fonctionne sur les données de séquence et Bio.AlignIO travaille sur les données d"alignement de séquence. Avant de commencer à apprendre, nous allons télécharger un exemple de séquence fichier d"alignement à partir d"Internet. Pour télécharger le fichier d"exemple, suivez les étapes ci-dessous - Étape 1 - Ouvrez votre navigateur préféré et accédez à http://pfam.xfam.org/family/browse" site Web. Il affichera toutes les familles Pfam par ordre alphabétique. Étape 2 - Choisissez une famille ayant moins de nombre de valeurs de départ. Il contient un minimum de données et nous permet de travailler facilement avec l"alignement. Ici, nous avons sélectionné / cliqué sur PF18225 et il ouvre aller à http : //pfam.xfam.org/family/PF18225 et montre des détails complets à ce sujet, y compris les alignements de séquence. Étape 3 - Allez à la section d"alignement et téléchargez le fichier d"alignement de séquence au format Stockholm (PF18225_seed.txt). Essayons de lire le fichier d"alignement de séquence téléchargé en utilisant Bio.AlignIO comme ci-dessous - Module d"importation Bio.AlignIO >>> from Bio import AlignIO Lire l"alignement en utilisant la méthode read. read est utilisée pour lire les données d"alignement uniques disponibles dans le fichier donné. Si le fichier donné contient de nombreux alignements, nous pouvons utiliser la méthode parse. La méthode parse renvoie un objet d"alignement itérable similaire à la méthode parse dans le module Bio.SeqIO. >>> alignement = AlignIO.read (open ( "PF18225_seed.txt ") , "stockholm ") Imprimer l"objet d"alignement. >>> print (alignement) SingleLetterAlphabet () alignement avec 6 lignes et 65 colonnes MQNTPAERLPAIIEKAKSKHDINVWLLDRQGRDLLEQRVPAKVA ... EGP B7RZ31_9GAMM / 59-123 AKQRGIAGLEEWLHRLDHSEAIPIFL IDEAGKDLLEREVPADIT ... KKP A0A0C3NPG9_9PROT / 58-119 ARRHGQEYFQQWLERQPKKVKEQVFAVDQFGRELLGRPLPEDMA ... KKP A0A143HL37_9GAMM / 57-121 TRRHGPESFRFWLERQPVEARDRIYAIDRSGAEILDRPIPRGMA ... NKP A0A0X3UC67_9GAMM / 57-121 AINRNTQQLTQDLRAMPNWSLRFVYIVDRNNQDLLKRPLPPGIM ... NRK B3PFT7_CELJU / 62-126 AVNATEREFTERIRTLPHWARRNVFVLDSQGFEIFDRELPSPVA ... TRN K4KEM7_SIMAS / 61-125 >>> Nous pouvons également vérifier les séquences (SeqRecord) disponibles dans l"alignement ainsi que ci-dessous - >>> pour l"alignement : ... print (align.seq) ... MQNTPAERLPAIIEKAKSKHDINVWLLDRQGRDLLEQRVPAKVATVANQLRGRKRRAFARHREGP AKQRGIAGLEEWLHRLDHSEAIPIFLIDEAGKDLLEREVPADITA --- RLDRRREHGEHGVRKKP ARRHGQEYFQQWLERQPKKVKEQVFAVDQFGRELLGRPLPEDMAPMLIALNYRNRESHAQVDKKP TRRHGPESFRFWLERQPVEARDRIYAIDRSGAEILDRPIPRGMAPLFKVLSFRNREDQGLVNNKP AINRNTQQLTQDLRAMPNWSLRFVYIVDRNNQDLLKRPLPPGIMVLAPRLTAKHPYDKVQDRNRK AVNATEREFTERIRTLPHWARRNVFVLDSQGFEIFDRELPSPVADLMRKLDLDRPFKKLERKNRT >>> Alignements multiples En général, la plupart des les fichiers d"alignement de séquence contiennent des données d"alignement uniques et il suffit d"utiliser la méthode read pour les analyser. Dans le concept d"alignement de séquences multiples, deux séquences ou plus sont comparées pour obtenir les meilleures correspondances de sous-séquences entre elles et aboutit à un alignement de séquences multiples dans un seul fichier. Si le format d"alignement de séquence d"entrée contient plus d"un alignement de séquence, alors nous devons utiliser la méthode parse au lieu de la méthode read comme spécifié ci-dessous - >>> de Bio import AlignIO >>> alignments = AlignIO.parse (open ( "PF18225_seed.txt "), "stockholm ") >>> print (alignements) >>> pour l"alignement dans les alignements: .. . imprimer (alignement) ... SingleLetterAlphabet alignement () avec 6 lignes et 65 colonnes MQNTPAERLPAIIEKAKSKHDINVWLLDRQGRDLLEQRVPAKVA ... EGP B7RZ31_9GAMM / 59-123 AKQRGIAGLEEWLHRLDHSEAIPIFLIDEAGKDLLEREVPADIT ... KKP A0A0C3NPG9_9PROT / 58-119 ARRHGQEYFQQWLERQPKKVKEQVFAVDQFGRELLGRPLPEDMA ... KKP A0 A143HL37_9GAMM / 57-121 TRRHGPESFRFWLERQPVEARDRIYAIDRSGAEILDRPIPRGMA ... NKP A0A0X3UC67_9GAMM / 57-121 AINRNTQQLTQDLRAMPNWSLRFVYIVDRNNQDLLKRPLPPGIM ... NRK B3PFT7_CELJU / 62-126 AVNATEREFTERIRTLPHWARRNVFVLDSQGFEIFDRELPSPVA ... TRN K4KEM7_SIMAS / 61-125 >>> Ici, parse méthode renvoie objet d"alignement itérable et il peut être itéré pour obtenir des alignements réels. Alignement de séquence par paire L"alignement de séquence par paire ne compare que deux séquences à la fois et fournit le meilleur alignements de séquence possibles. Pairwise est facile à comprendre et exceptionnel à déduire de l"alignement de séquence résultant. Biopython fournit un module spécial, Bio.pairwise2 pour identifier la séquence d"alignement en utilisant la méthode par paires. Biopython applique le meilleur algorithme pour trouver la séquence d"alignement et il est comparable à d"autres logiciels. Écrivons un exemple pour trouver l"alignement de séquence de deux séquences simples et hypothétiques en utilisant le module par paires. Cela nous aidera à comprendre le concept d"alignement de séquence et comment le programmer en utilisant Biopython. Étape 1 Importez le module pairwise2 avec la commande donnée ci-dessous - >>> from Bio import pairwise2 Étape 2 Créez deux séquences, seq1 et seq2 - >>> depuis Bio.Seq import Seq >>> seq1 = Seq ( "ACCGGT ") >>> seq2 = Seq ( "ACGT ") Étape 3 Appelez la méthode pairwise2.align.globalxx avec seq1 et seq2 pour trouver les alignements en utilisant la ligne de code ci-dessous - >>> alignments = pairwise2.align.globalxx (seq1, seq2) Ici, la méthode globalxx effectue le travail réel et trouve tous les meilleurs alignements possibles dans les séquences données. En fait, Bio.pairwise2 fournit tout un ensemble de méthodes qui suivent la convention ci-dessous pour trouver des alignements dans différents scénarios. XY Elle e, le type d"alignement de séquence fait référence au type d"alignement qui peut être global ou local. Le type global consiste à rechercher l’alignement des séquences en prenant en compte la séquence entière. le type local consiste à trouver l"alignement des séquences en examinant également le sous-ensemble des séquences données. Ce sera fastidieux mais fournit une meilleure idée de la similitude entre les séquences données. X fait référence au score correspondant. Les valeurs possibles sont x (correspondance exacte), m (score basé sur des caractères identiques), d (dictionnaire fourni par l"utilisateur avec caractère et score de correspondance) et enfin c (fonction définie par l"utilisateur pour fournir un algorithme de notation personnalisé). Y se réfère à la pénalité d"écart. Les valeurs possibles sont x (pas de pénalités d"intervalle), s (mêmes pénalités pour les deux séquences), d (pénalités différentes pour chaque séquence) et enfin c (fonction définie par l"utilisateur pour fournir des pénalités d"écart personnalisées) Donc, localds est également une méthode valide, qui trouve l"alignement de séquence en utilisant la technique d"alignement local, le dictionnaire fourni par l"utilisateur pour les correspondances et la pénalité de décalage fournie par l"utilisateur pour les deux séquences. >>> test_alignments = pairwise2.align.localds (seq1, seq2, blosum62, -10, -1) Ici, blosum62 fait référence à un dictionnaire disponible dans le module pairwise2 pour fournir un score de correspondance . -10 fait référence à la pénalité d"ouverture de l"écart et -1 se réfère à la pénalité d"extension de l"écart. Étape 4 Boucle sur l"objet d"alignements itérable et récupère chaque objet d"alignement individuel et l"imprime. >>> pour l"alignement dans les alignements: ... print (alignement) ... ( "ACCGGT ", "AC-GT ", 4.0, 0, 6) ( "ACCGGT ", "AC - GT ", 4.0, 0, 6) ( "ACCGGT ", "A-CG-T ", 4.0, 0, 6) ( " ACCGGT ", " AC-GT ", 4.0, 0, 6) Étape 5 Le module Bio.pairwise2 fournit une méthode de formatage, format_alignment pour mieux visualiser le résultat - >>> de Bio.pairwise2 import format_alignment >>> alignments = pairwise2 .align.globalxx (seq1, seq2) >>> pour l"alignement dans les alignements: ... print (format_alignment (* alignement)) ... ACCGGT | | || Score A-C-GT = 4 ACCGGT || || Score AC - GT = 4 ACCGGT | || | Score A-CG-T = 4 ACCGGT || | | AC-G-T Score = 4 >>> Biopython fournit également un autre module pour faire l"alignement de séquence, Align. Ce module fournit un ensemble différent d"API pour simplement définir des paramètres tels que l"algorithme, le mode, le score de correspondance, les pénalités d"écart, etc., Un simple regard sur l"objet Align est le suivant - >>> from Bio import Align >>> aligner = Align.PairwiseAligner () >>> print (aligner) Aligneur de séquence par paires avec paramètres score de correspondance: 1,000000 score de discordance: 0,000000 score de l"écart ouvert cible: 0,00000000 cible élargir l"écart score: 0.000000 score de l"écart de la cible à gauche ouvert: 0.000000 score de l"écart de la cible à gauche: 0.000000 score du gap de l"ouverture de la cible à droite: 0.000000 score de l"écart de la cible à droite: 0,000000 score de l"écart de l"ouverture de la requête: 0,000000 score de l"écart de la prolongation de la requête: 0,000000 score de l"écart de l"ouverture de la gauche: 0,000000 requête à gauche étendre le score de l"écart: 0,000000 requête à droite score de l"écart: 0,000000 requête à droite étendre le score de l"écart: 0,000000 mode: global >>> Prise en charge des outils d"alignement de séquence Biopython fournit une interface pour de nombreux outils d"alignement de séquences via Bio.Align.Applicati module ons. Certains des outils sont listés ci-dessous - ClustalW MUSCLE EMBOSS aiguille et eau Écrivons un exemple simple en Biopython pour créer un alignement de séquence via l"outil d"alignement le plus populaire, ClustalW. Étape 1 - Téléchargez le programme Clustalw depuis http://www.clustal.org/download/current/" et installez-le. Mettez également à jour le PATH système avec le chemin d"installation «clustal». Étape 2 - importez ClustalwCommanLine à partir du module Bio.Align.Applications. >>> de Bio.Align.Applicati ons import ClustalwCommandline Étape 3 - Définissez cmd en appelant ClustalwCommanLine avec le fichier d"entrée, opuntia.fasta disponible dans le package Biopython. https:// raw.githubusercontent.com/biopython/biopython/master/Doc/examples/opuntia.fasta >> cmd = ClustalwCommandline ( "clustalw2 " , infile = "/ chemin / vers / biopython / sample / opuntia.fasta ") >>> print (cmd) clustalw2 -infile = fasta / opuntia.fasta Étape 4 - L"appel de cmd () exécutera la commande clustalw et donnera une sortie du fichier d"alignement résultant, opuntia.aln. >>> stdout, stderr = cmd ( ) Étape 5 - Lisez et imprimez le fichier d"alignement comme ci-dessous - >>> depuis Bio import p> >> align = AlignIO.read ( "/ chemin / vers / biopython / sample / opuntia.aln ", "clustal ") >>> print (aligner) l"alignement SingleLetterAlphabet () avec 7 lignes et 906 colonnes TATACATTAAAGAAGGGGGATGCGATAAATGGAAAGGCGAAAG. ..AGA gi | 6273285 | fr | AF191659.1 | AF191 TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG ... AGA gi | 6273284 | fr | AF191658.1 | AF191 TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG ... AGA gi | 6273287 | fr | AF191661.1 | AF191 TATACATAAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG ... AGA gi | 6273286 | fr | AF191660.1 | AF191 TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG ... AGA gi | 6273290 | gb | AF191664.1 | AF191 TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG ... AGA gi | 6273289 | gb | AF191663.1 | AF191 TATACATTAAAGGAGGGGGGGGGGATGCGGATAAATGGAAAGGCGAAAG ... AGA gi | 6273289 | gb | AF191663.1 | AF191 TATACATTAAAGGAGGGGGGGATGGGATGCGGATAAATGGAAAGGCGAAAG ... AGA gi | 6273289 | gb | AF191663.1 | AF191 TATACATTAAAGGAGGGGGGGATGCGATA19 Biopython - Présentation de BLAST BLAST signifie Basic Local Alignment Search Tool . Il trouve des régions de similitude entre les séquences biologiques. Biopython fournit le module Bio.Blast pour gérer le fonctionnement NCBI BLAST. Vous pouvez exécuter BLAST en connexion locale ou via une connexion Internet. Comprenons-les deux connexions en bref dans la section suivante - Courir sur Internet Biopython fournit le module Bio.Blast.NCBIWWW pour appeler la version en ligne de BLAST. Pour ce faire, nous devons importer le module suivant - >>> de Bio.Blast import NCBIWWW Le module NCBIWW fournit la fonction qblast pour interroger la version en ligne de BLAST, https:// blast .ncbi.nlm.nih.gov / Blast.cgi . qblast prend en charge tous les paramètres pris en charge par la version en ligne. Pour obtenir de l"aide sur ce module, utilisez la commande ci-dessous et comprenez les fonctionnalités - >>> help (NCBIWWW.qblast) Aide sur la fonction qblast dans le module Bio.Blast.NCBIWWW: qblast (programme, base de données, séquence, url_base = "https://blast.ncbi.nlm.nih.gov/Blast.cgi" ", auto_format = None, composition_based_statistics = None, db_genetic_code = None, endpoints = None, entrez_query = " (none) ", expect = 10.0, filter = None, gapcosts = None, gene_code = None, hitlist_size = 50, i_thresh = Aucun, layout = None, lcase_mask = None, matrix_name = None, nucl_penalty = None, nucl_reward = None, other_advanced = None, perc_ident = None, phi_pattern = None, query_file = None, query_believe_defline = None, query_from = None, query_to = None , searchsp_eff = None, service = None, threshold = None, ungapped_alignment = None, word_size = None, alignments = 500, align_view = None, descrip tions = 500, entrez_s_new_window = Aucun, expect_low = Aucun, expect_high = Aucun, format_entrez_query = Aucun, format_object = Aucun, format_type = "XML ", ncbi_gi = Aucun, results_file = Aucun, show_overview = Aucun, megablast = Aucun, template_type = Aucun Aucun, template_length = None) Recherche BLAST à l"aide du serveur QBLAST de NCBI ou d"un fournisseur de services cloud. Prend en charge tous les paramètres de l"API qblast pour Put and Get. Veuillez noter que BLAST sur le cloud prend en charge le point d"accès URL commun NCBI-BLAST Je (http://ncbi.github.io/blast-cloud/dev/api.html)." Pour utiliser cette fonctionnalité, veuillez définir url_base sur "http://host.my.cloud.service.provider.com/cgi-bin/blast.cgi" " et format_object = "Alignment ". Pour plus de détails, voir 8. Biopython - Présentation de BLAST https://blast.ncbi.nlm.nih.gov/Blast.cgi"?PAGE_TYPE = BlastDocs & DOC_TYPE = CloudBlast Quelques paramètres utiles: - programme blastn, blastp, blastx, tblastn, ou tblastx (minuscules) - base de données Dans quelle base de données rechercher (par exemple "nr "). - séquence La séquence à rechercher. - ncbi_gi TRUE / FALSE s"il faut donner l"identifiant "gi ". - deions Nombre de deions à afficher. Def 500. - alignments Nombre d"alignements à afficher. Def 500. - expect Une valeur limite attendue. Def 10.0. - matrice_name Spécifiez un alt. matrice (PAM30, PAM70, BLOSUM80, BLOSUM45). - le filtre "aucun " désactive le filtrage. Par défaut, aucun filtrage - type_format "HTML ", "Texte ", "ASN.1 " ou "XML ". Def. "XML ". - entrez_query Entrez la requête pour limiter la recherche Blast - hitlist_size Nombre de résultats à renvoyer. Par défaut 50 - megablast TRUE / FALSE utiliser ou non l"algorithme MEga BLAST (blastn uniquement) - service plain, psi, phi, rpsblast, megablast (minuscules) Cette fonction ne vérifie pas la validité des paramètres et transmet les valeurs au serveur comme si. Plus d"aide est disponible sur: https://ncbi.github.io/blast-cloud/dev/api.html" Habituellement, les arguments de la fonction qblast sont fondamentalement analogues à différents paramètres que vous pouvez définir sur la page Web BLAST. Cela rend la fonction qblast facile à comprendre et réduit la courbe d"apprentissage pour l"utiliser. Connexion et recherche Pour comprendre le processus de connexion et de recherche de la version en ligne de BLAST, laissez-nous effectuez une recherche de séquence simple (disponible dans notre fichier de séquence local) par rapport au serveur BLAST en ligne via Biopython. Étape 1 - Créez un fichier nommé blast_example.fasta dans le répertoire Biopython et donnez les informations de séquence ci-dessous en entrée Exemple de séquence unique en format FASTA / Pearson:.> Séquence A ggtaagtcctctagtacaaacacccccaatattgtgatataattaaaattatattcatat p> Séquence B ggtaagtcctctagtacaaacacccccaatattgtgatataattaaaattatattca tattctgttgccagaaaaaacacttttaggctatattagagccatcttctttgaagcgttgtc Etape 2 - importation du module NCBIWWW >>> depuis Bio.Blast import NCBIWWW Étape 3 - Ouvrez le fichier de séquence, blast_example.fasta en utilisant le module Python IO. >>> sequence_data = open ( "blast_example.fasta "). read () >>> sequence_data "Exemple d"une seule séquence au format FASTA / Pearson: n n p> séquence A nggtaagtcctctagtacaaacacccccaatattgtgatataattaaaatt atattcatat ntctgttgccagaaaaaacacttttaggctatattagccat - Maintenant, appelez la fonction qblast en passant les données de séquence comme paramètre principal. L"autre paramètre représente la base de données (nt) et le programme interne (blastn). >>> result_handle = NCBIWWW.qblast ( "blastn ", "nt ", sequence_data) >>> result_handle blast_results contient le résultat de notre recherche. Il peut être enregistré dans un fichier pour une utilisation ultérieure et également analysé pour obtenir les détails. Nous apprendrons comment le faire dans la section suivante. Étape 5 - La même fonctionnalité peut être effectuée en utilisant l"objet Seq plutôt qu"en utilisant le fichier fasta entier comme indiqué ci-dessous - >>> from Bio import SeqIO >>> seq_record = next (SeqIO.parse (open ( "blast_example.fasta "), "fasta " )) >>> seq_record.id "sequence " >>> seq_record.seq Seq ( "ggtaagtcctctagtacaaacacccccaatattgtgatataattaaaattatat ... gtc ", SingleLetterAlphabet ()) Maintenant, appelez la fonction qblast en passant Seq object, record.seq comme paramètre principal. >>> result_handle = NCBIWWW.qblast (" blastn ", " nt ", seq_record.seq) >>> print (result_handle) BLAST attribuera automatiquement un identifiant à votre séquence. Étape 6 - l"objet result_handle aura le résultat complet et pourra être enregistré dans un fichier pour une utilisation ultérieure. >>> avec open ( "results.>> blast_results = result_handle.read () >>> save_file.write (blast_results) Nous verrons comment analyser le fichier de résultat dans la section suivante. Exécution de BLAST autonome Cette section explique comment exécuter BLAST dans système local. Si vous exécutez BLAST dans un système local, cela peut être plus rapide et vous permet également de créer votre propre base de données pour rechercher des séquences. Connexion de BLAST En général, exécuter BLAST localement n"est pas recommandé en raison de sa grande taille, des efforts supplémentaires nécessaires pour exécuter le logiciel et du coût que cela implique. utile à des fins de base et avancées. Bien sûr, vous devrez parfois l"installer localement. Considérez que vous effectuez des recherches fréquentes en ligne, ce qui peut nécessiter beaucoup de temps et un volume de réseau élevé et si vous avez des données de séquence propriétaires ou des problèmes liés à l"IP, il est recommandé de l"installer localement. Pour ce faire, nous devons suivre les étapes ci-dessous - Étape 1 - Téléchargez et installez le dernier binaire blast en utilisant le lien donné - http://weblogo.berkeley.edu/" Ajoutez la séquence ci-dessus, créez un nouveau logo et enregistrez-le l"image nommée seq.png dans votre dossier biopython. seq.png Après avoir créé l"image, exécutez maintenant la commande suivante - >>> seq.weblogo ( "seq.png ") Ce motif de séquence d"ADN est représenté comme un logo de séquence pour le LexA- motif de liaison. Base de données JASPAR JASPAR est l"une des bases de données les plus populaires. Il fournit des installations de n"importe quel format de motif pour la lecture, l"écriture et la numérisation de séquences. Il stocke des méta-informations pour chaque motif. Le module Bio.motifs contient une class spécialisée jaspar.Motif pour représenter les attributs de méta-informations . Il a les types d"attributs notables suivants - matrix_id - ID de motif JASPAR unique name - Le nom du motif tf_family - La famille de motif, par ex. ’Helix-Loop-Helix’ data_type - le type de données utilisé dans le motif. Créons un format de sites JASPAR nommé dans sample.sites dans biopy dossier thon. Il est défini ci-dessous - sample.p> MA0001 ARNT 1 p> MA0001 ARNT 2 p> MA0001 ARNT 3 p> MA0001 ARNT 4 p> MA0001 ARNT 4 AACGTGacAgc ARNT 6 cggcctCGCGTGc Dans le fichier ci-dessus, nous avons créé des instances de motif. Maintenant, créons un objet motif à partir des instances ci-dessus - >>> à partir de motifs d"importation Bio >>> avec open ( "sample.sites ") comme handle: ... data = motifs.read (handle, "sites ") ... >>> print (data) Nom TF Aucun ID de matrice Aucun Matrice: 0 1 2 3 4 5 A: 2,00 5,00 0,00 0,00 0,00 1,00 C: 3,00 0,00 5,00 0,00 0,00 0,00 0,00 G: 0,00 1,00 1,00 6,00 0,00 5,00 T: 1,00 0,00 0,00 0,00 6,00 0,00 Ici, les données lisent toutes les instances de motif du fichier sample.sites. Pour imprimer toutes les instances à partir de données, utilisez la commande ci-dessous - >>> par exemple dans data.instances: ... print (instance) .. . AACGTG CAGGTG TACGTA AACGTG CACGTG CGCGTG Utilisez la commande ci-dessous pour compter toutes les valeurs - >>> print (data.counts) 0 1 2 3 4 5 A: 2,00 5,00 0,00 0,00 0,00 1,00 C: 3,00 0,00 5,00 0,00 0,00 0,00 0,00 G: 0,00 1,00 1,00 6,00 0,00 5,00 T: 1,00 0,00 0,00 0,00 6,00 0,00 >>> Biopython - Module BioSQL BioSQL est un schéma de base de données générique conçu principalement pour stocker des séquences et ses données associées pour tous les moteurs SGBDR. Il est conçu de manière à contenir les données de toutes les bases de données bioinformatiques populaires telles que GenBank, Swissport, etc. Il peut également être utilisé pour stocker des données internes. BioSQL fournit actuellement un schéma spécifique pour les bases de données ci-dessous - MySQL (biosqldb-mysql.s ql) PostgreSQL (biosqldb-pg.sql) Oracle (biosqldb-ora / *. sql) SQLite (biosqldb-sqlite.sql) Il fournit également un support minimal pour les bases de données Java HSQLDB et Derby. BioPython fournit des capacités ORM très simples, faciles et avancées pour travailler avec une base de données basée sur BioSQL. BioPython fournit un module, BioSQL pour faire les fonctionnalités suivantes - Créer / supprimer une base de données BioSQL Connect à une base de données BioSQL Analyser une base de données de séquences comme GenBank, Swisport, résultat BLAST, résultat Entrez, etc., et la charger directement dans la base de données BioSQL Récupérer les données de séquence depuis le Base de données BioSQL Récupérez les données de taxonomie de NCBI BLAST et stockez-les dans la base de données BioSQL Exécutez n"importe quelle requête SQL sur la base de données BioSQL Vue d"ensemble de Schéma de base de données BioSQL Avant d"aller plus loin dans BioSQL, comprenons les bases du schéma BioSQL. Le schéma BioSQL fournit plus de 25 tables pour contenir des données de séquence, une fonction de séquence, une catégorie de séquence / ontologie et des informations de taxonomie. Certains des tableaux importants sont les suivants - biodatabase bioentry biosequence seqfeature taxon taxon_name antologie terme dxref Créer une base de données BioSQL Dans cette section, créons un exemple de base de données BioSQL, biosql en utilisant le schéma fourni par l"équipe BioSQL. Nous travaillerons avec la base de données SQLite car il est vraiment facile de démarrer et n"a pas de configuration complexe. Ici, nous allons créer une base de données BioSQL basée sur SQLite en utilisant les étapes ci-dessous. Étape 1 - Téléchargez le moteur de base de données SQLite et installez-le. Étape 2 - Téléchargez le projet BioSQL à partir de l"URL GitHub. https://github.com/biosql/biosql" Étape 3 - Ouvrez une console et créez un répertoire en utilisant mkdir et entrez-y. cd / path / to / your / biopython / sample mkdir sqlite-biosql cd sqlite-biosql Étape 4 - Exécutez la commande ci-dessous pour créer une nouvelle base de données SQLite. > sqlite3.exe mybiosql.db SQLite version 3.25.2 2018-09-25 19:08:10 Entrez ". help " pour des conseils d"utilisation. p> Étape 5 - Copiez le fichier biosqldb-sqlite.sql du projet BioSQL (/ sql / biosqldb-sqlite.sql`) et stockez-le dans le répertoire courant. Étape 6 - Exécutez la commande ci-dessous pour créer toutes les tables. p> .read biosqldb-sqlite. sql Maintenant, toutes les tables sont créées dans notre nouvelle base de données. Étape 7 - Exécutez la commande ci-dessous pour voir toutes les nouvelles tables de notre base de données. p> .headers sur p> .mode colonne p> .separator ROW " n " p> SELECT nom FROM sqlite_master WHERE type = "table "; biodatabase taxon taxon_name ontologie terme term_synonym term_dbxref term_relationship term_relationship_term term_path BioEntry bioentry_relationship bioentry_path biosequence dbxref dbxref_qualifier_value bioentry_dbxref référence bioentry_reference commentaire bioentry_qualifier_value seqfeature seqfeature_relationship seqfeature_path seqfeature_qualifier_value seqfeature_dbxref emplacement location_qualifier_value p> Les trois premières commandes sont des commandes de configuration pour configurer SQLite pour montrer la résultat de manière formatée. Étape 8 - Copiez le fichier d"exemple GenBank, ls_orchid.gbk fourni par l"équipe BioPython https://raw.githubusercontent.com/biopython/biopython/master/Doc/" examples / ls_orchid.gbk dans le répertoire courant et enregistrez-le sous orchid.gbk. Étape 9 - Créez un python, load_orchid.py en utilisant le code ci-dessous et exécutez-le. depuis Bio importer SeqIO depuis BioSQL importer BioSeqDatabase import os server = BioSeqDatabase.open_database (driver = "sqlite3 ", db = " orchid.db ") db = server.new_database (" orchid ") count = db.load (SeqIO.parse ( "orchid.gbk ", "gb "), True) server.commit () server.close () Le code ci-dessus analyse l"enregistrement dans le et le convertit en objets python et l"insère dans la base de données BioSQL. Nous analyserons le code dans la section ultérieure. Enfin, nous avons créé une nouvelle base de données BioSQL et y avons chargé quelques exemples de données. Nous discuterons de la tables importantes dans le chapitre suivant. Diagramme ER simple biodatabase table est en haut de la hiérarchie et son objectif principal est d"organiser un ensemble de séquencer les données dans un seul groupe / base de données virtuelle. Chaque entrée de la biodatabase fait référence à une base de données distincte et ne se mêle pas à une autre base de données. Toutes les tables associées de la base de données BioSQL ont des références à l"entrée de la biodatabase. bioentrée tableau h olds tous les détails d"une séquence à l"exception des données de séquence. les données de séquence d"une bioentrée particulière seront stockées dans la table biosequence . taxon et taxon_name sont des détails de taxonomie et chaque entrée fait référence à cette table pour spécifier son taxon informations. Après avoir compris le schéma, examinons quelques requêtes dans la section suivante. Requêtes BioSQL Explorons quelques requêtes SQL pour mieux comprendre comment les données sont organisés et les tables sont liées les unes aux autres. Avant de continuer, ouvrons la base de données en utilisant la commande ci-dessous et définissons quelques commandes de formatage - > sqlite3 orchid.db SQLite version 3.25.2 2018-09-25 19: 08:10 Entrez ". Help " pour obtenir des conseils d"utilisation. p> .header sur p> colonnes .mode .header et .mode sont des options de formatage pour mieux visualiser le da ta . Vous pouvez également utiliser n"importe quel éditeur SQLite pour exécuter la requête. Répertoriez la base de données de séquences virtuelles disponible dans le système comme indiqué ci-dessous - sélectionnez * dans biodatabase; *** Résultat *** p> .width 15 15 15 15 p> sélectionnez * dans la base de données biologique; deion de l"autorité de nom biodatabase_id --------------- --------------- --------------- - -------------- 1 orchidée p> Ici, nous n"avons qu"une seule base de données, orchid . Liste les entrées (3 premiers) disponibles dans la base de données orchid avec le code ci-dessous sélectionnez be. *, bd.name à partir de la bioentrée être jointure interne biodatabase bd sur bd.biodatabase_id = be.biodatabase_id où bd.name = "orchid " Limit 1, 3; *** Résultat *** p> .width 15 15 10 10 10 10 10 50 10 10 p> sélectionnez be. *, Bd.name from bioentry be inner join biodatabase bd on bd.biodatabase_id = be.biodatabase_id où bd.name = "orchidée " Limite 1,3; bioentry_id biodatabase_id nom taxon_id identificateur d"accession deion de la Lister les détails de séquence associés à une entrée (accession - Z78530, nom - C. fasciculatum 5.8S rRNA gene et ITS1 et ITS2 DNA) avec le code donné - select substr (cast (bs.seq as varchar), 0, 10) || "... " comme seq, bs.length, be.accession, be.deion, bd.name de la biosequence bs jointure interne bioentry be on be.bioentry_id = bs.bioentry_id jointure interne biodatabase bd sur bd.biodatabase_id = be .biodatabase_id où bd.name = "orchidée " et be.accession = "Z78532 "; *** Résultat *** p> .width 15 5 10 50 10 p> select substr (cast (bs.seq as varchar), 0, 10) || "... " comme seq, bs.length, be.accession, be.deion, bd.name de la biosequence bs jointure interne bioentry be on be.bioentry_id = bs.bioentry_id jointure interne biodatabase bd sur bd.biodatabase_id = be .biodatabase_id où bd.name = "orchidée " et be.accession = "Z78532 "; nom de deion d"accession de longueur seq ------------ ---------- ---------- ------------ - ----------- ---------- ---------- ----------------- CGTAACAAG. .. 753 Z78532 C.californicum 5.8S rRNA gene and ITS1 and ITS2 DNA orchid p> Obtenez la séquence complète associée à une entrée (accession - Z78530, nom - C. fasciculatum Gène d"ARNr 5.8S et ADN ITS1 et ITS2) en utilisant le code ci-dessous - sélectionnez bs.seq à partir de la biosequence bs jointure interne bioentry be on be.bioentry_id = bs.bioentry_id jointure interne biodatabase bd sur bd.biodatabase_id = be.biodatabase_id où bd.name = "orchid " et be.accession = "Z78532 "; *** Résultat *** p> .width 1000 p> sélectionnez bs.seq de la biosequence bs jointure interne bioentry be on be.bioentry_id = bs.bioentry_id jointure interne biodatabase bd sur bd.biodatabase_id = be.biodatabase_id où bd.name = "orchidée " et be.accession = "Z78532 "; seq ------------------------------------------------- --------------------------------------- ----------- ----------------- CGTAACAAGGTTTCCGTAGGTGAACCTGCGGAAGGATCATTGTTGAGACAACAGAATATATGATCGAGTGAATCT GGAGGACCTGTGGTAACTCAGCTCGTCGTGGCACTGCTTTTGTCGTGACCCTGCTTTGTTGTTGGGCCTCC TCAAGAGCTTTCATGGCAGGTTTGAACTTTAGTACGGTGCAGTTTGCGCCAAGTCATATAAAGCATCACTGATGAATGACATTATTGT CAGAAAAAATCAGAGGGGCAGTATGCTACTGAGCATGCCAGTGAATTTTTATGACTCTCGCA ACGGATATCTTGGCTC TAACATCGATGAAGAACGCAG p> Liste des taxons associés à la base de données bio, orchidée sélectionnez distinct tn.name de la biodatabase d jointure interne bioentry e sur e.biodatabase_id = d.biodatabase_id jointure interne taxon t sur t.taxon_id = e.taxon_id jointure interne nom_taxe tn sur tn.taxon_id = t.taxon_id où d.name = "orchid " limit 10; *** Résultat *** p> sélectionnez tn.name distinct de la biodatabase d jointure interne bioentry e sur e.biodatabase_id = d.biodatabase_id jointure interne taxon t sur t.taxon_id = e.taxon_id jointure interne nom_taxon tn sur tn.taxon_id = t.taxon_id où d.name = "orchidée " limite 10; nom ------------------------------ Cypripedium irapeanum Cypripedium californicum Cypripedium fasciculatum Cypripedium margaritaceum Cypripedium lichiangense Cypripedium yatabeanum Cypripedium guttatum Cypripedium acaule pink lady "s slipper Cypripedium formosanum p> Charger des données dans la base de données BioSQL Apprenons comment charger des données de séquence dans la base de données BioSQL dans ce chapitre. Nous avons déjà le code pour charger les données dans la base de données dans la section précédente et le code est le suivant - from Bio import SeqIO from BioSQL import BioSeqDatabase import os server = BioSeqDatabase. open_database (driver = "sqlite3 ", db = "orchid.db ") DBSCHEMA = "biosqldb-sqlite.sql " SQL_FILE = os.path.join (os.getcwd (), DBSCHEMA) server.load_database_sql (SQL_FILE) server.commit () db = server.new_database ( "orchid ") count = db.load (SeqIO.parse ( "orchid.gbk ", "gb "), True) server.commit () server.close () Nous examinerons plus en détail chaque ligne du code et son but - Ligne 1 - Charge la SeqIO module. Ligne 2 - Charge le module BioSeqDatabase. Ce module fournit toutes les fonctionnalités pour interagir avec la base de données BioSQL. Ligne 3 - Charge le module os. Ligne 5 - open_database ouvre la base de données spécifiée (db) avec le pilote configuré (lecteur r) et renvoie un handle vers la base de données BioSQL (serveur). Biopython prend en charge les bases de données sqlite, mysql, postgresql et oracle. Line 6-10 - la méthode load_database_sql charge le sql à partir du fichier externe et l"exécute. La méthode commit valide la transaction. Nous pouvons sauter cette étape car nous avons déjà créé la base de données avec le schéma. Ligne 12 - Les méthodes new_database créent une nouvelle base de données virtuelle, orchidée et retourne un handle db pour exécuter la commande contre le base de données orchid. Ligne 13 - la méthode de chargement charge les entrées de séquence (SeqRecord itérable) dans la base de données orchid. SqlIO.parse analyse la base de données GenBank et renvoie toutes les séquences qu"elle contient en tant que SeqRecord itérable. Le deuxième paramètre (True) de la méthode de chargement lui demande de récupérer les détails de taxonomie des données de séquence sur le site Web NCBI Blast, si elles ne sont pas déjà disponibles dans le système. Ligne 14 - commit valide la transaction. Ligne 15 - close ferme la connexion à la base de données et détruit le deeur du serveur. Récupérer les données de séquence Récupérons une séquence avec l"identifiant, 2765658 de la base de données orchid comme ci-dessous - depuis BioSQL import BioSeqDatabase server = BioSeqDatabase.open_database (driver = "sqlite3 ", db = "orchid.db ") db = server [ "orchid "] seq_record = db.lookup (gi = 2765658) print (seq_record.id, seq_record.deion [: 50] + ".. . ") print (" Longueur de séquence% i, "% len (seq_record.seq)) Ici, le serveur [" orchid "] renvoie le handle pour récupérer les données de la base de données virtuelleorchid. La méthode lookup fournit une option pour sélectionner des séquences en fonction de critères et nous avons sélectionné la séquence avec l"identifiant, 2765658. lookup renvoie les informations de séquence sous la forme SeqRecordobject. Puisque nous savons déjà comment travailler avec SeqRecord`, il est facile d"en obtenir des données. Supprimer une base de données Supprimer une base de données est aussi simple que d"appeler la méthode remove_database avec nom de la base de données, puis en le validant comme spécifié ci-dessous - du serveur BioSQL import BioSeqDatabase = BioSeqDatabase.open_database (driver = "sqlite3 ", db = "orchid.db ") serveur .remove_database ( "orchids ") server.commit () Biopython - Génétique des populations La génétique des populations joue un rôle important dans la théorie de l"évolution. Il analyse la différence génétique entre les espèces ainsi que deux individus ou plus au sein de la même espèce. Biopython fournit le module Bio.PopGen pour la génétique des populations et supporte principalement `GenePop, un progiciel de génétique populaire développé par Michel Raymond et François Rousset. Un analyseur simple Écrivons une application simple pour analyser le format GenePop et comprendre le concept. Téléchargez le fichier genePop fourni par Biopython équipe dans le lien ci-dessous - https://raw.githubusercontent.com/biopython/biopython/master/Tests/PopGen/c3line.gen" Chargez le module GenePop en utilisant l"extrait de code ci-dessous - from Bio.PopGen import GenePop Analysez le fichier en utilisant la méthode GenePop.read comme ci-dessous - record = GenePop.read (open ( "c3line.gen ")) Afficher le informations sur les locus et la population comme indiqué ci-dessous - >>> record.loci_list [ "136255903 ", "136257048 ", "136257636 "] >> > record.pop_list [ "4 ", "b3 ", "5 "] >>> record.populations [[( "1 ", [(3, 3), (4, 4) , (2, 2)]), ( "2 ", [(3, 3), (3, 4), (2, 2)]), ( "3 ", [(3, 3) , (4, 4), (2, 2)]), ( "4 ", [(3, 3), (4, 3), (Aucun, Aucun)])], [( "b1 ", [(Aucun, Aucun), (4, 4), (2, 2)]), (" b2 ", [(Aucun, Aucun), (4, 4), (2, 2)]) , ( "b3 ", [(Aucun, Aucun), (4, 4), (2, 2)])], [( "1 ", [(3, 3), (4, 4) , (2, 2)]), ( "2 ", [(3, 3), (1, 4), (2, 2)]), ( "3 ", [(3, 2) , (1, 1), (2, 2)]), ( "4 ", [(Aucun, Aucun), (4, 4), (2, 2)] ), ( "5 ", [(3, 3), (4, 4), (2, 2)])]] >>> Ici, il y a trois loci disponibles dans le fichier et trois ensembles de population: la première population a 4 enregistrements, la deuxième population a 3 enregistrements et la troisième population a 5 enregistrements. record.populations montre tous les ensembles de population avec des données d"allèles pour chaque locus. Manipuler le fichier GenePop Biopython fournit des options pour supprimer les données de locus et de population. Supprimer une population définie par position, >>> record.remove_population (0) >>> record.populations [[( "b1 ", [(Aucun, Aucun), (4, 4), (2, 2)]), (" b2 ", [(Aucun, Aucun), (4, 4), (2, 2)] ), ( "b3 ", [(Aucun, Aucun), (4, 4), (2, 2)])], [( "1 ", [(3, 3), (4, 4 ), (2, 2)]), ( "2 ", [(3, 3), (1, 4), (2, 2)]), ( "3 ", [(3, 2 ), (1, 1), (2, 2)]), ( "4 ", [(Aucun, Aucun), (4, 4), (2, 2)]), ( "5 " , [(3, 3), (4, 4), (2, 2)])]] >>> Supprimer un lieu par position, >>> record.remove_locus_by_position (0) >>> record.loci_list [ "136257048 ", "136257636 "] >>> record.populations [[( " b1 ", [(4, 4), (2, 2)]), (" b2 ", [(4, 4), (2, 2)]), (" b3 ", [( 4, 4), (2, 2)])], [( "1 ", [(4, 4), (2, 2)]), ( "2 ", [(1, 4) , (2, 2)]), ( "3 ", [(1, 1), (2, 2)]), (" 4 ", [(4, 4), (2, 2)]), (" 5 ", [(4, 4), (2, 2)])]] >>> Supprimer un locus par son nom, >>> record.remove_locus_by_name ( "136257636 ") >>> record.loci_list [ "136257048 "] >>> record.populations [[( "b1 ", [(4, 4)]), ( "b2 ", [(4, 4)]), ( "b3 ", [(4, 4)])], [( "1 ", [(4, 4)]), ( "2 ", [(1, 4)]), ( "3 ", [(1, 1)]), ( "4 ", [(4, 4)]), ( "5 ", [(4, 4)])]] >>> Interface avec le logiciel GenePop Biopython fournit des interfaces pour interagir avec le logiciel GenePop et expose ainsi beaucoup de fonctionnalités à partir de cela. Le module Bio.PopGen.GenePop est utilisé à cet effet. Une de ces interfaces faciles à utiliser est EasyController. Laissez-nous vérifier comment analyser le fichier GenePop et faire des analyses en utilisant Eas yController. Tout d"abord, installez le logiciel GenePop et placez le dossier d"installation dans le chemin du système. Pour obtenir des informations de base sur le fichier GenePop, créez un objet EasyController puis appelez la méthode get_basic_info comme spécifié ci-dessous - >>> depuis Bio.PopGen.GenePop.EasyController import p> >> ec = EasyController ( "c3line.gen ") >>> print (ec.get_basic_info ()) ([ "4 ", "b3 ", "5 "], [ "136255903 ", " 136257048 ", " 136257636 "]) >>> Ici, le premier élément est la liste de population et le deuxième élément est la liste des locus. Pour obtenir toute la liste d"allèles d"un locus particulier, appelez la méthode get_alleles_all_pops en passant le nom du locus comme spécifié ci-dessous - >>> allele_list = ec.get_alleles_all_pops ( "136255903 ")> >> print (allele_list) [2, 3] Pour obtenir une liste d"allèles par population et locus spécifiques, appelez get_alleles en passant le nom du locus et la position de la population comme indiqué ci-dessous - >>> allele_list = ec.get_alleles (0, "136255903 ") >>> print (allele_list) >>> allele_li st = ec.get_alleles (1, "136255903 ") >>> print (allele_list) >>> allele_list = ec.get_alleles (2, "136255903 ") >>> print (allele_list) [2, 3] >>> De même, EasyController expose de nombreuses fonctionnalités: fréquence allélique, fréquence génotypique, statistiques F multilocus, équilibre Hardy-Weinberg, déséquilibre de liaison, etc. Biopython - Analyse génomique Un génome est un ensemble complet d"ADN, y compris tous ses gènes. L"analyse du génome fait référence à l"étude des gènes individuels et de leurs rôles dans l"hérédité. Diagramme du génome Le diagramme du génome représente l"information génétique sous forme de graphiques. Biopython utilise le module Bio.Graphics.GenomeDiagram pour représenter GenomeDiagram. Le module GenomeDiagram nécessite l"installation de ReportLab. Étapes de création d"un diagramme Le processus de création d"un diagramme suit généralement le modèle simple ci-dessous - Créez un FeatureSet pour chaque ensemble distinct d"entités que vous souhaitez afficher et ajoutez-leur des objets Bio.SeqFeature. Créez un GraphSet pour chaque graphique que vous souhaitez afficher, et ajoutez-leur des données graphiques. Créez une piste pour chaque piste que vous voulez sur le diagramme, et ajoutez des GraphSets et FeatureSets aux pistes que vous require. Créez un diagramme et ajoutez-y les pistes. Dites au diagramme de dessiner l"image. Ecrivez l"image dans un fichier. Prenons un exemple de fichier GenBank d"entrée - https://raw.githubusercontent.com/biopython/biopython/master/Doc/"examples/ls_orchid.gbk et lisez les enregistrements de l"objet SeqRecord puis dessinez enfin un diagramme du génome. Il est expliqué ci-dessous, Nous allons d"abord importer tous les modules comme indiqué ci-dessous - >>> depuis reportlab.lib importer les couleurs >>> depuis reportlab.lib.units import cm >>> depuis Bio.Graphics importer GenomeDiagram Maintenant, importez le module SeqIO pour lire les données - >>> from Bio import SeqIO record = SeqIO.read ( "example.gb ", "genbank ") Ici, l"enregistrement lit la séquence à partir du fichier genbank. Maintenant, créez un diagramme vide pour ajouter une piste et un ensemble de fonctionnalités - >>> diagram = GenomeDiagram .Diagram ( "Yersinia pestis biovar Microtus plasmid pPCP1 ") >>> track = diagram.new_track (1, name = "Annotated Features ") >>> feature = track.new_set () Maintenant, nous pouvons appliquer des changements de thème de couleur en utilisant des couleurs alternatives du vert au gris comme défini ci-dessous - >>> pour la fonctionnalité dans record.features: >>> si fonctionnalité .type! = "gène ": >>> continuer >>> si len (fonction)% 2 == 0: >>> couleur = couleurs.bleu >>> autre: >>> couleur = couleurs.p> >> >> > feature.add_feature (feature, color = color, label = True) Vous pouvez maintenant voir la réponse ci-dessous sur votre écran - Graphics.GenomeDiagram._Feature.Feature objet à p> Graphics.GenomeDiagram._Feature.Feature object à p> Graphics.GenomeDiagram._Feature.Feature objet .GenomeDiagram._Feature.Feature object at p> Graphics.GenomeDiagram._Feature.Feature object at p> Graphics.GenomeDiagram._Feature.Feature object at 0x105d574p> dessiner un diagramme pour les enregistrements d"entrée ci-dessus - >>> diagram.draw (format = "linear ", orientation = "landscape " , pagesize = "A4 ", ... fragments = 4, start = 0, end = len (record)) >>> diagram.write ( "orchid.pdf ", "PDF ") >> > diagram.write ( "orchid.eps ", "EPS ") >>> diagram.write ( "orchid.svg ", "SVG ") >>> diagram.write ( "orchidée .png ", " PNG ") Après avoir exécuté la commande ci-dessus, vous pouvez voir l"image suivante enregistrée dans votre répertoire Biopython. ** Résultat ** genome.png Vous pouvez également dessiner l"image au format circulaire en apportant les modifications ci-dessous - >> > diagram.draw (format = "circulaire ", circulaire = True, pageize = (20 * cm, 20 * cm), ... start = 0, end = len (record), circle_core = 0.7) >>> diagram.write ( "circular.pdf ", "PDF ") Présentation des chromosomes La molécule d"ADN est conditionnée dans des structures filiformes appelées chromosomes. Chaque chromosome est composé de L"ADN s"est enroulé de nombreuses fois autour de protéines appelées histones qui soutiennent sa structure. Les chromosomes ne sont pas visibles dans le noyau de la cellule - pas même au microscope - lorsque la cellule ne se Chez l"homme, chaque cellule contient normalement 23 paires de chromosomes, pour un total de 46. Vingt- deux de ces paires, appelées autosomes, se ressemblent aussi bien chez les hommes que chez les femmes. La 23e paire, les chromosomes sexuels, diffèrent entre les hommes et les femmes. Les femelles ont deux copies du chromosome X, tandis que les mâles ont un chromosome X et un chromosome Y. Biopython - Phenotype Microarray Le phénotype est défini comme un caractère ou un trait observable présenté par un organisme contre un produit chimique ou un environnement particulier. Phenotype microarray mesure simultanément la réaction d"un organisme contre un plus grand nombre de produits chimiques et d"environnement et analyse les données pour comprendre la mutation du gène, les caractères du gène, etc. Biopython fournit un excellent module, Bio.Phenotype à analyser données phénotypiques. Apprenons à analyser, interpoler, extraire et analyser les données des microréseaux phénotypiques dans ce chapitre. Analyse Les données des micropuces phénotypiques peuvent être dans deux formats: CSV et JSON. Biopython prend en charge les deux formats. L"analyseur Biopython analyse les données de la puce de phénotype et les renvoie comme une collection d"objets PlateRecord. Chaque objet PlateRecord contient une collection d"objets WellRecord. Chaque objet WellRecord contient des données au format 8 lignes et 12 colonnes. Les huit lignes sont représentées par A à H et 12 colonnes sont représentées par 01 à 12. Par exemple, la 4 ème ligne et la 6 ème colonne sont représentées par D06. Comprenons le format et le concept de l"analyse avec l"exemple suivant - Étape 1 - Téléchargez le fichier Plates.csv fourni par l"équipe Biopython - https://raw.githubusercontent.com/biopython/biopython/master/Doc/"examples/Plates.csv Étape 2 - Chargez le module phenotpe comme ci-dessous - >>> depuis Bio import phenotype Étape 3 - Appelez la méthode phenotype.parse en passant le fichier de données et l"option de format («pm-csv»). Elle renvoie le PlateRecord itérable comme ci-dessous, >>> plaques = liste (phenotype.parse ( "Plates.csv ", "pm-csv ")) >>> plaques [PlateRecord ( "WellRecord [" A01 "], WellRecord [" A02 "], WellRecord [" A03 "], ..., WellRecord [" H12 "] "), PlateRecord ( "WellRecord [" A01 "], WellRecord [ "A02 "], WellRecord [ "A03 "], ..., WellRecord [ "H12 "] "), PlateRecord (" WellRecord [ "A01 "], WellRecord [ "A02 "], WellRecord [ "A03 "], ..., WellRecord [ "H12 "] "), PlateRecord (" WellRecord [ "A01 "], WellRecord [ "A02 "], WellRecord [" A03 "], ..., WellRecord [" H12 "] ")] >>> Étape 4 - Accédez à la première plaque de la liste comme ci-dessous - >>> plate = plates [0] >>> plaque PlateRecord ( "WellRecord [" A01 "], WellRecord [" A02 "], WellRecord [" A03 "], ..., WellRecord [" H12 "] ") >>> Étape 5 - Comme indiqué précédemment, une plaque contient 8 rangées contenant chacune 12 éléments. WellRecord peut être accessible de deux manières comme spécifié ci-dessous - >>> well = plate [ "A04 "] >>> well = plate [0, 4] >>> bien WellRecord ( "(0.0, 0.0), (0.25, 0.0), (0.5, 0.0), (0.75, 0.0), (1.0, 0.0), ..., (71.75, 388.0) ") >>> Étape 6 - Chaque puits aura une série de mesures à différents moments et il peut être consulté en utilisant la boucle for comme spécifié ci-dessous - >>> pour v1, v2 dans le puits: ... print (v1, v2) ... 0.0 0.0 0.25 0.0 0.5 0.0 0.75 0.0 1.0 0.0 ... 71.25 388.0 71.5 388.0 71.75 388.p> >> Interpolation L"interpolation donne plus d"informations sur t il données. Biopython fournit des méthodes pour interpoler les données WellRecord pour obtenir des informations sur les points temporels intermédiaires. La syntaxe est similaire à l"indexation de liste et donc facile à apprendre. Pour obtenir les données à 20,1 heures, il suffit de passer comme valeurs d"index comme spécifié ci-dessous - >>> bien [20.10] 69.40000000000003 >>> Nous pouvons passer le point de départ et le point de fin ainsi que spécifié ci-dessous - >>> well [20:30] [67.0, 84.0, 102.0, 119.0, 135.0, 147.0, 158.0, 168.0, 179.0, 186.0] >>> La commande ci-dessus interpole les données à partir de 20 heures à 30 heures avec 1 heure d"intervalle. Par défaut, l"intervalle est de 1 heure et nous pouvons le changer en n"importe quelle valeur. Par exemple, donnons un intervalle de 15 minutes (0,25 heure) comme spécifié ci-dessous - >>> well [20: 21: 0.25] [67.0, 73.0, 75.0, 81.0] >>> Analyser et extraire Biopython fournit une méthode adaptée pour analyser les données WellRecord en utilisant les fonctions sigmoïdes de Gompertz, Logistic et Richards. Par défaut, la méthode fit utilise la fonction Gompertz. Nous devons appeler la méthode fit de l"objet WellRecord pour terminer la tâche. Le codage est le suivant - >>> well.fit () Traceback (dernier appel en dernier): ... Bio.MissingPythonDependencyError: Installez scipy pour extraire les paramètres de la courbe . >>> well.model >>> getattr (enfin, "min ") 0.0 >>> getattr (enfin, "max ") 388.0 >>> getattr (enfin, "average_height ") 205.42708333333334 >> > Biopython dépend du module scipy pour faire des analyses avancées. Il calculera les détails min, max et average_height sans utiliser le module scipy. Biopython - Tracé Ce chapitre explique comment tracer des séquences. Avant de passer à ce sujet, laissez-nous comprendre les bases du traçage. Tracé Matplotlib est une bibliothèque de traçage Python qui produit des figures de qualité dans une variété de formats. Nous pouvons créer différents types de tracés comme un graphique linéaire , histogrammes, histogramme, camembert, nuage de points, etc. pyLab est un module appartenant au matplotlib qui combine le module numérique numpy avec le module de traçage graphique pyplot. Biopython utilise le module pylab pour tracer des séquences. Pour ce faire, nous devons importer le code ci-dessous - import pylab Avant d"importer, nous devons installer le paquet matplotlib en utilisant la commande pip avec la commande donnée ci-dessous - pip install matplotlib Exemple de fichier d"entrée Créez un exemple de fichier nommé plot. FASTA dans votre répertoire Biopython et ajoutez les modifications suivantes - > seq0 p> seq1 p> seq2 p> seq3 p> SEQ4 p> seq5 p> seq6 p> seq7 SWEEFVERSVQLFRGDPNATRYVMKYRHCEGKLV p> seq8 p> seq9 p> seq10 FDSWDEFVSKSVELFRNHPDTTRYVVKYRHCEGKLVLKVTDNHECLKFKTDQAQDAKKMEK Terrain ligne Maintenant, nous allons créer un simple tracé de ligne pour le fichier FASTA ci-dessus. Étape 1 - Importez le module SeqIO pour lire le fichier fasta. >>> depuis Bio import SeqIO Étape 2 - Analyser le fichier d"entrée. >>> records = [len (rec) for rec dans SeqIO.parse ( "plot.fasta ", "fasta ")] >>> len (records) 11 >>> max (records) 72 >>> min (records) 57 Étape 3 - Laissez-nous importer le module pylab. >>> import pylab Étape 4 - Configurez le graphique en courbes en attribuant des étiquettes aux axes x et y. >>> pylab.xlabel ( "longueur de la séquence ") Texte (0.5, 0, "longueur de la séquence ") >>> pylab.ylabel ( "nombre ") Texte ( 0, 0.5, "count ") >>> Étape 5 - Configurez le graphique en courbes en définissant l"affichage de la grille. >>> pylab.grid () Étape 6 - Dessinez un graphique linéaire simple en appelant la méthode plot et en fournissant des enregistrements en entrée. >>> pylab.plot (records) [] Étape 7 - Enfin, enregistrez le graphique en utilisant la commande ci-dessous. >>> pylab.savefig ( "lines.png ") Résultat Après avoir exécuté la commande ci-dessus, vous pouvez voir l"image suivante enregistrée dans votre répertoire Biopython. Histogramme Un histogramme est utilisé pour les données continues, où les cases représentent des plages de données. L"histogramme du dessin est identique au graphique en courbes, sauf pylab.plot. Au lieu de cela, appelez la méthode hist du module pylab avec des enregistrements et une valeur personnalisée pour bins (5). Le codage complet est le suivant - Étape 1 - Importez le module SeqIO pour lire le fichier fasta. >>> de Bio import SeqIO Étape 2 - Analyser le fichier d"entrée. >>> records = [len (rec ) pour rec dans SeqIO.parse ( "plot.fasta ", "fasta ")] >>> len (records) 11 >>> max (records) 72 >>> min (records) 57 Étape 3 - Importons le module pylab. >>> import pylab Étape 4 - Configurez le graphique en courbes en attribuant des étiquettes aux axes x et y. >>> pylab.xlabel ( "sequence length ") Text ( 0,5, 0, "longueur de la séquence ") >>> pylab.ylabel ( "count ") Text (0, 0.5, "count ") >>> Étape 5 - Configurer le graphique en courbes en définissant l"affichage de la grille . >>> pylab.grid () Étape 6 - Dessinez un graphique linéaire simple en appelant la méthode plot et fournir des enregistrements en entrée. >>> pylab.hist (records, bins = 5) (array ([2., 3., 1., 3., 2 .]), tableau ([57., 60., 63., 66., 69., 72.]), ) >>> Étape 7 - Enfin, enregistrez le graphique en utilisant la commande ci-dessous. >>> pylab.savefig ( "hist.png " ) Résultat Après avoir exécuté la commande ci-dessus, vous pouvez voir l"image suivante enregistrée dans votre répertoire Biopython. Pourcentage GC dans la séquence Le pourcentage GC est l"une des données analytiques couramment utilisées pour comparer différentes séquences. Nous pouvons faire un graphique linéaire simple en utilisant GC Pourcentage d"un ensemble de séquences et le comparer immédiatement. Ici, nous pouvons simplement changer les données de la longueur de la séquence en pourcentage GC. Le codage complet est donné ci-dessous - Étape 1 - Importez le module SeqIO pour lire le fichier fasta. >>> depuis Bio import SeqIO Étape 2 - Analyser le fichier d"entrée. >>> depuis Bio.SeqUtils import GC >>> gc = trié (GC (rec.seq) pour rec dans SeqIO.parse ( "plot.fasta ", "fasta ")) Étape 3 - Importons le module pylab. >>> import pylab Étape 4 - Configurez le graphique linéaire par attribuer des étiquettes aux axes x et y. >>> pylab.xlabel ( "Genes ") Text (0.5, 0, "Genes ") >>> pylab.ylabel ( "GC Percentage ") Text (0, 0.5, "GC Percentage ") >>> Étape 5 - Configurez le graphique linéaire en définissant affichage de la grille. >>> pylab.grid () Étape 6 - Dessinez un graphique linéaire simple en appelant la méthode plot et en fournissant des enregistrements en entrée. >>> pylab.plot (gc) [] Étape 7 - Enfin enregistrer le graphique en utilisant la commande ci-dessous. >>> pylab.savefig ( "gc.png ") Résultat Après en exécutant la commande ci-dessus, vous pouvez voir l"image suivante enregistrée dans votre répertoire Biopython. Biopython - Analyse de cluster En général, l"analyse de cluster regroupe un ensemble d"objets dans le même groupe. Ce concept est principalement utilisé dans l"exploration de données, l"analyse de données statistiques, l"apprentissage automatique, la reconnaissance de formes, l"analyse d"images, la bioinformatique, etc. Il peut être réalisé par Selon la bioinformatique, l"analyse par cluster est principalement utilisée dans l"analyse des données d"expression génique pour trouver des groupes de gènes ayant une expression génique similaire. Dans ce chapitre, nous allons découvrir des algorithmes importants en Biopython pour comprendre les fondamentaux du clustering sur un vrai jeu de données. Biopython utilise le module Bio.Cluster pour implémenter tous les algorithmes. Il prend en charge les algorithmes suivants - Clustering hiérarchique K - Clustering Cartes auto-organisées Analyse en composantes principales Prenons une brève introduction sur les algorithmes ci-dessus. Clustering hiérarchique Le clustering hiérarchique est utilisé pour lier chaque nœud par une mesure de distance à son voisin le plus proche et créer un cluster. Le nœud Bio.Cluster a trois attributs: gauche, droite et distance. Créons un cluster simple comme indiqué ci-dessous - >>> depuis Bio.Cluster import Node >>> n = Node (1,10) >>> n. le ft = 11 >>> n.right = 0 >>> n.distance = 1 >>> print (n) (11, 0): 1 Si vous voulez construire un clustering basé sur un arbre, utilisez la commande ci-dessous - >>> n1 = [Node (1, 2, 0.2), Node (0, -1, 0.5)] >>> n1_tree = Tree (n1) >>> print (n1_tree) (1, 2): 0.2 (0, -1): 0.5 >>> print (n1_tree [0]) (1, 2): 0.2 Soit nous effectuons un clustering hiérarchique à l"aide du module Bio.Cluster. Considérez que la distance est définie dans un tableau. >>> import numpy as np >> > distance = array ([[1,2,3], [4,5,6], [3,5,7]]) Ajoutez maintenant le tableau de distance dans le cluster d"arbres. >>> de Bio.Cluster import treecluster >>> cluster = treecluster (distance) >>> print (cluster) (2, 1): 0.666667 (-1, 0) : 9.66667 La fonction ci-dessus renvoie un objet de cluster Tree. Cet objet contient des nœuds où le nombre d"éléments sont regroupés sous forme de lignes ou de colonnes. K - Clustering C"est un type d"algorithme de partitionnement et classé en k - moyennes, médianes et médoïdes regroupement. Comprenons chacun des clusters en bref. Clustering K-means Cette approche est populaire dans l"exploration de données. Le but de cet algorithme est de trouver des groupes dans les données, avec le nombre de groupes représenté par la variable K. L"algorithme fonctionne de manière itérative pour affecter chaque point de données à l"un des K groupes en fonction des caractéristiques qui sont fournis. Les points de données sont regroupés en fonction de la similitude des caractéristiques. >>> de Bio.Cluster import kcluster >>> de numpy import array >>> data = array ([[1 , 2], [3, 4], [5, 6]]) >>> clusterid, error, found = kcluster (données) >>> print (clusterid) [0 0 1] >>> print (found) 1 Clustering K-médianes C"est un autre type d"algorithme de clustering qui calcule la moyenne de chaque cluster pour déterminer son centre de gravité. Clustering K-medoids Cette approche est basée sur un ensemble d"items donné, en utilisant la distance ma trix et le nombre de clusters passés par l"utilisateur. Considérons la matrice de distance telle que définie ci-dessous - >>> distance = array ([[ 1,2,3], [4,5,6], [3,5,7]]) Nous pouvons calculer le clustering des k-médoïdes en utilisant la commande ci-dessous - >>> from Bio.Cluster import kmedoids >>> clusterid, error, found = kmedoids (distance) Prenons un exemple. La fonction kcluster prend une matrice de données en entrée et non des instances Seq. Vous devez convertir vos séquences en une matrice et les fournir à la fonction kcluster. Une façon de convertir les données en une matrice contenant uniquement des éléments numériques consiste à utiliser numpy.fromstring fonction. Il traduit essentiellement chaque lettre d"une séquence en son équivalent ASCII. Cela crée un tableau 2D de séquences codées que la fonction kcluster a reconnues et utilise pour regrouper vos séquences. >>> depuis Bio.Cluster import kcluster >>> import numpy as np >>> sequence = [ "AGCT ", "CGTA ", "AAGT ", "TCCG " ] >>> matrix = np.asarray ([np.fromstring (s, dtype = np.uint8) for s in sequence]) >>> clusterid, error, found = kcluster (matrice) >>> print (clusterid) [ 1 0 0 1] Cartes auto-organisées Cette approche est un type de réseau de neurones artificiels. Il est développé par Kohonen et souvent appelé carte de Kohonen. Il organise les éléments en clusters basés sur une topologie rectangulaire. Créons un cluster simple en utilisant la même distance de tableau que celle indiquée ci-dessous - >>> from Bio.Cluster import somcluster >>> from numpy import array >>> data = array ([[1, 2], [3, 4], [5, 6]]) >>> clusterid, map = somcluster (data ) >>> impression (carte) [[[-1.36032469 0.38667395]] [[-0.41170578 1.35295911]]] >>> impression (clusterid) [[1 0] [1 0] [1 0]] Ici, clusterid est un tableau avec deux colonnes, où le nombre de lignes est égal au nombre d"éléments qui ont été regroupés, et données est un tableau avec des dimensions soit des lignes, soit des colonnes. Analyse des composants principaux L"analyse des composants principaux est utile pour visualiser des données de grande dimension. C"est une méthode qui utilise des opérations matricielles simples à partir de l"algèbre linéaire et des statistiques pour calculer une projection des données d"origine dans le même nombre ou moins de dimensions. L"analyse en composantes principales renvoie une colonne de tuple, des coordonnées, des composants et valeurs propres. Examinons les bases de ce concept. >>> from numpy import array >>> from numpy import mean >>> from numpy import cov >>> from numpy.linalg import eig # définir une matrice >>> A = tableau ([[1, 2], [3, 4], [5, 6]]) >>> print (A) [[1 2] [3 4] [5 6]] # calculer la moyenne de chaque colonne >>> M = moyenne (AT, axe = 1) >>> imprimer (M) [3. 4.] # colonnes centrales en soustrayant les moyennes des colonnes >>> C = A - M >>> impression (C) [[-2. -2.] [0. 0.] [2. 2.]] # calculer la matrice de covariance de la matrice centrée >>> V = cov (CT) >>> print (V) [[4. 4.] [4. 4.]] # eigendecomposition de la matrice de covariance >>> valeurs, vecteurs = eig (V) >>> print (vecteurs) [[0.70710678 -0.70710678] [0.70710678 0.70710678]] >>> print (valeurs) [8. 0. ] Appliquons les mêmes données de matrice rectangulaire au module Bio.Cluster comme défini ci-dessous - >>> depuis Bio.Cluster import p> >> from numpy import array >>> data = array ([[1, 2], [3, 4], [5, 6]]) >>> columnmean, coordonnées, composants, valeurs propres = pca (données) >> > print (columnmean) [3. 4.] >>> print (coordonnées) [[-2.82842712 0.] [0. 0.] [2.82842712 0.]] >>> print (components) [[0.70710678 0.70710678] [ 0.70710678 -0.70710678]] >>> print (valeurs propres) [4. 0.] Biopython - Machine Learning La bioinformatique est un excellent domaine pour appliquer des algorithmes d"apprentissage automatique. Ici, nous avons des informations génétiques d"un grand nombre d"organismes et il n"est pas possible d"analyser manuellement toutes ces informations. Si la machine apprend ng est utilisé, nous pouvons extraire beaucoup d"informations utiles à partir de ces données. Biopython fournit un ensemble d"algorithmes utiles pour faire de l"apprentissage automatique supervisé. L"apprentissage supervisé est basé sur la variable d"entrée (X) et la variable de sortie (Y). Il utilise un algorithme pour apprendre la fonction de mappage de l"entrée à la sortie. Il est défini ci-dessous - Y = f (X) L"objectif principal de cette approche est d"approximer la fonction de mappage et quand vous avez de nouvelles données d"entrée (x), vous pouvez prédire les variables de sortie (Y) pour ces données. Modèle de régression logistique La régression logistique est un algorithme d"apprentissage automatique supervisé. Il est utilisé pour connaître la différence entre K classs en utilisant la somme pondérée des variables prédictives. Il calcule la probabilité d"occurrence d"un événement et peut être utilisé pour la détection du cancer. Biopython fournit le module Bio.LogisticRegression pour prédire les variables basées sur l"algorithme de régression logistique. Actuellement, Biopython implémente un algorithme de régression logistique pour deux classs uniquement (K = 2). k-Nearest Neighbours k-Nearest Vighbour est également un algorithme d"apprentissage automatique supervisé. Cela fonctionne en catégorisant les données en fonction des voisins les plus proches. Biopython fournit un module Bio.KNN pour prédire les variables en fonction de l"algorithme des k voisins les plus proches. Naive Bayes Les classificateurs Naive Bayes sont une collection d"algorithmes de classification basés sur le théorème de Bayes. Il ne s"agit pas d"un algorithme unique mais d"une famille d"algorithmes où tous partagent un principe commun, c"est-à-dire que chaque paire de caractéristiques classées est indépendante l"une de l"autre. Biopython fournit le module Bio.NaiveBayes pour travailler avec l"algorithme Naive Bayes. Modèle de Markov Un modèle de Markov est un système mathématique défini comme une collection de variables aléatoires, qui subit une transition d"un état à un autre selon certaines règles probabilistes. Biopython fournit les modules Bio.MarkovModel et Bio.HMM.MarkovModel pour fonctionner avec Markov m odels . Biopython - Techniques de test Biopython a un de test complet pour tester le logiciel dans différentes conditions afin de s"assurer que le logiciel est exempt de bogues. Pour exécuter le de test, téléchargez le code source du Biopython puis exécutez la commande ci-dessous - python run_tests.py Cela exécutera tout les s de test et donne la sortie suivante - Version Python: 2.7.12 (v2.7.12: d33e0cf91556, 26 juin 2016, 12:10:39) [GCC 4.2 .1 (Apple Inc. build 5666) (point 3)] Système d"exploitation: posix darwin test_Ace ... ok test_Affy ... ok test_AlignIO ... ok test_AlignIO_ClustalIO ... ok test_AlignIO_EmbossIO ... ok test_AlignIO_FastaIO ... ok test_AlignIO_MauveIO ... ok test_AlignIO_PhylipIO ... ok test_AlignIO_convert ... ok .................................... ....... ........................................... Nous pouvons également exécuter un de test individuel comme spécifié ci-dessous - python test_AlignIO.py Conclusion Comme nous l"avons appris, Biopython est l"un des logiciels importants dans le domaine de la bioinformatique. Ecrit en python (facile à apprendre et à écrire), il fournit des fonctionnalités étendues pour gérer tout calcul et toute opération dans le domaine de la bioinformatique. Il fournit également une interface simple et flexible à presque tous les logiciels de bioinformatique populaires pour exploiter également ses fonctionnalités.