undefined

undefined

undefined

undefined

from Bio.Seq import Seq

undefined

from Bio import SeqIO

undefined

from Bio import pairwise2
from Bio.Seq import Seq

seq1 = Seq("ACCGT")
seq2 = Seq("ACGT")

undefined

undefined

undefined

from Bio.Seq import Seq
from Bio.Alphabet import IUPAC

undefined

from Bio.Seq import Seq

undefined

from Bio.Seq import Seq

dna = Seq("ATGGGCTAG")

undefined

from Bio.Seq import Seq
from Bio.SeqUtils import GC, molecular_weight

seq = Seq("ATGGCCATTGTAATGGGCCGC")

undefined

from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord

undefined

from Bio import SeqIO

record = SeqIO.read("sequence.gb", "genbank")

undefined

from Bio import SeqIO

undefined

from Bio import SeqIO
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord

undefined

from Bio import SeqIO

avg_q = sum(quality) / len(quality)
min_q = min(quality)

print(f"{seq_id}: avg Q={avg_q:.1f}, min Q={min_q}")

undefined

from Bio import SeqIO

def filter_fastq(input_file, output_file, min_quality=20, min_length=50):
    """Filter FASTQ by quality and length."""
    good_reads = 0
    
    with open(output_file, "w") as out_handle:
        for record in SeqIO.parse(input_file, "fastq"):
            # Check length
            if len(record.seq) < min_length:
                continue
            
            # Check quality
            qualities = record.letter_annotations["phred_quality"]
            if min(qualities) >= min_quality:
                SeqIO.write(record, out_handle, "fastq")
                good_reads += 1
    
    return good_reads

undefined

from Bio import SeqIO

# Extract features
for feature in record.features:
    if feature.type == "CDS":
        product = feature.qualifiers.get("product", ["Unknown"])[0]
        start = feature.location.start
        end = feature.location.end
        print(f"  CDS: {product} ({start}-{end})")

undefined

from Bio import SeqIO

undefined

from Bio import pairwise2
from Bio.Seq import Seq
from Bio.pairwise2 import format_alignment

seq1 = Seq("ACCGGT")
seq2 = Seq("ACGT")

undefined

from Bio import pairwise2
from Bio.Seq import Seq
from Bio.Align import substitution_matrices

seq1 = Seq("KEVLA")
seq2 = Seq("KELVA")

undefined

from Bio import pairwise2
from Bio.Seq import Seq

undefined

from Bio import AlignIO
from Bio.Align.Applications import ClustalwCommandline

undefined

from Bio import AlignIO

alignment = AlignIO.read("alignment.fasta", "fasta")

for i in range(n):
    for j in range(i+1, n):
        seq1 = alignment[i].seq
        seq2 = alignment[j].seq
        
        matches = sum(a == b for a, b in zip(seq1, seq2) if a != '-' and b != '-')
        aligned_length = sum(1 for a, b in zip(seq1, seq2) if a != '-' and b != '-')
        
        identity = matches / aligned_length * 100 if aligned_length > 0 else 0
        identities.append(identity)

return identities

undefined

from Bio.Blast import NCBIWWW, NCBIXML
from Bio import SeqIO

undefined

from Bio.Blast import NCBIXML

for blast_record in blast_records:
    print(f"Query: {blast_record.query}")
    print(f"Number of hits: {len(blast_record.alignments)}")
    
    for alignment in blast_record.alignments:
        for hsp in alignment.hsps:
            if hsp.expect < 0.001:  # E-value threshold
                print(f"\n  Hit: {alignment.title}")
                print(f"  Length: {alignment.length}")
                print(f"  E-value: {hsp.expect}")
                print(f"  Identity: {hsp.identities}/{hsp.align_length} "
                      f"({hsp.identities/hsp.align_length*100:.1f}%)")
                print(f"  Query:   {hsp.query}")
                print(f"  Subject: {hsp.sbjct}")

undefined

from Bio.Blast import NCBIWWW

