Состав чисел от 1 до 10 таблица распечатать: состав числа до 10 домики тренажер распечатать: 3 тыс изображений найдено в Яндекс.Картинках

Существует 100 типов идентификаторов приложений, которые можно классифицировать следующим образом.Некоторые данные, следующие за каждым идентификатором приложения, содержат фиксированное количество цифр (стандартный идентификатор коробки, дата и единица измерения), а другие – неопределенное количество цифр (номер партии, серийный номер, количество в упаковке, количество и номер заказа. ).

 def NAME (СПИСОК ПАРАМЕТРОВ):
    ЗАЯВЛЕНИЯ
 

 def f (x):
    возврат 3 * x ** 2 - 2 * x + 5
 

 >>> f (3)
26 год
>>> f (0)
5
>>> f (1)
6
>>> f (-1)
10
>>> f (5)
70
 

 >>> def f (x):
... вернуть 3 * x ** 2 - 2 * x + 5
...
>>>
 

 >>> результат = f (3)
>>> результат
26 год
>>> результат = f (3) + f (-1)
>>> результат
36
 

 >>> def mystery ():
...    возвращение
...
>>> what_is_it = тайна ()
>>> what_is_it
>>> тип (what_is_it)
<класс 'NoneType'>
>>> печать (what_is_it)
Никто
 

 >>> def do_nothing_useful (n, m):
... х = п + м
... y = n - m
...
>>> do_nothing_useful (5, 3)
>>> результат = do_nothing_useful (5, 3)
>>> результат
>>>
>>> print (результат)
Никто
 

 >>> def try_to_print_dead_code ():
... print ("Это напечатает ...")
... print ("... и это будет.")
...    возвращение
... print ("Но не это ...")
... print ("потому что это мертвый код!")
...
>>> try_to_print_dead_code ()
Это напечатает ...
... и так будет.
>>>
 

 def f1 ():
    print ("Мо")

def f2 ():
    f4 ()
    print ("Минни")

def f3 ():
    f2 ()
    print ("Miny")
    f1 ()

def f4 ():
    print ("Ини")

f3 ()
 

 = 4203
count = 0

а число! = 0:
    count + = 1
    число // = 10

печать (количество)
 

 def num_digits ():
    число = 4203
    count = 0

    а число! = 0:
        count + = 1
        число // = 10

    счетчик возврата

печать (число_цифров ())
 

 def num_digits (число):
    count = 0

    а число! = 0:
        count + = 1
        число // = 10

    счетчик возврата

печать (число_цифров (4203))
 

 >>> def f (x):
... вернуть 2 * x
...
>>> def g (x):
... вернуть x + 5
...
>>> def h (x):
... вернуть x ** 2-3
>>> f (3)
6
>>> г (3)
8
>>> ч (4)
13
>>> f (g (3))
16
>>> g (f (3))
11
>>> h (f (g (0)))
97
>>>
 

 >>> # Предположим определения функций для f и g, как в предыдущем примере
>>> val = 10
>>> f (val)
20
>>> f (g (val))
30
>>>
 

 >>> def f ():
... print ("Привет из функции f!")
...
>>> тип (f)
<тип 'функция'>
>>> f ()
Привет, из функции f!
>>>
 

 >>> do_stuff = [f, g, h]
>>> для func в do_stuff:
... функция (10)
...
20
15
97
 

 def double_stuff_v1 (a_list):
    индекс = 0
    для значения в a_list:
        a_list [индекс] = 2 * значение
        индекс + = 1
 

 >>> from pure_v_modify import double_stuff_v1
>>> things = [2, 5, 'Спам', 9.5]
>>> double_stuff_v1 (вещи)
>>> вещи
[4, 10, 'SpamSpam', 19.0]
 

 def double_stuff_v2 (a_list):
    new_list = []
    для значения в a_list:
        новый_лист + = [2 * значение]
    вернуть новый_лист
 

 >>> from pure_v_modify import double_stuff_v2
>>> things = [2, 5, 'Спам', 9.5]
>>> double_stuff_v2 (вещи)
[4, 10, 'SpamSpam', 19.0]
>>> вещи
[2, 5, "Спам", 9.5]
>>>
 

 >>> вещи = double_stuff (вещи)
>>> вещи
[4, 10, 'SpamSpam', 19.0]
>>>
 

 >>> def double (вещь):
... вернуть 2 * вещь
...
>>> двойной (5)
10
>>> double ('Спам')
'СпамСпам'
>>> double ([1, 2])
[1, 2, 1, 2]
>>> двойной (3,5)
7.0
>>> double (('а', 'б'))
('а', 'б', 'а', 'б')
>>> двойной (Нет)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
  Файл "", строка 2, в двойном формате
TypeError: неподдерживаемые типы операндов для *: 'int' и 'NoneType'
>>>
 

 для i в диапазоне (1, 7):
    print (2 * i, end = "")
Распечатать()
 

 def print_multiples (n):
    для i в диапазоне (1, 7):
        print (n * i, end = "")
    Распечатать()
 

 для i в диапазоне (1, 7):
    print_multiples (я)
 

 1 2 3 4 5 6
2 4 6 8 10 12
3 6 9 12 15 18
4 8 12 16 20 24
5 10 15 20 25 30
6 12 18 24 30 36
 

 def print_mult_table ():
    для i в диапазоне (1, 7):
        print_multiples (я)
 

 >>> сумма ([1, 2, 8])
11
>>> sum ((3, 5, 8.5))
16,5
>>>
 

 >>> сумма ([1, 2, [11, 13], 8])
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: неподдерживаемые типы операндов для +: 'int' и 'list'
>>>
 

 def recursive_sum (список вложенных_числов):
    the_sum = 0
    для элемента в nested_num_list:
        если type (element) == list:
            the_sum = the_sum + recursive_sum (элемент)
        еще:
            the_sum = the_sum + элемент
    вернуть the_sum
 

 def recursive_max (nested_num_list):
    "" "
      >>> recursive_max ([2, 9, [1, 13], 8, 6])
      13
      >>> recursive_max ([2, [[100, 7], 90], [1, 13], 8, 6])
      100
      >>> recursive_max ([2, [[13, 7], 90], [1, 100], 8, 6])
      100
      >>> recursive_max ([[[13, 7], 90], 2, [1, 100], 8, 6])
      100
    "" "
    наибольший = nested_num_list [0]
    в то время как тип (наибольший) == тип ([]):
        наибольший = наибольший [0]

    для элемента в nested_num_list:
        если type (element) == type ([]):
            max_of_elem = recursive_max (элемент)
            если самый большой 
 Doctests включены, чтобы предоставить примеры работы  recursive_max .
 Дополнительным поворотом к этой проблеме является поиск числового значения для инициализации  наибольший . Мы не можем просто использовать  nested_num_list [0] , так как я либо
число или список. Чтобы решить эту проблему, мы используем цикл while, который назначает  наибольшее значение  до первого числового значения независимо от того, насколько глубоко оно вложено.
 Каждый из двух приведенных выше примеров имеет базовый вариант  , который не приводит к
рекурсивный вызов: случай, когда элемент является числом, а не списком.Без
в базовом случае у вас  бесконечная рекурсия , и ваша программа не будет работать.
Python останавливается после достижения максимальной глубины рекурсии и возвращает время выполнения
ошибка.
 Запишите следующее в файл с именем  infinite_recursion.py :
 #
# infinite_recursion.py
#
def recursion_depth (число):
    print "Число глубины рекурсии% d." % количество
    рекурсия_глубина (число + 1)

рекурсия_глубина (0)
 
 В командной строке unix в том же каталоге, в котором вы сохранили
программа, введите следующее:
 python infinite_recursion.ру
 
 После того, как вы увидите, как мелькают сообщения, вы увидите окончание
длинная трассировка, которая заканчивается следующим образом:
 ...
  Файл infinite_recursion.py, строка 3, в recursion_depth
    рекурсия_глубина (число + 1)
RuntimeError: превышена максимальная глубина рекурсии
 
 Мы, конечно, никогда не хотели бы, чтобы что-то подобное случилось с пользователем одного из
наши программы, поэтому, прежде чем закончить обсуждение рекурсии, давайте посмотрим, как
подобные ошибки обрабатываются в Python.
 5.18. Исключения 
 Каждый раз, когда возникает ошибка времени выполнения, создается исключение  . Программа останавливается
выполняется в этот момент, и Python распечатывает трассировку, которая заканчивается
произошедшее исключение.
 Например, деление на ноль создает исключение:
 >>> печать 55/0
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
ZeroDivisionError: целочисленное деление или по модулю нуля
>>>
 
 То же самое и с доступом к несуществующему элементу списка:
 >>> a = []
>>> выведите [5]
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
IndexError: список индекса вне допустимого диапазона
>>>
 
 Или попытка присвоения элемента кортежу:
 >>> tup = ('а', 'б', 'д', 'д')
>>> tup [2] = 'c'
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: объект 'tuple' не поддерживает назначение элементов
>>>
 
 В каждом случае сообщение об ошибке в последней строке состоит из двух частей: тип
ошибка перед двоеточием и подробные сведения об ошибке после двоеточия.
 Иногда мы хотим выполнить операцию, которая может вызвать исключение, но мы
не хочу, чтобы программа останавливалась. Мы можем  обработать исключение , используя  попробуйте  и , кроме операторов .
 Например, мы можем запросить у пользователя имя файла, а затем попытаться
Открой это. Если файл не существует, мы не хотим, чтобы программа вылетела из строя; мы хотим
для обработки исключения:
 filename = raw_input ('Введите имя файла:')
пытаться:
    f = open (имя файла, "r")
Кроме:
    print 'Нет файла с именем', имя файла
 
 Оператор  try  выполняет операторы в первом блоке.Если нет
возникают исключения, он игнорирует , за исключением оператора . Если возникает какое-либо исключение,
он выполняет операторы в , кроме ветви , а затем продолжает.
 Мы можем инкапсулировать эту возможность в функции:  существует  принимает имя файла
и возвращает true, если файл существует, и false, если его нет:
 def существует (имя файла):
    пытаться:
        f = open (имя файла)
        f.close ()
        вернуть True
    Кроме:
        вернуть ложь
 
 Вы можете использовать несколько блоков , кроме , для обработки различных типов исключений.
(см. Ошибки и исключения
урок от Python Tutorial от создателя Python Гвидо ван Россума для более полного обсуждения
исключения).
 Если ваша программа обнаруживает состояние ошибки, вы можете заставить ее  поднять  исключение. Вот пример, который получает ввод от пользователя и проверяет, что
число неотрицательно.
 #
# learn_exceptions.py
#
def get_age ():
    age = input ('Пожалуйста, введите свой возраст:')
    если возраст <0:
        Raise ValueError, "% s не является допустимым возрастом"% age
    возраст возвращения
 
 Оператор  raise  принимает два аргумента: тип исключения и конкретный
информация об ошибке. ValueError  - встроенное исключение, которое
наиболее точно соответствует той ошибке, которую мы хотим вызвать. Полный список
встроенных исключений находится в разделе встроенных исключений Python
Справочник по библиотеке, снова созданный создателем Python,
Гвидо ван Россум.
 Если функция, которая вызвала  get_age , обрабатывает ошибку, то программа может
Продолжить; в противном случае Python печатает трассировку и завершает работу:
 >>> get_age ()
Пожалуйста, введите ваш возраст: 42
42
>>> get_age ()
Пожалуйста, введите ваш возраст: -2
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
  Файл "learn_exceptions.py ", строка 4, в get_age
    Raise ValueError, "% s не является допустимым возрастом"% age
ValueError: -2 не является допустимым возрастом
>>>
 
 Сообщение об ошибке включает тип исключения и дополнительную информацию.
