Copying data is wasteful, mutating data is dangerous(pythonspeed.com)

  normalize(a)       # mutates in place. note: no return value.
  b = normalized(a)  # no mutation. returns a new instance. note the adjective.

  a.sort()
  b = sorted(a)

  low = array1.min()
  high = array1.max()
  array2 = array1 - low
  array3 = array2 / (high - low)
  return array3

  low = array1.min()
  high = array1.max()
  array2 = array1 - low
  array2 /= (high - low)
  return array2

  impl Vector {
      // The method reads this current vector and returns a new one.
      pub fn normalize(&self) -> Vector { ... }
      
      // The method reads and modifies this current vector in place.
      pub fn normalize(&mut self) { ... }
  }

  def normalize_in_place(array: numpy.ndarray):
      low = array.min()
      high = array.max()
      array -= low
      array /= high - low
    
  def visualize(array: numpy.ndarray):
      normalize_in_place(array)
      plot_graph(array)
  
  data = generate_data()
  if DEBUG_MODE:
      visualize(data)
  do_something(data)

  fn normalize_in_place(array: &mut numpy::ndarray) {
      let low = array.min();
      let high = array.max();
      array -= low;
      array /= high - low;
  }
  
  fn visualize(array: &numpy::ndarray) {
      normalize_in_place(array);  // ERROR
      plot_graph(array);
  }
  
  let data: numpy::ndarray = generate_data();
  if DEBUG_MODE {
    visualize(&data);
  }
  do_something(&data);

    // Definitely doesn't modify 'array', because 'array' is copied.
    vector<int> Normalize(vector<int> array);
    // Almost certainly doesn't modify 'array'.
    vector<int> Normalize(const vector<int>& array);
    // Probably *does* modify 'array' (otherwise author would have used
    // const reference instead of pointer.)
    void Normalize(vector<int>* array);

    def normalize(data, inplace=False):
        if not inplace:
            data = data.copy()
        ...

    def normalize(data, out=None):
        if out is None:
            out = data.copy()
        ...

  val f = List(4, 5, 6).prependedAll[Int](Array(1, 2, 3))

  override def prependedAll[B >: A](prefix: IterableOnce[B]): CC[B] = {
    val b = iterableFactory.newBuilder[B]
    b ++= prefix
    b ++= this
    b.result()
  }

    A = normalized(X*b - M*N*k); //creates a pipeline
    A.calculate(); //calculates all the stages destructively on the new copy