Defining Quantities =================== A quantity in Pint is the product of a unit and a magnitude. Pint supports several different ways of defining physical quantities, including a powerful string parsing system. These methods are largely interchangeable, though you may **need** to use the constructor form under certain circumstances (see :doc:`nonmult` for an example of where the constructor form is required). By multiplication ----------------- If you've read the :ref:`Tutorial`, you're already familiar with defining a quantity by multiplying a ``Unit()`` and a scalar: .. doctest:: >>> from pint import UnitRegistry >>> ureg = UnitRegistry() >>> ureg.meter >>> 30.0 * ureg.meter This works to build up complex units as well: .. doctest:: >>> 9.8 * ureg.meter / ureg.second**2 Using the constructor --------------------- In some cases it is useful to define :class:`Quantity() ` objects using it's class constructor. Using the constructor allows you to specify the units and magnitude separately. We typically abbreviate that constructor as `Q_` to make it's usage less verbose: .. doctest:: >>> Q_ = ureg.Quantity >>> Q_(1.78, ureg.meter) As you can see below, the multiplication and constructor methods should produce the same results: .. doctest:: >>> Q_(30.0, ureg.meter) == 30.0 * ureg.meter True >>> Q_(9.8, ureg.meter / ureg.second**2) Quantity can be created with itself, if units is specified ``pint`` will try to convert it to the desired units. If not, pint will just copy the quantity. .. doctest:: >>> length = Q_(30.0, ureg.meter) >>> Q_(length, 'cm') >>> Q_(length) Using string parsing -------------------- Pint includes a powerful parser for detecting magnitudes and units (with or without prefixes) in strings. Calling the ``UnitRegistry()`` directly invokes the parsing function: .. doctest:: >>> 30.0 * ureg('meter') >>> ureg('30.0 meters') >>> ureg('3000cm').to('meters') The parsing function is also available to the ``Quantity()`` constructor and the various ``.to()`` methods: .. doctest:: >>> Q_('30.0 meters') >>> Q_(30.0, 'meter') >>> Q_('3000.0cm').to('meter') Or as a standalone method on the ``UnitRegistry``: .. doctest:: >>> 2.54 * ureg.parse_expression('centimeter') It is fairly good at detecting compound units: .. doctest:: >>> g = ureg('9.8 meters/second**2') >>> g >>> g.to('furlongs/fortnight**2') And behaves well when given dimensionless quantities, which are parsed into their appropriate objects: .. doctest:: >>> ureg('2.54') 2.54 >>> type(ureg('2.54')) >>> Q_('2.54') >>> type(Q_('2.54')) .. note:: Pint's rule for parsing strings with a mixture of numbers and units is that **units are treated with the same precedence as numbers**. For example, the units of .. doctest:: >>> Q_('3 l / 100 km') may be unexpected at first but, are a consequence of applying this rule. Use brackets to get the expected result: .. doctest:: >>> Q_('3 l / (100 km)') Special strings for NaN (Not a Number) and inf(inity) are also handled in a case-insensitive fashion. Note that, as usual, NaN != NaN. .. doctest:: >>> Q_('inf m') >>> Q_('-INFINITY m') >>> Q_('nan m') >>> Q_('NaN m') .. note:: Since version 0.7, Pint **does not** use eval_ under the hood. This change removes the `serious security problems`_ that the system is exposed to when parsing information from untrusted sources. .. _eval: http://docs.python.org/3/library/functions.html#eval .. _`serious security problems`: http://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html