本文整理汇总了Python中Bio.Seq.MutableSeq.append方法的典型用法代码示例。如果您正苦于以下问题:Python MutableSeq.append方法的具体用法?Python MutableSeq.append怎么用?Python MutableSeq.append使用的例子?那么, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类Bio.Seq.MutableSeq
的用法示例。
在下文中一共展示了MutableSeq.append方法的6个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: generate_rolls
# 需要导入模块: from Bio.Seq import MutableSeq [as 别名]
# 或者: from Bio.Seq.MutableSeq import append [as 别名]
def generate_rolls(num_rolls):
"""Generate a bunch of rolls corresponding to the casino probabilities.
Returns:
- The generate roll sequence
- The state sequence that generated the roll.
"""
# start off in the fair state
cur_state = 'F'
roll_seq = MutableSeq('', DiceRollAlphabet())
state_seq = MutableSeq('', DiceTypeAlphabet())
# generate the sequence
for roll in range(num_rolls):
state_seq.append(cur_state)
# generate a random number
chance_num = random.random()
# add on a new roll to the sequence
new_roll = _loaded_dice_roll(chance_num, cur_state)
roll_seq.append(new_roll)
# now give us a chance to switch to a new state
chance_num = random.random()
if cur_state == 'F':
if chance_num <= .05:
cur_state = 'L'
elif cur_state == 'L':
if chance_num <= .1:
cur_state = 'F'
return roll_seq.toseq(), state_seq.toseq()
示例2: random_population
# 需要导入模块: from Bio.Seq import MutableSeq [as 别名]
# 或者: from Bio.Seq.MutableSeq import append [as 别名]
def random_population(genome_alphabet, genome_size, num_organisms,
fitness_calculator):
"""Generate a population of individuals with randomly set genomes.
Arguments:
o genome_alphabet -- An Alphabet object describing all of the
possible letters that could potentially be in the genome of an
organism.
o genome_size -- The size of each organisms genome.
o num_organism -- The number of organisms we want in the population.
o fitness_calculator -- A function that will calculate the fitness
of the organism when given the organisms genome.
"""
all_orgs = []
# a random number generator to get letters for the genome
letter_rand = random.Random()
# figure out what type of characters are in the alphabet
if isinstance(genome_alphabet.letters[0], str):
if sys.version_info[0] == 3:
alphabet_type = "u" # Use unicode string on Python 3
else:
alphabet_type = "c" # Use byte string on Python 2
elif isinstance(genome_alphabet.letters[0], int):
alphabet_type = "i"
elif isinstance(genome_alphabet.letters[0], float):
alphabet_type = "d"
else:
raise ValueError(
"Alphabet type is unsupported: %s" % genome_alphabet.letters)
for org_num in range(num_organisms):
new_genome = MutableSeq(array.array(alphabet_type), genome_alphabet)
# generate the genome randomly
for gene_num in range(genome_size):
new_gene = letter_rand.choice(genome_alphabet.letters)
new_genome.append(new_gene)
# add the new organism with this genome
all_orgs.append(Organism(new_genome, fitness_calculator))
return all_orgs
示例3: viterbi
# 需要导入模块: from Bio.Seq import MutableSeq [as 别名]
# 或者: from Bio.Seq.MutableSeq import append [as 别名]
def viterbi(self, sequence, state_alphabet):
"""Calculate the most probable state path using the Viterbi algorithm.
This implements the Viterbi algorithm (see pgs 55-57 in Durbin et
al for a full explanation -- this is where I took my implementation
ideas from), to allow decoding of the state path, given a sequence
of emissions.
Arguments:
o sequence -- A Seq object with the emission sequence that we
want to decode.
o state_alphabet -- The alphabet of the possible state sequences
that can be generated.
"""
# calculate logarithms of the initial, transition, and emission probs
log_initial = self._log_transform(self.initial_prob)
log_trans = self._log_transform(self.transition_prob)
log_emission = self._log_transform(self.emission_prob)
viterbi_probs = {}
pred_state_seq = {}
state_letters = state_alphabet.letters
# --- recursion
# loop over the training squence (i = 1 .. L)
# NOTE: My index numbers are one less than what is given in Durbin
# et al, since we are indexing the sequence going from 0 to
# (Length - 1) not 1 to Length, like in Durbin et al.
for i in range(0, len(sequence)):
# loop over all of the possible i-th states in the state path
for cur_state in state_letters:
# e_{l}(x_{i})
emission_part = log_emission[(cur_state, sequence[i])]
max_prob = 0
if i == 0:
# for the first state, use the initial probability rather
# than looking back to previous states
max_prob = log_initial[cur_state]
else:
# loop over all possible (i-1)-th previous states
possible_state_probs = {}
for prev_state in self.transitions_to(cur_state):
# a_{kl}
trans_part = log_trans[(prev_state, cur_state)]
# v_{k}(i - 1)
viterbi_part = viterbi_probs[(prev_state, i - 1)]
cur_prob = viterbi_part + trans_part
possible_state_probs[prev_state] = cur_prob
# calculate the viterbi probability using the max
max_prob = max(possible_state_probs.values())
# v_{k}(i)
viterbi_probs[(cur_state, i)] = (emission_part + max_prob)
if i > 0:
# get the most likely prev_state leading to cur_state
for state in possible_state_probs:
if possible_state_probs[state] == max_prob:
pred_state_seq[(i - 1, cur_state)] = state
break
# --- termination
# calculate the probability of the state path
# loop over all states
all_probs = {}
for state in state_letters:
# v_{k}(L)
all_probs[state] = viterbi_probs[(state, len(sequence) - 1)]
state_path_prob = max(all_probs.values())
# find the last pointer we need to trace back from
last_state = ''
for state in all_probs:
if all_probs[state] == state_path_prob:
last_state = state
assert last_state != '', "Didn't find the last state to trace from!"
# --- traceback
traceback_seq = MutableSeq('', state_alphabet)
loop_seq = range(1, len(sequence))
loop_seq.reverse()
# last_state is the last state in the most probable state sequence.
# Compute that sequence by walking backwards in time. From the i-th
# state in the sequence, find the (i-1)-th state as the most
# probable state preceding the i-th state.
state = last_state
traceback_seq.append(state)
for i in loop_seq:
state = pred_state_seq[(i - 1, state)]
#.........这里部分代码省略.........
示例4: viterbi
# 需要导入模块: from Bio.Seq import MutableSeq [as 别名]
# 或者: from Bio.Seq.MutableSeq import append [as 别名]
def viterbi(self, sequence, state_alphabet):
"""Calculate the most probable state path using the Viterbi algorithm.
This implements the Viterbi algorithm (see pgs 55-57 in Durbin et
al for a full explanation -- this is where I took my implementation
ideas from), to allow decoding of the state path, given a sequence
of emissions.
Arguments:
o sequence -- A Seq object with the emission sequence that we
want to decode.
o state_alphabet -- The alphabet of the possible state sequences
that can be generated.
"""
# calculate logarithms of the transition and emission probs
log_trans = self._log_transform(self.transition_prob)
log_emission = self._log_transform(self.emission_prob)
viterbi_probs = {}
pred_state_seq = {}
state_letters = state_alphabet.letters
# --- initialization
#
# NOTE: My index numbers are one less than what is given in Durbin
# et al, since we are indexing the sequence going from 0 to
# (Length - 1) not 1 to Length, like in Durbin et al.
#
# v_{0}(0) = 1
viterbi_probs[(state_letters[0], -1)] = 1
# v_{k}(0) = 0 for k > 0
for state_letter in state_letters[1:]:
viterbi_probs[(state_letter, -1)] = 0
# --- recursion
# loop over the training squence (i = 1 .. L)
for i in range(0, len(sequence)):
# now loop over all of the letters in the state path
for main_state in state_letters:
# e_{l}(x_{i})
emission_part = log_emission[(main_state, sequence[i])]
# loop over all possible states
possible_state_probs = {}
for cur_state in self.transitions_from(main_state):
# a_{kl}
trans_part = log_trans[(cur_state, main_state)]
# v_{k}(i - 1)
viterbi_part = viterbi_probs[(cur_state, i - 1)]
cur_prob = viterbi_part + trans_part
possible_state_probs[cur_state] = cur_prob
# finally calculate the viterbi probability using the max
max_prob = max(possible_state_probs.values())
viterbi_probs[(main_state, i)] = (emission_part + max_prob)
# now get the most likely state
for state in possible_state_probs:
if possible_state_probs[state] == max_prob:
pred_state_seq[(i - 1, main_state)] = state
break
# --- termination
# calculate the probability of the state path
# loop over all letters
all_probs = {}
for state in state_letters:
# v_{k}(L)
viterbi_part = viterbi_probs[(state, len(sequence) - 1)]
# a_{k0}
transition_part = log_trans[(state, state_letters[0])]
all_probs[state] = viterbi_part * transition_part
state_path_prob = max(all_probs.values())
# find the last pointer we need to trace back from
last_state = ''
for state in all_probs:
if all_probs[state] == state_path_prob:
last_state = state
assert last_state != '', "Didn't find the last state to trace from!"
# --- traceback
traceback_seq = MutableSeq('', state_alphabet)
loop_seq = range(0, len(sequence))
loop_seq.reverse()
cur_state = last_state
for i in loop_seq:
traceback_seq.append(cur_state)
cur_state = pred_state_seq[(i - 1, cur_state)]
# put the traceback sequence in the proper orientation
#.........这里部分代码省略.........
示例5: TestMutableSeq
# 需要导入模块: from Bio.Seq import MutableSeq [as 别名]
# 或者: from Bio.Seq.MutableSeq import append [as 别名]
#.........这里部分代码省略.........
def test_setting_slices(self):
self.assertEqual(MutableSeq('CAAA', IUPAC.ambiguous_dna),
self.mutable_s[1:5], "Slice mutable seq")
self.mutable_s[1:3] = "GAT"
self.assertEqual(MutableSeq("TGATAAAGGATGCATCATG", IUPAC.ambiguous_dna),
self.mutable_s,
"Set slice with string and adding extra nucleotide")
self.mutable_s[1:3] = self.mutable_s[5:7]
self.assertEqual(MutableSeq("TAATAAAGGATGCATCATG", IUPAC.ambiguous_dna),
self.mutable_s, "Set slice with MutableSeq")
self.mutable_s[1:3] = array.array(array_indicator, "GAT")
self.assertEqual(MutableSeq("TGATTAAAGGATGCATCATG", IUPAC.ambiguous_dna),
self.mutable_s, "Set slice with array")
def test_setting_item(self):
self.mutable_s[3] = "G"
self.assertEqual(MutableSeq("TCAGAAGGATGCATCATG", IUPAC.ambiguous_dna),
self.mutable_s)
def test_deleting_slice(self):
del self.mutable_s[4:5]
self.assertEqual(MutableSeq("TCAAAGGATGCATCATG", IUPAC.ambiguous_dna),
self.mutable_s)
def test_deleting_item(self):
del self.mutable_s[3]
self.assertEqual(MutableSeq("TCAAAGGATGCATCATG", IUPAC.ambiguous_dna),
self.mutable_s)
def test_appending(self):
self.mutable_s.append("C")
self.assertEqual(MutableSeq("TCAAAAGGATGCATCATGC", IUPAC.ambiguous_dna),
self.mutable_s)
def test_inserting(self):
self.mutable_s.insert(4, "G")
self.assertEqual(MutableSeq("TCAAGAAGGATGCATCATG", IUPAC.ambiguous_dna),
self.mutable_s)
def test_popping_last_item(self):
self.assertEqual("G", self.mutable_s.pop())
def test_remove_items(self):
self.mutable_s.remove("G")
self.assertEqual(MutableSeq("TCAAAAGATGCATCATG", IUPAC.ambiguous_dna),
self.mutable_s, "Remove first G")
self.assertRaises(ValueError, self.mutable_s.remove, 'Z')
def test_count(self):
self.assertEqual(7, self.mutable_s.count("A"))
self.assertEqual(2, self.mutable_s.count("AA"))
def test_index(self):
self.assertEqual(2, self.mutable_s.index("A"))
self.assertRaises(ValueError, self.mutable_s.index, "8888")
def test_reverse(self):
"""Test using reverse method"""
self.mutable_s.reverse()
self.assertEqual(MutableSeq("GTACTACGTAGGAAAACT", IUPAC.ambiguous_dna),
self.mutable_s)
示例6: get_optimal_alignment
# 需要导入模块: from Bio.Seq import MutableSeq [as 别名]
# 或者: from Bio.Seq.MutableSeq import append [as 别名]
def get_optimal_alignment(self):
"""Follow the traceback to get the optimal alignment."""
# intialize the two sequences which will return the alignment
align_seq1 = MutableSeq(array.array("c"),
Alphabet.Gapped(IUPAC.protein, GAP_CHAR))
align_seq2 = MutableSeq(array.array("c"),
Alphabet.Gapped(IUPAC.protein, GAP_CHAR))
# take care of the initial case with the bottom corner matrix
# item
current_cell = self.dpmatrix[(len(self.seq1), len(self.seq2))]
align_seq1.append(current_cell.seq1item)
align_seq2.append(current_cell.seq2item)
next_cell = current_cell.get_parent()
current_cell = next_cell
next_cell = current_cell.get_parent()
# keeping adding sequence until we reach (0, 0)
while next_cell:
# add the new sequence--three cases:
# 1. Move up diaganolly, add a new seq1 and seq2 to the
# aligned sequences
if ((next_cell.col_pos == current_cell.col_pos - 1) and
(next_cell.row_pos == current_cell.row_pos - 1)):
# print "case 1 -> seq1 %s, seq2 %s" % (
# current_cell.seq1item, current_cell.seq2item)
align_seq1.append(current_cell.seq1item)
align_seq2.append(current_cell.seq2item)
# 2. Move upwards, add a new seq2 and a gap in seq1
elif ((next_cell.col_pos == current_cell.col_pos) and
(next_cell.row_pos == current_cell.row_pos - 1)):
#print "case 2 -> seq2 %s" % current_cell.seq2item
align_seq1.append(GAP_CHAR)
align_seq2.append(current_cell.seq2item)
# 3. Move to the right, add a new seq1 and a gap in seq2
elif ((next_cell.col_pos == current_cell.col_pos - 1) and
(next_cell.row_pos == current_cell.row_pos)):
#print "case 3 -> seq1 % s" % current_cell.seq1item
align_seq1.append(current_cell.seq1item)
align_seq2.append(GAP_CHAR)
# now move on to the next sequence
current_cell = next_cell
next_cell = current_cell.get_parent()
# reverse the returned alignments since we are reading them in
# backwards
align_seq1.reverse()
align_seq2.reverse()
return align_seq1.toseq(), align_seq2.toseq()