Python модули: Модуль os.path | Python 3 для начинающих и чайников

Модуль unittest: тестируем свои программы

Представьте, что вы написали какую-либо программу, а теперь хотите проверить, правильно ли она работает. Что вы для этого сделаете? Скорее всего, вы запустите её несколько раз с различными входными данными, и убедитесь в правильности выдаваемого ответа.

А теперь вы что-то поменяли и снова хотите проверить корректность программы. Запускать ещё несколько раз? А если потом снова что-то поменяется? Нельзя ли как-то автоматизировать это дело?

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

Для автоматизации тестов, unittest поддерживает некоторые важные концепции:

• Испытательный стенд (test fixture) — выполняется подготовка, необходимая для выполнения тестов и все необходимые действия для очистки после выполнения тестов. Это может включать, например, создание временных баз данных или запуск серверного процесса.
• Тестовый случай (test case) — минимальный блок тестирования. Он проверяет ответы для разных наборов данных. Модуль unittest предоставляет базовый класс TestCase, который можно использовать для создания новых тестовых случаев.
• Набор тестов (test suite) — несколько тестовых случаев, наборов тестов или и того и другого. Он используется для объединения тестов, которые должны быть выполнены вместе.
• Исполнитель тестов (test runner) — компонент, который управляет выполнением тестов и предоставляет пользователю результат. Исполнитель может использовать графический или текстовый интерфейс или возвращать специальное значение, которое сообщает о результатах выполнения тестов.

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

Вот короткий скрипт для тестирования трех методов строк:

import unittest
class TestStringMethods(unittest.TestCase):
  def test_upper(self):
      self.assertEqual('foo'.upper(), 'FOO')
  def test_isupper(self):
      self.assertTrue('FOO'.isupper())
      self.assertFalse('Foo'.isupper())
  def test_split(self):
      s = 'hello world'
      self.assertEqual(s.split(), ['hello', 'world'])
      # Проверим, что s.split не работает, если разделитель - не строка
      with self.assertRaises(TypeError):
          s.split(2)
if __name__ == '__main__':
    unittest.main()

Тестовый случай создаётся путём наследования от unittest.TestCase. 3 отдельных теста определяются с помощью методов, имя которых начинается на test. Это соглашение говорит исполнителю тестов о том, какие методы являются тестами.

Суть каждого теста — вызов assertEqual() для проверки ожидаемого результата; assertTrue() или assertFalse() для проверки условия; assertRaises() для проверки, что метод порождает исключение.

Эти методы используются вместо обычного assert для того, чтобы исполнитель тестов смог взять все результаты и оформить отчёт.

Методы setUp() и tearDown() (которые в данном простом случае не нужны) позволяют определять инструкции, выполняемые перед и после каждого теста, соответственно.

Последние 2 строки показывают простой способ запуска тестов. unittest.main() предоставляет интерфейс командной строки для тестирования программы. Будучи запущенным из командной строки, этот скрипт выводит отчёт, подобный этому:

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s
OK

Интерфейс командной строки

unittest может быть использован из командной строки для запуска модулей с тестами, классов или даже отдельных методов:

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

Можно также указывать путь к файлу:

python -m unittest tests/test_something. py

С помощью флага -v можно получить более детальный отчёт:

python -m unittest -v test_module

Для нашего примера подробный отчёт будет таким:

test_isupper (__main__.TestStringMethods) ... ok
test_split (__main__.TestStringMethods) ... ok
test_upper (__main__.TestStringMethods) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.001s
OK

-b (—buffer) — вывод программы при провале теста будет показан, а не скрыт, как обычно.

-c (—catch) — Ctrl+C во время выполнения теста ожидает завершения текущего теста и затем сообщает результаты на данный момент. Второе нажатие Ctrl+C вызывает обычное исключение KeyboardInterrupt.

-f (—failfast) — выход после первого же неудачного теста.

—locals (начиная с Python 3.5) — показывать локальные переменные для провалившихся тестов.

Обнаружение тестов

unittest поддерживает простое обнаружение тестов. Для совместимости с обнаружением тестов, все файлы тестов должны быть модулями или пакетами, импортируемыми из директории верхнего уровня проекта (см. подробнее о правилах наименования модулей ).

Обнаружение тестов реализовано в TestLoader.discover(), но может быть использовано из командной строки:

cd project_directory
python -m unittest discover

-v (—verbose) — подробный вывод.

-s (—start-directory) directory_name — директория начала обнаружения тестов (текущая по умолчанию).

-p (—pattern) pattern — шаблон названия файлов с тестами (по умолчанию test*.py).

-t (—top-level-directory) directory_name — директория верхнего уровня проекта (по умолчанию равна start-directory).

Организация тестового кода

Базовые блоки тестирования это тестовые случаи — простые случаи, которые должны быть проверены на корректность.

Тестовый случай создаётся путём наследования от unittest.TestCase.

Тестирующий код должен быть самостоятельным, то есть никак не зависеть от других тестов.

Простейший подкласс TestCase может просто реализовывать тестовый метод (метод, начинающийся с test). Вымышленный пример:

import unittest
class DefaultWidgetSizeTestCase(unittest.TestCase):
    def test_default_widget_size(self):
        widget = Widget('The widget')
        self.assertEqual(widget.size(), (50, 50))

Заметьте, что для того, чтобы проверить что-то, мы используем один из assert\*() методов.

Тестов может быть много, и часть кода настройки может повторяться. К счастью, мы можем определить код настройки путём реализации метода setUp(), который будет запускаться

перед каждым тестом:

import unittest
class SimpleWidgetTestCase(unittest.TestCase):
    def setUp(self):
        self.widget = Widget('The widget')
    def test_default_widget_size(self):
        self.assertEqual(self.widget.size(), (50,50),
                         'incorrect default size')
    def test_widget_resize(self):
        self.widget.resize(100,150)
        self.assertEqual(self.widget.size(), (100,150),
                         'wrong size after resize')

Мы также можем определить метод tearDown(), который будет запускаться после каждого теста:

import unittest
class SimpleWidgetTestCase(unittest. TestCase):
    def setUp(self):
        self.widget = Widget('The widget')
    def tearDown(self):
        self.widget.dispose()

