Power Query Продвинутый №25. Функция List.Accumulate

Для удобства каждый параметр функции List.Accumulate сохраним в отдельную переменную/шаг.

Найдем сумму списка из чисел из {1..36}.

Seed — это начальное состояние.

let
   list_number = {1 .. 36},
   seed = 0,
   fn = (state, current) => state + current,
   list_accumulate = List.Accumulate(
      list_number,
      seed,
      fn
   )
in
   list_accumulate

Имеем исходный список {1,2,3,4,5} и желаем в результате получить список с таким же количеством значений, где каждый элемент является суммой всех предыдущих.

Seed в данном случае будет изначально являться пустым списком, который дополняется новым значением с каждым витком цикла.

let
   list_numbers = List.Buffer({1 .. 1000}),
   seed = {},
   fn = (state, current) =>
      if List.Last(state) <> null then
         state & {List.Last(state) + current}
      else
         {current},
   list_accumulate = List.Accumulate(
      list_numbers,
      seed,
      fn
   )
in
   list_accumulate

В каждом витке цикла значение будет увеличиваться на единицу.

Исходное положение — 0.

let
   list_numbers = {1 .. 36},
   seed = 0,
   fn = (state, current) => state + 1,
   list_accumulate = List.Accumulate(
      list_numbers,
      seed,
      fn
   )
in
   list_accumulate

В исходном списке {1,2,3,4,5} мы хотим посчитать значения.

Результат должен представлять из себя список, в котором каждый элемент считает количество элементов исходного списка до текущей позиции.

let
   list_numbers = {1 .. 36},
   seed = {},
   fn = (state, current) =>
      if List.Last(state) <> null then
         state & {List.Last(state) + 1}
      else
         {1},
   list_accumulate = List.Accumulate(
      list_numbers,
      seed,
      fn
   )
in
   list_accumulate

В каждом витке цикла сравнивается текущее значение с предыдущим. Если текущее значение больше, то оно назначается максимальным, а если нет, то пока максимальным остается предыдущее.

В первом витке цикла максимум назначается самое первое значение.

let
   list_numbers = {1, 2, 100, - 40, 5},
   seed = 0,
   fn = (state, current) =>
      if state < current then current else state,
   list_accumulate = List.Accumulate(
      list_numbers,
      seed,
      fn
   )
in
   list_accumulate

В исходном списке чисел найдем максимум и минимум и вернем оба результата в одной записи.

Изначально максимуму присвоим значение -бесконечность, а минимальному +бесконечность. Это сделано, чтобы уже в первом витке результаты обновились.

let
   list_numbers = {1, 2, 100, - 40, 4},
   seed = [min = #infinity, max = - #infinity],
   fn = (state, current) => [
      min = 
         if state[min] > current then
            current
         else
            state[min],
      max = 
         if state[max] < current then
            current
         else
            state[max]
   ],
   list_accumulate = List.Accumulate(
      list_numbers,
      seed,
      fn
   )
in
   list_accumulate

Посчитаем количество элементов списка чисел, которые делятся на 3 без остатка.

Исходное значение = 0, а каждый раз, когда нам будет встречаться число, делящееся без остатка на 3, число будет увеличиваться на 1.

let
   list_numbers = {1 .. 36},
   seed = 0,
   fn = (state, current) =>
      if Number.Mod(current, 3) = 0 then
         state + 1
      else
         state,
   list_accumulate = List.Accumulate(
      list_numbers,
      seed,
      fn
   )
in
   list_accumulate

В отличие от предыдущего примера в результате мы получим не одно число, а список всех чисел, которые делятся на 3 без остатка.

Теперь Seed будет не 0, а пустым списком, который будет наполняться с каждым витком цикла.

let
   list_numbers = {1 .. 36},
   seed = {},
   fn = (state, current) =>
      if List.Last(state) = null then
         (
            if Number.Mod(current, 3) = 0 then
               state & {3}
            else
               state
         )
      else if Number.Mod(current, 3) = 0 then
         state & {current}
      else
         state,
   list_accumulate = List.Accumulate(
      list_numbers,
      seed,
      fn
   )
in
   list_accumulate

Создадим список дат, которые являются первым числом каждого месяца, например, 2019 года.

let
   list_numbers = {1 .. 12},
   seed = {},
   fn = (state, current) =>
      state & {#date(2019, current, 1)},
   list_accumulate = List.Accumulate(
      list_numbers,
      seed,
      fn
   )
in
   list_accumulate

Сгенерируем таблицу с тремя столбцами: год, месяц, день.

В параметре Seed создадим пустую таблицу, которая будет заполняться с каждым витком цикла

let
   list_numbers = List.Buffer(
      List.Transform(
         {
            Number.From(Date.From("30.01.2010"))
               .. Number.From(
               Date.From(DateTime.LocalNow())
            )
         },
         Date.From
      )
   ),
   seed = #table({}, {}),
   fn = (state, current) =>
      Table.Combine(
         {
            state,
            #table(
               {"Месяц", "День", "Год"},
               {
                  {
                     Date.Year(current),
                     Date.Month(current),
                     Date.Day(current)
                  }
               }
            )
         }
      ),
   list_accumulate = Table.Buffer(
      List.Accumulate(list_numbers, seed, fn)
   )
in
   list_accumulate

Превратим исходный список {1,2,3,4,5} в строку «1,2,3,4,5».

Исходное значение является текстовой пустотой, которая заполняется текстом с каждым витком цикла.

let
   list_numbers = {1989 .. 2020},
   seed = "",
   fn = (state, current) =>
      Text.From(state) & Text.From(current) & ", ",
   list_accumulate = List.Accumulate(
      list_numbers,
      seed,
      fn
   )
in
   list_accumulate

В исходном списке числа, которые обозначают год.

Нужно вычислить сколько из них являются високосными.

let
   list_numbers = {1989 .. 2020},
   list_transformed = List.Transform(
      list_numbers,
      each Date.From("01.01." & Text.From(_))
   ),
   seed = 0,
   fn = (state, current) =>
      if Date.IsLeapYear(current) then
         state + 1
      else
         state,
   list_accumulate = List.Accumulate(
      list_transformed,
      seed,
      fn
   )
in
   list_accumulate

Здесь примерно то же самое, что и в предыдущем примере, но вернем список високосных лет из исходного списка.

let
   list_numbers = {1989 .. 2020},
   list_transformed = List.Transform(
      list_numbers,
      each Date.From("01.01." & Text.From(_))
   ),
   seed = {},
   fn = (state, current) =>
      if Date.IsLeapYear(current) then
         state & {current}
      else
         state,
   list_accumulate = List.Accumulate(
      list_transformed,
      seed,
      fn
   )
in
   list_accumulate