22 полезных примера кода на Python
Python — один из самых популярных языков программирования, чрезвычайно полезный и в решении повседневных задач. В этой статье я вкратце расскажу о 22 полезных примерах кода, позволяющих воспользоваться мощью Python.
Некоторые из примеров вы могли уже видеть ранее, а другие будут новыми и интересными для вас. Все эти примеры легко запоминаются.
1. Получаем гласные
Этот пример возвращает в строке найденные гласные "a e i o u" . Это может оказаться полезным при поиске или обнаружении гласных.
2. Первая буква в верхнем регистре
Этот пример используется для превращения каждой первой буквы символов строки в прописную букву. Он работает со строкой из одного или нескольких символов и будет полезен при анализе текста или записи данных в файл и т.п.
3. Печать строки N раз
Этот пример может печатать любую строку n раз без использования циклов Python.
4. Объединяем два словаря
Этот пример выполняет слияние двух словарей в один.
5. Вычисляем время выполнения
Этот пример полезен, когда вам нужно знать, сколько времени требуется для выполнения программы или функции.
6. Обмен значений между переменными
Это быстрый способ обменять местами две переменные без использования третьей.
7. Проверка дубликатов
Это самый быстрый способ проверки наличия повторяющихся значений в списке.
8. Фильтрация значений False
Этот пример используется для устранения всех ложных значений из списка, например false, 0, None, " " .
9. Размер в байтах
Этот пример возвращает длину строки в байтах, что удобно, когда вам нужно знать размер строковой переменной.
10. Занятая память
Пример позволяет получить объём памяти, используемой любой переменной в Python.
11. Анаграммы
Этот код полезен для проверки того, является ли строка анаграммой. Анаграмма — это слово, полученное перестановкой букв другого слова.
12. Сортировка списка
Этот пример сортирует список. Сортировка — это часто используемая задача, которую можно реализовать множеством строк кода с циклом, но можно ускорить свою работу при помощи встроенного метода сортировки.
13. Сортировка словаря
14. Получение последнего элемента списка
15. Преобразование разделённого запятыми списка в строку
Этот код преобразует разделённый запятыми список в единую строку. Его удобно использовать, когда нужно объединить весь список со строкой.
16. Проверка палиндромов
Этот пример показывает, как быстро проверить наличие палиндромов.
17. Перемешивание списка
18. Преобразование строки в нижний и верхний регистры
19. Форматирование строки
Этот код позволяет форматировать строку. Под форматированием в Python подразумевается присоединение к строке данных из переменных.
20. Поиск подстроки
Этот пример будет полезен для поиска подстроки в строке. Я реализую его двумя способами, позволяющими не писать много кода.
21. Печать в одной строке
Мы знаем, что функция print выполняет вывод в каждой строке, и если использовать две функции print, они выполнят печать в две строки. Этот пример покажет, как выполнять вывод в той же строке без перехода на новую.
22. Разбиение на фрагменты
Этот пример покажет, как разбить список на фрагменты и разделить его на меньшие части.
На правах рекламы
Серверы для разработчиков — выбор среди обширного списка предустановленных операционных систем, возможность использовать собственный ISO для установки ОС, огромный выбор тарифных планов и возможность создать собственную конфигурацию в пару кликов, активация любого сервера в течение минуты. Обязательно попробуйте!
Списки в Python
Привет всем! В прошлой записи мы познакомились с основными типами данных. И сегодня более подробно мы рассмотрим списки в Python.
В целом списки можно представить как некую упорядоченную коллекцию объектов, типы которых не имеют значения. В качестве самого простого списка можно представить любое слово. Например — слово «Пример». Для обозначения списка используются квадратные скобки [], после чего идет само тело списка:
Более подробно код можно расписать так:
list = [‘Пример’] — list — название списка, [] — обозначение списка, ‘Пример’ — содержимое списка
list2 = [1, 2] — list2 — название списка, [] — обозначение списка, 1, 2 — содержимое списка
print (list) — вывод списка list на экран
print (list2) — вывод списка list2 на экран
Список можно создавать и программным методом. Для этого используется цикл внутри квадратных скобок. Пример кода выглядит так:
где:
list = [ i*2 for i in range(1,10)] — созданный список list, заполненный с помощью цикла i*2 for i in range(1,10)]. i — итератор, умноженный на два для позиции i в промежутке от 1 до 10 (используется функция range(). Чаще всего она используется в циклах for. Сама функция может принимать от одного до трех аргументов, но аргументы могут быть только целыми числами)
print (list) — вывод сформированного списка
Понятное дело — созданный список нужно как-то обработать. А значит — пора познакомиться с основными функциями и методами списков.
Важно: все описанные ниже методы списков в отличии методов, имеющих отношение к строкам (подробнее тут) — изменяют сам список, а значит — результат исполнения не нужно записывать в переменную, привязанную к списку.
Для начала — попробуем вывести каждый элемент списка на отдельной строке. Для этого используем цикл в виде: for x in list, где x — итератор, list — название списка:
Более подробно код выглядит следующим образом:
list = [1, 2, 3, 4, 5] — сам список
for x in list: — цикл итерации по списку
print (x) — вывод элемента на экран
list.append(x) — добавление элемента х в конец списка list. На практике код выглядит следующим образом:
а если рассмотреть его более подробно, то:
list = [1, 2, 4] — сам список
print(list) — вывод списка на экран
list.append(5) — подключаем метод append и таким образом добавляем в список list (название списка) число 5. Важно: метод append добавляет в конец списка
print(list) — выводим список list на экран. Как видим — в конце появилось число 5
list.extend(list2) — добавляет в конец списка list все элементы списка list2. Сам пример рабочего кода — ниже:
Аналогично с предыдущим кодом, давайте разберем этот:
list = [1, 2, 3] — список 1
list2 = [4, 5, 6] — список 2
print(list) — вывод на экран списка 1
print(list2) — вывод на экран списка 2
list.extend(list2) — подключаем метод добавления данных из списка 2 в конец списка 1
print(list) — выводим содержимое списка 1. Как видим — в конце появились данные из списка 2
list.insert(i, x) — данный метод позволяет поставить на позицию i значение x. В виде кода это можно представить следующим образом:
где:
list = [1, 2, 4] — список list
print(list) — выводим список на экран
list.insert(2, 3) — подключаем метод insert, который добавляет на позицию 2 значение 3. Тут важно помнить, что отсчет в Python начинается с нуля).
print(list) — выводим на экран список list.
list.remove(x) — удаление первого элемента в списке, значение которого равно x. Важно знать что если такого элемента в списке не будет — получим ValueError:
list.pop([i]) — удаление элемента на позиции i и его возврат. Если i не указано — удаляем последний элемент:
Тут рассмотрим код подробнее:
list = [1, 2, 3, 4, 5] — сам список
print (list) — вывели список на экран
list.pop() — удалили последний элемент в списке (ведь индекс не указан!)
print (list) — распечатали список. Как видно — последний элемент и правда удален.
list.pop(2) — удаляем второй элемент в списке.
print (list) — распечатываем список. И правда — удален второй элемент.
list.index(x) — вывод номера позиции в списке элемента x:
list.count(x) — возврат количества элементов списка со значением x:
Как видно из кода:
list = [‘яблоко’, ‘абрикос’, ‘груша’] — имеется список из трех элементов
print (list) — выводим на экран список
print (list.count(‘яблоко’)) — подключаем функцию подсчета количества элементов в списке. Как видно — яблоко в списке встречается только раз.
list.sort([key=функция]) — сортировка списка на основе требуемой функции
list.reverse() — метод, позволяющий развернуть список:
list.copy() — метод создания поверхностной копии списка:
list.clear() — метод для очистки списка. Был себе список с данными, а потом оп-па… и данных нет. Но список есть:
Самое удивительное — а как удалить значение из списка я указать-то и забыл �� Восполняю пробел:
del list[0], где 0 — удаляемая позиция в списке ��
Списки, кортежи и словари
Для работы с наборами данных Python предоставляет такие встроенные типы как списки, кортежи и словари.
Список (list) представляет тип данных, который хранит набор или последовательность элементов. Во многих языках программирования есть аналогичная структура данных, которая называется массив.
Создание списка
Для создания списка применяются квадратные скобки [] , внутри которых через запятую перечисляются элементы списка. Например, определим список чисел:
Подобным образом можно определять списки с данными других типов, например, определим список строк:
Также для создания списка можно использовать функцию-конструктор list() :
Оба этих определения списка аналогичны — они создают пустой список.
Список необязательно должен содержать только однотипные объекты. Мы можем поместить в один и тот же список одновременно строки, числа, объекты других типов данных:
Для проверки элементов списка можно использовать стандартную функцию print, которая выводит содержимое списка в удобочитаемом виде:
Конструктор list может принимать набор значений, на основе которых создается список:
Если необходимо создать список, в котором повторяется одно и то же значение несколько раз, то можно использовать символ звездочки *, то есть фактически применить операцию умножения к уже существующему списку:
Обращение к элементам списка
Для обращения к элементам списка надо использовать индексы, которые представляют номер элемента в списка. Индексы начинаются с нуля. То есть первый элемент будет иметь индекс 0, второй элемент — индекс 1 и так далее. Для обращения к элементам с конца можно использовать отрицательные индексы, начиная с -1. То есть у последнего элемента будет индекс -1, у предпоследнего — -2 и так далее.
Для изменения элемента списка достаточно присвоить ему новое значение:
Разложение списка
Python позволяет разложить список на отдельные элементы:
В данном случае переменным tom, bob и sam последовательно присваиваются элементы из списка people. Однако следует учитывать, что количество переменных должно быть равно числу элементов присваиваемого списка.
Перебор элементов
Для перебора элементов можно использовать как цикл for, так и цикл while.
Перебор с помощью цикла for :
Здесь будет производиться перебор списка people, и каждый его элемент будет помещаться в переменную person.
Перебор также можно сделать с помощью цикла while :
Для перебора с помощью функции len() получаем длину списка. С помощью счетчика i выводит по элементу, пока значение счетчика не станет равно длине списка.
Сравнение списков
Два списка считаются равными, если они содержат один и тот же набор элементов:
В данном случае оба списка будут равны.
Получение части списка
Если необходимо получить какую-то определенную часть списка, то мы можем применять специальный синтаксис, который может принимать следующие формы:
list[:end] : через параметр end передается индекс элемента, до которого нужно копировать список
list[start:end] : параметр start указывает на индекс элемента, начиная с которого надо скопировать элементы
list[start:end:step] : параметр step указывает на шаг, через который будут копироваться элементы из списка. По умолчанию этот параметр равен 1.
Можно использовать отрицательные индексы, тогда отсчет будет идти с конца, например, -1 — предпоследний, -2 — третий сконца и так далее.
Методы и функции по работе со списками
Для управления элементами списки имеют целый ряд методов. Некоторые из них:
append(item) : добавляет элемент item в конец списка
insert(index, item) : добавляет элемент item в список по индексу index
extend(items) : добавляет набор элементов items в конец списка
remove(item) : удаляет элемент item. Удаляется только первое вхождение элемента. Если элемент не найден, генерирует исключение ValueError
clear() : удаление всех элементов из списка
index(item) : возвращает индекс элемента item. Если элемент не найден, генерирует исключение ValueError
pop([index]) : удаляет и возвращает элемент по индексу index. Если индекс не передан, то просто удаляет последний элемент.
count(item) : возвращает количество вхождений элемента item в список
sort([key]) : сортирует элементы. По умолчанию сортирует по возрастанию. Но с помощью параметра key мы можем передать функцию сортировки.
reverse() : расставляет все элементы в списке в обратном порядке
copy() : копирует список
Кроме того, Python предоставляет ряд встроенных функций для работы со списками:
len(list) : возвращает длину списка
sorted(list, [key]) : возвращает отсортированный список
min(list) : возвращает наименьший элемент списка
max(list) : возвращает наибольший элемент списка
Добавление и удаление элементов
Для добавления элемента применяются методы append() , extend и insert , а для удаления — методы remove() , pop() и clear() .
Проверка наличия элемента
Если определенный элемент не найден, то методы remove и index генерируют исключение. Чтобы избежать подобной ситуации, перед операцией с элементом можно проверять его наличие с помощью ключевого слова in :
Выражение if «Alice» in people возвращает True, если элемент «Alice» имеется в списке people. Поэтому конструкция if «Alice» in people может выполнить последующий блок инструкций в зависимости от наличия элемента в списке.
Удаление с помощью del
Python также поддерживает еще один способ удаления элементов списка — с помощью оператора del . В качестве параметра этому оператору передается удаляемый элемент или набор элементов:
Подсчет вхождений
Если необходимо узнать, сколько раз в списке присутствует тот или иной элемент, то можно применить метод count() :
Сортировка
Для сортировки по возрастанию применяется метод sort() :
Если необходимо отсортировать данные в обратном порядке, то мы можем после сортировки применить метод reverse() :
При сортировке фактически сравниваются два объекта, и который из них «меньше», ставится перед тем, который «больше». Понятия «больше» и «меньше» довольно условны. И если для чисел все просто — числа расставляются в порядке возрастания, то для строк и других объектов ситуация сложнее. В частности, строки оцениваются по первым символам. Если первые символы равны, оцениваются вторые символы и так далее. При чем цифровой символ считается «меньше», чем алфавитный заглавный символ, а заглавный символ считается меньше, чем строчный.
Таким образом, если в списке сочетаются строки с верхним и нижним регистром, то мы можем получить не совсем корректные результаты, так как для нас строка «bob» должна стоять до строки «Tom». И чтобы изменить стандартное поведение сортировки, мы можем передать в метод sort() в качестве параметра функцию:
Кроме метода sort мы можем использовать встроенную функцию sorted , которая имеет две формы:
sorted(list) : сортирует список list
sorted(list, key) : сортирует список list, применяя к элементам функцию key
При использовании этой функции следует учитывать, что эта функция не изменяет сортируемый список, а все отсортированные элементы она помещает в новый список, который возвращается в качестве результата.
Минимальное и максимальное значения
Встроенный функции Python min() и max() позволяют найти минимальное и максимальное значения соответственно:
Копирование списков
При копировании списков следует учитывать, что списки представляют изменяемый (mutable) тип, поэтому если обе переменных будут указывать на один и тот же список, то изменение одной переменной, затронет и другую переменную:
Это так называемое «поверхностное копирование» (shallow copy). И, как правило, такое поведение нежелательное. И чтобы происходило копирование элементов, но при этом переменные указывали на разные списки, необходимо выполнить глубокое копирование (deep copy). Для этого можно использовать метод copy() :
Соединение списков
Для объединения списков применяется операция сложения (+):
Списки списков
Списки кроме стандартных данных типа строк, чисел, также могут содержать другие списки. Подобные списки можно ассоциировать с таблицами, где вложенные списки выполняют роль строк. Например:
Чтобы обратиться к элементу вложенного списка, необходимо использовать пару индексов: people[0][1] — обращение ко второму элементу первого вложенного списка.
Добавление, удаление и изменение общего списка, а также вложенных списков аналогично тому, как это делается с обычными (одномерными) списками:
8. Списки¶
Список (англ.: list) есть упорядоченный набор значений, где каждое значение доступно по индексу. Значения, входящие в список, называются элементами.
Списки похожи на строки, так как строки тоже являются упорядоченными наборами элементов — символов. Но в отличие от строк, элементы списка могут быть любых типов. Списки и строки, а также другие типы, являющиеся упорядоченными наборами, называются последовательностями.
8.2. Списочные значения¶
Есть несколько способов создать новый список, простейший из них — заключить элементы в квадратные скобки, [ и ] :
В первом примере у нас список из четырех целых чисел. Во втором — список из трех строк. Элементы списка не обязательно относятся к одному типу. Следующий список содержит строку, число с плавающей точкой, целое число и. еще один список:
Список внутри другого списка называют вложенным.
Наконец, список может вовсе не содержать элементов. Такой список называют пустым и обозначают [] .
В логическом выражении пустой список, так же, как 0 или пустая строка, считается ложью:
Мы можем присваивать списочные значения переменным и передавать списки в качестве аргументов при вызове функций:
8.3. Доступ к элементам¶
Для доступа к элементам списка используется тот же оператор [] , что и для доступа к символам строки. Выражение в квадратных скобках задает индекс. Не забывайте, что индексы начинаются с 0:
В качестве индекса можно использовать любое целочисленное выражение:
Если попытаться получить доступ к несуществующему элементу, то получим ошибку выполнения:
Если индекс отрицательный, то счет идет от конца списка:
Выражение numbers[-1] дает последний элемент списка, numbers[-2] — второй от конца, а элемента numbers[-3] не существует.
Часто в качестве индекса используется переменная цикла.
Этот цикл while считает от 0 до 4. Когда переменная цикла i становится равна 4, условие становится ложным и цикл завершается. Таким образом, тело цикла выполняется для i со значениями 0, 1, 2 и 3.
В каждой итерации переменная i используется как индекс для списка, чтобы вывести i -тый элемент. Этот прием называется обход списка.
8.4. Длина списка¶
Функция len возвращает длину списка, то есть, количество элементов в списке. В качестве верхней границы в цикле удобно использовать возвращаемое этой функцией значение, а не константу. При этом, если размер списка изменится, вам не придется просматривать программу и вносить изменения во все циклы, работающие с этим списком; они будут работать корректно со списком любого размера:
В последней итерации i равно len(horsemen) - 1 , то есть, индексу последнего элемента списка. Когда i становится равным len(horsemen) , условие цикла становится ложным и тело цикла не выполняется. И это правильно, поскольку len(horsemen) недопустимый для данного списка индекс.
Хотя список может содержать другой список, вложенный список считается одним элементом. Длина этого списка равна 4:
8.5. Проверка вхождения в список¶
Оператор in проверяет вхождение элемента в последовательность и дает в результате логическое значение. Мы уже использовали его со строками, но он также работает со списками и другими последовательностями:
Поскольку ‘pestilence’ входит в список horsemen , то оператор in возвращает True . Поскольку ‘debauchery’ не входит в список, in возвращает False .
Используя not вместе с in , можно проверить, что элемент не является элементом списка:
8.6. Операции над списками¶
Оператор + конкатенирует списки:
Оператор * повторяет элементы списка заданное число раз:
В первом примере 0 повторяется четыре раза. Во втором три раза повторяются элементы 1, 2, 3 .
8.7. Срезы списков¶
Мы выполняли срезы строк, но срезы также работают для списков:
8.8. Функция range ¶
В программировании часто требуются списки последовательных целых чисел, и Python предоставляет простой способ для их создания:
Функция range принимает два аргумента и возвращает список целых, начиная от числа, заданного первым аргументом, и до числа, заданного вторым аргументом, не включая последнее.
Можно вызывать range и по-другому. При вызове с единственным аргументом функция возвращает список, начинающийся с 0:
Третий аргумент, если он указан, задает шаг между соседними значениями в списке. Получим список чисел от 1 до 10 с шагом 2:
Если шаг задан отрицательным числом, то начальное число должно быть больше конечного:
Иначе результатом будет пустой список:
8.9. Списки изменяемы¶
В отличие от строк, списки изменяемы. Это означает, мы можем изменять их элементы. Используя оператор [] в левой части присваивания, можно избирательно обновить один из элементов:
Оператор [] может использоваться со списком в любом месте выражения. Если он появляется слева от оператора присваивания, он изменяет элемент списка. В приведенном примере первый элемент списка fruit изменяется с 'banana' на 'pear' , а последний — с 'quince' на 'orange' . Присваивание отдельному элементу не работает для строк:
Но работает для списков:
Используя срез, можно изменить несколько элементов сразу:
Можно также удалить элементы из списка, присвоив им пустой список:
А можно добавить элементы в список, втиснув их в пустой срез в нужном месте:
8.10. Удаление списка¶
Удаление элементов с помощью присваивания срезов довольно вычурно, и потому чревато ошибками. Python предлагает альтернативный способ, более легкий для чтения и понимания, и, к тому же, более универсальный.
del удаляет элемент из списка:
Как и следовало ожидать, del работает с отрицательными индексами, и генерирует ошибку выполнения, если заданный индекс выходит за границы разрешенного диапазона.
С del можно использовать срез:
8.11. Объекты и значения¶
Выполним предложения присваивания:
Теперь мы знаем, что и a и b указывают на строку "banana" . Но мы не можем сказать, указывают ли они на одну и ту же строку.
Есть два варианта:
В первом случае a и b указывают на два разных объекта с одинаковыми значениями. Во втором случае они ссылаются на один и тот же объект. Объект — это что-то, с чем может быть связано имя переменной.
У каждого объекта имеется уникальный идентификатор, который можно получить с помощью функции id . Отобразив идентификаторы объектов, на которые указывают a и b , мы узнаем, связаны ли эти переменные с одним и тем же объектом:
Мы два раза получили один и тот же идентификатор, а это значит, что Python создал только одну строку, и обе переменные, a и b , связаны с ней. Вы, вероятно, получите другое значение идентификатора.
Интересно, что списки ведут себя иначе. Если создать два списка, то мы получим два объекта:
На диаграмме это выглядит так:
Переменные a и b ссылаются на разные объекты, имеющие одинаковые значения.
8.12. Альтернативные имена¶
Поскольку переменные ссылаются на объекты, то, если мы присвоим одну переменную другой, обе переменные будут ссылаться на один и тот же объект:
На диаграмме это выглядит так:
Поскольку два разных имени, a и b , связаны с одним и тем же списком, будем называть их альтернативными именами. Изменения, сделанные с использованием одного имени, оказывают влияние и на другое:
Хотя такое поведение может быть полезным, иногда оно оказывается нежелательным. Вообще говоря, лучше избегать альтернативных имен, работая с изменяемыми объектами. А вот для неизменяемых объектов альтернативные имена не представляют никаких проблем. Поэтому Python создает альтернативные имена для строк, когда представляется случай сэкономить память компьютера.
8.13. Клонирование списков¶
Если нужно изменить список и при этом сохранить копию оригинального списка, то понадобится сделать копию самого списка, а не ссылки на него. Этот процесс иногда называют клонированием.
Простейший способ клонировать список — воспользоваться оператором среза:
Получение любого среза списка a приводит к созданию нового списка. В данном случае срез включает весь список.
Теперь можно изменять список b , не беспокоясь об a :
8.14. Списки и циклы for ¶
Цикл for также работает со списками. Синтаксис такой:
Это предложение эквивалентно следующему фрагменту кода:
Цикл for более лаконичен, поскольку мы можем обойтись без переменной цикла i . Вот рассмотренный выше цикл, переписанный с помощью for .
Он читается почти по-английски: для (каждого) horseman (англ.: всадник) в (списке) horsemen (англ.: всадники) напечатать horseman.
Любое списочное выражение может быть использовано в цикле for :
В первом примере выводятся все числа, кратные 3, между 0 и 19. Во втором примере выражается энтузиазм по поводу разных видов фруктов.
Поскольку списки изменяемы, часто выполняется обход списка с изменением каждого из его элементов. Следующий пример возводит в квадрат все числа в списке от 1 до 5 :
Подумайте над выражением range(len(numbers)) и разберитесь, как оно работает. В данном случае нам нужно как значение, так и индекс элемента списка для того, чтобы мы могли присвоить ему новое значение.
Такой прием довольно распространен в программировании, поэтому Python предлагает более красивый способ реализовать его:
Здесь функция enumerate в каждой итерации возвращает очередной индекс и связанное с ним значение. Еще один пример того, как работает enumerate :
8.15. Списочные параметры¶
При передаче списка в качестве аргумента передается ссылка на список, а не его копия. А поскольку списки изменяемы, то изменение параметра внутри функции означает также и изменение аргумента. Например, функция ниже принимает список в качестве аргумента и умножает каждый элемент списка на 2:
Если поместить функцию double_stuff в файл ch08.py , то сможем так протестировать ее:
Параметр a_list и переменная things являются альтернативными именами одного и того же объекта.
Если функция модифицирует списочный параметр, изменения будут видны в вызывающем коде.
8.16. Чистые и модифицирующие функции¶
Функции, которые принимают списки как аргументы и изменяют эти списки в ходе выполнения, называются модифицирующими, а изменения, которые они делают, называются побочным эффектом.
Чистая функция не производит побочных эффектов. Все ее связи с вызывающей программой сводятся к параметрам, которых она не изменяет, и возвращаемому значению. Вот чистая функция double_stuff :
Эта версия double_stuff не изменяет своих аргументов:
При использовании чистой функции double_stuff , для изменения things вам понадобится присвоить возвращаемое значение things :
8.17. Какая функция лучше?¶
Все, что можно сделать с помощью модифицирующих функций, может быть сделано и при помощи чистых функций. На самом деле, некоторые языки программирования поддерживают только чистые функции. Есть мнение, что программы, использующие только чистые функции, быстрее разрабатывать и в них закрадывается меньше ошибок. И все же, иногда модифицирующие функции удобны, а в отдельных случаях программы с чистыми функциями менее эффективны.
Вообще, мы рекомендуем писать чистые функции всегда, когда это разумно, и прибегать к модифицирующим только в случаях, когда их использование дает несомненное преимущество.
8.18. Вложенные списки¶
Вложенный список — это список, являющийся элементом другого списка. В следующем списке элемент с индексом 3 есть вложенный список:
Если ввести nested[3] , то получим [10, 20] . Извлечь элемент из вложенного списка можно за два шага:
А можно объединить эти два шага в выражение:
Оператор квадратная скобка вычисляется слева направо, так что это выражение берет 3-й элемент списка nested и извлекает из него 1-ый элемент.
8.19. Матрицы¶
Вложенные списки часто используют для того, чтобы представлять матрицы. Например, матрицу
можно представить так:
matrix есть список из трех элементов, в котором каждый элемент задает строку матрицы. Можно получить целую строку матрицы, как обычно:
Также можно извлечь отдельный элемент матрицы, используя два индекса:
Первый индекс выбирает строку, а второй — столбец. Хотя этот способ представления матриц самый распространенный, он не является единственным. Его вариацией является список столбцов вместо списка строк. Позднее мы увидим более радикальную альтернативу, использующую словарь.
8.20. Разработка через тестирование¶
Разработка через тестирование (англ.: Test-driven development, TDD) — это практика разработки программ, в которой программа создается серией небольших итераций, в каждой из которых сначала пишутся автоматические тесты, а затем код, реализующий тестируемую функциональность. От итерации к итерации растет реализованная и оттестированная функциональность.
Продемонстрируем разработку через тестирование с помощью доктестов. Скажем, нам нужна функция, которая создает матрицу с rows строк и columns столбцов, принимая аргументы для rows и columns .
Сначала подготовим тест для этой функции в файле matrices.py :
Выполнив скрипт, видим, что тест не прошел:
Тест не проходит, поскольку тело функции не содержит ничего, кроме строки в тройных кавычках, и поэтому возвращает None . Наш тест требует, чтобы функция возвращала матрицу 3 x 5, заполненную нулями.
Правила разработки через тестирование говорят, что для начала нужно написать самый простой вариант, который бы удовлетворял тест. Так что, в этом случае, просто вернем ожидаемый результат:
Теперь при выполнении скрипта тест успешно проходит, но наша реализация make_matrix всегда возвращает один и тот же результат, а это явно не то, что имелось в виду. В качестве мотивации дальнейших улучшений добавим тест:
Как и следовало ожидать, тест не проходит:
Этот процесс называется разработкой через тестирование, потому что код пишется только тогда, когда имеется тест, который не проходит. Мотивированные последним тестом, теперь напишем более общее решение:
Это решение, похоже, работает, поскольку тесты проходят. Однако, начав пользоваться новой функцией, быстро обнаружим баг:
Мы хотели присвоить значение 7 элементу во второй строке и третьем столбце, но, вместо этого, значение 7 получили все элементы третьего столбца!
По размышлении становится ясно, что в нашем текущем решении каждая строка матрицы — всего лишь ссылка на один и тот же список. Это определенно не то, что нам нужно. Приступая к исправлению бага, сначала напишем тест, демонстрирующий наличие этого бага:
Теперь, имея тест, который демонстрирует баг в программе, мы должны найти лучшее решение:
Процесс разработки через тестирование имеет ряд преимуществ. Этот процесс:
- заставляет конкретно думать о задаче, которую нужно решить, прежде чем пытаться ее решить,
- поощряет разбивать сложные задачи на более мелкие и простые, и пошагово приближаться к решению задачи в целом,
- дает набор автоматических тестов для программы, облегчая внесение в нее изменений и дополнений в дальнейшем.
8.21. Строки и списки¶
В Python есть функция list , которая принимает значение некоторой последовательности как аргумент и создает список из ее элементов.
Также существует функция str , которая берет любое значение Python как аргумент и возвращает его строковое представление.
Как видно из последнего примера, с помощью str не удается соединить вместе элементы списка символов. Это можно сделать с помощью функции join из модуля string :
Две очень полезные функции модуля string имеют дело со списками строк. Функция split разбивает строку на слова, возвращая список слов. По умолчанию считается, что слова отделяются друг от друга одним или более пробельными символами:
Необязательный аргумент позволяет указать, какие символы считать разделителями слов. В следующем примере в качестве разделителя указана последовательность двух символов ai :
Заметьте, что ai не попадает в список.
Функция string.join делает обратное функции string.split . Она принимает два аргумента: список строк и разделитель, который будет разделять элементы списка в результирующей строке.
8.22. Глоссарий¶
8.23. Упражнения¶
Напишите цикл, который обходит список
и выводит длину каждого элемента. Что происходит, когда вы передаете целое число функции len ? Замените 1 на 'one' и выполните вашу программу снова.
Создайте файл ch08e02.py следующего содержания:
Добавляйте следующие наборы доктестов в докстроку в начале файла и пишите код Python, который обеспечит прохождение доктестов. Добавляйте по одному набору доктестов за один раз.