Можно разместить все тесты в том же файле, что и сама программа (таком как widgets.py), но размещение тестов в отдельном файле (таком как test_widget.py) имеет много преимуществ:

• Модуль с тестом может быть запущен автономно из командной строки.
• Тестовый код может быть легко отделён от программы.
• Меньше искушения изменить тесты для соответствия коду программы без видимой причины.
• Тестовый код должен изменяться гораздо реже, чем программа.
• Протестированный код может быть легче переработан.
• Тесты для модулей на C должны быть в отдельных модулях, так почему же не быть последовательным?
• Если стратегия тестирования изменяется, нет необходимости изменения кода программы.

Пропуск тестов и ожидаемые ошибки

unittest поддерживает пропуск отдельных тестов, а также классов тестов. Вдобавок, поддерживается пометка теста как «не работает, но так и надо».

Пропуск теста осуществляется использованием декоратора skip() или одного из его условных вариантов.

class MyTestCase(unittest.TestCase):
    @unittest.skip("demonstrating skipping")
    def test_nothing(self):
        self.fail("shouldn't happen")
    @unittest.skipIf(mylib.__version__ < (1, 3),
                     "not supported in this library version")
    def test_format(self):
        # Tests that work for only a certain version of the library.
        pass
    @unittest.skipUnless(sys.platform.startswith("win"), "requires Windows")
    def test_windows_support(self):
        # windows specific testing code
        pass

test_format (__main__.MyTestCase) ... skipped 'not supported in this library version'
test_nothing (__main__.MyTestCase) ... skipped 'demonstrating skipping'
test_windows_support (__main__.MyTestCase) ... skipped 'requires Windows'
----------------------------------------------------------------------
Ran 3 tests in 0.005s
OK (skipped=3)

Классы также могут быть пропущены:

@unittest. skip("showing class skipping")
class MySkippedTestCase(unittest.TestCase):
    def test_not_run(self):
        pass

Ожидаемые ошибки используют декоратор expectedFailure():

class ExpectedFailureTestCase(unittest.TestCase):
    @unittest.expectedFailure
    def test_fail(self):
        self.assertEqual(1, 0, "broken")

Очень просто сделать свой декоратор. Например, следующий декоратор пропускает тест, если переданный объект не имеет указанного атрибута:

def skipUnlessHasattr(obj, attr):
    if hasattr(obj, attr):
        return lambda func: func
    return unittest.skip("{!r} doesn't have {!r}".format(obj, attr))

Декораторы, пропускающие тесты или говорящие об ожидаемых ошибках:

@unittest.skip(reason) — пропустить тест. reason описывает причину пропуска.

@unittest.skipIf(condition, reason) — пропустить тест, если condition истинно.

@unittest.skipUnless(condition, reason) — пропустить тест, если condition ложно.

@unittest.expectedFailure — пометить тест как ожидаемая ошибка.

Для пропущенных тестов не запускаются setUp() и tearDown(). Для пропущенных классов не запускаются setUpClass() и tearDownClass(). Для пропущенных модулей не запускаются setUpModule() и tearDownModule().

Различение итераций теста с помощью подтестов

Когда некоторые тесты имеют лишь незначительные отличия, например некоторые параметры, unittest позволяет различать их внутри одного тестового метода, используя менеджер контекста subTest().

Например, следующий тест:

class NumbersTest(unittest.TestCase):
    def test_even(self):
        """
        Test that numbers between 0 and 5 are all even.
        """
        for i in range(0, 6):
            with self.subTest(i=i):
                self.assertEqual(i % 2, 0)

даст следующий отчёт:

======================================================================
FAIL: test_even (__main__.NumbersTest) (i=1)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "subtests. py", line 32, in test_even
    self.assertEqual(i % 2, 0)
AssertionError: 1 != 0
======================================================================
FAIL: test_even (__main__.NumbersTest) (i=3)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "subtests.py", line 32, in test_even
    self.assertEqual(i % 2, 0)
AssertionError: 1 != 0
======================================================================
FAIL: test_even (__main__.NumbersTest) (i=5)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "subtests.py", line 32, in test_even
    self.assertEqual(i % 2, 0)
AssertionError: 1 != 0

Без использования подтестов, выполнение будет остановлено после первой ошибки, и ошибку будет сложнее диагностировать, потому что значение i не будет показано:

======================================================================
FAIL: test_even (__main__.NumbersTest)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "subtests. py", line 32, in test_even
    self.assertEqual(i % 2, 0)
AssertionError: 1 != 0

Проверки на успешность

Модуль unittest предоставляет множество функций для самых различных проверок:

assertEqual(a, b) — a == b

assertNotEqual(a, b) — a != b

assertTrue(x) — bool(x) is True

assertFalse(x) — bool(x) is False

assertIs(a, b) — a is b

assertIsNot(a, b) — a is not b

assertIsNone(x) — x is None

assertIsNotNone(x) — x is not None

assertIn(a, b) — a in b

assertNotIn(a, b) — a not in b

assertIsInstance(a, b) — isinstance(a, b)

assertNotIsInstance(a, b) — not isinstance(a, b)

assertRaises(exc, fun, *args, **kwds) — fun(*args, **kwds) порождает исключение exc

assertRaisesRegex(exc, r, fun, *args, **kwds) — fun(*args, **kwds) порождает исключение exc и сообщение соответствует регулярному выражению r

assertWarns(warn, fun, *args, **kwds) — fun(*args, **kwds) порождает предупреждение

assertWarnsRegex(warn, r, fun, *args, **kwds) — fun(*args, **kwds) порождает предупреждение и сообщение соответствует регулярному выражению r

assertAlmostEqual(a, b) — round(a-b, 7) == 0

assertNotAlmostEqual(a, b) — round(a-b, 7) != 0

assertGreater(a, b) — a > b

assertGreaterEqual(a, b) — a >= b

assertLess(a, b) — a < b

assertLessEqual(a, b) — a <= b

assertRegex(s, r) — r. search(s)

assertNotRegex(s, r) — not r.search(s)

assertCountEqual(a, b) — a и b содержат те же элементы в одинаковых количествах, но порядок не важен

