biopython

v1.71.0

biopython v1.71.0 Bio.SeqFeature.FeatureLocation

Specify the location of a feature along a sequence.

The FeatureLocation is used for simple continuous features, which can be described as running from a start position to and end position (optionally with a strand and reference information). More complex locations made up from several non-continuous parts (e.g. a coding sequence made up of several exons) are described using a SeqFeature with a CompoundLocation.

Note that the start and end location numbering follow Python’s scheme, thus a GenBank entry of 123..150 (one based counting) becomes a location of [122:150] (zero based counting).

 >>> from Bio.SeqFeature import FeatureLocation
 >>> f = FeatureLocation(122, 150)
 >>> print(f)
 [122:150]
 >>> print(f.start)
 122
 >>> print(f.end)
 150
 >>> print(f.strand)
 None

Note the strand defaults to None. If you are working with nucleotide sequences you’d want to be explicit if it is the forward strand:

 >>> from Bio.SeqFeature import FeatureLocation
 >>> f = FeatureLocation(122, 150, strand=+1)
 >>> print(f)
 [122:150](+)
 >>> print(f.strand)
 1

Note that for a parent sequence of length n, the FeatureLocation start and end must satisfy the inequality 0 <= start <= end <= n. This means even for features on the reverse strand of a nucleotide sequence, we expect the ‘start’ coordinate to be less than the ‘end’.

 >>> from Bio.SeqFeature import FeatureLocation
 >>> r = FeatureLocation(122, 150, strand=-1)
 >>> print(r)
 [122:150](-)
 >>> print(r.start)
 122
 >>> print(r.end)
 150
 >>> print(r.strand)
 -1

i.e. Rather than thinking of the ‘start’ and ‘end’ biologically in a strand aware manor, think of them as the ‘left most’ or ‘minimum’ boundary, and the ‘right most’ or ‘maximum’ boundary of the region being described. This is particularly important with compound locations describing non-continuous regions.

In the example above we have used standard exact positions, but there are also specialised position objects used to represent fuzzy positions as well, for example a GenBank location like complement(<123..150) would use a BeforePosition object for the start.

Link to this section Summary

Functions

__add__()

Combine location with another FeatureLocation object, or shift it

__contains__()

Check if an integer position is within the FeatureLocation object

__eq__()

Implement equality by comparing all the location attributes

__init__()

Initialize the class

__iter__()

Iterate over the parent positions within the FeatureLocation object

__len__()

Return the length of the region described by the FeatureLocation object

__ne__()

Implement the not-equal operand

__nonzero__()

Return True regardless of the length of the feature

__radd__()

Add a feature locationanother FeatureLocation object to the left

__repr__()

Represent the FeatureLocation object as a string for debugging

__str__()

Return a representation of the FeatureLocation object (with python counting)

_flip()

Return a copy of the location after the parent is reversed (PRIVATE)

_get_strand()

Get function for the strand property (PRIVATE)

_set_strand()

Set function for the strand property (PRIVATE)

_shift()

Return a copy of the FeatureLocation shifted by an offset (PRIVATE)

end()

End location - right most (maximum) value, regardless of strand

extract()

Extract the sequence from supplied parent sequence using the FeatureLocation object

nofuzzy_end()

End position (integer, approximated if fuzzy, read only) (OBSOLETE)

nofuzzy_start()

Start position (integer, approximated if fuzzy, read only) (OBSOLETE)

parts()

Read only list of sections (always one, the FeatureLocation object)

start()

Start location - left most (minimum) value, regardless of strand

Link to this section Functions

Link to this function __add__()

Combine location with another FeatureLocation object, or shift it.

You can add two feature locations to make a join CompoundLocation:

 >>> from Bio.SeqFeature import FeatureLocation
 >>> f1 = FeatureLocation(5, 10)
 >>> f2 = FeatureLocation(20, 30)
 >>> combined = f1 + f2
 >>> print(combined)
 join{[5:10], [20:30]}

This is thus equivalent to:

 >>> from Bio.SeqFeature import CompoundLocation
 >>> join = CompoundLocation([f1, f2])
 >>> print(join)
 join{[5:10], [20:30]}

You can also use sum(…) in this way:

 >>> join = sum([f1, f2])
 >>> print(join)
 join{[5:10], [20:30]}

Furthermore, you can combine a FeatureLocation with a CompoundLocation in this way.

Separately, adding an integer will give a new FeatureLocation with its start and end offset by that amount. For example:

 >>> print(f1)
 [5:10]
 >>> print(f1 + 100)
 [105:110]
 >>> print(200 + f1)
 [205:210]

This can be useful when editing annotation.

Link to this function __contains__()

Check if an integer position is within the FeatureLocation object.

Note that extra care may be needed for fuzzy locations, e.g.

 >>> from Bio.SeqFeature import FeatureLocation
 >>> from Bio.SeqFeature import BeforePosition, AfterPosition
 >>> loc = FeatureLocation(BeforePosition(5), AfterPosition(10))
 >>> len(loc)
 5
 >>> [i for i in range(15) if i in loc]
 [5, 6, 7, 8, 9]
Link to this function __eq__()

Implement equality by comparing all the location attributes.

Link to this function __init__()

Initialize the class.

start and end arguments specify the values where the feature begins and ends. These can either by any of the *Position objects that inherit from AbstractPosition, or can just be integers specifying the position. In the case of integers, the values are assumed to be exact and are converted in ExactPosition arguments. This is meant to make it easy to deal with non-fuzzy ends.

