ak.full_like

Defined in awkward.operations.structure on line 1086.

ak.full_like(array, fill_value, highlevel=True, behavior=None, dtype=None)
Parameters
  • array – Array to use as a model for a replacement that contains only fill_value.

  • fill_value – Value to fill new new array with.

  • highlevel (bool, default is True) – If True, return an ak.Array; otherwise, return a low-level ak.layout.Content subclass.

  • behavior (None or dict) – Custom ak.behavior for the output array, if high-level.

  • dtype (None or type) – Overrides the data type of the result.

This is the equivalent of NumPy’s np.full_like for Awkward Arrays.

Although it’s possible to produce an array of fill_value with the structure of an array using ak.broadcast_arrays:

>>> array = ak.Array([[1, 2, 3], [], [4, 5]])
>>> ak.broadcast_arrays(array, 1)
[<Array [[1, 2, 3], [], [4, 5]] type='3 * var * int64'>,
 <Array [[1, 1, 1], [], [1, 1]] type='3 * var * int64'>]
>>> ak.broadcast_arrays(array, 1.0)
[<Array [[1, 2, 3], [], [4, 5]] type='3 * var * int64'>,
 <Array [[1, 1, 1], [], [1, 1]] type='3 * var * float64'>]

Such a technique takes its type from the scalar (1 or 1.0), rather than the array. This function gets all types from the array, which might not be the same in all parts of the structure.

Here is an extreme example:

>>> array = ak.Array([
... [{"x": 0.0, "y": []},
...  {"x": 1.1, "y": [1]},
...  {"x": 2.2, "y": [1, 2]}],
... [],
... [{"x": 3.3, "y": [1, 2, None, 3]},
...  False,
...  False,
...  True,
...  {"x": 4.4, "y": [1, 2, None, 3, 4]}]])
>>> ak.to_list(ak.full_like(array, 12.3))
[[{"x": 12.3, "y": []},
  {"x": 12.3, "y": [12]},
  {"x": 12.3, "y": [12, 12]}],
 [],
 [{"x": 12.3, "y": [12, 12, None, 12]},
  True,
  True,
  True,
  {"x": 12.3, "y": [12, 12, None, 12, 12]}]]

The "x" values get filled in with 12.3 because they retain their type (float64) and the "y" list items get filled in with 12 because they retain their type (int64). Booleans get filled with True because 12.3 is not zero. Missing values remain in the same positions as in the original array. (To fill them in, use ak.fill_none.)

See also ak.zeros_like and ak.ones_like.

(There is no equivalent of NumPy’s np.empty_like because Awkward Arrays are immutable.)