Для вставки кода на Python в комментарий заключайте его в теги <pre><code>Ваш код</code></pre>

Python модули и пакеты / Хабр

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

После разделения кода по файлам, следует выстроить их взаимодействие. В языке программирования Python данный механизм реализуется с использованием import. Импортировать можно любые компоненты(если Вы кодом не ограничивали таковые) модулей или пакетов.

Модули также могут быть написаны и на других языках, но данная статья направлена на рассмотрение использования данного механизмах в рамках Python.

Модули

В языке программирования Python модулями являются все файлы с расширением *.py(* обозначает, что на этом месте может стоять любой символ или любое их количество). Исключением является служебный файл __init__.py(о назначении которого описано далее в статье).

Дальше стоит понимать, что любая программа имеет некую точку входа. Это своего рода место с которого стартует наш скрипт. В языках предшественниках данной точкой служила функция main и могла быть лишь только одной. В нашем случае допускается отсутствие таковой, но это снижает качество кода, делая его сложным и малопредсказуемым(при импорте код содержащийся на верхнем уровне исполняется). Для того чтобы указать точку входа(может быть указана только в модулях) используется специальная переменная __name__, в которой содержится наименование текущего модуля или пакета. Если текущий модуль находится на верхнем уровне исполнения(мы явно его передали на исполнение Python), то он называется __main__ независимо от названия файла.

# Указание входной точки
## Если __name__ равно "__main__" исполни
if __name__ == "__main__":
  print('Я главный!')
  # Вызов других функций, например main()

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

# http_get.modules.http_get
# Расположен в дирректории http_get, modules и назван http_get
def get_dict():
    return {'status': 200, 'data': 'success'}
# Поскольку зависимых импортов нет, мы можем исполнить этот код для проверки
# Т.е. в качестве входной точки использовать нашу функцию
# Данный код исполнится только, когда этот файл будет исполняемым(не импортируемым)
if __name__ == '__main__':
    print(get_dict())

Далее в корне создадим main.py файл, в который импортируем наш модуль двумя разными способами(об импортах описано в статье):

# main.py
from ModulesAndPackages.module_examples.http_get.modules.http_get import get_dict as absolute
from http_get.modules.http_get import get_dict as relative
def main():
    # Работает
    print(absolute())
    print(relative())
if __name__ == '__main__':
    main()

Все без проблем исполняется.

Трудности

При переносе файлов куда-либо из директории возникнут проблемы из-за первого импорта(main.py). Поскольку часто приходится писать один и тот же код, использование уже хорошо написанного пакета или модуля может экономить много времени, но исправление большого количества импортов требует Ваших ресурсов. Хорошо написанный пакет, модуль или импорт может экономить ваши рабочие часы, а иногда и нервы.

Смена директории

Не изменяя наши модули(импорты), при изменении положения файлов возникает ошибка импорта:

# Не работает в другом проекте
from ModulesAndPackages.module_examples.http_get.modules.http_get import get_dict as absolute
# Всегда работает
from http_get.modules.http_get import get_dict as relative
def main():
    print(absolute())
    print(relative())
if __name__ == '__main__':
    main()

Пакеты

В языке программирования Python пакетами являются все директории(вне зависимости от наличия в них модулей), содержащие файл __init__. py, который исполняется при импорте пакета и несет его название (__name__).

Для примера реализуем простой пакет(package), на базе вышеописанного модуля(http_get.py):

package/modules/http_get.py

# package/modules/http_get.py
def get_dict():
    return {'status': 200, 'data': 'success'}
if __name__ == '__main__':
    print(get_dict())

# package/__init__.py
from .modules.http_get import get_dict
...
def get_data():
    return get_dict()
...
# Не работает
# __init__ не может иметь точки входа
#
# if __name__ == '__main__':
#     get_data()

А также реализуем простой пакет с такой же логикой, но с использованием абсолютного импорта:

package_2

# package_2/modules/http_get.py
def get_dict():
    return {'status': 200, 'data': 'success'}
if __name__ == '__main__':
    print(get_dict())

# package_2/__init__.py
from ModulesAndPackages.package_examples.package_2.modules.http_get import get_dict
...
def get_data():
    return get_dict()
. ..
# Не работает
# __init__ не может иметь точки входа
#
# if __name__ == '__main__':
#     get_data()

В корне директории(на уровень выше пакета) создадим файл, в котором воспользуемся нашими пакетами(main.py):

# main.py
from package import get_data
from package_2 import get_data as get_data_2
def main():
    # Работает
    print(get_data())
    print(get_data_2())
if __name__ == '__main__':
    main()

Все работает без ошибок.

Трудности

Но при переносе нашего package_2 в другой проект, он теряет свою работоспособность из-за ошибки импортирования в __init__.py файле, в отличии от package.

Смена директории

# package_transferring/package/modules/http_get.py
def get_dict():
    return {'status': 200, 'data': 'success'}
if __name__ == '__main__':
    print(get_dict())

# package_transferring/package/__init__.py
from .modules.http_get import get_dict
...
def get_data():
    return get_dict()
. ..
# Не работает
# __init__ не может иметь точки входа
#
# if __name__ == '__main__':
#     get_data()

# package_transferring/package_2/modules/http_get.py
def get_dict():
    return {'status': 200, 'data': 'success'}
if __name__ == '__main__':
    print(get_dict())

# package_transferring/package_2/__init__.py 
# Ошибка импорта т.к. изменилась директория
from ModulesAndPackages.package_examples.package_2.modules.http_get import get_dict
...
def get_data():
    return get_dict()
...
# Does not work!
# Because init file in package could not have entry point
#
# if __name__ == '__main__':
#     get_data()

# package_transferring/main.py
from package import get_data
# Ошибка импорта
from package_2 import get_data as get_data_2
def main():
    print(get_data())
    print(get_data_2())
if __name__ == '__main__':
    main()

P.S.

Данная статья написана для новичков, которые изучают язык программирования Python. Задача которой продемонстрировать на простых примерах способы написания пакетов и модулей(не является туториалом), а так же показать какие трудности могут возникнуть и пути их решения.

Github с проектом к данной статье: ModulesAndPackages