вы предоставили.
 Используя обработку исключений, теперь мы можем изменить  infinite_recursion.py  так, чтобы
он останавливается, когда достигает максимальной разрешенной глубины рекурсии:
 #
# infinite_recursion.py
#
def recursion_depth (число):
    print "Число глубины рекурсии% d." % количество
    пытаться:
        рекурсия_глубина (число + 1)
    Кроме:
        print "Превышена максимальная глубина рекурсии."

рекурсия_глубина (0)
 
 Запустите эту версию и посмотрите на результаты.
 5.19. Хвостовая рекурсия 
 Когда единственное, что возвращается из функции, - это рекурсивный вызов, на нее ссылаются
как  хвостовая рекурсия .
 Вот версия функции обратного отсчета   из главы 6, написанная с использованием
хвостовая рекурсия:
 Обратный отсчет
 def (n):
    если n == 0:
        печать "Blastoff!"
    еще:
        напечатать n
        обратный отсчет (n-1)
 
 Любые вычисления, которые могут быть выполнены с использованием итераций, также могут быть выполнены с использованием
рекурсия.Вот версия  find_max , написанная с использованием хвостовой рекурсии:
 def find_max (seq, max_so_far):
    если не seq:
        вернуть max_so_far
    если max_so_far 
 Хвостовая рекурсия считается плохой практикой в ​​Python, поскольку Python
компилятор не выполняет оптимизацию для хвостовых рекурсивных вызовов. Рекурсивный
решение в таких случаях использует больше системных ресурсов, чем эквивалент
итеративное решение.
 5.20. Рекурсивные математические функции 
 Несколько хорошо известных математических функций определены рекурсивно. Факториал, например, получает особую
оператор, ! , и определяется по:
 Мы можем легко запрограммировать это на Python:
 def factorial (n):
    если n == 0:
        возврат 1
    еще:
        вернуть n * факториал (n-1)
 
 Еще одно хорошо известное рекурсивное соотношение в математике - это соотношение Фибоначчи.
последовательность, которая определяется
по:
 фибоначчи (0) = 1
фибоначчи (1) = 1
фибоначчи (п) = фибоначчи (п-1) + фибоначчи (п-2)
 
 Это также можно легко написать на Python:
 def fibonacci (n):
    если n == 0 или n == 1:
        возврат 1
    еще:
        вернуть фибоначчи (n-1) + fibonacci (n-2)
 
 Вызов  факториала (1000)  превысит максимальную глубину рекурсии.И попробовать
запускаем  fibonacci (35)  и посмотрим, сколько времени потребуется для завершения (будьте терпеливы, это
завершу).
 Вам будет предложено написать итеративную версию  факториала  как
упражнение, и мы увидим лучший способ обработки  и  фибоначчи в следующем
глава.
 5.21. Глоссарий 
 аргумент
 Значение, передаваемое функции при ее вызове. Это значение
присваивается соответствующему параметру в функции.
 поток выполнения
 Порядок, в котором операторы выполняются во время выполнения программы.
 кадр
 Поле на диаграмме стека, представляющее вызов функции. Это содержит
локальные переменные и параметры функции.
 функция
 Именованная последовательность операторов, выполняющая некоторые полезные операции.
Функции могут принимать или не принимать параметры, а также могут создавать или не создавать
результат.
 вызов функции
 Оператор, выполняющий функцию.Он состоит из названия
функция, за которой следует список аргументов, заключенный в круглые скобки.
 композиция функций
 Использование выходных данных одного вызова функции в качестве входных данных для другого.
 определение функции
 Оператор, который создает новую функцию, указывая ее имя,
параметры и операторы, которые он выполняет.
 Первая часть составного отчета. Заголовки начинаются с ключевого слова и
заканчиваться двоеточием (:)
 локальная переменная
 Переменная, определенная внутри функции.Можно использовать только локальную переменную
внутри его функции.
  Нет 
 Единственное значение .  Нет  часто используется для
представляют собой отсутствие значения. Также возвращается  return  оператор без аргументов или функция, которая достигает конца своего
body без нажатия  return  statement, содержащего значение.
 параметр
 Имя, используемое внутри функции для ссылки на значение, переданное как
аргумент.
 диаграмма стека
 Графическое представление стека функций, их переменных,
и ценности, к которым они относятся.
 трассировка
 Список выполняемых функций, распечатываемый во время выполнения.
возникает ошибка. Отслеживание также обычно называют  трассировка стека , поскольку он перечисляет функции в том порядке, в котором они
хранятся в
стек времени выполнения.
 функций высшего порядка - выучите Haskell на благо! 
 Функции Haskell могут принимать функции как параметры и возвращать функции как возвращаемые значения.Функция, которая выполняет одно из этих действий, называется функцией более высокого порядка. Функции высшего порядка - это не просто часть опыта Haskell, они в значительной степени являются частью опыта Haskell. Оказывается, если вы хотите определить вычисления, определив, что  является , вместо определения шагов, которые изменяют какое-то состояние и, возможно, зацикливают их, функции более высокого порядка незаменимы. Это действительно эффективный способ решения проблем и размышлений о программах.
 Функции карри 
 Каждая функция в Haskell официально принимает только один параметр.Так как же возможно, что мы определили и использовали несколько функций, которые до сих пор принимают более одного параметра? Что ж, это хитрый трюк! Все функции, которые приняли  несколько параметров , до сих пор были  каррированными функциями . Что это обозначает? Лучше всего вы это поймете на примере. Возьмем нашего хорошего друга, функцию max. Похоже, он принимает два параметра и возвращает тот, который больше. Выполнение max 4 5 сначала создает функцию, которая принимает параметр и возвращает либо 4, либо этот параметр, в зависимости от того, какой из них больше.Затем к этой функции применяется 5, и эта функция дает желаемый результат. Звучит непросто, но на самом деле это действительно крутая концепция. Следующие два вызова эквивалентны:
ghci> макс 4 5
5
ghci> (максимум 4) 5
5
 
 Помещение пробела между двумя объектами - это просто  функциональное приложение . Пробел похож на оператор и имеет наивысший приоритет. Разберем тип макс. Это max :: (Ord a) => a -> a -> a. Это также можно записать как max :: (Ord a) => a -> (a -> a).Это можно читать так: max принимает a и возвращает (это ->) функцию, которая принимает a и возвращает a. Вот почему возвращаемый тип и параметры функций просто разделены стрелками.
 Так чем это нам выгодно? Проще говоря, если мы вызываем функцию со слишком небольшим количеством параметров, мы возвращаем  частично примененную функцию , то есть функцию, которая принимает столько параметров, сколько мы упустили. Использование частичного приложения (вызов функций со слишком небольшим количеством параметров, если хотите) - это изящный способ создания функций на лету, чтобы мы могли передать их другой функции или заполнить их некоторыми данными.
 Взгляните на эту оскорбительно простую функцию:
multThree :: (Num a) => a -> a -> a -> a
multThree x y z = x * y * z
 
 Что на самом деле происходит, когда мы выполняем multThree 3 5 9 или ((multThree 3) 5) 9? Во-первых, 3 применяется к multThree, потому что они разделены пробелом. Это создает функцию, которая принимает один параметр и возвращает функцию. Итак, к нему применяется 5, что создает функцию, которая примет параметр и умножит его на 15. К этой функции применяется 9, и результат будет 135 или что-то в этом роде.Помните, что тип этой функции также может быть записан как multThree :: (Num a) => a -> (a -> (a -> a)). Вещь перед -> - это параметр, который принимает функция, а вещь после него - это то, что она возвращает. Итак, наша функция принимает a и возвращает функцию типа (Num a) => a -> (a -> a). Точно так же эта функция принимает a и возвращает функцию типа (Num a) => a -> a. И эта функция, наконец, просто принимает a и возвращает a. Взгляните на это:
ghci> пусть multTwoWithNine = multThree 9
ghci> multTwoWithNine 2 3
54
ghci> пусть multWithEighteen = multTwoWithNine 2
ghci> multWithEighteen 10
180
 
 Вызывая функции со слишком малым числом параметров, так сказать, мы создаем новые функции на лету.Что, если бы мы хотели создать функцию, которая принимает число и сравнивает его со 100? Мы могли бы сделать что-то вроде этого:
compareWithHundred :: (Num a, Ord a) => a -> Порядок
compareWithHundred x = сравнивать 100 x
 
 Если мы вызовем его с помощью 99, он вернет GT. Все просто. Обратите внимание, что x находится справа по обе стороны уравнения. Теперь давайте подумаем, что возвращает compare 100. Он возвращает функцию, которая принимает число и сравнивает его со 100. Вау! Разве это не та функция, которую мы хотели? Мы можем переписать это как:
compareWithHundred :: (Num a, Ord a) => a -> Порядок
compareWithHundred = сравнивать 100
 
 Объявление типа остается прежним, потому что compare 100 возвращает функцию.Compare имеет тип (Ord a) => a -> (a -> Ordering), и его вызов с 100 возвращает (Num a, Ord a) => a -> Ordering. Дополнительное ограничение класса подкрадывается, потому что 100 также является частью класса типов Num.
  Йоу!  Убедитесь, что вы действительно понимаете, как работают каррированные функции и частичное приложение, потому что они действительно важны!
 Функции Infix также могут быть частично применены с помощью разделов. Чтобы разделить инфиксную функцию, просто заключите ее в круглые скобки и укажите параметр только с одной стороны.Это создает функцию, которая принимает один параметр и затем применяет его к стороне, у которой отсутствует операнд. Оскорбительно банальная функция:
DivideByTen :: (Плавающий a) => a -> a
divByTen = (/ 10)
 
 Вызов, скажем, divByTen 200 эквивалентен выполнению 200/10, как и (/ 10) 200. Функция, которая проверяет, является ли переданный ей символ заглавной буквой:
isUpperAlphanum :: Char -> Bool
isUpperAlphanum = (`elem` ['A' .. 'Z'])
 
 Единственная особенность разделов - это использование -.Из определения разделов (-4) приведет к функции, которая берет число и вычитает из него 4. Однако для удобства (-4) означает минус четыре. Поэтому, если вы хотите создать функцию, которая вычитает 4 из числа, которое она получает в качестве параметра, частично примените функцию вычитания следующим образом: (вычесть 4).
 Что произойдет, если мы попытаемся просто выполнить multThree 3 4 в GHCI вместо того, чтобы привязать его к имени с помощью let  или передать его другой функции?
ghci> multThree 3 4
<интерактивный>: 1: 0:
    Нет экземпляра для (Показать (t -> t))
      возникает из-за использования print в : 1: 0-12
    Возможное исправление: добавьте объявление экземпляра для (Show (t -> t))
    В выражении: распечатайте
    В выражении do: распечатайте его
 
 GHCI сообщает нам, что выражение создало функцию типа a -> a, но не знает, как вывести ее на экран.Функции не являются экземплярами класса типов Show, поэтому мы не можем получить аккуратное строковое представление функции. Когда мы выполняем, скажем, 1 + 1 в приглашении GHCI, он сначала вычисляет это как 2, а затем вызывает show on 2, чтобы получить текстовое представление этого числа. А текстовое представление числа 2 - это просто строка "2", которая затем выводится на наш экран.
 Порядок более высокого порядка 
 Функции могут принимать функции как параметры, а также возвращать функции. Чтобы проиллюстрировать это, мы собираемся создать функцию, которая принимает функцию, а затем применяет ее дважды к чему-либо!