result_handle = NCBIWWW.qblast(
    program="blastp",
    database="nr",
    sequence=protein_seq,
    expect=0.001,          # E-value threshold
    word_size=3,           # Word size
    matrix_name="BLOSUM62", # Substitution matrix
    gapcosts="11 1",       # Gap costs (open, extend)
    hitlist_size=50,       # Number of hits
    filter="L"             # Low complexity filter
)

from Bio.Blast import NCBIWWW, NCBIXML
from Bio import SeqIO
import time

def batch_blast(fasta_file, output_file):
    """Run BLAST for multiple sequences."""
    results = []
    
    for record in SeqIO.parse(fasta_file, "fasta"):
        print(f"BLASTing {record.id}...")
        
        result_handle = NCBIWWW.qblast(
            "blastn", "nt",
            str(record.seq),
            hitlist_size=5
        )
        
        blast_record = NCBIXML.read(result_handle)
        results.append((record.id, blast_record))
        
        # Be nice to NCBI servers
        time.sleep(1)
    
    return results

undefined

from Bio.PDB import PDBParser

undefined

from Bio.PDB import PDBParser

parser = PDBParser()
structure = parser.get_structure("protein", "protein.pdb")

    for residue in chain:
        # Skip hetero atoms (water, ligands)
        if residue.id[0] == ' ':
            resname = residue.resname
            resid = residue.id[1]
            
            # Get atoms
            for atom in residue:
                atom_name = atom.name
                coord = atom.coord
                print(f"  {resname}{resid} {atom_name}: {coord}")

undefined

from Bio.PDB import PDBParser
import numpy as np

parser = PDBParser()
structure = parser.get_structure("protein", "protein.pdb")

undefined

from Bio.PDB import PDBParser
import numpy as np

parser = PDBParser()
structure = parser.get_structure("protein", "protein.pdb")

def calculate_center_of_mass(entity):
    """Calculate center of mass for Structure/Model/Chain."""
    coords = []
    masses = []
    
    for atom in entity.get_atoms():
        coords.append(atom.coord)
        masses.append(atom.mass)
    
    coords = np.array(coords)
    masses = np.array(masses)
    
    com = np.average(coords, axis=0, weights=masses)
    return com

undefined

from Bio.PDB import PDBParser, Selection

parser = PDBParser()
structure = parser.get_structure("protein", "protein.pdb")

undefined

from Bio.PDB import PDBParser
from Bio.PDB.DSSP import DSSP

parser = PDBParser()
structure = parser.get_structure("protein", "protein.pdb")
model = structure[0]

print(f"{chain_id} {res_id}: {ss} (ASA={acc:.1f})")

undefined

from Bio.PDB import PDBParser
from Bio.PDB.Polypeptide import PPBuilder

parser = PDBParser()
structure = parser.get_structure("protein", "protein.pdb")

undefined

from Bio.PDB import PDBParser, PDBIO, Select

undefined

from Bio import AlignIO, Phylo
from Bio.Phylo.TreeConstruction import DistanceCalculator, DistanceTreeConstructor

undefined

from Bio import Phylo

undefined

from Bio import Phylo

tree = Phylo.read("tree.xml", "phyloxml")

undefined

from Bio.Phylo.BaseTree import Tree, Clade

undefined

from Bio import Entrez

undefined

from Bio import Entrez, SeqIO

Entrez.email = "your.email@example.com"

undefined

from Bio import Entrez, SeqIO

Entrez.email = "your.email@example.com"

def download_sequences(id_list, output_file):
    """Download multiple sequences by ID."""
    # Fetch records
    handle = Entrez.efetch(
        db="nucleotide",
        id=id_list,
        rettype="fasta",
        retmode="text"
    )
    
    records = SeqIO.parse(handle, "fasta")
    SeqIO.write(records, output_file, "fasta")
    handle.close()

undefined

from Bio import Entrez

Entrez.email = "your.email@example.com"

# Process batch
data = fetch_handle.read()
fetch_handle.close()