Может быть полезно выгрузить модуль или пакет и попробовать внедрить его в свой проект.

Стандартная библиотека Python — документация Python 3.11.4

Хотя справочник по языку Python описывает точный синтаксис и семантика языка Python, это справочное руководство по библиотеке описывает стандартную библиотеку, распространяемую вместе с Python. Это также описывает некоторые необязательные компоненты, которые обычно включаются в дистрибутивах Python.

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

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

В дополнение к стандартной библиотеке имеется активная коллекция сотни тысяч компонентов (от отдельных программ и модулей до пакеты и целые среды разработки приложений), доступные на Индекс пакетов Python.

• Введение
  • Примечания о наличии
• Встроенные функции
• Встроенные константы
  • Константы, добавленные модулем сайта
• Встроенные типы
  • Проверка достоверности
  • Логические операции — и , или , не
  • Сравнения
  • Числовые типы — int , float , complex
  • Типы итераторов
  • Типы последовательностей — список , кортеж , диапазон
  • Тип последовательности текста — str
  • Типы двоичных последовательностей — байта , bytearray , memoryview
  • Типы наборов — набор , замороженный набор
  • Типы отображения — dict
  • Типы диспетчера контекста
  • Type Типы аннотаций — общий псевдоним, объединение
  • Другие встроенные типы
  • Специальные атрибуты
  • Ограничение длины преобразования целочисленной строки
• Встроенные исключения
  • Контекст исключения
  • Наследование от встроенных исключений
  • Базовые классы
  • Исключения для бетона
  • Предупреждения
  • Группы исключений
  • Иерархия исключений
• Службы обработки текста
  • строка — Общие операции со строками
  • относительно — Операции с регулярными выражениями
  • difflib — Помощники для вычисления дельт
  • textwrap — Обтекание и заполнение текста
  • unicodedata — База данных Юникода
  • stringprep — Подготовка строки Интернета
  • readline — интерфейс GNU readline
  • rlcompleter — Функция завершения для GNU readline
• Службы двоичных данных
  • struct — интерпретировать байты как упакованные двоичные данные
  • кодеки — Реестр кодеков и базовые классы
• Типы данных
  • datetime — Базовые типы даты и времени
  • zoneinfo — поддержка часовых поясов IANA
  • календарь — Общие функции, связанные с календарем
  • коллекции — Контейнерные типы данных
  • collections. abc — Абстрактные базовые классы для контейнеров
  • heapq — Алгоритм очереди кучи
  • bisect — Алгоритм деления массива пополам
  • массив — Эффективные массивы числовых значений
  • weakref — Слабые ссылки
  • типы — Создание динамического типа и имена для встроенных типов
  • копия — операции поверхностного и глубокого копирования
  • pprint — Принтер данных
  • reprlib — Альтернатива repr() реализация
  • enum — Поддержка перечислений
  • graphlib — Функциональность для работы с графоподобными структурами
• Числовые и математические модули
  • числа — Числовые абстрактные базовые классы
  • math — Математические функции
  • cmath — Математические функции для комплексных чисел
  • decimal — Десятичная арифметика с фиксированной и плавающей запятой
  • дроби — Рациональные числа
  • random — Генерация псевдослучайных чисел
  • статистика — Функции математической статистики
• Модули функционального программирования
  • itertools — Функции, создающие итераторы для эффективного цикла
  • functools — Функции и операции высшего порядка над вызываемыми объектами
  • оператор — Стандартные операторы как функции
• Доступ к файлам и каталогам
  • pathlib — Пути к объектно-ориентированным файловым системам
  • os. path — Общие манипуляции с путями
  • fileinput — Перебор строк из нескольких входных потоков
  • stat — Интерпретация stat() результатов
  • filecmp — Сравнение файлов и каталогов
  • tempfile — Создание временных файлов и каталогов
  • glob — Расширение шаблона пути в стиле Unix
  • fnmatch — соответствие шаблону имени файла Unix
  • linecache — Произвольный доступ к текстовым строкам
  • Shutil — Высокоуровневые файловые операции
• Data Persistence
  • pickle — сериализация объектов Python
  • copyreg — Регистрация pickle поддержка функций
  • полка — постоянство объекта Python
  • marshal — Внутренняя сериализация объектов Python
  • dbm — Интерфейсы к «базам данных» Unix
  • sqlite3 — интерфейс DB-API 2. 0 для баз данных SQLite
• Сжатие и архивирование данных
  • zlib — сжатие, совместимое с gzip
  • gzip — Поддержка файлов gzip
  • bz2 — Поддержка сжатия bzip2
  • lzma — Сжатие с использованием алгоритма LZMA
  • zipfile — Работа с ZIP архивами
  • tarfile — Чтение и запись архивных файлов tar
• Форматы файлов
  • csv — Чтение и запись файлов CSV
  • configparser — Анализатор файла конфигурации
  • tomllib — Анализ файлов TOML
  • netrc — обработка файла netrc
  • plistlib — Создание и анализ файлов Apple .plist
• Cryptographic Services
  • hashlib — Безопасные хэши и дайджесты сообщений
  • hmac — Хэширование по ключу для аутентификации сообщений
  • секреты — Создание безопасных случайных чисел для управления секретами
• Универсальные службы операционной системы
  • os — Разные интерфейсы операционной системы
  • io — Базовые инструменты для работы с потоками
  • время — Время доступа и преобразования
  • argparse — Анализатор параметров командной строки, аргументов и подкоманд
  • getopt — анализатор в стиле C для параметров командной строки
  • logging — Средство ведения журнала для Python
  • logging. config — Конфигурация ведения журнала
  • logging.handlers — Обработчики протоколирования
  • getpass — Портативный ввод пароля
  • curses — Обработка терминала для отображения символьных ячеек
  • curses.textpad — Виджет ввода текста для программ curses
  • curses.ascii — Утилиты для символов ASCII
  • curses.panel — Расширение стека панелей для curses
  • платформа — Доступ к идентифицирующим данным базовой платформы
  • errno — Стандартные системные символы errno
  • ctypes — Внешняя библиотека функций для Python
