# skbio.sequence.DNA

class `skbio.sequence.``DNA`(sequence, metadata=None, positional_metadata=None, lowercase=False, validate=True)

  Store DNA sequence data and optional associated metadata.

  Only characters in the IUPAC DNA character set [R178] are supported.

  Parameters:

  sequence : str, Sequence, or 1D np.ndarray (np.uint8 or ‘|S1’)

  > Characters representing the DNA sequence itself.

  metadata : dict, optional

  > Arbitrary metadata which applies to the entire sequence.

  positional_metadata : Pandas DataFrame consumable, optional

  > Arbitrary per-character metadata. For example, quality data from sequencing reads. Must be able to be passed directly to the Pandas DataFrame constructor.

  lowercase : bool or str, optional

  > If `True`, lowercase sequence characters will be converted to uppercase characters in order to be valid IUPAC DNA characters. If `False`, no characters will be converted. If a str, it will be treated as a key into the positional metadata of the object. All lowercase characters will be converted to uppercase, and a `True` value will be stored in a boolean array in the positional metadata under the key.

  validate : bool, optional

  > If `True`, validation will be performed to ensure that all sequence characters are in the IUPAC DNA character set. If `False`, validation will not be performed. Turning off validation will improve runtime performance. If invalid characters are present, however, there is no guarantee that operations performed on the resulting object will work or behave as expected. Only turn off validation if you are certain that the sequence characters are valid. To store sequence data that is not IUPAC-compliant, use `Sequence`.

  See also

  `RNA`

  References

  [R178] | (1, 2) Nomenclature for incompletely specified bases in nucleic acid sequences: recommendations 1984. Nucleic Acids Res. May 10, 1985; 13(9): 3021-3030. A Cornish-Bowden

  Examples

      >>> from skbio import DNA
      >>> DNA('ACCGAAT')
      DNA
      -----------------------------
      Stats:
          length: 7
          has gaps: False
          has degenerates: False
          has non-degenerates: True
          GC-content: 42.86%
      -----------------------------
      0 ACCGAAT

  Convert lowercase characters to uppercase:

      >>> DNA('AcCGaaT', lowercase=True)
      DNA
      -----------------------------
      Stats:
          length: 7
          has gaps: False
          has degenerates: False
          has non-degenerates: True
          GC-content: 42.86%
      -----------------------------
      0 ACCGAAT

  Attributes

  `values` | Array containing underlying sequence characters.
  `metadata` | `dict` containing metadata which applies to the entire object.
  `positional_metadata` | `pd.DataFrame` containing metadata along an axis.
  `alphabet` | Return valid IUPAC characters.
  `gap_chars` | Return characters defined as gaps.
  `default_gap_char` | Gap character to use when constructing a new gapped sequence.
  `nondegenerate_chars` | Return non-degenerate IUPAC characters.
  `degenerate_chars` | Return degenerate IUPAC characters.
  `degenerate_map` | Return mapping of degenerate to non-degenerate characters.
  `complement_map` | Return mapping of nucleotide characters to their complements.

  Methods

  `complement`([reverse]) | Return the complement of the nucleotide sequence.
  `concat`(sequences[, how]) | Concatenate an iterable of `Sequence` objects.
  `copy`([deep]) | Return a copy of this sequence.
  `count`(subsequence[, start, end]) | Count occurrences of a subsequence in this sequence.
  `degap`() | Return a new sequence with gap characters removed.
  `degenerates`() | Find positions containing degenerate characters in the sequence.
  `distance`(other[, metric]) | Compute the distance to another sequence.
  `expand_degenerates`() | Yield all possible non-degenerate versions of the sequence.
  `find_motifs`(motif_type[, min_length, ignore]) | Search the biological sequence for motifs.
  `find_with_regex`(regex[, ignore]) | Generate slices for patterns matched by a regular expression.
  `frequencies`([chars, relative]) | Compute frequencies of characters in the sequence.
  `gaps`() | Find positions containing gaps in the biological sequence.
  `gc_content`() | Calculate the relative frequency of G’s and C’s in the sequence.
  `gc_frequency`([relative]) | Calculate frequency of G’s and C’s in the sequence.
  `has_degenerates`() | Determine if sequence contains one or more degenerate characters.
  `has_gaps`() | Determine if the sequence contains one or more gap characters.
  `has_metadata`() | Determine if the object has metadata.
  `has_nondegenerates`() | Determine if sequence contains one or more non-degenerate characters
  `has_positional_metadata`() | Determine if the object has positional metadata.
  `index`(subsequence[, start, end]) | Find position where subsequence first occurs in the sequence.
  `is_reverse_complement`(other) | Determine if a sequence is the reverse complement of this sequence.
  `iter_contiguous`(included[, min_length, invert]) | Yield contiguous subsequences based on included.
  `iter_kmers`(k[, overlap]) | Generate kmers of length k from this sequence.
  `kmer_frequencies`(k[, overlap, relative]) | Return counts of words of length k from this sequence.
  `lowercase`(lowercase) | Return a case-sensitive string representation of the sequence.
  `match_frequency`(other[, relative]) | Return count of positions that are the same between two sequences.
  `matches`(other) | Find positions that match with another sequence.
  `mismatch_frequency`(other[, relative]) | Return count of positions that differ between two sequences.
  `mismatches`(other) | Find positions that do not match with another sequence.
  `nondegenerates`() | Find positions containing non-degenerate characters in the sequence.
  `read`(file[, format]) | Create a new `DNA` instance from a file.
  `reverse_complement`() | Return the reverse complement of the nucleotide sequence.
  `to_regex`() | Return regular expression object that accounts for degenerate chars.
  `transcribe`() | Transcribe DNA into RNA.
  `translate`(*args, **kwargs) | Translate DNA sequence into protein sequence.
  `translate_six_frames`(*args, **kwargs) | Translate DNA into protein using six possible reading frames.
  `write`(file[, format]) | Write an instance of `DNA` to a file.