applyTwice :: (а -> а) -> а -> а
applyTwice f x = f (f x)
 
 Прежде всего, обратите внимание на объявление типа.Раньше нам не нужны были круглые скобки, потому что -> естественно правоассоциативно. Однако здесь они обязательны. Они указывают, что первый параметр - это функция, которая что-то принимает и возвращает то же самое. Второй параметр также относится к тому же типу, и возвращаемое значение также имеет тот же тип. Мы могли бы прочитать это объявление типа каррированным способом, но, чтобы избавить себя от головной боли, мы просто скажем, что эта функция принимает два параметра и возвращает одно значение. Первый параметр - это функция (типа a -> a), а второй - это то же самое a.Функция также может иметь вид Int -> Int или String -> String или что-то еще. Но тогда и второй параметр должен быть того же типа.
  Примечание:  С этого момента мы будем говорить, что функции принимают несколько параметров, несмотря на то, что каждая функция фактически принимает только один параметр и возвращает частично примененные функции, пока мы не достигнем функции, которая возвращает твердое значение. Поэтому для простоты мы скажем, что a -> a -> a принимает два параметра, хотя мы знаем, что на самом деле происходит под капотом.
 Суть функции довольно проста. Мы просто используем параметр f как функцию, применяя к нему x, разделяя их пробелом, а затем снова применяя результат к f. Так или иначе, поигрался с функцией:
ghci> применить дважды (+3) 10
16
ghci> applyTwice (++ "ХАХА") "ЭЙ"
"ЭЙ ХАХА ХАХА"
ghci> applyTwice ("ХАХА" ++) "ЭЙ"
"ХА-ХА-ХА-ХА-ХЕЙ"
ghci> applyTwice (multThree 2 2) 9
144
ghci> applyTwice (3 :) [1]
[3,3,1]
 
 Великолепие и полезность частичного применения очевидны.Если наша функция требует, чтобы мы передали ей функцию, которая принимает только один параметр, мы можем частично применить функцию к точке, где она принимает только один параметр, а затем передать ее.
 Теперь мы собираемся использовать программирование более высокого порядка, чтобы реализовать действительно полезную функцию из стандартной библиотеки. Это называется zipWith. Он принимает функцию и два списка в качестве параметров, а затем объединяет два списка, применяя функцию между соответствующими элементами. Вот как мы это реализуем:
zipWith ':: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith '_ [] _ ​​= []
zipWith '_ _ [] = []
zipWith 'f (x: xs) (y: ys) = f x y: zipWith' f xs ys
 
 Посмотрите на объявление типа.Первый параметр - это функция, которая принимает два объекта и производит третье. Они не обязательно должны быть одного типа, но могут. Второй и третий параметр - это списки. Результат - тоже список. Первым должен быть список а, потому что функция соединения принимает в качестве первого аргумента. Второй должен быть списком b, потому что второй параметр функции соединения имеет тип b. Результатом является список c. Если в объявлении типа функции указано, что она принимает функцию a -> b -> c в качестве параметра, она также примет функцию a -> a ->, но не наоборот! Помните, что когда вы создаете функции, особенно более высокого порядка, и не уверены в типе, вы можете просто попробовать опустить объявление типа, а затем проверить, что Haskell предполагает его использование, используя: t.
 Действия в функции очень похожи на обычный zip. Граничные условия такие же, только есть дополнительный аргумент, функция соединения, но этот аргумент не имеет значения в граничных условиях, поэтому мы просто используем для него _. И тело функции в последнем шаблоне также похоже на zip, только не (x, y), а f x y. Одна функция более высокого порядка может использоваться для множества различных задач, если она достаточно общая. Вот небольшая демонстрация того, что может делать наша функция zipWith:
ghci> zipWith '(+) [4,2,5,6] [2,6,2,3]
[6,8,7,9]
ghci> zipWith 'max [6,3,2,1] [7,3,1,5]
[7,3,2,5]
ghci> zipWith '(++) ["foo", "bar", "baz"] ["fighters", "hoppers", "aldrin"]
["foo fighters", "bar hoppers", "baz aldrin"]
ghci> zipWith '(*) (репликация 5 2) [1..]
[2,4,6,8,10]
ghci> zipWith '(zipWith' (*)) [[1,2,3], [3,5,6], [2,3,4]] [[3,2,2], [3,4, 5], [5,4,3]]
[[3,4,6], [9,20,30], [10,12,12]]
 
 Как видите, одну функцию более высокого порядка можно использовать очень гибко. В императивном программировании обычно используются такие вещи, как циклы for, циклы while, установка чего-либо для переменной, проверка ее состояния и т. Д. Для достижения некоторого поведения, а затем обертывание его вокруг интерфейса, как функция. Функциональное программирование использует функции высшего порядка, чтобы абстрагироваться от общих шаблонов, таких как изучение двух списков в парах и выполнение каких-либо действий с этими парами или получение набора решений и удаление тех, которые вам не нужны.
 Мы реализуем еще одну функцию, которая уже есть в стандартной библиотеке, под названием flip. Flip просто принимает функцию и возвращает функцию, аналогичную нашей исходной функции, только первые два аргумента переворачиваются. Реализовать это можно так:
flip ':: (a -> b -> c) -> (b -> a -> c)
флип 'f = g
    где g x y = f y x
 
 Читая объявление типа, мы говорим, что он принимает функцию, которая принимает a и a b, и возвращает функцию, которая принимает a b и a.Но поскольку функции каррированы по умолчанию, вторая пара круглых скобок действительно не нужна, потому что -> по умолчанию является правой ассоциативной. (a -> b -> c) -> (b -> a -> c) совпадает с (a -> b -> c) -> (b -> (a -> c)), что является то же, что (a -> b -> c) -> b -> a -> c. Мы писали, что g x y = f y x. Если это правда, то f y x = g x y также должно выполняться, верно? Имея это в виду, мы можем определить эту функцию еще проще.
flip ':: (a -> b -> c) -> b -> a -> c
флип 'f y x = f x y
 
 Здесь мы пользуемся тем фактом, что функции каррированы.Когда мы вызываем flip 'f без параметров y и x, он вернет f, который принимает эти два параметра, но называет их перевернутыми. Несмотря на то, что перевернутые функции обычно передаются другим функциям, мы можем воспользоваться каррированием при создании функций более высокого порядка, подумав заранее и написав, каким был бы их конечный результат, если бы они были вызваны полностью примененными.
ghci> flip 'zip [1,2,3,4,5] "привет"
[('h', 1), ('e', 2), ('l', 3), ('l', 4), ('o', 5)]
ghci> zipWith (flip 'div) [2,2 ..] [10,8,6,4,2]
[5,4,3,2,1]
 
 Карты и фильтры 
 Карта
 принимает функцию и список и применяет эту функцию к каждому элементу в списке, создавая новый список.Давайте посмотрим, что это за сигнатура типа и как она определяется.
map :: (a -> b) -> [a] -> [b]
карта _ [] = []
карта f (x: xs) = f x: карта f xs
 
 Сигнатура типа говорит, что она принимает функцию, которая принимает a и возвращает b, список a и возвращает список b. Интересно, что, просто взглянув на сигнатуру типа функции, иногда можно определить, что она делает. map - одна из тех действительно универсальных функций высшего порядка, которые можно использовать миллионами различных способов.2)) [[1,2], [3,4,5,6], [7,8]]
[[1,4], [9,16,25,36], [49,64]]
ghci> map fst [(1,2), (3,5), (6,3), (2,6), (2,5)]
[1,3,6,2,2] 
 Вы, наверное, заметили, что каждого из них можно достичь с помощью списка. map (+3) [1,5,3,1,6] - это то же самое, что и запись [x + 3 | х <- [1,5,3,1,6]]. Однако использование карты гораздо удобнее для чтения в тех случаях, когда вы применяете только некоторую функцию к элементам списка, особенно когда вы имеете дело с картами карт, и тогда все это с большим количеством скобок может стать немного беспорядочным.
 Фильтр
 - это функция, которая принимает предикат (предикат - это функция, которая сообщает, истинно что-то или нет, поэтому в нашем случае функция, которая возвращает логическое значение) и список, а затем возвращает список элементов, удовлетворяющих предикат. Подпись типа и реализация выглядят следующим образом:
filter :: (a -> Bool) -> [a] -> [a]
фильтр _ [] = []
фильтр p (x: xs)
    | p x = x: фильтр p xs
    | в противном случае = filter p xs
 
 Довольно простые вещи.Если p x принимает значение True, элемент включается в новый список. Если этого не произойдет, он останется. Некоторые примеры использования:
ghci> filter (> 3) [1,5,3,2,1,6,4,3,2,1]
[5,6,4]
ghci> фильтр (== 3) [1,2,3,4,5]
[3]
ghci> фильтровать даже [1..10]
[2,4,6,8,10]
ghci> let notNull x = not (null x) в фильтре notNull [[1,2,3], [], [3,4,5], [2,2], [], [], []]
[[1,2,3], [3,4,5], [2,2]]
ghci> filter (`elem` ['a' .. 'z'])" U LaUgH aT Me BeCaUsE I aM DifffeRent "
"uagameasadifeent"
ghci> filter (`elem` ['A'..'Z ']) "Я хваляю тебя, потому что ты все то же самое"
"ГАЙБОЛЫ"
 
 Все это также может быть достигнуто с помощью составления списков с помощью предикатов. Нет установленного правила, когда использовать карту и фильтр по сравнению с использованием понимания списка, вам просто нужно решить, что более читабельно, в зависимости от кода и контекста. Фильтр, эквивалентный применению нескольких предикатов в понимании списка, - это либо фильтрация чего-либо несколько раз, либо соединение предикатов с помощью логической функции &&.
 Помните нашу функцию быстрой сортировки из предыдущей главы? Мы использовали составные части списка, чтобы отфильтровать элементы списка, которые меньше (или равны) и больше, чем точка поворота. Мы можем достичь той же функциональности в более удобочитаемом виде, используя фильтр:
quicksort :: (Ord a) => [a] -> [a]
quicksort [] = []
быстрая сортировка (x: xs) =
    пусть меньшеСортировано = быстрая сортировка (фильтр (<= x) xs)
        большеСортировано = быстрая сортировка (фильтр (> x) xs)
    in lessSorted ++ [x] ++ большеSorted
 
 Отображение и фильтрация - это основа инструментария каждого функционального программиста.Эм-м-м. Неважно, делаете ли вы это с помощью функций карты и фильтрации или списков. Вспомните, как мы решали задачу поиска прямоугольных треугольников с определенной окружностью. При императивном программировании мы бы решили эту проблему, вложив три цикла, а затем проверив, удовлетворяет ли текущая комбинация прямоугольному треугольнику и имеет ли она правильный периметр. Если бы это было так, мы бы распечатали это на экран или что-то в этом роде. В функциональном программировании этот шаблон достигается с помощью сопоставления и фильтрации.Вы создаете функцию, которая принимает значение и дает какой-то результат. Мы сопоставляем эту функцию со списком значений, а затем отфильтровываем полученный список для результатов, удовлетворяющих нашему поиску. Благодаря ленивости Haskell, даже если вы несколько раз сопоставите что-то со списком и несколько раз отфильтруете, оно пройдет по списку только один раз.
 Давайте  найдем наибольшее число меньше 100 000, которое делится на 3829 . Для этого мы просто отфильтруем набор возможностей, в которых, как мы знаем, лежит решение.
КрупнейшийDivisible :: (Интеграл a) => a
largeDivisible = head (фильтр p [100000,99999 ..])
    где p x = x `mod` 3829 == 0
 
 Сначала мы составляем список всех чисел меньше 100 000 по убыванию. Затем мы фильтруем его по нашему предикату, и поскольку числа отсортированы по убыванию, наибольшее число, удовлетворяющее нашему предикату, является первым элементом отфильтрованного списка. Нам даже не нужно было использовать конечный список для нашего начального набора. Это снова лень в действии.Поскольку в конечном итоге мы используем только заголовок отфильтрованного списка, не имеет значения, является ли отфильтрованный список конечным или бесконечным. Оценка прекращается, когда найдено первое адекватное решение.
 Далее мы собираемся найти  сумму всех нечетных квадратов, которые меньше 10 000 . Но сначала, поскольку мы будем использовать его в нашем решении, мы собираемся представить функцию takeWhile. Он принимает предикат и список, а затем идет с начала списка и возвращает его элементы, пока предикат остается истинным.2)])
