Basics

This page describes the basic use and some internals of the Python module.

Installation

The PhysicalQuantities module can be installed like any other Python module:

pip install PhysicalQuantities

Loading the Python Module

>>> import PhysicalQuantities as pq

Basic Use

You can now define physical quantities using the PhysicalQuantity(value, unit) constructor:

>>> a = pq.PhysicalQuantity(1.1, 'm')
>>> a
>>> 1.1 m

or using the shortcut q:

>>> from PhysicalQuantities import q
>>> a = 1 * q.mm
>>> b = 2 * q['mm']
>>> a, b
(1 mm, 2 mm)

Calling a = 1 * q.mm creates a new PhysicalQuantity object:

>>> print("object: %s" % a)
object: 1 mm
>>> print("object type: %s" % type(a))
object type: <class 'PhysicalQuantities.Quantity.PhysicalQuantity'>

The value and unit are stored as attributes of the class:

>>> print("value: %s" % a.value)
value: 1
>>> print("value type: %s" % type(a.value))
value type: <class 'int'>
>>> print("unit: %s" % a.unit)
unit: mm
>>> print("unit type: %s" % type(a.unit))
unit type: <class 'PhysicalQuantities.Unit.PhysicalUnit'>

Using .to() let’s you convert to other representations of the unit. This can be used for scaling or to express the quantity in a derived unit. The .base property will convert

>>> g = pq.PhysicalQuantity(1.1, 'm')
>>> print("g = %s" % g)
g = 1.1 m
>>> print("g in mm = %s" %g.to('mm'))
g in mm = 1100.0 mm
>>> x = pq.PhysicalQuantity(2, 'm*kg/s**2')
>>> print("x = %s" %x)
x = 2 kg*m/s^2
>>> print("x in N = %s" % x.to('N'))
x in N = 2.0 N
>>> u = 1 V
>>> print("u = %s" %u)
u = 1 V
>>> print("u in base units = %s" %u.base)
u in base units = 1.0 kg*m^2/s^3/A

Scaling of simple units is easy using scaling attributes:

>>> print(g.nm)
1100000000.0 nm
>>> print(g.um)
1100000.0 um
>>> print(g.mm)
1100.0 mm
>>> print(g.cm)
110.00000000000001 cm
>>> print(g.m)
1.1 m
>>> print(g.km)
0.0011 km

The physical quantity can converted back to a unitless value using the underscore _ with the scaling attribute:

>>> print(g.nm_)
1100000000.0
>>> print(g.um_)
1100000.0
>>> print(g.mm_)
1100.0
>>> print(g.cm_)
110.00000000000001
>>> print(g.m_)
1.1
>>> print(g.km_)
0.0011

It is also possible to remove the unit without implicit scaling, however this might be dangerous:

>>> g._
1.1

Internal Representation

Internally, a physical quantity is represented using two classes: * PhysicalQuantity holding the value and the unit * PhysicalUnit describing the unit

>>> a = pq.Q([1, 2, 3], 'm**2*s**3/A**2/kg')
>>> a.value
[1, 2, 3]

The value attribute is basically only a container, allowing different types of values. Tested types are: * integers * floats * complex numbers * uncertainties * numpy arrays * lists

>>> a.unit

\(\frac{\text{s}^{3}\cdot \text{m}^{2}}{\text{kg}\cdot \text{A}^2}\)

>>> type(a.unit)
PhysicalQuantities.Unit.PhysicalUnit

The unit is stored in a PhysicalUnit class. This class has a number of attributes: * factor - scaling factor from base units * powers - list of SI base units contained in unit. All other units can be reduced to these base units. * prefixed - unit is a scaled version of a base unit

>>> pq.Q(1,'mm').unit.factor, pq.Q(1,'mm').unit.prefixed
(0.001, True)

>>> from PhysicalQuantities.unit import base_names
>>> print(base_names) # list containing names of base units
['m', 'kg', 's', 'A', 'K', 'mol', 'cd', 'rad', 'sr']
>>> a = q.m
>>> print(a.unit.powers)
[1, 0, 0, 0, 0, 0, 0, 0, 0]
>>> print(a.unit.baseunit)
m

A more complex example:

>>> from PhysicalQuantities.unit import base_names
>>> print(base_names) # list containing names of base units
['m', 'kg', 's', 'A', 'K', 'mol', 'cd', 'rad', 'sr']
>>> a = q.m
>>> print(a.unit.powers)
[1, 0, 0, 0, 0, 0, 0, 0, 0]
>>> print(a.unit.baseunit)
m

A more complex example:

>>> from PhysicalQuantities.Unit import base_names
>>> print(base_names) # list containing names of base units
['m', 'kg', 's', 'A', 'K', 'mol', 'cd', 'rad', 'sr']
>>> a = q.m
>>> print(a.unit.powers)
[1, 0, 0, 0, 0, 0, 0, 0, 0]
>>> print(a.unit.baseunit)
m

A more complex example:

>>> a = pq.Q([1,2,3], 'm**2*s**3/A**2/kg')
>>> print(base_names)
['m', 'kg', 's', 'A', 'K', 'mol', 'cd', 'rad', 'sr']
>>> print(a.unit.powers)
[2, -1, 3, -2, 0, 0, 0, 0, 0]
>>> print(a.unit.baseunit)
s^3*m^2/kg/A^2