Kniga-Online.club
» » » » Миран Липовача - Изучай Haskell во имя добра!

Миран Липовача - Изучай Haskell во имя добра!

Читать бесплатно Миран Липовача - Изучай Haskell во имя добра!. Жанр: Программирование издательство -, год 2004. Так же читаем полные версии (весь текст) онлайн без регистрации и SMS на сайте kniga-online.club или прочесть краткое содержание, предисловие (аннотацию), описание и ознакомиться с отзывами (комментариями) о произведении.
Перейти на страницу:

Другие операции над списками

Что ещё можно делать со списками? Вот несколько основных функций работы с ними.

Функция head принимает список и возвращает его головной элемент. Головной элемент списка – это, собственно, его первый элемент.

ghci> head [5,4,3,2,1]

5

Функция tail принимает список и возвращает его «хвост». Иными словами, эта функция отрезает «голову» списка и возвращает остаток.

ghci> tail [5,4,3,2,1]

[4,3,2,1]

Функция last принимает список и возвращает его последний элемент.

ghci> last [5,4,3,2,1]

1

Функция init принимает список и возвращает всё, кроме его последнего элемента.

ghci> init [5,4,3,2,1]

[5,4,3,2]

Если представить список в виде сороконожки, то с функциями получится примерно такая картина:

Но что будет, если мы попытаемся получить головной элемент пустого списка?

ghci> head []

*** Exception: Prelude.head: empty list

Ну и ну! Всё сломалось!.. Если нет сороконожки, нет и «головы». При использовании функций head, tail, last и init будьте осторожны – не применяйте их в отношении пустых списков. Эту ошибку нельзя отловить на этапе компиляции, так что всегда полезно предотвратить случайные попытки попросить язык Haskell выдать несколько элементов из пустого списка.

Функция length, очевидно, принимает список и возвращает его длину:

ghci> length [5,4,3,2,1]

5

Функция null проверяет, не пуст ли список. Если пуст, функция возвращает True, в противном случае – False. Используйте эту функцию вместо xs == [] (если у вас есть список с именем xs).

ghci> null [1,2,3]

False

ghci> null []

True

Функция reverse обращает список (расставляет его элементы в обратном порядке).

ghci> reverse [5,4,3,2,1]

[1,2,3,4,5]

Функция take принимает число и список. Она извлекает соответствующее числовому параметру количество элементов из начала списка:

ghci> take 3 [5,4,3,2,1]

[5,4,3]

ghci> take 1 [3,9,3]

[3]

ghci> take 5 [1,2]

[1,2]

ghci> take 0 [6,6,6]

[]

Обратите внимание, что если попытаться получить больше элементов, чем есть в списке, функция возвращает весь список. Если мы пытаемся получить 0 элементов, функция возвращает пустой список.

Функция drop работает сходным образом, но отрезает указанное количество элементов с начала списка:

ghci> drop 3 [8,4,2,1,5,6]

[1,5,6]

ghci> drop 0 [1,2,3,4]

[1,2,3,4]

ghci> drop 100 [1,2,3,4]

[]

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

Функция minimum возвращает наименьший элемент.

ghci> minimum [8,4,2,1,5,6]

1

ghci> maximum [1,9,2,3,4]

9

Функция sum принимает список чисел и возвращает их сумму.

Функция product принимает список чисел и возвращает их произведение.

ghci> sum [5,2,1,6,3,2,5,7]

31

ghci> product [6,2,1,2]

24

ghci> product [1,2,5,6,7,9,2,0]

0

Функция elem принимает элемент и список элементов и проверяет, входит ли элемент в список. Обычно эта функция вызывается как инфиксная, поскольку так её проще читать:

ghci> 4 `elem` [3,4,5,6]

True

ghci> 10 `elem` [3,4,5,6]

False

Интервалы

А что если нам нужен список всех чисел от 1 до 20? Конечно, мы могли бы просто набрать их подряд, но, очевидно, это не решение для джентльмена, требующего совершенства от языка программирования. Вместо этого мы будем использовать интервалы. Интервалы – это способ создания списков, являющихся арифметическими последовательностями элементов, которые можно перечислить по порядку: один, два, три, четыре и т. п. Символы тоже могут быть перечислены: например, алфавит – это перечень символов от A до Z. А вот имена перечислить нельзя. (Какое, например, имя будет идти после «Иван»? Лично я понятия не имею!)

Чтобы создать список, содержащий все натуральные числа от 1 до 20, достаточно написать [1..20]. Это эквивалентно полной записи [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20], и единственная разница в том, что записывать каждый элемент списка, как показано во втором варианте, довольно глупо.

ghci> [1..20]

[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]

ghci> ['a'..'z']

"abcdefghijklmnopqrstuvwxyz"

ghci> ['K'..'Z']

"KLMNOPQRSTUVWXYZ"

Интервалы замечательны ещё и тем, что они позволяют указать шаг. Что если мы хотим внести в список все чётные числа от 1 до 20? Или каждое третье число от 1 до 20?