166650 

Какой из них красивее - дело вкуса. Опять же, свойство лени в Haskell - вот что делает это возможным. Мы можем отображать и фильтровать бесконечный список, потому что он не будет отображать и фильтровать его сразу, это задержит эти действия. Только когда мы заставляем Haskell показать нам сумму, функция sum сообщает takeWile, что ей нужны эти числа. takeWhile вызывает фильтрацию и отображение, но только до тех пор, пока не встретится число, большее или равное 10 000.

В следующей задаче мы будем иметь дело с последовательностями Коллатца. Берем натуральное число. Если это число четное, мы делим его на два. Если он нечетный, мы умножаем его на 3, а затем прибавляем к нему 1. Мы берем полученное число и применяем к нему то же самое, что дает новое число и так далее. По сути, мы получаем цепочку чисел. Считается, что для всех начальных номеров цепочки заканчиваются на цифре 1. Итак, если мы возьмем начальный номер 13, мы получим следующую последовательность: 13, 40, 20, 10, 5, 16, 8, 4, 2, 1 .13 * 3 + 1 равно 40. 40, разделенное на 2, равно 20 и т. Д. Мы видим, что в цепочке 10 элементов.

Теперь мы хотим знать следующее: для всех начальных чисел от 1 до 100, сколько цепочек имеют длину больше 15? Прежде всего, мы напишем функцию, которая производит цепочку:

цепь :: (Интеграл a) => a -> [a]
цепочка 1 = [1]
цепь п
    | четное n = n: цепочка (n `div` 2)
    | нечетное n = n: цепочка (n * 3 + 1)
 

Поскольку цепи заканчиваются на 1, это крайний случай.Это довольно стандартная рекурсивная функция.

ghci> цепочка 10
[10,5,16,8,4,2,1]
ghci> цепочка 1
[1]
ghci> цепь 30
[30,15,46,23,70,35,106,53,160,80,40,20,10,5,16,8,4,2,1]
 

Ура! Вроде работает правильно. А теперь функция, которая сообщает нам ответ на наш вопрос:

numLongChains :: Int
numLongChains = length (фильтр isLong (цепочка карт [1..100]))
    где isLong xs = длина xs> 15
 

Мы сопоставляем функцию цепочки с [1..100], чтобы получить список цепочек, которые сами представлены в виде списков.Затем мы фильтруем их с помощью предиката, который просто проверяет, превышает ли длина списка 15. После фильтрации мы видим, сколько цепочек осталось в итоговом списке.

Примечание: Эта функция имеет тип numLongChains :: Int, поскольку length возвращает Int вместо Num a по историческим причинам. Если бы мы хотели вернуть более общее Num a, мы могли бы использовать fromIntegral для полученной длины.