• Параллельное выполнение
  • Многопоточность — Параллелизм на основе потоков
  • многопроцессорность — Параллелизм на основе процессов
  • multiprocessing.shared_memory — Общая память для прямого доступа между процессами
  • Параллельный пакет
  • concurrent. futures — Запуск параллельных задач
  • подпроцесс — Управление подпроцессом
  • планировщик — Планировщик событий
  • очередь — Класс синхронизированной очереди
  • contextvars — Контекстные переменные
  • _thread — Низкоуровневый API многопоточности
• Сеть и межпроцессное взаимодействие
  • asyncio — Асинхронный ввод-вывод
  • сокет — Низкоуровневый сетевой интерфейс
  • SSL — Оболочка TLS/SSL для объектов сокета
  • select — Ожидание завершения ввода/вывода
  • селекторы — Мультиплексирование ввода/вывода высокого уровня
  • signal — Установить обработчики асинхронных событий
  • mmap — Поддержка отображаемых в память файлов
• Internet Data Handling
  • электронная почта — Пакет обработки электронной почты и MIME
  • json — кодировщик и декодер JSON
  • почтовый ящик — Работа с почтовыми ящиками различных форматов
  • mimetypes — Преобразовать имена файлов в типы MIME
  • base64 — Base16, Base32, Base64, Base85 Кодировки данных
  • binascii — Преобразование между двоичным кодом и ASCII
  • quopri — Кодировать и декодировать данные MIME в кавычках и для печати
• Средства обработки структурированной разметки
  • html — Поддержка языка гипертекстовой разметки
  • html. parser — Простой анализатор HTML и XHTML
  • html.entities — Определения общих сущностей HTML
  • Модули обработки XML
  • xml.etree.ElementTree — XML-API ElementTree
  • xml.dom — API объектной модели документа
  • xml.dom.minidom — Минимальная реализация DOM
  • xml.dom.pulldom — Поддержка построения частичных деревьев DOM
  • xml.sax — Поддержка парсеров SAX2
  • xml.sax.handler — Базовые классы для обработчиков SAX
  • xml.sax.saxutils — Утилиты SAX
  • xml.sax.xmlreader — Интерфейс для парсеров XML
  • xml.parsers.expat — Быстрый анализ XML с помощью Expat
• Интернет-протоколы и поддержка
  • веб-браузер — удобный контроллер веб-браузера
  • wsgiref — Утилиты WSGI и справочная реализация
  • urllib — Модули обработки URL
  • urllib. request — Расширяемая библиотека для открытия URL
  • urllib.response — Классы ответов, используемые urllib
  • urllib.parse — Разбирать URL на компоненты
  • urllib.error — Классы исключений, вызванные urllib.request
  • urllib.robotparser — Парсер для robots.txt
  • http — модули HTTP
  • http.client — клиент протокола HTTP
  • ftplib — клиент протокола FTP
  • poplib — клиент протокола POP3
  • imaplib — клиент протокола IMAP4
  • smtplib — Клиент протокола SMTP
  • uuid — объекты UUID в соответствии с RFC 4122
  • socketserver — Фреймворк для сетевых серверов
  • http.server — HTTP-серверы
  • http.cookies — Управление состоянием HTTP
  • http. cookiejar — Обработка файлов cookie для HTTP-клиентов
  • xmlrpc — сервер XMLRPC и клиентские модули
  • xmlrpc.client — доступ клиента XML-RPC
  • xmlrpc.server — Базовые серверы XML-RPC
  • ipaddress — библиотека управления IPv4/IPv6
• Службы мультимедиа
  • волна — Чтение и запись файлов WAV
  • colorsys — Преобразование между цветовыми системами
• Интернационализация
  • gettext — Услуги многоязычной интернационализации
  • региональный номер — Услуги интернационализации
• Program Frameworks
  • черепаха — Графика черепахи
  • cmd — Поддержка линейных интерпретаторов команд
  • shlex — Простой лексический анализ
• Графические пользовательские интерфейсы с Tk
  • tkinter — интерфейс Python для Tcl/Tk
  • tkinter. colorchooser — Диалог выбора цвета
  • tkinter.font — Оболочка шрифта Tkinter
  • Диалоги Tkinter
  • tkinter.messagebox — Подсказки сообщения Tkinter
  • tkinter.scrolledtext — Виджет прокручиваемого текста
  • tkinter.dnd — Поддержка перетаскивания
  • tkinter.ttk — Тематические виджеты Tk
  • tkinter.tix — Расширение виджетов для Tk
  • холостого хода
• Средства разработки
  • ввод — поддержка подсказок типа
  • pydoc — Генератор документации и интерактивная справочная система
  • Режим разработки Python
  • doctest — Проверка интерактивных примеров Python
  • unittest — Платформа модульного тестирования
  • unittest.mock — библиотека фиктивных объектов
  • unittest.mock — начало работы
  • 2to3 — Автоматический перевод кода Python 2 в 3
  • test — Пакет регрессионных тестов для Python
  • test. support — Утилиты для набора тестов Python
  • test.support.socket_helper — Утилиты для тестов сокетов
  • test.support.script_helper — Утилиты для выполнения тестов Python
  • test.support.bytecode_helper — Инструменты поддержки для проверки правильности генерации байт-кода
  • test.support.threading_helper — Утилиты для многопоточных тестов
  • test.support.os_helper — Утилиты для тестов ОС
  • test.support.import_helper — Утилиты для импорта тестов
  • test.support.warnings_helper — Утилиты для тестов предупреждений
• Отладка и профилирование
  • Таблица событий аудита
  • bdb — Платформа отладчика
  • обработчик ошибок — Дамп обратной трассировки Python
  • pdb — Отладчик Python
  • Профилировщики Python
  • timeit — Измерение времени выполнения небольших фрагментов кода
  • trace — Трассировка или отслеживание выполнения оператора Python
  • tracemalloc — Трассировка выделения памяти
• Упаковка и распространение программного обеспечения
  • distutils — Сборка и установка модулей Python
  • surepip — Начальная загрузка установщика pip
  • venv — Создание виртуальных сред
  • zipapp — Управление исполняемыми zip-архивами Python
