def generate_plot(key, my_seq): analysed_seq = ProteinAnalysis(my_seq) l = len(my_seq) window_size = 21 scale = analysed_seq.protein_scale(param_dict=amino_acids, window=window_size, edge=0.75) x = range((window_size + 1) / 2, len(scale) + (window_size + 1) / 2) lookahead = 7 minp, maxp = peakdetect(scale, lookahead=(lookahead + 1) / 2) start = min(x) - 1 xpeaks = [xp[0] + (window_size + 1) / 2 for xp in minp] ypeaks = [scale[xpi - (window_size + 1) / 2] for xpi in xpeaks] t_x = np.array(scale) added_min = np.where(t_x < 0.9)[0] print(added_min) xdpeaks = [xdp[0] + (window_size + 1) / 2 for xdp in maxp] ydpeaks = [scale[xdpi - (window_size + 1) / 2] for xdpi in xdpeaks] num_pos = np.where(np.array(ydpeaks) < 0.9)[0].size print(num_pos) if num_pos == 0 and len(added_min) != 0: added_val = [scale[i] for i in list(added_min)] minimum = added_val.index(min(added_val)) - start + 2 print(added_min[minimum]) print(added_val[minimum]) xdpeaks.append(added_min[minimum]) ydpeaks.append(added_val[minimum]) print("maxs:", np.array(xpeaks) + start) print("mins:", np.array(xdpeaks) + start) #print(scale) plt.clf() plt.plot(x, scale, 'b', xpeaks, ypeaks, 'ro', xdpeaks, ydpeaks, 'go') plt.grid(True) #plt.axis([0,max(x), min(scale)-0.05*min(scale), max(scale)+0.05*max(scale)]) #plt.axis([0,max(x), 0.85, max(scale)+0.05*max(scale)]) plt.legend(['Scores for ' + key]) #,'local maxima', 'local minima' ]) plt.xlabel('Position') plt.ylabel('Score') plt.savefig('figs/' + key + '.png')
def generate_plot(key, my_seq): analysed_seq = ProteinAnalysis(my_seq) l = len(my_seq) window_size = 21 scale = analysed_seq.protein_scale(param_dict=amino_acids, window=window_size, edge=0.75) x = range((window_size+1)/2,len(scale)+(window_size+1)/2) lookahead = 7 minp, maxp = peakdetect(scale, lookahead=(lookahead+1)/2) start = min(x)-1 xpeaks = [xp[0]+(window_size+1)/2 for xp in minp] ypeaks = [scale[xpi-(window_size+1)/2] for xpi in xpeaks] t_x = np.array(scale) added_min = np.where(t_x < 0.9)[0] print(added_min) xdpeaks = [xdp[0]+(window_size+1)/2 for xdp in maxp] ydpeaks = [scale[xdpi-(window_size+1)/2] for xdpi in xdpeaks] num_pos = np.where(np.array(ydpeaks) < 0.9)[0].size print(num_pos) if num_pos == 0 and len(added_min) != 0: added_val = [scale[i] for i in list(added_min)] minimum = added_val.index(min(added_val))-start+2 print(added_min[minimum]) print(added_val[minimum]) xdpeaks.append(added_min[minimum]) ydpeaks.append(added_val[minimum]) print("maxs:",np.array(xpeaks)+start) print("mins:",np.array(xdpeaks)+start) #print(scale) plt.clf() plt.plot(x,scale,'b', xpeaks, ypeaks ,'ro', xdpeaks, ydpeaks ,'go') plt.grid(True) #plt.axis([0,max(x), min(scale)-0.05*min(scale), max(scale)+0.05*max(scale)]) #plt.axis([0,max(x), 0.85, max(scale)+0.05*max(scale)]) plt.legend( ['Scores for '+key])#,'local maxima', 'local minima' ]) plt.xlabel('Position') plt.ylabel('Score') plt.savefig('figs/'+key+'.png')
def biopython_protein_scale(inseq, scale, custom_scale_dict=None, window=7): """Use Biopython to calculate properties using a sliding window over a sequence given a specific scale to use.""" if scale == 'kd_hydrophobicity': scale_dict = kd_hydrophobicity_one elif scale == 'bulkiness': scale_dict = bulkiness_one elif scale == 'custom': scale_dict = custom_scale_dict else: raise ValueError('Scale not available') inseq = ssbio.protein.sequence.utils.cast_to_str(inseq) analysed_seq = ProteinAnalysis(inseq) result = analysed_seq.protein_scale(param_dict=scale_dict, window=window) # Correct list length by prepending and appending "inf" (result needs to be same length as sequence) for i in range(window // 2): result.insert(0, float("Inf")) result.append(float("Inf")) return result
for seq in sequences: X=ProteinAnalysis(str(seq)) isoelectricPt.append(X.isoelectric_point()) aromaticity.append(X.aromaticity()) aminoPercent.append(X.get_amino_acids_percent()) secstruct.append(X.secondary_structure_fraction()) # These features throw Key & Value Errors due to non standard amino acids # (i.e. out of the 20 standard ones) e.g. X, U etc try: gravy.append(X.gravy()) molweight.append(X.molecular_weight()) instidx.append(X.instability_index()) flex.append(X.flexibility()) hydrophob.append(X.protein_scale(ProtParamData.kd, 9, 0.4)) hydrophil.append(X.protein_scale(ProtParamData.hw, 9, 0.4)) surface.append(X.protein_scale(ProtParamData.em, 9, 0.4)) except (KeyError,ValueError): gravy.append(0) molweight.append(0) instidx.append(0) flex.append([0,0]) hydrophob.append([0,0]) hydrophil.append([0,0]) surface.append([0,0]) isoelectricPt_df = pd.DataFrame(isoelectricPt,columns=['isoelectricPt']) aromaticity_df = pd.DataFrame(aromaticity,columns=['aromaticity']) aminoPercent_df = pd.DataFrame()
def openfile(): global prob, probab, te global my_seq global anti global structure, structure_id, filename global antigenicity, hydro, flex, sec global m, a, c, b, length, j, k global hydroph, flexi, access anti = [] sec = [] probab = [] from tkinter import filedialog root = Tk() root.filename = filedialog.askopenfilename( initialdir="/", title="Select file", filetypes=(("pdb files", "*.pdb"), ("pdb files", "*.pdb"))) filename = root.filename print(filename) structure_id = "1e6j" structure = PDBParser().get_structure(structure_id, root.filename) ppb = PPBuilder() for pp in ppb.build_peptides(structure): my_seq = pp.get_sequence() # type: Seq print(my_seq) for model in structure: for chain in model: print(chain) sequence = list(my_seq) m = ''.join(sequence) print(m) length = len(m) # type: int print("Sequence consist of", length, "Amino Acids") from Bio.SeqUtils.ProtParam import ProteinAnalysis analysed_seq = ProteinAnalysis(m) print("Molecular weight = ", analysed_seq.molecular_weight()) print("Amino Acid Count = ", analysed_seq.count_amino_acids()) print("Secondary structure fraction =", analysed_seq.secondary_structure_fraction()) kd = { 'A': 1.8, 'R': -4.5, 'N': -3.5, 'D': -3.5, 'C': 2.5, 'Q': -3.5, 'E': -3.5, 'G': -0.4, 'H': -3.2, 'I': 4.5, 'L': 3.8, 'K': -3.9, 'M': 1.9, 'F': 2.8, 'P': -1.6, 'S': -0.8, 'T': -0.7, 'W': -0.9, 'Y': -1.3, 'V': 4.2 } c = list(analysed_seq.flexibility()) b = list(analysed_seq.protein_scale(kd, 10, 1.0)) hydro = list(analysed_seq.protein_scale(kd, 10, 1.0)) flex = list(analysed_seq.flexibility()) hydroph = list(analysed_seq.protein_scale(kd, 10, 1.0)) flexi = list(analysed_seq.flexibility()) i = 1 j = -1 # type: int k = 9 while i <= (length - 10): print("Sequence is = ", m[j + 1:k + 1]) print("Flexibility value = ", c[j + 1]) print("Hydrophilicity value = ", b[j + 1]) ana_seq = ''.join(m[j + 1:k + 1]) analyze_seq = ProteinAnalysis(ana_seq) # For Secondary structure Analysis print("Secondary structure fraction =", analyze_seq.secondary_structure_fraction()) a = list(analyze_seq.secondary_structure_fraction()) a = a[0] sec.append(a) i += 1 j += 1 k += 1 f = length r = 1 y = 10 global acc, logacc acc = [] for i in range(0, f): str1 = "accessibility, resi " str2 = str(r) + "-" + str(y) saving = str1 + str2 print(saving) r = r + 1 y = y + 1 structure = freesasa.Structure("1e6j.pdb") resulta = freesasa.calc(structure) area_classes = freesasa.classifyResults(resulta, structure) print("Total : %.2f A2" % resulta.totalArea()) for key in area_classes: print(key, ": %.2f A2" % area_classes[key]) resulta = freesasa.calc( structure, freesasa.Parameters({ 'algorithm': freesasa.LeeRichards, 'n-slices': 10 })) selections = freesasa.selectArea(('alanine, resn ala', saving), structure, resulta) for key in selections: print(key, ": %.2f A2" % selections[key]) a = selections[key] acc.append(a) l = acc[0::2] access = l print(acc) print(l) logacc = [math.log(y, 10) for y in l] print(logacc)
class Protein(ProteinAnalysis): category_codes = { 'cyto': 0, 'mito': 1, 'secreted': 2, 'nucleus': 3, 'blind': 4 } inv_category_codes = { 0: 'cyto', 1: 'mito', 2: 'secreted', 3: 'nucleus', 4: 'blind' } def __init__(self, category_name, name, sequence): super(Protein, self).__init__(sequence) self._name = name self._category = Protein.category_codes[category_name] self._sequence = sequence if 'X' in sequence or 'U' in sequence or 'B' in sequence: self._contains_unknown = True new_seq = self._sequence.replace('U', '') new_seq = new_seq.replace('B', '') new_seq = new_seq.replace('X', '') self._no_unknowns = ProteinAnalysis(new_seq) else: self._contains_unknown = False self._no_unknowns = self def get_name(self): return self._name def get_sequence(self): return self._sequence def sequence_length(self): return len(sequence) def get_sub_sequence(self, seq_flag): if seq_flag == WHOLE_SEQUENCE: return self elif seq_flag == N_TERMINAL_50: return Protein(Protein.inv_category_codes[self._category], self._name, self._sequence[:50]) elif seq_flag == C_TERMINAL_50: return Protein(Protein.inv_category_codes[self._category], self._name, self._sequence[-50:]) def get_category(self): return self._category def molecular_weight(self): #overrides base class if self._contains_unknown: new_seq = '' for aa in self._sequence: if aa not in UNKNOWNS: new_seq += aa new_p = ProteinAnalysis(new_seq) mw = new_p.molecular_weight() #just increase by avg mw of known aa's mw *= len(self._sequence) / len(new_seq) else: mw = super(Protein, self).molecular_weight() return mw def instability_index(self): #overrides base class if self._contains_unknown: index = ProtParamData.DIWV score = 0.0 sub_sequences = self._sequence.replace('U', 'X') sub_sequences = sub_sequences.replace('B', 'X') sub_sequences = sub_sequences.split('X') for seq in sub_sequences: for i in range(len(seq) - 1): this, nextt = seq[i:i + 2] dipeptide_value = index[this][nextt] score += dipeptide_value in_idx = (10.0 / (len(self._sequence) - len(sub_sequences) + 1)) * score else: in_idx = super(Protein, self).instability_index() return in_idx def flexibility(self): #overrides base class if self._contains_unknown: new_sequence = self._sequence.replace('X', 'R') #replace with an avg aa new_sequence = new_sequence.replace('U', 'R') #replace with an avg aa new_sequence = new_sequence.replace('B', 'R') #replace with an avg aa new_p = ProteinAnalysis(new_sequence) flex = new_p.flexibility() else: flex = super(Protein, self).flexibility() return flex def in_vivo_half_life(self): #N-end rule if self._sequence[0] not in UNKNOWNS: return in_vivo_half_life[self._sequence[0]] else: return 5 #approx avg value def has_KDEL(self): #ER retention signal if self._sequence[-4:] == 'KDEL': return True else: return False def has_KKXX(self): #ER retention signal if self._sequence[-4:-2] == 'KK': return True else: return False def has_NLS(self): #NLS signal if 'PKKKRKV' in self._sequence: return True else: return False def has_Chelsky_sequence(self): #NLS signal # K-K/R-X-K/R try: found = re.search('K[KR].[KR]', self._sequence) except AttributeError: # AAA, ZZZ not found in the original string found = None # apply your error handling if found is not None: return True else: return False def has_PTS( self): #peroxisomal targeting signal (PTS) - SKL in carboxy tail if self._sequence[-3:] == 'SKL': return True else: return False def hydrophobicity(self): hphob = self._no_unknowns.protein_scale(ProtParamData.kd, 3) return np.mean(hphob) def surface_accessibility(self): em = self._no_unknowns.protein_scale(ProtParamData.em, 3) return np.mean(em) def transfer_energy(self): te = self._no_unknowns.protein_scale(ProtParamData.ja, 3) return np.mean(te) def hydrophilicity(self): hphil = self._no_unknowns.protein_scale(ProtParamData.hw, 3) return np.mean(hphil)
def openfile(): global my_seq global antigenicity global m, a, c, b from tkinter import filedialog root = Tk() root.filename = filedialog.askopenfilename( initialdir="/", title="Select file", filetypes=(("pdb files", "*.pdb"), ("pdb files", "*.pdb"))) print(root.filename) structure_id = "1e6j" structure = PDBParser().get_structure(structure_id, root.filename) ppb = PPBuilder() for pp in ppb.build_peptides(structure): my_seq = pp.get_sequence() # type: Seq print(my_seq) for model in structure: for chain in model: print(chain) sequence = list(my_seq) m = ''.join(sequence) # type: str print(m) length = len(m) # type: int print(length) print("Sequence consist of", len(m), "Amino Acids") from Bio.SeqUtils.ProtParam import ProteinAnalysis analysed_seq = ProteinAnalysis(m) print("Molecular weight = ", analysed_seq.molecular_weight()) print("Amino Acid Count = ", analysed_seq.count_amino_acids()) print("Secondary structure fraction =", analysed_seq.secondary_structure_fraction()) kd = { 'A': 1.8, 'R': -4.5, 'N': -3.5, 'D': -3.5, 'C': 2.5, 'Q': -3.5, 'E': -3.5, 'G': -0.4, 'H': -3.2, 'I': 4.5, 'L': 3.8, 'K': -3.9, 'M': 1.9, 'F': 2.8, 'P': -1.6, 'S': -0.8, 'T': -0.7, 'W': -0.9, 'Y': -1.3, 'V': 4.2 } c = list(analysed_seq.flexibility()) b = list(analysed_seq.protein_scale(kd, 10, 1.0)) i = 1 j = -1 # type: int k = 9 while i <= (length - 10): print("Sequence is = ", m[j + 1:k + 1]) print("Flexibility value = ", c[j + 1]) print("Hydrophilicity value = ", b[j + 1]) ana_seq = ''.join(m[j + 1:k + 1]) analyze_seq = ProteinAnalysis(ana_seq) # For Secondary structure Analysis print("Secondary structure fraction =", analyze_seq.secondary_structure_fraction()) a = list(analyze_seq.secondary_structure_fraction()) global tupleall tupleall = (m[j + 1:k + 1], c[j + 1], b[j + 1], a) print(tupleall[0], tupleall[2], tupleall[1], tupleall[3]) i = i + 1 if a[0] >= a[1]: a[0] = 1 else: a[0] = a[1] # For Hydrophilicity if b[j + 1] > 0.5: b[j + 1] = 2 elif b[j + 1] < 0.5 or b[j + 1] > 0: b[j + 1] = 1 elif b[j + 1] > 0 or b[j + 1] > -0.4: b[j + 1] = -1 elif b[j + 1] < -0.4: b[j + 1] = -2 else: b[j + 1] = 0 # For Flexibility if c[j + 1] > 1.0: c[j + 1] = 1 else: c[j + 1] = 0 # For antigenicity Index antigenicity = 0.3 * b[j + 1] + 0.15 * 1 + 0.15 * c[j + 1] + 0.2 * a[0] print("antigenicity", antigenicity) j += 1 k += 1
def transform(self, X): vec = np.zeros((len(X), 1)) for i in range(len(X)): pa = ProteinAnalysis(str(X[i])) vec[i, 0] = pa.protein_scale() return vec
def disruptin_table(garnier_file, fasta_file): # Iterable variables position = 1 net_charge = 0 charge_res = 0 record_number = 0 # loop structures names = [] sec_struct = [] # reading the lines from the garnier csv file # with open(garnier_file,'r') as csvfile: # garnierreader = csv.reader(csvfile) for row in garnier_file: if row[0] == 'Sequence: ': names += [row[1]] elif row[0] in 'HETC': row = row.split('\t') sec_struct += [''.join(row)] record = [] p = [] r = [] c = [] h = [] s = [] # Parse the .fasta file and get the sequence for rec in SeqIO.parse(fasta_file, "fasta"): sequence = str(rec.seq) # Set up the information vectors: for position #, residue, hydrophobic/charge/polar/nonpolar, and secondary # structure record += [rec.id] position_vec = [] residue_vec = [] charge_sym_vec = [] sec_struct_vec = [] for aa in sequence: position_vec += [str(position)] residue_vec += [str(aa)] sec_struct_vec += [str(sec_struct[record_number][position - 1])] # For R and K residues a positive charge is given if aa in "RK": symbol = "+" # For D and E residues a negative charge is given elif aa in "DE": symbol = "-" elif aa in "AVMILPWFG": symbol = "N" elif aa in "HSYTCQN": symbol = "P" charge_sym_vec += symbol position += 1 # Calculating hyrophobicity based on Kyte and Doolittle scale. Using binning value of 9. Since the binning # is 9, the first 4 residues and last 4 residues as set blank so as to center the values to their # approximate position on the sequence. prot_ana_seq = ProteinAnalysis(sequence) hydro = [0] * 4 + prot_ana_seq.protein_scale(ProtParamData.kd, 9) + [0] * 4 record_number += 1 position = 1 p += [position_vec] r += [residue_vec] c += [charge_sym_vec] h += [hydro] s += [sec_struct_vec] # returns values for name of the sequence return record, p, r, c, h, s
'--graph', type=bool, default=False, help='Toggles the creation of a folder with images of the hydropathy graphs' ) args = parser.parse_args() #Parsing the preestablished sequences for record in SeqIO.parse(args.input_reference, 'fasta'): seq_record.append(str(record.seq)) seq_names.append(str(record.id)) for index in range(len(seq_names)): seq = ProteinAnalysis(seq_record[index]) test = seq.protein_scale(kyle_doolittle, 7) seq_analysis.append(test) all_trends = [] s_regions = [] #Generates Average for preestablished data for index in range(len(seq_analysis)): a = generate_region_average( filter_profiles( analyze_profile(create_cors(seq_analysis[index], 4), []))) s_regions.append(a) for index in range(len(s_regions)): all_trends = mysort(s_regions[index], all_trends)
def featurise(self, data): """ Featurise the data. Parameters: ----------- data : `list` of `Bio.SeqRecord.SeqRecord` The data to be featurised. Returns: ------- featurised_data : `pandas.DataFrame` (num_data, features) The featurised data. """ # Get features of data features = collections.defaultdict(list) # Featurise the data for i, example in enumerate(data): # Convert Bio.SeqRecord.SeqRecord object to string for Bio.SeqUtils.ProtParam.ProteinAnalysis analysed_example = ProteinAnalysis(str(example.seq)) first50_analysed_example = ProteinAnalysis(str(example.seq)[:50]) last50_analysed_example = ProteinAnalysis(str(example.seq)[-50:]) features["length"].append(analysed_example.length) features["molecular_weight"].append( analysed_example.molecular_weight()) features["isoelectric_point"].append( analysed_example.isoelectric_point()) features["aromaticity"].append(analysed_example.aromaticity()) features["instability_index"].append( analysed_example.instability_index()) features["gravy"].append(analysed_example.gravy()) reduced, oxidised = analysed_example.molar_extinction_coefficient() features["reduced"].append(reduced) features["oxidised"].append(oxidised) helix, turn, sheet = analysed_example.secondary_structure_fraction( ) features["helix"].append(helix) features["turn"].append(turn) features["sheet"].append(sheet) features["charge_at_ph1"].append(analysed_example.charge_at_pH(1)) # features["charge_at_ph2"].append(analysed_example.charge_at_pH(2)) # features["charge_at_ph3"].append(analysed_example.charge_at_pH(3)) # features["charge_at_ph4"].append(analysed_example.charge_at_pH(4)) features["charge_at_ph7"].append(analysed_example.charge_at_pH(7)) features["charge_at_ph12"].append( analysed_example.charge_at_pH(12)) features["hydrophobicity"].append( np.mean( analysed_example.protein_scale(self.dicts['kd'], window=5, edge=1.0))) features["flexibility"].append( np.mean( analysed_example.protein_scale(self.dicts['flex'], window=5, edge=1.0))) features["hydrophilicity"].append( np.mean( analysed_example.protein_scale(self.dicts['hw'], window=5, edge=1.0))) features["surface_accessibility"].append( np.mean( analysed_example.protein_scale(self.dicts['em'], window=5, edge=1.0))) features["janin"].append( np.mean( analysed_example.protein_scale(self.dicts['ja'], window=5, edge=1.0))) # features["dipeptide_dg "].append(np.mean(analysed_example.protein_scale(self.dicts['diwv'], window=5, edge=1.0))) features["first50_hydrophobicity"].append( np.mean( first50_analysed_example.protein_scale(self.dicts['kd'], window=5, edge=1.0))) features["first50_flexibility"].append( np.mean( first50_analysed_example.protein_scale(self.dicts['flex'], window=5, edge=1.0))) features["first50_hydrophilicity"].append( np.mean( first50_analysed_example.protein_scale(self.dicts['hw'], window=5, edge=1.0))) features["first50_surface_accessibility"].append( np.mean( first50_analysed_example.protein_scale(self.dicts['em'], window=5, edge=1.0))) features["first50_janin"].append( np.mean( first50_analysed_example.protein_scale(self.dicts['ja'], window=5, edge=1.0))) features["last50_hydrophobicity"].append( np.mean( last50_analysed_example.protein_scale(self.dicts['kd'], window=5, edge=1.0))) features["last50_flexibility"].append( np.mean( last50_analysed_example.protein_scale(self.dicts['flex'], window=5, edge=1.0))) features["last50_hydrophilicity"].append( np.mean( last50_analysed_example.protein_scale(self.dicts['hw'], window=5, edge=1.0))) features["last50_surface_accessibility"].append( np.mean( last50_analysed_example.protein_scale(self.dicts['em'], window=5, edge=1.0))) features["last50_janin"].append( np.mean( last50_analysed_example.protein_scale(self.dicts['ja'], window=5, edge=1.0))) for key, val in analysed_example.get_amino_acids_percent().items(): features[key].append(val * 5) for key, val in first50_analysed_example.get_amino_acids_percent( ).items(): features["first_50_" + str(key)].append(val * 5) for key, val in last50_analysed_example.get_amino_acids_percent( ).items(): features["last_50_" + str(key)].append(val * 5) return pd.DataFrame.from_dict(features)
st.write('Thank you for your feedback, it has been recorded!') st.markdown('---') if show_aa_chart: st.subheader('Breakdown of Virus Amino Acids') display_aa_chart(virus_df) st.markdown('---') if show_prot_scale: st.subheader( 'Protein Scale of Virus Sequence (Hydropathicity Amino Acid Scale)' ) analysis = ProteinAnalysis(virus_df[virus_df['id'] == virus_select] ['protein_sequence'].iloc[0]) prot_scale = analysis.protein_scale(param_dict=hydropathicity, window=wsl, edge=esl) scale_fig = go.Figure(data=go.Scatter(x=np.arange(1, len(prot_scale)), y=np.array(prot_scale))) scale_fig.update_layout(xaxis_title='Position', yaxis_title='Hydropathicity') st.plotly_chart(scale_fig) st.markdown('---') if show_df: st.subheader('Raw Data') st_ms = st.multiselect("Columns", virus_df.columns.tolist(), default=ms_cols) # row_limit = st.sidebar.slider("Dataframe rows:", 1, 10, 1) st.dataframe(virus_df[virus_df['id'] == virus_select][st_ms].head())
from Bio.SeqUtils.ProtParam import ProteinAnalysis from Bio.SeqUtils import ProtParamData from Bio import SeqIO with open('../../samples/pdbaa') as fh: for rec in SeqIO.parse(fh,'fasta'): myprot = ProteinAnalysis(str(rec.seq)) print(myprot.count_amino_acids()) print(myprot.get_amino_acids_percent()) print(myprot.molecular_weight()) print(myprot.aromaticity()) print(myprot.instability_index()) print(myprot.flexibility()) print(myprot.isoelectric_point()) print(myprot.secondary_structure_fraction()) print(myprot.protein_scale(ProtParamData.kd, 9, .4))