Используя map, мы также можем делать такие вещи, как map (*) [0..], если не по какой-либо другой причине, кроме как проиллюстрировать, как работает каррирование и как (частично применяемые) функции являются реальными значениями, которые вы можете передавать другим функциям или помещать в списки (вы просто не можете превратить их в строки). До сих пор мы отображали только функции, которые принимают один параметр над списками, например map (* 2) [0 ..], чтобы получить список типа (Num a) => [a], но мы также можем сделать map ( *) [0 ..] без проблем. Здесь происходит следующее: число в списке применяется к функции *, которая имеет тип (Num a) => a -> a -> a.Применение только одного параметра к функции, которая принимает два параметра, возвращает функцию, которая принимает один параметр. Если мы сопоставим * над списком [0 ..], мы получим обратно список функций, которые принимают только один параметр, поэтому (Num a) => [a -> a]. map (*) [0 ..] создает список, подобный тому, который мы получили бы, написав [(0 *), (1 *), (2 *), (3 *), (4 *), (5 * ) ...

ghci> пусть listOfFuns = map (*) [0 ..]
ghci> (listOfFuns !! 4) 5
20
 

Получение элемента с индексом 4 из нашего списка возвращает функцию, эквивалентную (4 *).А затем мы просто применяем 5 к этой функции. Это как написать (4 *) 5 или просто 4 * 5.

Лямбды

Лямбды - это в основном анонимные функции, которые используются, потому что некоторые функции нам нужны только один раз. Обычно лямбда создается с единственной целью - передать ее функции более высокого порядка. Чтобы сделать лямбду, мы пишем \ (потому что она выглядит как греческая буква лямбда, если прищуриться), а затем мы записываем параметры, разделенные пробелами. После этого идет ->, а затем тело функции.Обычно мы заключаем их в круглые скобки, потому что в противном случае они расширяются вправо.

Если вы посмотрите примерно на 5 дюймов вверх, вы увидите, что мы использовали , где привязка в нашей функции numLongChains, чтобы сделать функцию isLong с единственной целью - передать ее фильтру. Что ж, вместо этого мы можем использовать лямбда:

numLongChains :: Int
numLongChains = length (filter (\ xs -> length xs> 15) (цепочка карт [1..100]))
 

Лямбды - это выражения, поэтому мы можем просто передавать их вот так.Выражение (\ xs -> length xs> 15) возвращает функцию, которая сообщает нам, превышает ли длина переданного ему списка 15.

Люди, не знакомые с принципами каррирования и частичного применения, часто используют лямбда-выражения там, где в этом нет необходимости. Например, выражения map (+3) [1,6,3,2] и map (\ x -> x + 3) [1,6,3,2] эквивалентны, поскольку и (+3), и (\ x -> x + 3) - это функции, которые берут число и добавляют к нему 3. Излишне говорить, что создание лямбды в этом случае глупо, поскольку использование частичного приложения намного более читабельно.

Как и обычные функции, лямбда-выражения могут принимать любое количество параметров:

ghci> zipWith (\ a b -> (a * 30 + 3) / b) [5,4,3,2,1] [1,2,3,4,5]
[153,0,61,5,31,0,15,75,6,6]
 

И, как обычные функции, вы можете сопоставить с образцом в лямбдах. Единственное отличие состоит в том, что вы не можете определить несколько шаблонов для одного параметра, например, создать шаблон [] и (x: xs) для одного и того же параметра, а затем получить значения, которые пропадают. Если сопоставление с образцом в лямбда-выражении не удается, возникает ошибка времени выполнения, поэтому будьте осторожны при сопоставлении с образцом в лямбда-выражениях!

ghci> map (\ (a, b) -> a + b) [(1,2), (3,5), (6,3), (2,6), (2,5)]
[3,8,9,8,7]
 

Лямбды обычно заключаются в круглые скобки, если мы не подразумеваем, что они расширяются до упора вправо.Вот кое-что интересное: из-за того, как функции каррированы по умолчанию, эти два эквивалента:

addThree :: (Num a) => a -> a -> a -> a
addThree x y z = x + y + z
 

addThree :: (Num a) => a -> a -> a -> a
addThree = \ x -> \ y -> \ z -> x + y + z
 

Если мы определим такую ​​функцию, станет очевидно, почему объявление типа именно такое. И в объявлении типа, и в уравнении есть три символа ->. Но, конечно, первый способ написания функций гораздо более читабелен, второй - в значительной степени уловка для иллюстрации каррирования.

Однако бывают случаи, когда использовать эту нотацию круто. Я думаю, что функция переворота наиболее читаема, если она определена так:

flip ':: (a -> b -> c) -> b -> a -> c
перевернуть 'f = \ x y -> f y x
 

Хотя это то же самое, что писать flip 'f x y = f y x, мы делаем очевидным, что большую часть времени это будет использоваться для создания новой функции. Наиболее распространенный вариант использования flip - это вызов его только с параметром функции, а затем передача полученной функции на карту или фильтр.Поэтому используйте лямбды таким образом, если вы хотите явно указать, что ваша функция в основном предназначена для частичного применения и передачи функции в качестве параметра.

Только складки и кони

Еще когда мы имели дело с рекурсией, мы заметили тему во многих рекурсивных функциях, работающих со списками. Обычно у нас есть крайний случай для пустого списка. Мы вводили шаблон x: xs, а затем выполняли некоторые действия, которые касаются одного элемента и остальной части списка.Оказалось, что это очень распространенный шаблон, поэтому была введена пара очень полезных функций для его инкапсуляции. Эти функции называются складками. Они похожи на функцию карты, только сокращают список до некоторого единственного значения.

Сворачивание принимает двоичную функцию, начальное значение (я люблю называть его аккумулятором) и список, который нужно сворачивать. Сама бинарная функция принимает два параметра. Бинарная функция вызывается с аккумулятором и первым (или последним) элементом и создает новый аккумулятор.Затем двоичная функция вызывается снова с новым аккумулятором и новым теперь первым (или последним) элементом и так далее. После того, как мы пройдемся по всему списку, останется только аккумулятор, до которого мы сократили список.

Сначала давайте взглянем на функцию foldl, также называемую левой складкой. Он сворачивает список вверх с левой стороны. Двоичная функция применяется между начальным значением и заголовком списка. Это создает новое значение аккумулятора, и двоичная функция вызывается с этим значением, следующим элементом и т. Д.

Давайте снова реализуем sum, только на этот раз мы будем использовать свертку вместо явной рекурсии.

sum ':: (Num a) => [a] -> a
sum 'xs = foldl (\ acc x -> acc + x) 0 xs
 

Тестирование, раз, два, три:

ghci> сумма [3,5,2,1]
11
 

Давайте подробно рассмотрим, как происходит этот фолд. \ acc x -> acc + x - двоичная функция. 0 - начальное значение, а xs - список, который нужно свернуть. Теперь сначала 0 используется как параметр acc для двоичной функции, а 3 используется как параметр x (или текущий элемент).0 + 3 дает 3 и становится, так сказать, новым значением аккумулятора. Далее, 3 используется как значение аккумулятора, 5 - как текущий элемент, а 8 становится новым значением аккумулятора. Двигаясь вперед, 8 - это значение аккумулятора, 2 - текущий элемент, новое значение аккумулятора - 10. Наконец, 10 используется как значение аккумулятора, а 1 - как текущий элемент, что дает 11. Поздравляю, вы сделали складывать!

Эта профессиональная диаграмма слева показывает, как происходит фолд, шаг за шагом (день за днем!).Зеленовато-коричневое число - это значение аккумулятора. Вы можете видеть, как список как бы поглощается аккумулятором слева. Ом ном ном ном! Если учесть, что функции каррированы, мы можем написать эту реализацию еще лаконичнее, например так:

sum ':: (Num a) => [a] -> a
сумма '= foldl (+) 0
 

Лямбда-функция (\ acc x -> acc + x) такая же, как (+). Мы можем опустить xs в качестве параметра, потому что вызов foldl (+) 0 вернет функцию, которая принимает список.Как правило, если у вас есть функция типа foo a = bar b a, вы можете переписать ее как foo = bar b из-за каррирования.

Anyhoo, давайте реализуем еще одну функцию с левым сгибом, прежде чем переходить к правому сгибу. Я уверен, что вы все знаете, что elem проверяет, является ли значение частью списка, поэтому я не буду вдаваться в это снова (упс, только что сделал!). Реализуем это с левым сгибом.

elem ':: (Eq a) => a -> [a] -> Bool
elem 'y ys = foldl (\ acc x -> if x == y then True else acc) False ys
 

Ну-ну-ну что тут у нас? Начальное значение и аккумулятор здесь - логическое значение.Тип значения аккумулятора и конечный результат всегда одинаковы при работе со свертками. Помните, что если вы когда-нибудь не знаете, что использовать в качестве начального значения, это даст вам некоторое представление. Начнем с False. Имеет смысл использовать False в качестве начального значения. Мы предполагаем, что его там нет. Кроме того, если мы вызовем свертку для пустого списка, результатом будет просто начальное значение. Затем мы проверяем, что текущий элемент - это тот элемент, который мы ищем. Если это так, мы устанавливаем аккумулятор в True. Если нет, просто оставляем аккумулятор без изменений.Если раньше оно было False, оно остается таким, потому что текущий элемент им не является. Если это было True, мы оставим это как есть.

Правая свертка, foldr работает аналогично левой свертке, только аккумулятор съедает значения справа. Кроме того, у двоичной функции левой свертки первым параметром является аккумулятор, а вторым - текущее значение (так что \ acc x -> ...), двоичная функция правой свертки имеет текущее значение как первый параметр и аккумулятор как второй (так \ x acc ->...). Кажется логичным, что в правом сгибе аккумулятор находится справа, потому что он сгибается с правой стороны.

Суммарное значение (и, следовательно, результат) свертки может быть любого типа. Это может быть число, логическое значение или даже новый список. Мы будем реализовывать функцию карты с правым сгибом. Накопитель будет списком, мы будем накапливать отображаемый список элемент за элементом. Отсюда очевидно, что начальным элементом будет пустой список.

map ':: (a -> b) -> [a] -> [b]
map 'f xs = foldr (\ x acc -> f x: acc) [] xs
 

Если мы сопоставляем (+3) с [1,2,3], мы подходим к списку с правой стороны.Мы берем последний элемент, равный 3, и применяем к нему функцию, которая в итоге становится 6. Затем мы добавляем его к аккумулятору, который был []. 6: [] равно [6], и теперь это аккумулятор. Мы применяем (+3) к 2, то есть 5, и добавляем (:) его к аккумулятору, так что аккумулятор теперь [5,6]. Мы применяем (+3) к 1 и добавляем его к аккумулятору, поэтому конечное значение равно [4,5,6].

Конечно, мы могли реализовать эту функцию и с левым сгибом. Это будет map 'f xs = foldl (\ acc x -> acc ++ [fx]) [] xs, но дело в том, что функция ++ намного дороже, чем:, поэтому мы обычно используем правые складки, когда мы Формируем новые списки из списка.

Если вы перевернете список, вы можете свернуть его вправо, как если бы вы сделали левый, и наоборот. Иногда даже этого не нужно делать. Функция суммы может быть реализована практически одинаково с левым и правым сгибом. Одно большое отличие состоит в том, что правые складки работают с бесконечными списками, а левые - нет! Проще говоря, если вы в какой-то момент возьмете бесконечный список и свернете его справа, вы в конечном итоге дойдете до начала списка. Однако, если вы возьмете бесконечный список и попытаетесь свернуть его слева, вы никогда не дойдете до конца!

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

Функции foldl1 и foldr1 работают так же, как foldl и foldr, только вам не нужно указывать им явное начальное значение. Они предполагают, что первый (или последний) элемент списка является начальным значением, а затем начинают свертку с элемента рядом с ним. Имея это в виду, функцию суммы можно реализовать так: sum = foldl1 (+).Поскольку они зависят от сворачиваемых списков, содержащих хотя бы один элемент, они вызывают ошибки времени выполнения, если вызываются с пустыми списками. С другой стороны, foldl и foldr отлично работают с пустыми списками. Делая свертку, подумайте, как она действует с пустым списком. Если функция не имеет смысла при наличии пустого списка, вы, вероятно, можете использовать foldl1 или foldr1 для ее реализации.

Чтобы показать вам, насколько мощны складки, мы собираемся реализовать ряд стандартных библиотечных функций с помощью складок:

максимум ':: (Ord a) => [a] -> a
максимум '= foldr1 (\ x acc -> if x> acc, then x else acc)

обратный ':: [a] -> [a]
reverse '= foldl (\ acc x -> x: acc) []

product ':: (Num a) => [a] -> a
product '= foldr1 (*)

filter ':: (a -> Bool) -> [a] -> [a]
filter 'p = foldr (\ x acc -> if p x then x: acc else acc) []

голова ':: [а] -> а
голова '= foldr1 (\ x _ -> x)

последний ':: [а] -> а
last '= foldl1 (\ _ x -> x)
 

лучше реализована путем сопоставления с образцом, но это просто показывает, что вы все еще можете добиться этого, используя складки.Я думаю, что наше обратное определение довольно умно. Мы берем начальное значение пустого списка, затем приближаемся к нашему списку слева и просто добавляем его в наш аккумулятор. В конце концов, мы составляем перевернутый список. \ acc x -> x: acc выглядит как функция:, только параметры меняются местами. Вот почему мы могли бы также записать наш реверс как foldl (flip (:)) [].

Другой способ изобразить правую и левую складки: скажем, у нас есть правая складка, двоичная функция - f, а начальное значение - z.Если мы сворачиваем вправо список [3,4,5,6], мы, по сути, делаем это: f 3 (f 4 (f 5 (f 6 z))). f вызывается с последним элементом в списке и аккумулятором, это значение передается как аккумулятор для предпоследнего значения и так далее. Если мы возьмем f равным +, а значение начального аккумулятора равным 0, то получится 3 + (4 + (5 + (6 + 0))). Или, если мы напишем + как префиксную функцию, это будет (+) 3 ((+) 4 ((+) 5 ((+) 6 0))). Аналогичным образом, свертывание влево по этому списку с g в качестве двоичной функции и z в качестве аккумулятора эквивалентно g (g (g (g z 3) 4) 5) 6.Если мы используем flip (:) в качестве двоичной функции и [] в качестве аккумулятора (так что мы меняем список), то это эквивалент flip (:) (flip (:) (flip (:) (flip (: ) [] 3) 4) 5) 6. И действительно, если вы оцените это выражение, вы получите [6,5,4,3].

scanl и scanr похожи на foldl и foldr, только они сообщают обо всех промежуточных состояниях аккумулятора в виде списка. Также есть scanl1 и scanr1, которые аналогичны foldl1 и foldr1.

ghci> scanl (+) 0 [3,5,2,1]
[0,3,8,10,11]
ghci> scanr (+) 0 [3,5,2,1]
[11,8,3,1,0]
ghci> scanl1 (\ acc x -> if x> acc, то x else acc) [3,4,5,3,7,9,2,1]
[3,4,5,5,7,9,9,9]
ghci> scanl (перевернуть (:)) [] [3,2,1]
[[], [3], [2,3], [1,2,3]]
 

При использовании scanl окончательный результат будет в последнем элементе результирующего списка, в то время как сканер поместит результат в заголовок.

Сканирование используется для отслеживания выполнения функции, которая может быть реализована как свертка. Давайте ответим нам на этот вопрос: Сколько элементов нужно, чтобы сумма корней всех натуральных чисел превысила 1000? Чтобы получить квадраты всех натуральных чисел, мы просто выполняем map sqrt [1 ..]. Теперь, чтобы получить сумму, мы могли бы выполнить свертку, но поскольку нас интересует, как увеличивается сумма, мы собираемся выполнить сканирование. Как только мы проведем сканирование, мы просто увидим, сколько сумм меньше 1000.Первая сумма в списке сканирования обычно равна 1. Второй будет равен 1 плюс квадратный корень из 2. Третьим будет плюс квадратный корень из 3. Если имеется X сумм меньше 1000, то требуется X + 1 элементов, чтобы сумма превысила 1000.

sqrtSums :: Int
sqrtSums = length (takeWhile (<1000) (scanl1 (+) (map sqrt [1 ..]))) + 1
 

ghci> sqrtSums
131
ghci> сумма (карта sqrt [1..131])
1005.0942035344083
ghci> сумма (карта sqrt [1..130])
993.6486803
7
 

Мы используем здесь takeWhile вместо фильтра, потому что фильтр не работает с бесконечными списками.Несмотря на то, что мы знаем, что список возрастает, фильтр не работает, поэтому мы используем takeWhile, чтобы вырезать список сканирования при первом появлении суммы, превышающей 1000.

Функциональное приложение с $

Хорошо, теперь мы рассмотрим функцию $, также называемую приложением функции . Прежде всего, давайте посмотрим, как это определяется:

($) :: (a -> b) -> a -> b
f $ x = f x
 

Что за черт? Что это за бесполезный оператор? Это просто функциональное приложение! Ну, почти, но не совсем! В то время как обычное приложение-функция (помещающее пробел между двумя объектами) имеет действительно высокий приоритет, функция $ имеет самый низкий приоритет.Применение функции с пробелом является левоассоциативным (поэтому f a b c совпадает с ((f a) b) c)), приложение функции с $ является правоассоциативным.

Это все хорошо, но чем это нам поможет? В большинстве случаев это удобная функция, поэтому нам не нужно писать так много скобок. Рассмотрим выражение sum (map sqrt [1..130]). Поскольку $ имеет такой низкий приоритет, мы можем переписать это выражение как sum $ map sqrt [1..130], сэкономив драгоценные нажатия клавиш! Когда встречается знак $, выражение справа от него применяется как параметр к функции слева.Как насчет sqrt 3 + 4 + 9? Это складывает 9, 4 и квадратный корень из 3. Если мы хотим получить квадратный корень из 3 + 4 + 9 , нам нужно будет написать sqrt (3 + 4 + 9) или, если мы используем $, мы можем напишите его как sqrt $ 3 + 4 + 9, потому что $ имеет самый низкий приоритет среди всех операторов. Вот почему вы можете представить, что $ является своего рода эквивалентом написания открывающей круглой скобки, а затем написания закрывающей в крайней правой части выражения.