undefined

from Bio import Entrez, SeqIO
from Bio.Seq import Seq
from Bio.SeqUtils import GC

Entrez.email = "your.email@example.com"

def analyze_gene(gene_id):
    """Complete analysis of a gene."""
    # 1. Fetch sequence
    handle = Entrez.efetch(db="nucleotide", id=gene_id, rettype="gb", retmode="text")
    record = SeqIO.read(handle, "genbank")
    handle.close()
    
    # 2. Basic stats
    length = len(record.seq)
    gc_content = GC(record.seq)
    
    # 3. Extract CDS
    cds_list = []
    for feature in record.features:
        if feature.type == "CDS":
            cds_seq = feature.extract(record.seq)
            product = feature.qualifiers.get("product", ["Unknown"])[0]
            cds_list.append((product, cds_seq))
    
    # 4. Translate CDS
    proteins = []
    for product, cds in cds_list:
        try:
            protein = cds.translate(to_stop=True)
            proteins.append((product, protein))
        except:
            proteins.append((product, None))
    
    return {
        'id': record.id,
        'length': length,
        'gc': gc_content,
        'n_cds': len(cds_list),
        'proteins': proteins
    }

undefined

from Bio import SeqIO
import numpy as np

def process_rnaseq_reads(fastq_file, min_quality=30, min_length=50):
    """Process RNA-seq reads with quality filtering."""
    stats = {
        'total': 0,
        'passed_quality': 0,
        'passed_length': 0,
        'final': 0
    }
    
    passed_reads = []
    
    for record in SeqIO.parse(fastq_file, "fastq"):
        stats['total'] += 1
        
        # Quality filter
        qualities = record.letter_annotations["phred_quality"]
        if np.mean(qualities) < min_quality:
            continue
        stats['passed_quality'] += 1
        
        # Length filter
        if len(record.seq) < min_length:
            continue
        stats['passed_length'] += 1
        
        # Trim adapters (simple example)
        # In reality, use specialized tools like Cutadapt
        
        passed_reads.append(record)
        stats['final'] += 1
    
    return passed_reads, stats

undefined

from Bio import SeqIO
from Bio.Restriction import *

undefined

from Bio import SeqIO
from collections import Counter

def analyze_codon_usage(genbank_file):
    """Analyze codon usage in CDS features."""
    codon_counts = Counter()
    total_codons = 0
    
    for record in SeqIO.parse(genbank_file, "genbank"):
        for feature in record.features:
            if feature.type == "CDS":
                # Extract CDS sequence
                cds = feature.extract(record.seq)
                
                # Count codons
                for i in range(0, len(cds) - 2, 3):
                    codon = str(cds[i:i+3])
                    if len(codon) == 3:
                        codon_counts[codon] += 1
                        total_codons += 1
    
    # Calculate frequencies
    codon_freq = {codon: count/total_codons 
                  for codon, count in codon_counts.items()}
    
    return codon_counts, codon_freq

undefined

from Bio import SeqIO

def process_large_fasta(filename, process_func):
    """Process large FASTA without loading into memory."""
    count = 0
    
    for record in SeqIO.parse(filename, "fasta"):
        process_func(record)
        count += 1
        
        # Progress report
        if count % 10000 == 0:
            print(f"Processed {count} sequences")
    
    return count

undefined

from Bio import SeqIO
from multiprocessing import Pool
from functools import partial

def process_sequence(record, min_length=100):
    """Process single sequence."""
    if len(record.seq) >= min_length:
        from Bio.SeqUtils import GC
        return (record.id, len(record.seq), GC(record.seq))
    return None

def parallel_process_fasta(filename, n_processes=4):
    """Process FASTA in parallel."""
    # Load sequences
    records = list(SeqIO.parse(filename, "fasta"))
    
    # Process in parallel
    with Pool(n_processes) as pool:
        results = pool.map(process_sequence, records)
    
    # Filter None results
    return [r for r in results if r is not None]

undefined

from Bio import SeqIO