Calculadora de Peso Molecular de Proteínas

Introducción

La calculadora de peso molecular de proteínas es una herramienta esencial para bioquímicos, biólogos moleculares y científicos de proteínas que necesitan determinar la masa de las proteínas en función de sus secuencias de aminoácidos. Las proteínas son macromoléculas complejas compuestas por cadenas de aminoácidos, y conocer su peso molecular es crucial para diversas técnicas de laboratorio, diseño experimental y análisis de datos. Esta calculadora proporciona una forma rápida y precisa de estimar el peso molecular de cualquier proteína utilizando su secuencia de aminoácidos, ahorrando tiempo valioso a los investigadores y reduciendo el potencial de errores de cálculo.

El peso molecular de las proteínas, a menudo expresado en Daltons (Da) o kilodaltons (kDa), representa la suma de los pesos individuales de todos los aminoácidos en la proteína, teniendo en cuenta las moléculas de agua perdidas durante la formación de enlaces peptídicos. Esta propiedad fundamental influye en el comportamiento de la proteína en solución, la movilidad en electroforesis, las propiedades de cristalización y muchas otras características físicas y químicas que son importantes en aplicaciones de investigación e industriales.

Nuestra calculadora fácil de usar requiere solo la secuencia de aminoácidos en notación de una letra de su proteína para generar estimaciones precisas del peso molecular, lo que la hace accesible tanto para investigadores experimentados como para estudiantes nuevos en la ciencia de proteínas.

Cómo se Calcula el Peso Molecular de las Proteínas

La Fórmula Básica

El peso molecular de una proteína se calcula utilizando la siguiente fórmula:

$MW_{proteína} = \sum_{i=1}^{n} MW_{aminoácido_i} - (n-1) \times MW_{agua} + MW_{agua}$

Donde:

• $MW_{proteína}$ es el peso molecular de la proteína entera en Daltons (Da)
• $\sum_{i=1}^{n} MW_{aminoácido_i}$ es la suma de los pesos moleculares de todos los aminoácidos individuales
• $n$ es el número de aminoácidos en la secuencia
• $MW_{agua}$ es el peso molecular del agua (18.01528 Da)
• $(n-1)$ representa el número de enlaces peptídicos formados
• El último término $+ MW_{agua}$ tiene en cuenta los grupos terminales (H y OH)

Pesos Moleculares de Aminoácidos

El cálculo utiliza los pesos moleculares estándar de los 20 aminoácidos comunes:

Pérdida de Agua en la Formación de Enlaces Peptídicos

Cuando los aminoácidos se unen para formar una proteína, crean enlaces peptídicos. Durante este proceso, se libera una molécula de agua (H₂O) por cada enlace formado. Esta pérdida de agua debe tenerse en cuenta en el cálculo del peso molecular.

Para una proteína con n aminoácidos, se forman (n-1) enlaces peptídicos, lo que resulta en la pérdida de (n-1) moléculas de agua. Sin embargo, se agrega de nuevo una molécula de agua para tener en cuenta los grupos terminales (H en el extremo N y OH en el extremo C).

Ejemplo de Cálculo

Calculemos el peso molecular de un tripeptido simple: Ala-Gly-Ser (AGS)

1. Sumar los pesos de los aminoácidos individuales:

   • Alanina (A): 71.03711 Da
   • Glicina (G): 57.02146 Da
   • Serina (S): 87.03203 Da
   • Total: 215.0906 Da

2. Restar la pérdida de agua por los enlaces peptídicos:

   • Número de enlaces peptídicos = 3-1 = 2
   • Peso molecular del agua = 18.01528 Da
   • Pérdida total de agua = 2 × 18.01528 = 36.03056 Da

3. Agregar de nuevo una molécula de agua para los grupos terminales:

   • 18.01528 Da

4. Peso molecular final:

   • 215.0906 - 36.03056 + 18.01528 = 197.07532 Da

Cómo Usar Esta Calculadora

Usar la Calculadora de Peso Molecular de Proteínas es sencillo:

1. Ingrese su secuencia de proteína en el cuadro de texto utilizando los códigos estándar de aminoácidos de una letra (A, R, N, D, C, E, Q, G, H, I, L, K, M, F, P, S, T, W, Y, V).

2. La calculadora validará automáticamente su entrada para asegurarse de que contenga solo códigos de aminoácidos válidos.

3. Haga clic en el botón "Calcular Peso Molecular" o espere a que se complete el cálculo automático.

4. Vea los resultados, que incluyen:

   • El peso molecular calculado en Daltons (Da)
   • La longitud de la secuencia (número de aminoácidos)
   • Un desglose de la composición de aminoácidos
   • La fórmula utilizada para el cálculo

5. Puede copiar los resultados al portapapeles haciendo clic en el botón "Copiar" para usarlos en informes o análisis posteriores.

Directrices de Entrada

Para obtener resultados precisos, siga estas directrices al ingresar su secuencia de proteína:

• Use solo los códigos estándar de aminoácidos de una letra (mayúsculas o minúsculas)
• No incluya espacios, números o caracteres especiales
• Elimine cualquier carácter que no sea un aminoácido (como la numeración de secuencias)
• Para secuencias con aminoácidos no estándar, considere usar herramientas alternativas que admitan códigos de aminoácidos ampliados

Interpretando los Resultados

La calculadora proporciona varias piezas de información:

1. Peso Molecular: El peso molecular estimado de su proteína en Daltons (Da). Para proteínas más grandes, esto puede expresarse en kilodaltons (kDa).

2. Longitud de la Secuencia: El número total de aminoácidos en su secuencia.

3. Composición de Aminoácidos: Un desglose visual del contenido de aminoácidos de su proteína, mostrando tanto el conteo como el porcentaje de cada aminoácido.

4. Método de Cálculo: Una explicación clara de cómo se calculó el peso molecular, incluida la fórmula utilizada.

Casos de Uso

La Calculadora de Peso Molecular de Proteínas tiene numerosas aplicaciones en diversos campos de las ciencias de la vida:

Purificación y Análisis de Proteínas

Los investigadores utilizan la información sobre el peso molecular para:

• Configurar columnas de filtración por gel adecuadas
• Determinar concentraciones apropiadas de gel de poliacrilamida para SDS-PAGE
• Interpretar datos de espectrometría de masas
• Validar resultados de expresión y purificación de proteínas

Producción de Proteínas Recombinantes

Las empresas biotecnológicas confían en cálculos precisos del peso molecular para:

• Diseñar construcciones de expresión
• Estimar rendimientos de proteínas
• Desarrollar estrategias de purificación
• Caracterizar productos finales

Síntesis de Péptidos

Los químicos de péptidos utilizan cálculos de peso molecular para:

• Determinar la cantidad de materiales de partida necesarios
• Calcular rendimientos teóricos
• Verificar la identidad de los péptidos sintetizados
• Diseñar métodos analíticos para control de calidad

Biología Estructural

Los biólogos estructurales necesitan información sobre el peso molecular para:

• Configurar ensayos de cristalización
• Interpretar datos de difracción de rayos X
• Analizar complejos de proteínas
• Calcular estequiometría de interacciones proteína-proteína

Desarrollo Farmacéutico

Los desarrolladores de fármacos utilizan el peso molecular de las proteínas para:

• Caracterizar proteínas terapéuticas
• Desarrollar estrategias de formulación
• Diseñar métodos analíticos
• Establecer especificaciones de control de calidad

Investigación Académica

Los estudiantes e investigadores utilizan la calculadora para:

• Experimentos de laboratorio
• Análisis de datos
• Diseño experimental
• Fines educativos

Alternativas

Si bien nuestra Calculadora de Peso Molecular de Proteínas proporciona estimaciones rápidas y precisas, hay enfoques alternativos para determinar el peso molecular de las proteínas:

1. Métodos Experimentales:

   • Espectrometría de Masas (MS): Proporciona mediciones de peso molecular altamente precisas y puede detectar modificaciones post-traduccionales
   • Cromatografía de Exclusión por Tamaño (SEC): Estima el peso molecular en función del radio hidrodinámico
   • SDS-PAGE: Proporciona un peso molecular aproximado basado en la movilidad electroforética