Как насчет суммы (фильтр (> 10) (карта (* 2) [2.2), sqrt] [7.0,30.0,9.0,1.7320508075688772]

Функциональный состав

В математике композиция функций определяется следующим образом:, что означает, что при объединении двух функций создается новая функция, которая при вызове с параметром, скажем, x эквивалентна вызову g с параметром x , а затем позвонив на f с таким результатом.

В Haskell композиция функций - это почти то же самое. Мы выполняем композицию функций с помощью.функция, которая определяется так:

(.) :: (b -> c) -> (a -> b) -> a -> c
f. г = \ х -> е (г х)
 

Обратите внимание на объявление типа. f должен принимать в качестве параметра значение того же типа, что и возвращаемое значение g. Таким образом, результирующая функция принимает параметр того же типа, что и g, и возвращает значение того же типа, что возвращает f. Выражение отрицать. (* 3) возвращает функцию, которая принимает число, умножает его на 3, а затем отменяет его.

Одно из применений композиции функций - создание функций на лету для передачи другим функциям.Конечно, для этого можно использовать лямбды, но во многих случаях композиция функций более четкая и лаконичная. Допустим, у нас есть список чисел, и мы хотим превратить их все в отрицательные числа. Один из способов сделать это - получить абсолютное значение каждого числа, а затем отрицать его, например:

ghci> map (\ x -> negate (abs x)) [5, -3, -6,7, -3,2, -19,24]
[-5, -3, -6, -7, -3, -2, -19, -24]
 

Обратите внимание на лямбда и то, как она выглядит как композиция функции результата. Используя композицию функций, мы можем переписать это как:

ghci> карта (отрицать.абс) [5, -3, -6,7, -3,2, -19,24]
[-5, -3, -6, -7, -3, -2, -19, -24]
 

Потрясающе! Композиция функций является правоассоциативной, поэтому мы можем составлять много функций одновременно. Выражение f (g (z x)) эквивалентно (f. G. Z) x. Имея это в виду, мы можем превратить

ghci> map (\ xs -> negate (sum (tail xs))) [[1..5], [3..6], [1..7]]
[-14, -15, -27]
 

в

ghci> map (negate. sum. tail) [[1..5], [3..6], [1..7]]
[-14, -15, -27]
 

А как насчет функций, которые принимают несколько параметров? Что ж, если мы хотим использовать их в композиции функций, нам обычно приходится частично применять их настолько, чтобы каждая функция принимала только один параметр.сумма (реплика 5 (макс. 6,7 8,9)) может быть переписана как (сумма. реплика 5. макс. 6,7) 8,9 или как сумма. повторить 5. макс 6,7 $ 8,9. Здесь происходит следующее: создается функция, которая берет максимум 6,7 и применяет к ней реплику 5. Затем создается функция, которая берет результат этого и выполняет его сумму. Наконец, эта функция вызывается с 8.9. Но обычно вы просто читаете это как: применить 8.9 ​​к максимуму 6.7, затем применить реплику 5 к этому, а затем применить сумму к этому. Если вы хотите переписать выражение с большим количеством круглых скобок, используя композицию функций, вы можете начать с помещения последнего параметра самой внутренней функции после $, а затем просто составить все остальные вызовы функций, записать их без последнего параметра и поставить точки между ними.Если у вас есть репликация 100 (product (map (* 3) (zipWith max [1,2,3,4,5] [4,5,6,7,8]))), вы можете записать ее как реплику 100. продукт . карта (* 3). zipWith max [1,2,3,4,5] $ [4,5,6,7,8]. Если выражение заканчивается тремя круглыми скобками, скорее всего, если вы переведете его в композицию функций, у него будет три оператора композиции.

Другое распространенное использование композиции функций - определение функций в так называемом безточечном стиле (также называемом стилем «точка минус »). Возьмем, к примеру, эту функцию, которую мы написали ранее:

sum ':: (Num a) => [a] -> a
сумма 'xs = foldl (+) 0 xs
 

Хз выставлен с обеих правых сторон.Из-за каррирования мы можем опустить xs с обеих сторон, потому что вызов foldl (+) 0 создает функцию, которая принимает список. Запись функции как sum '= foldl (+) 0 называется безточечной записью. Как бы мы могли написать это в безточечном стиле?

fn x = потолок (negate (tan (cos (max 50 x))))
 

Мы не можем просто избавиться от x с обеих правых сторон. После x в теле функции ставятся круглые скобки. cos (макс. 50) не имеет смысла. Вы не можете получить косинус функции.Что мы можем сделать, так это выразить fn как композицию функций.

fn = потолок. отрицать. загар. cos. не более 50
 

Отлично! Во многих случаях стиль без точек является более читаемым и кратким, потому что он заставляет вас думать о функциях и о том, какие функции их составляют, вместо того, чтобы думать о данных и о том, как они перемещаются. Вы можете взять простые функции и использовать композицию как клей для создания более сложных функций. Однако во многих случаях написание функции в безточечном стиле может быть менее читаемым, если функция слишком сложна.Вот почему создание длинных цепочек функциональной композиции не рекомендуется, хотя я признаю себя виновным в том, что иногда слишком увлекаюсь композицией. Предпочтительный стиль - использовать привязки let для обозначения промежуточных результатов или разделения проблемы на подзадачи, а затем объединить их так, чтобы функция имела смысл для того, кто ее читает, вместо того, чтобы просто создавать огромную цепочку композиций.

В разделе о картах и ​​фильтрах мы решили задачу нахождения суммы всех нечетных квадратов, меньших 10 000.2) [1 ..] belowLimit = takeWhile (<10000) oddSquares в сумме ниже

Это не выиграет ни в одном соревновании по гольфу кода, но кто-то, читающий функцию, вероятно, сочтет ее легче читать, чем цепочку композиций.

Состав микробиоты кишечника отражает тяжесть заболевания и дисфункциональные иммунные реакции у пациентов с COVID-19

Значение этого исследования

Что уже известно по этому вопросу?

• SARS-CoV-2 в первую очередь поражает дыхательные пути, однако патофизиологию COVID-19 можно отнести к аберрантным иммунным ответам при избавлении от вируса.

• Несколько линий доказательств, таких как репликация SARS-CoV-2 в энтероцитах человека, обнаружение вирусов в образцах фекалий и изменение состава кишечной микробиоты у пациентов с COVID-19, предполагают поражение желудочно-кишечного тракта.

• Обследования кишечной микробиоты COVID-19 ограничены и не изучали связи между кишечным микробиомом и патофизиологией заболевания.

Какие новые выводы?

• Состав микробиоты кишечника у пациентов с COVID-19 соответствует тяжести заболевания и величине концентраций в плазме некоторых воспалительных цитокинов, хемокинов и маркеров повреждения тканей в крови.

• У пациентов с COVID-19 были истощены кишечные бактерии с известным иммуномодулирующим потенциалом, такие как Faecalibacterium prausnitzii , Eubacterium rectale и несколько видов бифидобактерий.

• Дисбиотический состав микробиоты кишечника у пациентов с COVID-19 сохраняется после выведения вируса.

Значение этого исследования

Как оно может повлиять на клиническую практику в обозримом будущем?

• Эти данные свидетельствуют о том, что истощение иммуномодулирующих кишечных микроорганизмов способствует тяжелому заболеванию COVID-19.

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

• Поддержка полезных видов кишечника, обедненных COVID-19, может служить новым способом смягчения тяжелых заболеваний, подчеркивая важность управления микробиотой кишечника пациентов во время и после COVID-19.

Введение

Инфекция SARS-CoV-2 вызывает иммунный ответ на элиминацию вируса, но появляется все больше свидетельств того, что аберрантные ответы ответственны за тяжелые исходы и, возможно, другие воспалительные состояния, помимо COVID-19.У пациентов с тяжелым заболеванием наблюдается высокий уровень воспалительных цитокинов и маркеров воспаления в плазме крови, таких как IL 6, 8 и 10, а также C-реактивный белок (CRP) и лактатдегидрогеназа (LDH), что отражает иммунный ответ и повреждение тканей от SARS-CoV-2. инфекция. 1–3 Кроме того, у некоторых пациентов после выздоровления развиваются аутовоспалительные симптомы, наиболее выраженными из которых являются мультисистемный воспалительный синдром и болезнь Кавасаки у детей. 4–6 Некоторые наблюдения предполагают значительное поражение желудочно-кишечного тракта, например, способность SARS- CoV-2 для инфицирования и репликации в энтероцитах тонкого кишечника человека 7, последовательное обнаружение вирусной РНК в образцах фекалий8, 9 и измененный состав микробиоты кишечника у субъектов, инфицированных SARS-CoV-2.10 11 Поскольку желудочно-кишечный тракт является крупнейшим иммунологическим органом в организме, а его резидентная микробиота, как известно, модулирует иммунные ответы хозяина, 12 мы предположили, что микробиота кишечника связана с воспалительными иммунными ответами хозяина при COVID-19. Здесь мы охарактеризовали микробиоту кишечника и иммунный ответ у 100 пациентов с COVID-19 во время госпитализации и до 30 дней после выздоровления, показав, что состав микробиоты кишечника во время госпитализации связан с тяжестью заболевания и концентрациями в плазме нескольких цитокинов и воспалительных маркеров.Более того, состав микробиоты кишечника выздоровевших пациентов оставался значительно измененным по сравнению с людьми, не инфицированными COVID-19, что может иметь важные последствия для будущих проблем со здоровьем, помимо COVID-19.

Материалы и методы

Набор субъектов и сбор образцов

Исследование проводилось в соответствии с Хельсинкской декларацией. Все пациенты дали письменное информированное согласие. Как описано в нашем предыдущем исследовании, 10 пациентов с COVID-19 были набраны из больниц Принца Уэльского и Объединенных христианских больниц в Гонконге в период с февраля по май 2020 года.Эти пациенты были лабораторно подтверждены SARS-CoV-2 положительными с помощью количественной ПЦР с обратной транскрипцией (RT-qPCR), проведенной на мазках из носоглотки, собранных персоналом больницы. Обследование кишечного микробиома популяции проводилось с помощью рекламы14 или контрольных групп, не связанных с заболеванием, из испытаний колоноскопии 15, при этом у субъектов была нормальная колоноскопия (стул был собран за несколько дней до подготовки кишечника). Пациенты с COVID-19 были разделены на четыре группы степени тяжести на основе симптомов, как сообщалось Wu et al .16 Вкратце, пациенты были классифицированы как легкие, если не было рентгенологических признаков пневмонии, умеренные, если пневмония с лихорадкой и симптомами респираторных путей, тяжелые, если частота дыхания ≥30 вдохов в минуту, сатурация кислорода ≤93% при вдыхании окружающим воздухом или PaO2 / FiO2 ≤300 мм рт. Ст., Критическое, если дыхательная недостаточность требует искусственной вентиляции легких или органная недостаточность, требующая интенсивной терапии. Кровь и стул у госпитализированных пациентов собирались персоналом больницы, в то время как выписанные пациенты предоставляли стул в день наблюдения или самостоятельно брали пробы дома.Стул собирали в пробирки, содержащие консерванты (каталожный номер 63700, Norgen Biotek Corp, Онтарио, Канада), и хранили при -80 ° C до обработки. Ранее мы показали, что состав кишечной микробиоты, полученный из стула, собранного в этой консервативной среде, был сопоставим с результатами, полученными при немедленном замораживании при -80 ° C.17

Экстракция ДНК из стула и секвенирование

Подробные методы описаны в Zuo et al .10 Вкратце, ДНК экстрагировали из 0.1 г гомогенизированных образцов фекалий с использованием набора Maxwell RSC PureFood GMO and Authentication Kit и платформы для экстракции нуклеиновых кислот Maxwell RSC Instrument (Promega, Висконсин, США) в соответствии с инструкциями производителя. Библиотеки секвенирования получали из экстрагированной ДНК с использованием набора Nextera DNA Flex Library Prep Kit (Illumina, Калифорния, США) и секвенировали на системе Illumina NovaSeq 6000 (2 × 150 п.н.) в Центре исследований кишечной микробиоты Китайского университета Гонконга. Необработанные данные о последовательностях, созданные для этого исследования, доступны в архиве чтения последовательностей под регистрационным номером PRJNA650244 BioProject.

Обработка данных последовательностей, определение состава кишечной микробиоты и статистический анализ