ghci> [2,4..20]

[2,4,6,8,10,12,14,16,18,20]

ghci> [3,6..20]

[3,6,9,12,15,18]

Нужно всего лишь поставить запятую между первыми двумя элементами последовательности и указать верхний предел диапазона. Но, хотя интервалы достаточно «умны», на их сообразительность не всегда следует полагаться. Вы не можете написать [1,2,4,8,16..100] и после этого ожидать, что получите все степени двойки. Во-первых, потому, что при определении интервала можно указать только один шаг. А во-вторых, потому что некоторые последовательности, не являющиеся арифметическими, неоднозначны, если представлены только несколькими первыми элементами.

ПРИМЕЧАНИЕ. Чтобы создать список со всеми числами от 20 до 1 по убыванию, вы не можете просто написать [20..1], а должны написать [20,19..1]. При попытке записать такой интервал без шага (т. е. [20..1]) Haskell начнёт с пустого списка, а затем будет увеличивать начальный элемент на единицу, пока не достигнет или не превзойдёт элемент в конце интервала. Поскольку 20 уже превосходит 1, результат окажется просто пустым списком.

Будьте осторожны при использовании чисел с плавающей точкой в интервалах! Из-за того что они не совсем точны (по определению), их использование в диапазонах может привести к весьма забавным результатам.

ghci> [0.1, 0.3 .. 1]

[0.1,0.3,0.5,0.7,0.8999999999999999,1.0999999999999999]

Мой совет: не используйте такие числа в интервалах!

Интервалы, кроме прочего, можно использовать для создания бесконечных списков, просто не указывая верхний предел. Позже мы рассмотрим этот вариант в подробностях. А сейчас давайте посмотрим, как можно получить список первых 24 чисел, кратных 13. Конечно, вы могли бы написать [13,26..24*13]. Но есть способ получше: take 24 [13,26..]. Поскольку язык Haskell ленив, он не будет пытаться немедленно вычислить бесконечный список, потому что процесс никогда не завершится. Он подождёт, пока вы не захотите получить что-либо из такого списка. Тут-то обнаружится, что вы хотите получить только первые 24 элемента, что и будет исполнено.

Немного функций, производящих бесконечные списки:

• Функция cycle принимает список и зацикливает его в бесконечный. Если вы попробуете отобразить результат, на это уйдёт целая вечность, поэтому вам придётся где-то его обрезать.

ghci> take 10 (cycle [1,2,3])

[1,2,3,1,2,3,1,2,3,1]

ghci> take 12 (cycle "LOL ")

"LOL LOL LOL "

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

ghci> take 10 (repeat 5)

[5,5,5,5,5,5,5,5,5,5]

Однако проще использовать функцию replicate, если вам нужен список из некоторого количества одинаковых элементов. replicate 3 10 вернёт [10,10,10].

Генераторы списков

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

Вот пример простого описания множества. Множество, состоящее из первых десяти чётных чисел, это S = {2 · x | x ∈ N, x ≤ 10}, где выражение перед символом | называется производящей функцией (output function), x – переменная, N – входной набор, а x ≤ 10 – условие выборки. Это означает, что множество содержит удвоенные натуральные числа, которые удовлетворяют условию выборки.

Если бы нам потребовалось написать то же самое на языке Haskell, можно было бы изобрести что-то вроде: take 10 [2,4..]. Но что если мы хотим не просто получить первые десять удвоенных натуральных чисел, а применить к ним некую более сложную функцию? Для этого можно использовать генератор списков. Он очень похож на описание множеств:

Перейти на страницу:

Миран Липовача читать все книги автора по порядку

Миран Липовача - все книги автора в одном месте читать по порядку полные версии на сайте онлайн библиотеки kniga-online.club.


Изучай Haskell во имя добра! отзывы

Отзывы читателей о книге Изучай Haskell во имя добра!, автор: Миран Липовача. Читайте комментарии и мнения людей о произведении.


Уважаемые читатели и просто посетители нашей библиотеки! Просим Вас придерживаться определенных правил при комментировании литературных произведений.

  • 1. Просьба отказаться от дискриминационных высказываний. Мы защищаем право наших читателей свободно выражать свою точку зрения. Вместе с тем мы не терпим агрессии. На сайте запрещено оставлять комментарий, который содержит унизительные высказывания или призывы к насилию по отношению к отдельным лицам или группам людей на основании их расы, этнического происхождения, вероисповедания, недееспособности, пола, возраста, статуса ветерана, касты или сексуальной ориентации.
  • 2. Просьба отказаться от оскорблений, угроз и запугиваний.
  • 3. Просьба отказаться от нецензурной лексики.
  • 4. Просьба вести себя максимально корректно как по отношению к авторам, так и по отношению к другим читателям и их комментариям.

Надеемся на Ваше понимание и благоразумие. С уважением, администратор kniga-online.


Прокомментировать
Подтвердите что вы не робот:*
Подтвердите что вы не робот:*