• Python Runtime Services
  • sys — Системные параметры и функции
  • sysconfig — предоставить доступ к информации о конфигурации Python
  • встроенные объекты — Встроенные объекты
  • __main__ — Среда кода верхнего уровня
  • предупреждения — Управление предупреждением
  • классы данных — Классы данных
  • contextlib — Утилиты для с контекстами операторов
  • abc — Абстрактные базовые классы
  • atexit — Обработчики выхода
  • traceback — Распечатать или получить трассировку стека
  • __future__ — Определения операторов будущего
  • gc — интерфейс сборщика мусора
  • инспектировать — инспектировать живые объекты
  • сайт — Перехватчик конфигурации для конкретного сайта
• Пользовательские интерпретаторы Python
  • код — Базовые классы интерпретатора
  • codeop — Скомпилировать код Python
• Импорт модулей
  • zipimport — Импорт модулей из Zip архивов
  • pkgutil — Утилита расширения пакета
  • modulefinder — Поиск модулей, используемых скриптом
  • runpy — Поиск и выполнение модулей Python
  • importlib — Реализация import
  • importlib. resources — Ресурсы
  • Устаревшие функции
  • importlib.resources.abc — Абстрактные базовые классы для ресурсов
  • Использование importlib.metadata
  • Инициализация модуля sys.path пути поиска
• Python Language Services
  • ast — Абстрактные синтаксические деревья
  • symtable — Доступ к таблицам символов компилятора
  • токен — Константы, используемые с деревьями синтаксического анализа Python
  • ключевое слово — Тестирование ключевых слов Python
  • tokenize — Токенизатор для исходного кода Python
  • tabnanny — Обнаружение неоднозначного отступа
  • pyclbr — поддержка браузера модуля Python
  • py_compile — Скомпилировать исходные файлы Python
  • compileall — библиотеки Python с байтовой компиляцией
  • dis — Дизассемблер для байт-кода Python
  • pickletools — Инструменты для разработчиков pickle
• Специальные службы MS Windows
  • msvcrt — Полезные подпрограммы из среды выполнения MS VC++
  • winreg — Доступ к реестру Windows
  • winsound — Звуковой интерфейс для Windows
• Специальные службы Unix
  • posix — Наиболее распространенные системные вызовы POSIX
  • pwd — База паролей
  • grp — Групповая база данных
  • termios — элемент управления tty в стиле POSIX
  • телетайп — Функции управления терминалом
  • pty — Псевдотерминальные утилиты
  • fcntl — fcntl и ioctl системные вызовы
  • resource — Информация об использовании ресурсов
  • системный журнал — подпрограммы библиотеки системного журнала Unix
• Замененные модули
  • aifc — Чтение и запись файлов AIFF и AIFC
  • asynchat — Обработчик команды/ответа асинхронного сокета
  • asyncore — обработчик асинхронных сокетов
  • audioop — Управление необработанными аудиоданными
  • cgi — поддержка общего интерфейса шлюза
  • cgitb — Менеджер трассировки для CGI-скриптов
  • chunk — Чтение фрагментированных данных IFF
  • crypt — Функция проверки паролей Unix
  • imghdr — Определить тип изображения
  • imp — Доступ к внутренним компонентам импорта
  • mailcap — Обработка файла Mailcap
  • msilib — Чтение и запись файлов установщика Microsoft
  • nis — Интерфейс к Sun NIS (Желтые страницы)
  • nntplib — клиент протокола NNTP
  • optparse — Анализатор параметров командной строки
  • ossaudiodev — Доступ к OSS-совместимым аудиоустройствам
  • трубы — Интерфейс к трубопроводам оболочки
  • smtpd — SMTP-сервер
  • sndhdr — Определить тип звукового файла
  • spwd — База теневых паролей
  • sunau — Чтение и запись файлов Sun AU
  • telnetlib — Клиент Telnet
  • uu — Кодировать и декодировать файлы uuencode
  • xdrlib — кодирование и декодирование данных XDR
• Вопросы безопасности

встроенных модулей Python — Knowledgehut

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

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

Интерпретатор Python имеет ряд встроенных функций. Они всегда доступны для использования в каждом сеансе интерпретатора. Многие из них обсуждались ранее. Например, print() и input() для ввода-вывода, функции преобразования чисел (int(), float(), комплекс()), преобразования типов данных (list(), tuple(), set()) и т. д. Вот полный список встроенных функций Python:

913 01 setattr() 9130 1 окт() 9 1301 точка останова() 9130 1 frostset()

					абс()	делеттр()	hash()	memoryview()	set()
all()	dict()	help()	min()
any()	dir()	hex()	next()	slice()
ascii() 9130 2	divmod()	id()	object()	sorted()
bin()	enumerate()	input()	staticmethod()
bool()	eval()	int()	open()	str()
exec()	isinstance()	ord()	sum()
bytearray()	filter()	is subclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reverse()	__import__()
complex()	hasattr()	max()

Другие функции появятся позже главы этого руководства.

Помимо встроенных функций, большое количество предопределенных функций также доступно как часть библиотек, входящих в состав дистрибутивов Python. Однако они не доступны для автоматического использования. Эти функции определены в модулях. Модуль — это файл, содержащий определение функций, классов, переменных, констант или любого другого объекта Python. Стандартный дистрибутив Python содержит большое количество модулей, обычно называемых встроенными модулями. Каждый встроенный модуль содержит ресурсы для определенных функций, таких как управление ОС, дисковый ввод-вывод, работа в сети, подключение к базе данных и т. д.

В большинстве случаев встроенные модули написаны на C и интегрированы с интерпретатором Python.

Встроенным модулем может быть скрипт Python (с расширением .py), содержащий полезные утилиты.

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

 >>> help('modules') 

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

модуль импорта

module.function([аргументы, если есть])

Функция sqrt() в математическом модуле возвращает квадратный корень числа.

 >>> импорт математики
>>> мат.кв.(100)
10.0 

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

• модуль ОС
• случайный модуль
• математический модуль
• модуль времени
• системный модуль
• модуль коллекций
• модуль статистики

модуль ОС

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

mkdir():

Мы можем создать новый каталог, используя функцию mkdir() из модуля ОС.

 >>> импорт ОС