2. Otras Herramientas Computacionales:

   • ExPASy ProtParam: Ofrece parámetros adicionales de proteínas más allá del peso molecular
   • EMBOSS Pepstats: Proporciona un análisis estadístico detallado de secuencias de proteínas
   • Protein Calculator v3.4: Incluye cálculos adicionales como punto isoeléctrico y coeficiente de extinción

3. Software Especializado:

   • Para proteínas con aminoácidos no estándar o modificaciones post-traduccionales
   • Para ensamblajes de proteínas complejas o proteínas multiméricas
   • Para proteínas etiquetadas isotópicamente utilizadas en estudios de NMR

Historia de la Determinación del Peso Molecular de Proteínas

El concepto de peso molecular ha sido fundamental para la química desde que John Dalton propuso su teoría atómica a principios del siglo XIX. Sin embargo, la aplicación a las proteínas tiene una historia más reciente:

Ciencia de Proteínas Temprana (1800-1920)

• En 1838, Jöns Jacob Berzelius acuñó el término "proteína" a partir de la palabra griega "proteios", que significa "primario" o "de primera importancia".
• Científicos de proteínas tempranos como Frederick Sanger comenzaron a entender que las proteínas estaban compuestas por aminoácidos.
• El concepto de proteínas como macromoléculas con pesos moleculares definidos emergió gradualmente.

Desarrollo de Técnicas Analíticas (1930-1960)

• La invención de la ultracentrifugación por Theodor Svedberg en la década de 1920 permitió las primeras mediciones precisas de pesos moleculares de proteínas.
• El desarrollo de técnicas de electroforesis en la década de 1930 por Arne Tiselius proporcionó otro método para estimar el tamaño de las proteínas.
• En 1958, Stanford Moore y William H. Stein completaron la primera secuencia completa de aminoácidos de la ribonucleasa, permitiendo un cálculo preciso del peso molecular.

Era Moderna (1970-Presente)

• El desarrollo de técnicas de espectrometría de masas revolucionó la determinación del peso molecular de proteínas.
• John Fenn y Koichi Tanaka recibieron el Premio Nobel de Química en 2002 por su desarrollo de métodos de ionización por desorción suave para análisis espectrométricos de macromoléculas biológicas.
• Los métodos computacionales para predecir propiedades de proteínas, incluido el peso molecular, se volvieron cada vez más sofisticados y accesibles.
• La llegada de la genómica y la proteómica en las décadas de 1990 y 2000 creó una necesidad de herramientas de análisis de proteínas de alto rendimiento, incluidas calculadoras de peso molecular automatizadas.

Hoy en día, el cálculo del peso molecular de proteínas es una parte rutinaria pero esencial de la ciencia de proteínas, facilitado por herramientas como nuestra calculadora que hacen que estos cálculos sean accesibles para investigadores de todo el mundo.

Ejemplos de Código

Aquí hay ejemplos de cómo calcular el peso molecular de proteínas en varios lenguajes de programación:

1' Función VBA de Excel para el Cálculo del Peso Molecular de Proteínas
2Function ProteinMolecularWeight(sequence As String) As Double
3    ' Pesos moleculares de aminoácidos
4    Dim aaWeights As Object
5    Set aaWeights = CreateObject("Scripting.Dictionary")
6    
7    ' Inicializar pesos de aminoácidos
8    aaWeights("A") = 71.03711
9    aaWeights("R") = 156.10111
10    aaWeights("N") = 114.04293
11    aaWeights("D") = 115.02694
12    aaWeights("C") = 103.00919
13    aaWeights("E") = 129.04259
14    aaWeights("Q") = 128.05858
15    aaWeights("G") = 57.02146
16    aaWeights("H") = 137.05891
17    aaWeights("I") = 113.08406
18    aaWeights("L") = 113.08406
19    aaWeights("K") = 128.09496
20    aaWeights("M") = 131.04049
21    aaWeights("F") = 147.06841
22    aaWeights("P") = 97.05276
23    aaWeights("S") = 87.03203
24    aaWeights("T") = 101.04768
25    aaWeights("W") = 186.07931
26    aaWeights("Y") = 163.06333
27    aaWeights("V") = 99.06841
28    
29    ' Peso molecular del agua
30    Const WATER_WEIGHT As Double = 18.01528
31    
32    ' Convertir secuencia a mayúsculas
33    sequence = UCase(sequence)
34    
35    ' Calcular peso total
36    Dim totalWeight As Double
37    totalWeight = 0
38    
39    ' Sumar pesos de aminoácidos individuales
40    Dim i As Integer
41    For i = 1 To Len(sequence)
42        Dim aa As String
43        aa = Mid(sequence, i, 1)
44        
45        If aaWeights.Exists(aa) Then
46            totalWeight = totalWeight + aaWeights(aa)
47        Else
48            ' Código de aminoácido no válido
49            ProteinMolecularWeight = -1
50            Exit Function
51        End If
52    Next i
53    
54    ' Restar pérdida de agua por enlaces peptídicos y agregar agua terminal
55    Dim numAminoAcids As Integer
56    numAminoAcids = Len(sequence)
57    
58    ProteinMolecularWeight = totalWeight - (numAminoAcids - 1) * WATER_WEIGHT + WATER_WEIGHT
59End Function
60
61' Uso en Excel:
62' =ProteinMolecularWeight("ACDEFGHIKLMNPQRSTVWY")
63

1def calculate_protein_molecular_weight(sequence):
2    """
3    Calcular el peso molecular de una proteína a partir de su secuencia de aminoácidos.
4    
5    Args:
6        sequence (str): Secuencia de proteína utilizando códigos de aminoácidos de una letra
7        
8    Returns:
9        float: Peso molecular en Daltons (Da)
10    """
11    # Pesos moleculares de aminoácidos
12    aa_weights = {
13        'A': 71.03711,
14        'R': 156.10111,
15        'N': 114.04293,
16        'D': 115.02694,
17        'C': 103.00919,
18        'E': 129.04259,
19        'Q': 128.05858,
20        'G': 57.02146,
21        'H': 137.05891,
22        'I': 113.08406,
23        'L': 113.08406,
24        'K': 128.09496,
25        'M': 131.04049,
26        'F': 147.06841,
27        'P': 97.05276,
28        'S': 87.03203,
29        'T': 101.04768,
30        'W': 186.07931,
31        'Y': 163.06333,
32        'V': 99.06841
33    }
34    
35    # Peso molecular del agua
36    WATER_WEIGHT = 18.01528
37    
38    # Convertir secuencia a mayúsculas
39    sequence = sequence.upper()
40    
41    # Validar secuencia
42    for aa in sequence:
43        if aa not in aa_weights:
44            raise ValueError(f"Código de aminoácido no válido: {aa}")
45    
46    # Sumar pesos de aminoácidos individuales
47    total_weight = sum(aa_weights[aa] for aa in sequence)
48    
49    # Restar pérdida de agua por enlaces peptídicos y agregar agua terminal
50    num_amino_acids = len(sequence)
51    molecular_weight = total_weight - (num_amino_acids - 1) * WATER_WEIGHT + WATER_WEIGHT
52    
53    return molecular_weight
54
55# Ejemplo de uso:
56sequence = "MVKMDVYKGSSIGDSMSRSM"
57mw = calculate_protein_molecular_weight(sequence)
58print(f"Peso molecular: {mw:.2f} Da")
59

