## 5.6.2 Decimal objects

 class Decimal( [value [, context]])
Constructs a new Decimal object based from value.

value can be an integer, string, tuple, or another Decimal object. If no value is given, returns `Decimal("0")`. If value is a string, it should conform to the decimal numeric string syntax:

```    sign           ::=  '+' | '-'
digit          ::=  '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
indicator      ::=  'e' | 'E'
digits         ::=  digit [digit]...
decimal-part   ::=  digits '.' [digits] | ['.'] digits
exponent-part  ::=  indicator [sign] digits
infinity       ::=  'Infinity' | 'Inf'
nan            ::=  'NaN' [digits] | 'sNaN' [digits]
numeric-value  ::=  decimal-part [exponent-part] | infinity
numeric-string ::=  [sign] numeric-value | [sign] nan
```

If value is a tuple, it should have three components, a sign (0 for positive or 1 for negative), a tuple of digits, and an integer exponent. For example, "Decimal((0, (1, 4, 1, 4), -3))" returns `Decimal("1.414")`.

The context precision does not affect how many digits are stored. That is determined exclusively by the number of digits in value. For example, "Decimal("3.00000")" records all five zeroes even if the context precision is only three.

The purpose of the context argument is determining what to do if value is a malformed string. If the context traps InvalidOperation, an exception is raised; otherwise, the constructor returns a new Decimal with the value of NaN.

Once constructed, Decimal objects are immutable.

Decimal floating point objects share many properties with the other builtin numeric types such as float and int. All of the usual math operations and special methods apply. Likewise, decimal objects can be copied, pickled, printed, used as dictionary keys, used as set elements, compared, sorted, and coerced to another type (such as float or long).

In addition to the standard numeric properties, decimal floating point objects also have a number of specialized methods:

Return the adjusted exponent after shifting out the coefficient's rightmost digits until only the lead digit remains: `Decimal("321e+5").adjusted()` returns seven. Used for determining the position of the most significant digit with respect to the decimal point.

 as_tuple( )
Returns a tuple representation of the number: "(sign, digittuple, exponent)".

 compare( other[, context])
Compares like __cmp__() but returns a decimal instance:
```        a or b is a NaN ==> Decimal("NaN")
a < b           ==> Decimal("-1")
a == b          ==> Decimal("0")
a > b           ==> Decimal("1")
```

 max( other[, context])
Like "max(self, other)" except that the context rounding rule is applied before returning and that NaN values are either signalled or ignored (depending on the context and whether they are signaling or quiet).

 min( other[, context])
Like "min(self, other)" except that the context rounding rule is applied before returning and that NaN values are either signalled or ignored (depending on the context and whether they are signaling or quiet).

 normalize( [context])
Normalize the number by stripping the rightmost trailing zeroes and converting any result equal to Decimal("0") to Decimal("0e0"). Used for producing canonical values for members of an equivalence class. For example, `Decimal("32.100")` and `Decimal("0.321000e+2")` both normalize to the equivalent value `Decimal("32.1")`.

 quantize( exp [, rounding[, context[, watchexp]]])
Quantize makes the exponent the same as exp. Searches for a rounding method in rounding, then in context, and then in the current context.

If watchexp is set (default), then an error is returned whenever the resulting exponent is greater than Emax or less than Etiny.

 remainder_near( other[, context])
Computes the modulo as either a positive or negative value depending on which is closest to zero. For instance, "Decimal(10).remainder_near(6)" returns `Decimal("-2")` which is closer to zero than `Decimal("4")`.

If both are equally close, the one chosen will have the same sign as self.

 same_quantum( other[, context])
Test whether self and other have the same exponent or whether both are NaN.

 sqrt( [context])
Return the square root to full precision.

 to_eng_string( [context])
Convert to an engineering-type string.

Engineering notation has an exponent which is a multiple of 3, so there are up to 3 digits left of the decimal place. For example, converts `Decimal('123E+1')` to `Decimal("1.23E+3")`

 to_integral( [rounding[, context]])
Rounds to the nearest integer without signaling Inexact or Rounded. If given, applies rounding; otherwise, uses the rounding method in either the supplied context or the current context.