i.e. Short form:

 >>> from Bio.SeqFeature import FeatureLocation
 >>> loc = FeatureLocation(5, 10, strand=-1)
 >>> print(loc)
 [5:10](-)

Explicit form:

 >>> from Bio.SeqFeature import FeatureLocation, ExactPosition
 >>> loc = FeatureLocation(ExactPosition(5), ExactPosition(10), strand=-1)
 >>> print(loc)
 [5:10](-)

Other fuzzy positions are used similarly,

 >>> from Bio.SeqFeature import FeatureLocation
 >>> from Bio.SeqFeature import BeforePosition, AfterPosition
 >>> loc2 = FeatureLocation(BeforePosition(5), AfterPosition(10), strand=-1)
 >>> print(loc2)
 [<5:>10](-)

For nucleotide features you will also want to specify the strand, use 1 for the forward (plus) strand, -1 for the reverse (negative) strand, 0 for stranded but strand unknown (? in GFF3), or None for when the strand does not apply (dot in GFF3), e.g. features on proteins.

 >>> loc = FeatureLocation(5, 10, strand=+1)
 >>> print(loc)
 [5:10](+)
 >>> print(loc.strand)
 1

Normally feature locations are given relative to the parent sequence you are working with, but an explicit accession can be given with the optional ref and db_ref strings:

 >>> loc = FeatureLocation(105172, 108462, ref="AL391218.9", strand=1)
 >>> print(loc)
 AL391218.9[105172:108462](+)
 >>> print(loc.ref)
 AL391218.9
Link to this function __iter__()

Iterate over the parent positions within the FeatureLocation object.

 >>> from Bio.SeqFeature import FeatureLocation
 >>> from Bio.SeqFeature import BeforePosition, AfterPosition
 >>> loc = FeatureLocation(BeforePosition(5), AfterPosition(10))
 >>> len(loc)
 5
 >>> for i in loc: print(i)
 5
 6
 7
 8
 9
 >>> list(loc)
 [5, 6, 7, 8, 9]
 >>> [i for i in range(15) if i in loc]
 [5, 6, 7, 8, 9]

Note this is strand aware:

 >>> loc = FeatureLocation(BeforePosition(5), AfterPosition(10), strand = -1)
 >>> list(loc)
 [9, 8, 7, 6, 5]
Link to this function __len__()

Return the length of the region described by the FeatureLocation object.

Note that extra care may be needed for fuzzy locations, e.g.

 >>> from Bio.SeqFeature import FeatureLocation
 >>> from Bio.SeqFeature import BeforePosition, AfterPosition
 >>> loc = FeatureLocation(BeforePosition(5), AfterPosition(10))
 >>> len(loc)
 5
Link to this function __ne__()

Implement the not-equal operand.

Link to this function __nonzero__()

Return True regardless of the length of the feature.

This behaviour is for backwards compatibility, since until the len method was added, a FeatureLocation always evaluated as True.

Note that in comparison, Seq objects, strings, lists, etc, will all evaluate to False if they have length zero.

WARNING: The FeatureLocation may in future evaluate to False when its length is zero (in order to better match normal python behaviour)!

Link to this function __radd__()

Add a feature locationanother FeatureLocation object to the left.

Link to this function __repr__()

Represent the FeatureLocation object as a string for debugging.

Link to this function __str__()

Return a representation of the FeatureLocation object (with python counting).

For the simple case this uses the python splicing syntax, [122:150] (zero based counting) which GenBank would call 123..150 (one based counting).

Link to this function _flip()

Return a copy of the location after the parent is reversed (PRIVATE).

Link to this function _get_strand()

Get function for the strand property (PRIVATE).

Link to this function _set_strand()

Set function for the strand property (PRIVATE).

Link to this function _shift()

Return a copy of the FeatureLocation shifted by an offset (PRIVATE).

Link to this function end()

End location - right most (maximum) value, regardless of strand.

Read only, returns an integer like position object, possibly a fuzzy position.

Link to this function extract()

Extract the sequence from supplied parent sequence using the FeatureLocation object.

The parent_sequence can be a Seq like object or a string, and will generally return an object of the same type. The exception to this is a MutableSeq as the parent sequence will return a Seq object.

 >>> from Bio.Seq import Seq
 >>> from Bio.Alphabet import generic_protein
 >>> from Bio.SeqFeature import FeatureLocation
 >>> seq = Seq("MKQHKAMIVALIVICITAVVAAL", generic_protein)
 >>> feature_loc = FeatureLocation(8, 15)
 >>> feature_loc.extract(seq)
 Seq('VALIVIC', ProteinAlphabet())
Link to this function nofuzzy_end()

End position (integer, approximated if fuzzy, read only) (OBSOLETE).

This is now an alias for int(feature.end), which should be used in preference — unless you are trying to support old versions of Biopython.

Link to this function nofuzzy_start()

Start position (integer, approximated if fuzzy, read only) (OBSOLETE).

This is now an alias for int(feature.start), which should be used in preference — unless you are trying to support old versions of Biopython.

Link to this function parts()

Read only list of sections (always one, the FeatureLocation object).

This is a convenience property allowing you to write code handling both simple FeatureLocation objects (with one part) and more complex CompoundLocation objects (with multiple parts) interchangeably.

Link to this function start()

Start location - left most (minimum) value, regardless of strand.

Read only, returns an integer like position object, possibly a fuzzy position.