1function calculateProteinMolecularWeight(sequence) {
2  // Pesos moleculares de aminoácidos
3  const aaWeights = {
4    'A': 71.03711,
5    'R': 156.10111,
6    'N': 114.04293,
7    'D': 115.02694,
8    'C': 103.00919,
9    'E': 129.04259,
10    'Q': 128.05858,
11    'G': 57.02146,
12    'H': 137.05891,
13    'I': 113.08406,
14    'L': 113.08406,
15    'K': 128.09496,
16    'M': 131.04049,
17    'F': 147.06841,
18    'P': 97.05276,
19    'S': 87.03203,
20    'T': 101.04768,
21    'W': 186.07931,
22    'Y': 163.06333,
23    'V': 99.06841
24  };
25  
26  // Peso molecular del agua
27  const WATER_WEIGHT = 18.01528;
28  
29  // Convertir secuencia a mayúsculas
30  sequence = sequence.toUpperCase();
31  
32  // Validar secuencia
33  for (let i = 0; i < sequence.length; i++) {
34    const aa = sequence[i];
35    if (!aaWeights[aa]) {
36      throw new Error(`Código de aminoácido no válido: ${aa}`);
37    }
38  }
39  
40  // Sumar pesos de aminoácidos individuales
41  let totalWeight = 0;
42  for (let i = 0; i < sequence.length; i++) {
43    totalWeight += aaWeights[sequence[i]];
44  }
45  
46  // Restar pérdida de agua por enlaces peptídicos y agregar agua terminal
47  const numAminoAcids = sequence.length;
48  const molecularWeight = totalWeight - (numAminoAcids - 1) * WATER_WEIGHT + WATER_WEIGHT;
49  
50  return molecularWeight;
51}
52
53// Ejemplo de uso:
54const sequence = "ACDEFGHIKLMNPQRSTVWY";
55try {
56  const mw = calculateProteinMolecularWeight(sequence);
57  console.log(`Peso molecular: ${mw.toFixed(2)} Da`);
58} catch (error) {
59  console.error(error.message);
60}
61

1import java.util.HashMap;
2import java.util.Map;
3
4public class ProteinMolecularWeightCalculator {
5    private static final Map<Character, Double> aminoAcidWeights = new HashMap<>();
6    private static final double WATER_WEIGHT = 18.01528;
7    
8    static {
9        // Inicializar pesos de aminoácidos
10        aminoAcidWeights.put('A', 71.03711);
11        aminoAcidWeights.put('R', 156.10111);
12        aminoAcidWeights.put('N', 114.04293);
13        aminoAcidWeights.put('D', 115.02694);
14        aminoAcidWeights.put('C', 103.00919);
15        aminoAcidWeights.put('E', 129.04259);
16        aminoAcidWeights.put('Q', 128.05858);
17        aminoAcidWeights.put('G', 57.02146);
18        aminoAcidWeights.put('H', 137.05891);
19        aminoAcidWeights.put('I', 113.08406);
20        aminoAcidWeights.put('L', 113.08406);
21        aminoAcidWeights.put('K', 128.09496);
22        aminoAcidWeights.put('M', 131.04049);
23        aminoAcidWeights.put('F', 147.06841);
24        aminoAcidWeights.put('P', 97.05276);
25        aminoAcidWeights.put('S', 87.03203);
26        aminoAcidWeights.put('T', 101.04768);
27        aminoAcidWeights.put('W', 186.07931);
28        aminoAcidWeights.put('Y', 163.06333);
29        aminoAcidWeights.put('V', 99.06841);
30    }
31    
32    public static double calculateMolecularWeight(String sequence) throws IllegalArgumentException {
33        // Convertir secuencia a mayúsculas
34        sequence = sequence.toUpperCase();
35        
36        // Validar secuencia
37        for (int i = 0; i < sequence.length(); i++) {
38            char aa = sequence.charAt(i);
39            if (!aminoAcidWeights.containsKey(aa)) {
40                throw new IllegalArgumentException("Código de aminoácido no válido: " + aa);
41            }
42        }
43        
44        // Sumar pesos de aminoácidos individuales
45        double totalWeight = 0;
46        for (int i = 0; i < sequence.length(); i++) {
47            totalWeight += aminoAcidWeights.get(sequence.charAt(i));
48        }
49        
50        // Restar pérdida de agua por enlaces peptídicos y agregar agua terminal
51        int numAminoAcids = sequence.length();
52        double molecularWeight = totalWeight - (numAminoAcids - 1) * WATER_WEIGHT + WATER_WEIGHT;
53        
54        return molecularWeight;
55    }
56    
57    public static void main(String[] args) {
58        try {
59            String sequence = "MVKMDVYKGSSIGDSMSRSM";
60            double mw = calculateMolecularWeight(sequence);
61            System.out.printf("Peso molecular: %.2f Da%n", mw);
62        } catch (IllegalArgumentException e) {
63            System.err.println(e.getMessage());
64        }
65    }
66}
67