Необработанные данные последовательностей были качественно отфильтрованы с помощью Trimmomatic V.39 для удаления адаптеров и низкокачественных последовательностей. После этого профили состава микробиоты были выведены из предварительных чтений с фильтрацией качества с использованием MetaPhlAn218 V.2.7.7 с базой данных V.20. Подсчет участков с разбивкой по видам и таблицы относительной численности были введены в R19 V.3.5.1 для статистического анализа. Ординация анализа главных компонентов (PCA) использовалась для визуализации кластеризации образцов на основе их композиционных профилей на уровне видов.Связь между составом кишечного сообщества и параметрами пациентов оценивалась с помощью пермутационного многомерного дисперсионного анализа (PERMANOVA) и анализа Прокруста. Связи конкретных видов микробов с параметрами пациента были идентифицированы с использованием статистических структур линейного дискриминантного анализа (LEfSe) и многомерного анализа с помощью линейных моделей (MaAsLin), реализованных в экземпляре Huttenhower Lab Galaxy (http: //huttenhower.sph.harvard. эду / галактика /). Анализ PCA, PERMANOVA и Procrustes реализован в веганском пакете R20 V.2.4–6.

Измерение нагрузки SARS-CoV-2 в образцах стула

Нагрузку вируса SARS-CoV-2 измеряли с помощью RT-qPCR, как описано в Zuo et al. . 10 РНК экстрагировали из 0,1 г гомогенизированного стула с использованием вирусной РНК QIAamp. Mini Kit (QIAGEN, Hilden Germany) в соответствии с инструкциями производителя. Последовательности праймера и зонда SARS-CoV-2 были предоставлены Центрами по контролю и профилактике заболеваний США (2019-nCoV_N1-F: 5'-GACCCCAAAATCAGC GAAAT-3 ', 2019-nCoV_N1-R: 5'-TCTGGTTACTGCCAGTTGAATCTG-3' и 2019-nCoV_N1-P: 5'-FAM-ACCCCGCATTACGTTTGGTGGACC-BHQ1-3 ').Каждая одностадийная реакция RT-qPCR содержала 10 мкл экстрагированной РНК, 4 мкл 1-этапной мастер-смеси TaqMan Fast Virus (Thermo Fisher Scientific, Массачусетс, США) в конечном реакционном объеме 20 мкл. Концентрации праймера и зонда составляли 0,5 мкМ и 0,125 мкМ соответственно. Условия цикла: 25 ° C в течение 2 минут, 50 ° C в течение 15 минут, 95 ° C в течение 2 минут, затем 45 циклов при 95 ° C в течение 15 секунд и 55 ° C в течение 30 секунд. Термоциклирование проводили в системе для ПЦР в реальном времени StepOnePlus (Thermo Fisher Scientific). Значения порога цикла (Ct) были преобразованы в копии вирусной РНК на основе стандартной кривой, построенной из 10-кратных серийных разведений известных копий плазмид, содержащих полный ген N (2019-nCoV_N_Positive Control, Integrated DNA Technologies, США).Образцы считались отрицательными, если значения Ct превышали 39,9 цикла. Предел обнаружения составил 347 копий / мл.

Измерения цитокинов в плазме

Образцы цельной крови, собранные в пробирки, обработанные антикоагулянтом, центрифугировали при 2000 × g в течение 10 минут и собирали супернатант. Концентрации цитокинов и хемокинов измеряли, используя MILLIPLEX MAP Human Cytokine / Chemokine Magnetic Bead Panel - иммунологический мультиплексный анализ (Merck Millipore, Массачусетс, США) на системе Bio-Plex 200 (Bio-Rad Laboratories, Калифорния, США).Концентрацию натрийуретического пептида N-конца мозга (NT-proBNP) измеряли с использованием наборов ELISA для человеческого NT-proBNP (Abcam, Кембридж, Великобритания).

Участие пациентов и общественности

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

Результаты

Когорта пациентов с COVID-19

В период с февраля по май 2020 года мы собрали образцы крови и стула у 100 пациентов с COVID-19, подтвержденных положительным результатом ОТ-КПЦР на SARS-CoV-2.Демографические и клинические характеристики этих пациентов и контрольной когорты, не связанной с COVID-19, из 78 взрослых, набранных в Гонконге до COVID-19, представлены в таблице 1. Среди пациентов с COVID-19 было 47 женщин и 53 мужчины со средним возрастом ± SD. 36,4 ± 18,7 года. Критическое, тяжелое, среднетяжелое и легкое заболевание16 наблюдалось у 3,0%, 5,0%, 45,0% и 47,0% пациентов соответственно. Для сравнения, когорта без COVID-19 состояла из 45 женщин и 33 мужчин со средним возрастом ± SD 45,5 ± 13,3 года. Сопутствующие заболевания в когорте COVID-19 включали гипертензию, гиперлипидемию, диабет и сердечные заболевания, хотя у каждого было менее пяти пациентов, за исключением гипертонии с 11.Для когорты, не связанной с COVID-19, гипертония была единственным серьезным сопутствующим заболеванием у 11 человек. Из 100 пациентов с COVID-19 41 предоставил несколько образцов стула во время их пребывания в больнице и / или последующего наблюдения после выписки; 34 и 46 пациентов получали антибиотики и противовирусные препараты, соответственно, до сбора стула.

Характеристики когорт COVID-19 и не-COVID-19

Измененный состав кишечной микробиоты у пациентов с COVID-19

Всего было секвенировано 274 образца стула, в среднем 6.8 Гбит (47 386 950 чтений) на образец. Во-первых, мы сравнили состав кишечной микробиоты первых образцов стула каждого пациента с COVID-19, собранных во время госпитализации (n = 87; 13 из 100 пациентов с COVID-19 испражнялись только после выздоровления) (40 женщин против 47 мужчин, 35,6 ± 18,8 лет (среднее значение ± стандартное отклонение)) с субъектами, не связанными с COVID-19 (от 45 женщин до 33 мужчин, возраст 45,5 ± 17,4 года (среднее ± стандартное отклонение)), чтобы оценить, изменился ли состав кишечной микробиоты в этой когорте COVID-19. На уровне филума представители Bacteroidetes были относительно многочисленнее среди пациентов с COVID-19 по сравнению с людьми, не инфицированными COVID-19 (в среднем 23.9% против 12,8%, p <0,001, тест Манна-Уитни), тогда как актинобактерий были более многочисленны у лиц, не инфицированных COVID-19 (26,1% против 19,0%, p <0,05, тест Манна-Уитни) (рисунок 1A). ). На уровне видов мы выявили значительную связь с заболеванием (COVID-19 против COVID-19) и антибиотиками (рис. 1B) (p <0,05, PERMANOVA), но не с нагрузкой SARS-CoV-2 стулом, противовирусными препаратами (лопинавир / ритонавир). , рибавирин или осельтамивир у 39 из 87 пациентов), использование кортикостероидов и ингибиторов протонной помпы (онлайн-дополнительная таблица S1).Без контроля использования антибиотиков, различия в составе кишечной микробиоты COVID-19 в первую очередь были вызваны обогащением видов, включая Ruminococcus gnavus , Ruminococcus torques и Bacteroides dorei и истощение Bifacteriсdobacterium Facalibidobacterium и Eubacterium rectale (p <0,05, LEfSe) (таблица 2, дополнительная таблица S2 онлайн). Когда изучали эффекты антибиотиков, различия между когортами были в первую очередь связаны с обогащением таксонов, таких как Parabacteroides , Sutterella wadsworthensis и Bacteroides caccae и истощение Adlercreutzia equolifaciens и Dloraptus , -19 по сравнению с не COVID-19 (p <0.05, MaAsLin) (онлайн-дополнительная таблица S3), хотя средняя относительная численность большинства затронутых таксонов в этих образцах составляла менее 0,1%. В то время как общий состав кишечной микробиоты отличался между 87 пациентами с COVID-19 и 78 пациентами без COVID-19, не было значительных различий в видовом богатстве и разнообразии Шеннона (p> 0,05, тест Манна-Уитни) (дополнительный рисунок S1 онлайн). В когорте COVID-19 состав микробиоты кишечника, отобранный во время госпитализации (n = 87), был наиболее значимо связан с тяжестью заболевания (легкая, умеренная, тяжелая, критическая), за которой следовали антибиотики с убывающей силой эффекта (p <0.05, ПЕРМАНОВА) (онлайн-дополнительная таблица S1). При идентификации видов микробов, связанных с серьезностью заболевания, мы обнаружили, что F. prausnitzii и Bifidobacterium bifidum отрицательно коррелировали с тяжестью заболевания после поправки на использование антибиотиков и возраст пациентов (p <0,05, порядковая регрессия). Относительная численность нескольких других видов микробов, обычно присутствующих в кишечнике человека, включая B. adolescentis и E. rectale , также показала снижение с увеличением тяжести заболевания, хотя это не было статистически значимым (онлайн-дополнительная таблица S4).

Различия в составе микробиоты кишечника между пациентами с COVID-19 и без COVID-19. (A) Среднее относительное количество микробных типов, обнаруженных в стуле у стационарных пациентов с COVID-19, пациентов, выписанных после отрицательной RT-qPCR на вирусную РНК в мазках из носоглотки, и лиц, не инфицированных COVID-19. (B) Анализ основных компонентов микробиоты кишечника пациентов с COVID-19 с антибиотиками и без них по сравнению с субъектами без COVID-19.Закрашенные кружки представляют первые образцы стула (если доступны серийные образцы) пациентов в больнице, тогда как крестики представляют пациентов, не инфицированных COVID-19. Центроиды групп обозначены метками групп.

Виды бактерий, ассоциированные с пациентами с COVID-19 во время госпитализации

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

При инфекции COVID-19 иммунная система вырабатывает воспалительные цитокины в ответ на вирусная инфекция.В некоторых случаях воспалительная реакция может быть чрезмерно агрессивной (например, «цитокиновый шторм») и приводить к широко распространенному повреждению тканей, септическому шоку и полиорганной недостаточности.1 На основании наблюдения, что микробиота кишечника изменяется у пациентов с COVID-19 ( рисунок 1) и ассоциации нескольких видов с тяжестью заболевания (онлайн-дополнительная таблица S4), мы предположили, что эти композиционные изменения играют роль в обострении заболевания, способствуя нарушению регуляции иммунного ответа. Визуализация состава кишечной микробиоты в когорте из 87 пациентов с COVID-19 во время госпитализации выявила континуум в группах легкой, средней, тяжелой и критической степени тяжести заболевания (рисунок 2), что указывает на стратификацию состава кишечной микробиоты, связанную с серьезностью заболевания.Затем мы сопоставили плазменные концентрации цитокинов (измеренные при поступлении; в среднем за 2 дня до образцов стула) и маркеры воспаления на PCA и наблюдали, что лиганд 10 мотива CXC (CXCL10), IL-10, фактор некроза опухоли-α (TNF-α) , аспартатаминотрансфераза (AST), гамма-глутамилтрансфераза (GGT), CRP, LDH, NT-proBNP и скорость оседания эритроцитов были значительно связаны с составом микробиоты (рисунок 2) (p <0,05, анализ Прокруста). Примечательно, что эти измерения увеличились одновременно с составом микробиоты, представляющим более тяжелые болезненные состояния.Поскольку CXCL10, IL-10, TNF-α, AST, GGT, CRP, LDH и NT-proBNP обычно повышены при более тяжелой форме COVID-19,2 21–23, эти результаты предполагают, что состав кишечной микробиоты связан с величиной иммунного ответа. ответ на COVID-19 и последующее повреждение тканей и, таким образом, может играть роль в регулировании тяжести заболевания. Затем мы оценили, какие конкретные виды, обогащенные или истощенные у пациентов с COVID-19, коррелируют с концентрациями цитокинов. Из списка наиболее распространенных видов в таблице 2 шесть видов, истощенных в когорте COVID-19, отрицательно коррелировали с CXCL10, пять - с IL-10 и по два - с TNF-α и лигандом 2 мотива CC (CCL2) (рис. 3A– D) (p <0.05, корреляция Спирмена). К ним относятся B. adolescentis , E. rectale и F. prausnitzii , которые, как известно, играют иммуномодулирующую роль в системе желудочно-кишечного тракта человека.24–26 И наоборот, два вида, обогащенные в когорте COVID-19: B. dorei и Akkermansia muciniphila положительно коррелировали с IL-1β, IL-6 и лигандом 8 мотива CXC (CXCL8) (рис. 3E – G). Корреляции с другими относительно менее многочисленными кишечными бактериями показаны в дополнительной онлайн-таблице S5).