>>> os.mkdir("d:\\tempdir") 

Будет создан новый каталог, соответствующий пути в строковом аргументе функции. Если мы откроем диск D в проводнике Windows, мы должны заметить созданную папку tempdir.

chdir():

Чтобы изменить текущий рабочий каталог, используйте функцию chdir() .

 >>> импорт ОС
>>> os.chdir("d:\\temp") 

getcwd():

Эта функция возвращает имя текущего рабочего каталога.

 >>> os.getcwd()
'd:\\temp' 

Пути к каталогам также могут быть относительными. Если текущий каталог установлен на диск D, а затем на временный без указания предыдущего пути, то текущий рабочий каталог также будет изменен на d:\temp

 >>> os.chdir("d:\\")
>>> os.getcwd()
'д:\\'
>>> os.chdir("temp")
>>> os.getcwd()
'd:\\temp' 

Чтобы установить текущий каталог как родительский, используйте «..» в качестве аргумента функции chdir().

 >>> os.chdir("d:\\temp")
>>> os.getcwd()
'д:\\темп'
>>> os.chdir("..")
>>> os.getcwd()
'd:\\' 

rmdir():

Функция rmdir() в модуле os удаляет указанный каталог либо с абсолютным, либо с относительным путем. Однако это не должен быть текущий рабочий каталог, и он должен быть пустым.

 >>> os.chdir("tempdir")
>>> os.getcwd()
'd:\\tempdir'
>>> os.rmdir("d:\\temp")
PermissionError: [WinError 32] Процесс не может получить доступ к файлу, поскольку он используется другим процессом: 'd:\\temp'
>>> os.chdir("..")
>>> os.rmdir("temp") 

listdir():

В модуле ОС есть функция listdir() , которая возвращает список всех файлов в указанном каталоге.

 >>> os.listdir("c:\\Пользователи")
['acer', 'Все пользователи', 'По умолчанию', 'Пользователь по умолчанию', 'desktop.ini', 'Общедоступный'] 

модуль random

Стандартная библиотека Python содержит модуль random, который определяет различные функции для обработки рандомизации. Python использует генератор псевдослучайных чисел, основанный на алгоритме Mersenne Twister, который производит 53-битные числа с плавающей запятой. Функции в этом модуле зависят от функции генератора псевдослучайных чисел random(), которая генерирует случайное число с плавающей запятой в диапазоне от 0,0 до 1,0.

random.random(): Возвращает случайное число с плавающей точкой от 0,0 до 1,0. Функция не нуждается в аргументах

 >>> import random
>>> случайный.случайный()
0.755173688207591 

Другие функции модуля random описаны здесь:

random.randint(): Возвращает случайное целое число между указанными целыми числами

 >>> import random
>>> случайный.randint(1100)
58
>>> случайный.randint(1100)
91 

random.randrange(): Возвращает случайный элемент из диапазона, созданного аргументами start, stop и step. Параметры start, stop и step ведут себя аналогично функции range().

 >>> случайный.randrange(1,10)
2
>>> случайный.randrange(1,10,2)
3
>>> random.randrange(0,101,10)
40 

random.choice(): Возвращает случайно выбранный элемент из объекта последовательности, такого как строка, список или кортеж. Пустая последовательность в качестве аргумента вызывает IndexError

 >>> случайный импорт
>>> random. choice('компьютер')
'о'
>>> случайный.выбор([12,23,45,67,65,43])
65
>>> случайный.выбор((12,23,45,67,65,43))
23 

random.shuffle(): Эта функция случайным образом переупорядочивает элементы в списке.

 >>> числа=[12,23,45,67,65,43]
>>> random.shuffle(числа)
>>> числа
[23, 12, 43, 65, 67, 45]
>>> random.shuffle(числа)
>>> числа
[23, 43, 65, 45, 12, 67] 

математический модуль

В этом модуле представлены часто используемые математические функции.

• тригонометрические функции
• функции представления
• логарифмические функции
• функции преобразования углов

Кроме того, в этом модуле определены две математические константы.

Круг π   , который определяется как отношение длины окружности к диаметру круга и имеет значение 3,14159.2653589793, доступен в математическом модуле.

 >>> импорт математики
>>> math. pi
3.141592653589793 

Еще одна математическая константа в этом модуле — e. Оно называется числом Эйлера и является основанием натурального логарифма. Его значение равно 2,718281828459045

 >>> math.e
2.718281828459045 

Этот модуль содержит функции для расчета различных тригонометрических соотношений для заданного угла. Функциям (sin, cos, tan и т. д.) в качестве аргумента требуется угол в радианах. С другой стороны, мы привыкли выражать угол в градусах. В математическом модуле представлены две функции преобразования углов (градусы() и радианы()) для преобразования угла в градусах в радианы и наоборот.

Тригонометрические функции:

радианы (): преобразует угол в градусах в радианы. (Примечание: π радиан эквивалентно 180 градусам)

 >>> math.radians(30)
0,5235987755982988 

градусов (): преобразует угол в радианах в градусы.

 >>> математические степени (math. pi/6)
29,999999999999996 

Следующие утверждения показывают коэффициенты sin, cos и tan для угла 30 градусов (0,5235987755982988 радиан)

 >> math.sin(0.5235987755982988)
0,49999999999999994
>>> math.cos(0.5235987755982988)
0,8660254037844387
>>> math.tan(0.5235987755982988)
0,57735026 
257 

sin(30)	0,5	0,499999999999999994
cos(30)	3/2	0,8660254037844387)
tan(30)	1/2	0 57735026 257

math.log(): возвращает натуральный логарифм заданного числа. Натуральный логарифм рассчитывается по основанию e.

math.log10() : возвращает логарифм по основанию 10 или стандартный логарифм заданного числа.

 >>> math.log10(10)
1.0 

math.exp(): возвращает число с плавающей запятой после возведения e (math.e) в заданное число. exp(x) эквивалентно e**x

 >>> math.log10(10)
1,0
>>> мат.e**10
22026.465794806703 

math.pow(): Эта функция получает два аргумента типа float, возводит первый ко второму и возвращает результат. pow(4,4) эквивалентно 4**4

 >>> math.pow(4,4)