1#include <iostream>
2#include <string>
3#include <map>
4#include <stdexcept>
5#include <algorithm>
6
7double calculateProteinMolecularWeight(const std::string& sequence) {
8    // Pesos moleculares de aminoácidos
9    std::map<char, double> aaWeights = {
10        {'A', 71.03711},
11        {'R', 156.10111},
12        {'N', 114.04293},
13        {'D', 115.02694},
14        {'C', 103.00919},
15        {'E', 129.04259},
16        {'Q', 128.05858},
17        {'G', 57.02146},
18        {'H', 137.05891},
19        {'I', 113.08406},
20        {'L', 113.08406},
21        {'K', 128.09496},
22        {'M', 131.04049},
23        {'F', 147.06841},
24        {'P', 97.05276},
25        {'S', 87.03203},
26        {'T', 101.04768},
27        {'W', 186.07931},
28        {'Y', 163.06333},
29        {'V', 99.06841}
30    };
31    
32    // Peso molecular del agua
33    const double WATER_WEIGHT = 18.01528;
34    
35    // Convertir secuencia a mayúsculas
36    std::string upperSequence = sequence;
37    std::transform(upperSequence.begin(), upperSequence.end(), upperSequence.begin(), ::toupper);
38    
39    // Validar secuencia
40    for (char aa : upperSequence) {
41        if (aaWeights.find(aa) == aaWeights.end()) {
42            throw std::invalid_argument(std::string("Código de aminoácido no válido: ") + aa);
43        }
44    }
45    
46    // Sumar pesos de aminoácidos individuales
47    double totalWeight = 0.0;
48    for (char aa : upperSequence) {
49        totalWeight += aaWeights[aa];
50    }
51    
52    // Restar pérdida de agua por enlaces peptídicos y agregar agua terminal
53    int numAminoAcids = upperSequence.length();
54    double molecularWeight = totalWeight - (numAminoAcids - 1) * WATER_WEIGHT + WATER_WEIGHT;
55    
56    return molecularWeight;
57}
58
59int main() {
60    try {
61        std::string sequence = "ACDEFGHIKLMNPQRSTVWY";
62        double mw = calculateProteinMolecularWeight(sequence);
63        std::cout << "Peso molecular: " << std::fixed << std::setprecision(2) << mw << " Da" << std::endl;
64    } catch (const std::exception& e) {
65        std::cerr << "Error: " << e.what() << std::endl;
66    }
67    
68    return 0;
69}
70

Preguntas Frecuentes

¿Qué es el peso molecular de una proteína?

El peso molecular de una proteína, también llamado masa molecular, es la masa total de una molécula de proteína expresada en Daltons (Da) o kilodaltons (kDa). Representa la suma de las masas de todos los átomos en la proteína, teniendo en cuenta la pérdida de moléculas de agua durante la formación de enlaces peptídicos. Esta propiedad fundamental es crucial para la caracterización, purificación y análisis de proteínas.

¿Qué tan precisa es esta calculadora de peso molecular de proteínas?

Esta calculadora proporciona el peso molecular teórico basado en la secuencia de aminoácidos con alta precisión. Utiliza las masas monoisotópicas estándar de los aminoácidos y tiene en cuenta la pérdida de agua durante la formación de enlaces peptídicos. Sin embargo, no tiene en cuenta modificaciones post-traduccionales, aminoácidos no estándar o variaciones isotópicas que podrían estar presentes en proteínas reales.

¿Qué unidades se utilizan para el peso molecular de proteínas?