Связь между составом микробиоты кишечника госпитализированных пациентов с COVID-19 и концентрацией воспалительных цитокинов и маркеров воспаления в плазме крови. (A) Анализ основных компонентов (PCA) состава кишечной микробиоты и ассоциации с плазменными концентрациями цитокинов / хемокинов. (B) PCA состава микробиоты кишечника и связь с маркерами воспаления крови. Статистические корреляции определяли с помощью тестов Прокруста. Показаны только цитокины и маркеры воспаления, достоверно коррелированные с составом микробиоты кишечника.Красные стрелки представляют градиенты соответствующих концентраций цитокинов / маркеров воспаления и указывают направление наибольшего увеличения этих показателей. Цвет кружков представляет группы тяжести заболевания, а эллипсы представляют стандартное отклонение центроида группы. Центроиды групп обозначены метками групп. AST, аспартатаминотрансфераза; CRP, C-реактивный белок; СОЭ, скорость оседания эритроцитов; GGT, гамма-глутамилтрансфераза; ЛДГ, лактатдегидрогеназа; NT-proBNP, натрийуретический пептид N-конца мозга; TNF, фактор некроза опухоли.

Корреляции между обогащенными / истощенными COVID-19 кишечными микробными таксонами и концентрациями в плазме (A) CXCL10, (B) IL-10, (C) TNF-α, (D) CCL2, (E) CXCL8, (F ) ИЛ-1β и (G) ИЛ-6. Показаны только статистически значимые корреляции. Линии линейной регрессии показаны на каждом графике разброса синим цветом, а заштрихованные области представляют 95% доверительных интервалов. CCL, лиганд мотива C-C; CXCL, лиганд мотива C-X-C; TNF, фактор некроза опухоли.

Дисбиоз кишечной микробиоты сохраняется после устранения SARS-CoV-2

Поскольку некоторые пациенты с COVID-19 сообщают о стойких симптомах после выздоровления и / или впоследствии у них развивается мультисистемное воспаление, 27 мы предположили, что дисбиотическая микробиота кишечника наблюдается у пациентов с COVID- 19 сохраняется после выздоровления и может способствовать возникновению этих состояний.Для оценки состава кишечной микробиоты после выздоровления от COVID-19 было взято 42 образца стула у 27 пациентов (от 13 женщин до 14 мужчин, возраст 45,6 ± 17,6 лет (среднее ± стандартное отклонение)) в течение 30 дней (в среднем 6 дней, IQR 14 дней. ) после того, как их аспираты или мазки из носоглотки дали отрицательный результат на SARS-CoV-2 с помощью RT-qPCR. По сравнению с субъектами, не инфицированными COVID-19, состав кишечной микробиоты 27 выздоровевших пациентов оставался значительно различающимся независимо от того, получали ли они антибиотики (p <0,05, PERMANOVA) (14 получали антибиотики, 13 - нет), хотя состав у пациентов, у которых был получавшие антибиотики были более разными по сравнению с пациентами, не получавшими COVID-19, чем пациенты, которые этого не делали (рисунок 4).Микробиота кишечника выздоровевших пациентов была обогащена видами, включая Bifidobacterium dentium и Lactobacillus ruminis , независимо от того, получали ли они антибиотики и были ли они истощены в E. rectale , R. bromii , F. prausnitzii (p <0,05, LEfSe) (таблица 3; онлайн-дополнительная таблица S6). Чтобы определить, были ли антибиотики связаны с улучшением исходов заболевания у пациентов с COVID-19, мы изучили их использование в когорте умеренных заболеваний, в которой количество пациентов, которые получали / не получали антибиотики, было сопоставимым (21 из 45 пациентов с умеренным заболеванием получали антибиотики. ).Представленность при других болезненных состояниях была менее сбалансированной (таблица 1). Мы не обнаружили разницы в количестве дней от появления симптомов COVID-19 до выписки из больницы с антибиотиками или без них (p> 0,05, тест Манна-Уитни). Кроме того, поскольку не было записей о бактериемии или посевах крови у 45 пациентов и у всех, кроме одного, уровень прокальцитонина во время госпитализации был <0,2 нг / мл, эти результаты показали, что антибиотики вряд ли будут связаны с улучшением результатов лечения пациентов, если предположить, что бактериальных коинфекций нет, но нет. контраст может усугубить и продлить дисбактериоз кишечной микробиоты у пациентов с COVID-19.

Анализ основных компонентов микробиоты кишечника у выздоровевших пациентов с COVID-19, которые получали или не получали антибиотики, по сравнению с субъектами, не инфицированными COVID-19. Пациенты считались выздоровевшими после отрицательных количественных тестов ПЦР с обратной транскрипцией (RT-qPCR) на РНК SARS-CoV-2 в мазках из носоглотки. Закрашенные кружки представляют весь стул, собранный после выписки из больницы, тогда как крестики представляют субъектов, не инфицированных COVID-19.

Виды бактерий, ассоциированные с пациентами с COVID-19 после выздоровления

Обсуждение

Патофизиология инфекции SARS-CoV-2 характеризуется агрессивными воспалительными реакциями, которые в значительной степени являются причиной полиорганной дисфункции, наблюдаемой у некоторых пациентов. и, таким образом, серьезность заболевания, вероятно, связана не только с вирусной инфекцией, но и с иммунными реакциями хозяина.1 21 28–30 Здесь мы показываем, что состав микробиоты кишечника пациентов с COVID-19 во время госпитализации коррелирует с концентрациями в плазме нескольких цитокинов, хемокинов и маркеров воспаления, предполагая, что микробиота кишечника может играть роль в модуляции иммунного ответа хозяина и потенциально влияют на тяжесть заболевания и исходы. В частности, истощение нескольких видов бактерий в когорте COVID-19 было связано с повышенными концентрациями TNF-α, CXCL10, CCL2 и IL-10 в соответствии с иммунологическими исследованиями пациентов с COVID-19,2, указывающими на то, что эти истощенные таксоны могут иметь роль в предотвращении чрезмерно агрессивного воспаления.В подтверждение этого вывода, истощенные кишечные комменсалы, такие как B. adolescentis , F. prausnitzii , E. rectale , R . ( Blautia ) obeum и D. formicigenerans были по отдельности связаны со снижением воспалительной реакции хозяина при других связанных с воспалительными заболеваниях. 24–26 Например, было показано, что F. prausnitzii индуцирует праймирование толстой кишки человека. регуляторные Т-клетки, которые секретируют противовоспалительный цитокин ИЛ-10,31, имеют высокое относительное количество E.rectale в кишечнике связаны с уменьшением воспаления при болезни Альцгеймера 32 и B. adolescentis может подавлять активацию ядерного фактора κB, который способствует экспрессии провоспалительных цитокинов.33 Кроме того, обогащение Ruminococcus gnavus , Ruminococcus Torques , Bacteroides dorei и Bacteroides vulgatus при COVID-19 также согласуется с выводом об опосредованной микробами иммунной дисрегуляции. Р.gnavus и R. крутящие моменты в кишечнике, как сообщается, одновременно возникают с воспалительным заболеванием кишечника, 34 35 и B. dorei и B. vulgatus участвуют в нескольких воспалительных заболеваниях кишечника, таких как заболевание раздраженного кишечника и язвенный колит.36 Однако остается неизвестным, действительно ли ассоциированные с воспалительным процессом кишечные микроорганизмы, обогащенные COVID-19, играют активную роль в заболевании или просто развиваются оппортунистически из-за истощения других кишечных микроорганизмов.

Потенциальная роль кишечных микроорганизмов в COVID-19 может позволить использовать профиль риска на основе микробиома для выявления лиц, подверженных риску тяжелого заболевания или последующих воспалительных симптомов, таких как мультисистемное воспаление и болезнь Кавасаки у детей.4 6 37 По данным нескольких пациентов, опрошенных в этом исследовании в течение 30 дней после излечения от SARS-CoV-2, микробиота кишечника, вероятно, останется значительно измененной после выздоровления от COVID-19. В свете сообщений о том, что часть выздоровевших пациентов с COVID-19 испытывает стойкие симптомы, такие как усталость, одышка и боли в суставах, у некоторых более чем через 80 дней после первоначального появления симптомов 27, 38, 39 мы полагаем, что дисбиотический микробиом кишечника может способствовать иммунной системе. -связанные с проблемами здоровья после COVID-19.Наш короткий период наблюдения не позволяет экстраполировать состав кишечной микробиоты на долгосрочные стойкие симптомы. Таким образом, необходимо более длительное наблюдение за пациентами с COVID-19 (например, от 3 месяцев до 1 года после устранения вируса), чтобы ответить на вопросы, связанные с продолжительностью дисбактериоза кишечной микробиоты после выздоровления, связью между дисбиозом микробиоты и долгосрочным устойчивым заболеванием. симптомы и то, предрасполагает ли дисбактериоз или обогащение / истощение определенных кишечных микроорганизмов выздоровевшим людям к будущим проблемам со здоровьем.

Наше исследование имеет несколько недостатков, в том числе неоднородное клиническое ведение пациентов, которое может искажать микробные сигнатуры, связанные с COVID-19. Для должным образом контролируемого исследования необходима однородная когорта случай-контроль с адекватным представлением в каждой группе тяжести заболевания и минимальной вариабельностью по видам лечения, хотя эти идеалы могут оказаться невозможными в реальном мире. Таким образом, неясно, в какой степени состав кишечной микробиоты в результате COVID-19 зависит от клинического ведения.Более того, наблюдаемый состав микробиоты кишечника может быть просто реакцией на состояние здоровья пациентов и иммунное состояние, а не прямым влиянием на тяжесть заболевания, как таковой, он может не иметь прямого отношения к прогнозированию предрасположенности к заболеванию у субъектов, не страдающих COVID-19. Также необходима осторожность при интерпретации результатов лечения пациентов, связанных с применением антибиотиков. Было подсчитано, что от половины до трех четвертей пациентов с COVID-19 получали антибиотики эмпирически, несмотря на то, что менее 7% имели бактериальные инфекции.40 41 Мы не обнаружили разницы в результатах с антибиотиками или без них, что поддерживает призывы к ограничению использования ненужных антибиотиков при ведении пациентов с COVID-19, но наше сравнение ограничивалось пациентами с умеренным заболеванием, поскольку количество пациентов в этой подгруппе было более сопоставимым. Хотя наши данные свидетельствуют о том, что антибиотики не улучшают исходы лечения пациентов, все же возможно, что более частое применение антибиотиков у тяжелых и критических пациентов может усугубить воспаление.42 Наконец, состав кишечной микробиоты очень неоднороден в разных популяциях людей, и изменения в составе, описанные здесь может не обязательно отражаться на пациентах с COVID-19 из других биогеографий.Тем не менее, это исследование изменений микробиоты кишечника в связи с нарушением иммунной регуляции показало, что кишечные микроорганизмы, вероятно, участвуют в модуляции воспалительных реакций хозяина при COVID-19. Все больше доказательств того, что кишечные микроорганизмы связаны с воспалительными заболеваниями в кишечнике и за его пределами, 12 43 подчеркивают острую необходимость понимания конкретной роли кишечных микроорганизмов в иммунной функции человека и системном воспалении.

Заявления по этике

Согласие пациента на публикацию

Не требуется.

Одобрение этики

Это исследование было одобрено Объединенным комитетом по этике клинических исследований Восточного кластера Китайского университета Гонконга (ссылочный номер 2020.076). Письменное информированное согласие было получено от всех участников до сбора образцов стула.

Благодарности

Мы хотели бы поблагодарить всех медицинских работников, работающих в изоляторах больниц Принца Уэльского и Объединенных христианских больниц, САР Гонконг, Китай. Мы благодарим Miu Ling Chin, Apple CM Yeung, Wendy CS Ho, Rity Wong, Vickie Li, Ida MT Chu и других сотрудников / студентов за их технический вклад в это исследование, включая сбор образцов, инвентаризацию и обработку, а также Hui Zhan, Yating Wan, Нан Чен за помощь в извлечении ДНК.

Разнообразие, распространенность и экспрессия генов цианаз (cynS) в морских планктонных микроорганизмах