256,0
>>> 4**4
256 

math.sqrt(): Эта функция вычисляет квадратный корень из заданного числа

 >>> math.sqrt(100)
10,0
>>> math.sqrt(3)
1.7320508075688772 

Функции представления:

Функция ceil() приближает заданное число к наименьшему целому числу, большему или равному заданному числу с плавающей запятой. Функция floor() возвращает наибольшее целое число, меньшее или равное заданному числу

 >>> math.ceil(4.5867)
5
>>> мат.этаж(4.5687)
4 

sys-модуль

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

sys.argv

Этот возвращаемый список аргументов командной строки передается сценарию Python. Элемент в 0-м индексе этого списка всегда является именем скрипта. Остальные аргументы сохраняются в последующих индексах.

Вот скрипт Python (test.py), использующий два аргумента из командной строки.

 система импорта
print ("Меня зовут {}. Мне {} лет".format(sys.argv[1], sys.argv[2])) 

Этот сценарий выполняется из командной строки следующим образом:

 C:\python37>python tmp.py Анил 23
Меня зовут Анил. Мне 23 года 

sys.exit

Это приводит к завершению программы и возврату либо в консоль Python, либо в командную строку. Используется для безопасного выхода из программы в случае исключения.

sys.maxsize

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

 >>> импорт системы
>>> sys.maxsize
9223372036854775807 

системный путь

Это переменная среды, которая возвращает путь поиска для всех модулей Python.

 >>> sys.path
['', 'C:\\python37\\Lib\\idlelib', 'C:\\python37\\python36.zip', 'C:\\python37\\DLLs', 'C:\\python37\\lib', 'C:\\python37', 'C:\\Users\\acer\\AppData\\Roaming\\Python\\Python37\\site- пакеты», «C:\\python37\\lib\\site-packages»] 

sys.stdin, sys.stdout, sys.stderr

Это файловые объекты, используемые интерпретатором для стандартного ввода, вывода и ошибок. stdin используется для всего интерактивного ввода (оболочка Python). stdout используется для вывода print() и input(). Подсказки интерпретатора и сообщения об ошибках отправляются в stderr.

sys.version

Этот атрибут отображает строку, содержащую номер версии текущего интерпретатора Python.

модуль коллекций

Этот модуль предоставляет альтернативы встроенным типам данных контейнера, таким как список, кортеж и словарь.

функция namedtuple()

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

 collections.namedtuple(typename, field-list) 

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

Следующий оператор объявляет сотрудника namedtuple с именем, возрастом и зарплатой в качестве полей

 >>> импорт коллекций
>>> employee=collections.namedtuple('сотрудник', [имя, возраст, зарплата])
Чтобы создать новый объект этого namedtuple
>>> e1=сотрудник("Рави", 251, 20000) 

Значения поля могут быть доступны при поиске по атрибуту

 >>> e1.name
'Рави' 

Или по индексу

 >>> e1[0]
'Ravi' 

Функция OrderedDict()

Упорядоченный словарь аналогичен обычному словарю. Однако обычный словарь запоминает порядок вставки ключей в него, тогда как упорядоченный объект словаря тот же. Пары ключ-значение в обычном объекте словаря появляются в произвольном порядке.

 >>> д1={}
>>> d1['A']=20
>>> d1['B']=30
>>> d1['C']=40
>>> d1['D']=50 

Затем мы просматриваем словарь с помощью цикла for,

 >>> for k,v в d1.items():
печать (к, в)

А 20
Б 30
Д 50
C 40 

Но в случае объекта OrderedDict:

 >>> импорт коллекций
>>> d2=коллекции.OrderedDict()
>>> d2['A']=20
>>> d2['B']=30
>>> d2['C']=40
>>> d2['D']=50 

Пары «ключ-значение» будут отображаться в порядке их вставки.

 >>> для k,v в d2.items():
печать (к, в)
А 20
Б 30
С 40
D 50 

Функция deque()

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

 >>> q=collections.deque([10,20,30,40])
>>> q.appendleft(110)
>>> д
двойная очередь ([110, 10, 20, 30, 40])
>>> q.append(41)
>>> д
двойная очередь ([0, 10, 20, 30, 40, 41])
>>> q.pop()
40
>>> д
двойная очередь ([0, 10, 20, 30, 40])
>>> q.popleft()
110
>>> д
двойная очередь ([10, 20, 30, 40]) 

модуль статистики

Этот модуль предоставляет следующие статистические функции:

mean() : вычисление среднего арифметического чисел в списке

 >>> импорт статистики
>>> статистика.среднее([2,5,6,9])
5.5 

median() : возвращает среднее значение числовых данных в списке. Для нечетных элементов в списке он возвращает значение в позиции (n+1)/2. Для четных значений возвращается среднее значение в n/2 и (n/2)+1 позициях.

 >>> статистика импорта
>>> статистика.медиана([1,2,3,8,9])
3
>>> статистика.медиана([1,2,3,7,8,9])
5.0 

mode(): возвращает наиболее повторяющуюся точку данных в списке.

 >>> статистика импорта
>>> статистика.режим([2,5,3,2,8,3,9,4,2,5,6])
2 

stdev() : вычисляет стандартное отклонение для данной выборки в виде списка.

 >>> статистика импорта
>>>statistics.stdev([1,1.5,2,2.5,3,3.5,4,4.5,5])
1,3693063937629153 

модуль времени

Этот модуль имеет множество функций, связанных со временем.

time():

Эта функция возвращает текущее системное время в тиках. Тики — это количество секунд, прошедших после времени эпохи, т.е. 12:00, 1 января 1970 года.

 >>> time.time()
1544348359.1183174 

localtime():

Эта функция переводит время в тики в виде кортежа времени.

 >>> тк=время.время()
>>> время.местное время(тк)
time.struct_time (tm_year = 2018, tm_mon = 12, tm_mday = 9, tm_hour=15, tm_min=11, tm_sec=25, tm_wday=6, tm_yday=343, tm_isdst=0) 

asctime():

Эта функция возвращает удобочитаемый формат местного времени

 >>> тк=время.