Package pygeodesy :: Module basics |
[frames] | no frames]

# Module basics

Some, basic definitions and functions.

Version: 21.06.30

Functions
bool |
isinf(x) Check if float x is infinite (positive or negative). |
bool |
isnan(x) Check if float x is not a number (NaN). |
clips(bstr, limit=50, white='') Clip a string to the given length limit. |
copysign0(x, y) Like `math.copysign(x, y)` except `zero`, unsigned. |
copytype(x, y) Return the value of x as `type` of `y`. |
halfs2(str2) Split a string in 2 halfs. |
isbool(obj) Check whether an object is `bool`ean. |
isodd(x) Is `x` odd? |
isclass(obj) Return `True` if `obj` is a `class`. |
isfinite(obj) Check for `Inf` and `NaN` values. |
isidentifier(obj) Return `True` if `obj` is a valid Python identifier. |
isint(obj, both=False) Check for `int` type or an integer `float` value. |
iskeyword(x, y) y in x. |
isneg0(x) Check for NEG0, negative `0.0`. |
isscalar(obj) Check for scalar types. |
issequence(obj, *excluded) Check for sequence types. |
isstr(obj) Check for string types. |
issubclassof(Sub, *Supers) Check whether a class is a sub-class of some class(es). |
len2(items) Make built-in function `len` work for generators, iterators, etc. |
map1(fun1, *xs) Apply each argument to a single-argument function and return a `tuple` of results. |
map2(func, *xs) Apply arguments to a function and return a `tuple` of results. |
neg(x) Negate `x` unless `zero` or `NEG0`. |
neg_(*xs) Negate all of `xs` with neg. |
signOf(x) Return sign of `x` as `int`. |
splice(iterable, n=2, **fill) Split an iterable into `n` slices. |
ub2str(ub) Convert `unicode` or `bytes` to `str`. |
unsign0(x) Return unsigned `0.0`. |

Variables
| __all__ = `_ALL_LAZY.basics`

Function Details

### clips (bstr, limit=50, white='') |
Clip a string to the given length limit. Arguments: `bstr` - String (`bytes` or `str`). `limit` - Length limit (`int`). `white` - Optionally, replace all whitespace (`str`). Returns: The clipped or unclipped `bstr`.

### copysign0 (x, y) |
Like `math.copysign(x, y)` except `zero`, unsigned. Returns: `math.copysign(x, y)` if `x` else `0`.

### copytype (x, y) |
Return the value of x as `type` of `y`. Returns: `type(y)(x)`.

### halfs2 (str2) |
Split a string in 2 halfs. Arguments: `str2` - String to split (`str`). Returns: 2-Tuple (_1st, _2nd) half (`str`). Raises: `ValueError` - Zero or odd `len`(`str2`).

### isbool (obj) |
Check whether an object is `bool`ean. Arguments: `obj` - The object (any `type`). Returns: `True` if `obj` is `bool`ean, `False` otherwise.

### isodd (x) |
Is `x` odd? Arguments: `x` - Value (`scalar`). Returns: `True` if `x` is odd, `False` otherwise.

### isclass (obj) |
Return `True` if `obj` is a `class`. See Also: Python's `inspect.isclass`.

### isfinite (obj) |
Check for `Inf` and `NaN` values. Arguments: `obj` - Value (`scalar`). Returns: `False` if `obj` is `INF` or `NAN`, `True` otherwise. Raises: `TypeError` - Non-scalar `obj`.

### isint (obj, both=False) |
Check for `int` type or an integer `float` value. Arguments: `obj` - The object (any `type`). `both` - Optionally, check `float` type and value (`bool`). Returns: `True` if `obj` is `int` or an integer `float`, `False` otherwise. Note: `isint(True)` or `isint(False)` returns `False` (and no longer `True`).

### isneg0 (x) |
Check for NEG0, negative `0.0`. Arguments: `x` - Value (`scalar`). Returns: `True` if `x` is `NEG0` or `-0.0`, `False` otherwise.

### isscalar (obj) |
Check for scalar types. Arguments: `obj` - The object (any `type`). Returns: `True` if `obj` is `scalar`, `False` otherwise.

### issequence (obj, *excluded) |
Check for sequence types. Arguments: `obj` - The object (any `type`). `excluded` - Optional exclusions (`type`). Returns: `True` if `obj` is a sequence, `False` otherwise. Note: Excluding `tuple` implies excluding `namedtuple`.

### isstr (obj) |
Check for string types. Arguments: `obj` - The object (any `type`). Returns: `True` if `obj` is `str`, `False` otherwise.

### issubclassof (Sub, *Supers) |
Check whether a class is a sub-class of some class(es). Arguments: `Sub` - The sub-class (`class`). `Supers` - One or more C(super) classes (`class`). Returns: `True` if `Sub` is a sub-class of any `Supers`, `False` otherwise (`bool`).

### len2 (items) |
Make built-in function `len` work for generators, iterators, etc. since those can only be started exactly once. Arguments: `items` - Generator, iterator, list, range, tuple, etc. Returns: 2-Tuple `(n, items)` of the number of items (`int`) and the items (`list` or `tuple`).

### map1 (fun1, *xs) |
Apply each argument to a single-argument function and return a `tuple` of results. Arguments: `fun1` - 1-Arg function to apply (`callable`). `xs` - Arguments to apply (`any positional`). Returns: Function results (`tuple`).

### map2 (func, *xs) |
Apply arguments to a function and return a `tuple` of results. Unlike Python 2's built-in `map`, Python 3+ `map` returns a `map` object, an iterator-like object which generates the results only once. Converting the `map` object to a tuple maintains Python 2 behavior. Arguments: `func` - Function to apply (`callable`). `xs` - Arguments to apply (`list, tuple, ...`). Returns: Function results (`tuple`).

### neg (x) |
Negate `x` unless `zero` or `NEG0`. Returns: `-x` if `x` else `0.0`.

### neg_ (*xs) |
Negate all of `xs` with neg. Returns: A `tuple(neg(x) for x in xs)`.

### signOf (x) |
Return sign of `x` as `int`. Returns: -1, 0 or +1 (`int`).

### splice (iterable, n=2, **fill) |
Split an iterable into `n` slices. Arguments: `iterable` - Items to be spliced (`list`, `tuple`, ...). `n` - Number of slices to generate (`int`). `fill` - Optional fill value for missing items. Returns: A generator for each of `n` slices, iterable[i::n] for i=0..n. Raises: `TypeError` - Invalid `n`. Note: Each generated slice is a `tuple` or a `list`, the latter only if the `iterable` is a `list`. Example:
    >>> from pygeodesy import splice
    >>> a, b = splice(range(10))
    >>> a, b
    ((0, 2, 4, 6, 8), (1, 3, 5, 7, 9))
    >>> a, b, c = splice(range(10), n=3)
    >>> a, b, c
    ((0, 3, 6, 9), (1, 4, 7), (2, 5, 8))
    >>> a, b, c = splice(range(10), n=3, fill=-1)
    >>> a, b, c
    ((0, 3, 6, 9), (1, 4, 7, -1), (2, 5, 8, -1))
    >>> tuple(splice(list(range(9)), n=5))
    ([0, 5], [1, 6], [2, 7], [3, 8], [4])
    >>> splice(range(9), n=1)
    <generator object splice at 0x0...>

### unsign0 (x) |
Return unsigned `0.0`. Returns: `x` if `x` else `0.0`.