Los pesos moleculares de proteínas se expresan típicamente en Daltons (Da) o kilodaltons (kDa), donde 1 kDa equivale a 1,000 Da. El Dalton es aproximadamente igual a la masa de un átomo de hidrógeno (1.66 × 10^-24 gramos). A modo de referencia, los péptidos pequeños pueden ser de unos pocos cientos de Da, mientras que las proteínas grandes pueden ser de cientos de kDa.

¿Por qué mi peso molecular calculado difiere de los valores experimentales?

Varios factores pueden causar discrepancias entre los pesos moleculares calculados y experimentales:

1. Modificaciones post-traduccionales (fosforilación, glicosilación, etc.)
2. Formación de enlaces disulfuro
3. Procesamiento proteolítico
4. Aminoácidos no estándar
5. Errores de medición experimental
6. Variaciones isotópicas

Para la determinación precisa del peso molecular de proteínas modificadas, se recomienda la espectrometría de masas.

¿Puede esta calculadora manejar aminoácidos no estándar?

Sí, pero esta calculadora no ajusta automáticamente para enlaces disulfuro. Cada formación de enlace disulfuro resulta en la pérdida de dos átomos de hidrógeno (2.01588 Da). Para tener en cuenta los enlaces disulfuro, reste 2.01588 Da del peso molecular calculado por cada enlace disulfuro en su proteína.

¿Cómo se relaciona el peso molecular de las proteínas con el tamaño de la proteína?

Si bien el peso molecular se correlaciona con el tamaño de la proteína, la relación no siempre es directa. Los factores que afectan el tamaño físico de una proteína incluyen:

• Composición de aminoácidos
• Estructura secundaria y terciaria
• Capa de hidratación
• Modificaciones post-traduccionales
• Condiciones ambientales (pH, concentración de sal)

Para una estimación aproximada, una proteína globular de 10 kDa tiene un diámetro de aproximadamente 2-3 nm.

Referencias

1. Gasteiger E., Hoogland C., Gattiker A., Duvaud S., Wilkins M.R., Appel R.D., Bairoch A. (2005) Herramientas de Identificación y Análisis de Proteínas en el Servidor ExPASy. En: Walker J.M. (eds) El Manual de Protocolos de Proteómica. Humana Press.

2. Nelson, D. L., & Cox, M. M. (2017). Principios de Bioquímica de Lehninger (7ª ed.). W.H. Freeman and Company.

3. Steen, H., & Mann, M. (2004). Las ABC's (y XYZ's) de la secuenciación de péptidos. Nature Reviews Molecular Cell Biology, 5(9), 699-711.

4. Voet, D., Voet, J. G., & Pratt, C. W. (2016). Fundamentos de Bioquímica: La Vida a Nivel Molecular (5ª ed.). Wiley.

5. Creighton, T. E. (2010). La Química Biofísica de Ácidos Nucleicos y Proteínas. Helvetian Press.

6. UniProt Consortium. (2021). UniProt: la base de datos de conocimiento universal de proteínas en 2021. Nucleic Acids Research, 49(D1), D480-D489.

7. Artimo, P., Jonnalagedda, M., Arnold, K., Baratin, D., Csardi, G., de Castro, E., Duvaud, S., Flegel, V., Fortier, A., Gasteiger, E., Grosdidier, A., Hernandez, C., Ioannidis, V., Kuznetsov, D., Liechti, R., Moretti, S., Mostaguir, K., Redaschi, N., Rossier, G., Xenarios, I., & Stockinger, H. (2012). ExPASy: Portal de recursos bioinformáticos SIB. Nucleic Acids Research, 40(W1), W597-W603.

8. Kinter, M., & Sherman, N. E. (2005). Secuenciación e Identificación de Proteínas Usando Espectrometría de Masas. Wiley-Interscience.

Pruebe hoy nuestra Calculadora de Peso Molecular de Proteínas para determinar rápida y precisamente el peso molecular de sus secuencias de proteínas. Ya sea que esté planificando experimentos, analizando resultados o aprendiendo sobre bioquímica de proteínas, esta herramienta proporciona la información que necesita en segundos.