Урок 5.
Модули и пакеты в Python. Импорт. Виртуальная среда venv.

Рассматриваем модули и пакеты из стандартной библиотеки Python и PyPI. Учимся использовать инструкции import и from..import и различать абсолютный и относительный импорт. Разбираемся с виртуальными пространствами venv. Создаем собственные модули.

Logo Python Course Lesson 5
Урок 5.
Модули и пакеты в Python. Импорт. Виртуальная среда venv.
Рассматриваем модули и пакеты из стандартной библиотеки Python и PyPI. Учимся использовать инструкции import и from..import и различать абсолютный и относительный импорт. Разбираемся с виртуальными пространствами venv. Создаем собственные модули.

ТЕОРЕТИЧЕСКИЙ БЛОК

В КОНЦЕ УРОКА ЕСТЬ ВИДЕО
Close
One
1

Модуль (Module) в Python

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

Что такое модуль в терминологии Python? Официальная документация дает следующее определение:
Python Модуль
Module - an object that serves as an organizational unit of Python code. Modules have a namespace containing arbitrary Python objects. Modules are loaded into Python by the process of importing.
Иными словами, модуль(module) в Python - это просто файл, содержащий код на Python. Каждый модуль может содержать переменные, классы и функции. Кроме того, в модуле может находиться исполняемый код. Имя модуля соответствует имени файла. Например:
Пример
# Имя файла
math.py

# Имя модуля
math
Каждая программа может импортировать модуль и получить доступ к его классам, функциям и объектам. Нужно заметить, что модуль может быть написан не только на Python(обычные модули), а например, на C или C++(модули расширения).
Подытожим
Модуль - это отдельный файл с кодом на Python, который:
  1. Имеет расширение *.py (имя файла без расширения является именем модуля).
  2. Может быть импортирован.
  3. Может быть многократно использован.
  4. Позволяет вам логически организовать ваш код на Python.
Two
2

Пакет (Package) в Python

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

Вот что на эту тему говорит документация Python:
Python Пакет
Package - a Python module which can contain submodules or recursively, subpackages.
Пакет - это набор взаимосвязанных модулей(при этом стоит уточнить, что сам пакет тоже является модулем), предназначенных для решения задач определенного класса некоторой предметной области. Это такой способ структуризации модулей. Пакет представляет собой папку, в которой содержатся модули и другие пакеты и обязательный файл __init__.py, отвечающий за инициализацию пакета.
На самом деле
Некоторые пакеты Python не содержат файл __init__.py. Это так называемые namespace packages, которые служат просто как контейнеры подпакетов. Однако мы не станем на них подробно останавливаться, просто будем иметь ввиду, что такие пакеты существуют. Подробнее можно почитать в PEP 420.
Пример содержимого каталога стандартного пакета json, который, как можно заметить, состоит из 4 модулей и файла __init__.py:
Пример
json/
├── __init__.py
├── decoder.py
├── encoder.py
├── scanner.py
└── tool.py
Подытожим
Пакет - это каталог с модулями, другими пакетами и файлом __init__.py. При этом:
  1. Именем пакета является название данного каталога.
  2. С версии Python 3.3 любая папка (даже без __init__.py) считается пакетом.
  3. Пакет может быть импортирован(так же как и модуль).
  4. Пакет может быть многократно использован(так же как и модуль).
Three
3

Классификация модулей

Для удобной и эффективной разработки на Python создано огромное количество модулей и пакетов. Их все можно разделить на 3 группы в зависимости от того, кем создается и где хранится код конкретного модуля:
  1. Стандартная библиотека Python (англ. Standard Library).
  2. Сторонние модули (англ. 3rd Party Modules)
  3. Пользовательские модули
Python. Классификация модулей.
Python. Классификация модулей.
Поговорим о каждой из групп немного подробнее - расскажем, где найти модули в каждом случае, и приведем примеры самых популярных и полезных из них.

1. Стандартная библиотека Python


Стандартная библиотека Python является очень обширной и включает в себя два типа модулей:
  1. Встроенные модули. Входят в состав интерпретатора и написаны на языке С, что позволяет им обеспечивать эффективный доступ к функциональности на уровне ОС - например, к системе ввода-вывода данных. Многие из встроенных модулей являются платформозависимыми. Например, модуль winreg, предназначенный для работы с реестром ОС Windows, устанавливается только на соответствующей ОС.
  2. Модули расширения. Написаны на Python. Представляют собой стандартные способы решения наиболее часто встречающихся задач программирования. Сюда входят модули для работы со многими сетевыми протоколами и форматами интернета, регулярными выражениями, текстовыми кодировками, мультимедийными форматами, криптографическими протоколами, архивами, а также для сериализации данных, поддержки юнит-тестирования и др.
Рассмотрим несколько примеров модулей/пакетов из Стандартной библиотеки Python:
2. Сторонние модули (англ. 3rd Party Modules)

Это модули и пакеты, которые не входят в дистрибутив Python и могут быть установлены из каталога пакетов Python с помощью пакетного менеджера (например, pip или easy_install).

PyPI (Python Package Index) - главный каталог библиотек на Python. Содержит более 200 000 пакетов.

Приведем несколько примеров популярных пакетов из каталога PyPI.
3. Пользовательские (собственные) модули
Python предоставляет возможность создания собственных модулей. Для создания таких модулей нет особенных правил - любой файл с расширением *.py является модулем, а создается, как правило, разработчиком для собственных нужд. В подавляющем большинстве случае такой пакет или модуль не размещается в каталоге пакетов Python.
Four
4

Инструкция импорта import

Python. Инструкция Import для модулей
Чтобы воспользоваться функционалом модуля или пакета, необходимо его импортировать внутрь вашей программы. При импорте интерпретатор сначала ищет встроенный модуль с заданным именем. Если такого модуля нет, то идёт поиск файла <имя_модуля>.py в списке директорий, определённых в переменной sys.path.

Переменная sys.path трибут path модуля sys) – это список строк, которые указывают пути поиска для модулей. При инициализации данный список включает:
  1. рабочую директорию скрипта (основного модуля);
  2. переменную окружения PYTHONPATH и пути инсталляции Python
Если модуль не удается найти, возбуждается исключение ImportError.

Посмотреть данный список можно следующим образом:
      Python - интерактивный режим
      >>> import sys
      >>> sys.path
      ['', '/usr/local/Cellar/python/3.7.5/Frameworks/Python.framework/Versions/3.7/lib/python37.zip', '/usr/local/Cellar/python/3.7.5/Frameworks/Python.framework/Versions/3.7/lib/python3.7', '/usr/local/Cellar/python/3.7.5/Frameworks/Python.framework/Versions/3.7/lib/python3.7/lib-dynload', '/usr/local/lib/python3.7/site-packages']
      При импорте модуля Python выполняет весь код в нём, а при импорте пакета Python выполняет код в файле пакета __init__.py, если такой имеется. Все объекты, определённые в модуле или __init__.py, становятся доступны импортирующему.
      Теперь подробнее рассмотрим процесс импорта с помощью инструкции import. Синтаксис данной команды выглядит следующим образом:
      Синтаксис
      import <модуль/пакет_1> [ as <псевдоним_1> ] [, <модуль/пакет_2> as <псевдоним_2>] ...
      После ключевого слова import указывается название модуля. Одной инструкцией можно подключить несколько модулей, хотя этого не рекомендуется делать, так как это снижает читаемость кода. Правильным тоном считается располагать новый импорт на новой строке.

      После импортирования модуля его название становится переменной, через которую можно получить доступ к атрибутам модуля. Если название модуля слишком длинное, или оно вам не нравится по каким-то другим причинам, то для него можно создать псевдоним с помощью ключевого слова as. При использовании псевдонима доступ ко всем атрибутам модуля осуществляется только с помощью переменной-псевдонима, а переменной с оригинальным именем модуля в этой программе уже не будет (если, конечно, вы после этого не напишете import <модуль>, тогда модуль будет доступен как под именем-псевдонимом, так и под оригинальным именем).

      Далее рассмотрим несколько примеров:
      Терминал - интерактивный режим
      # Импортируем модули time и random
      >>> import time
      >>> import random
      
      # Получаем текущее время в секундах в формате Unix time через модуль time и одноименную функцию time()
      >>> time.time()
      1573500409.296088
      
      # Генерируем рандомное число в диапазоне [0, 1) через модуль random и функцию random()
      >>> random.random()
      0.17151933176087286
      
      # Импортируем модуль os с псевдонимом linux_os
      >>> import os as linux_os
      # Вызываем функцию getcwd() для получения текущей директории, обращаемся через псевдоним
      >>> linux_os.getcwd()
      '/usr/local/Cellar/'
      
      # Импортируем модуль math с псевдонимом m и обратимся к числу e
      >>> import math as m
      >>> m.e
      2.718281828459045

      Задачи по теме


      Импорт библиотек в Python. Различие модулей и пакетов, причины их использования. Актуальные вопросы для проверки понимания темы и задание для самостоятельной практики.

      Five
      5

      Инструкция импорта from ... import

      Инструкция from...import чаще всего используется для частичного импорта.
      Синтаксис данной команды выглядит следующим образом:
      Синтаксис
      from <модуль/пакет> import <атрибут/модуль_1> [ as <псевдоним_1> ], [<атрибут/модуль_2> [ as <псевдоним_2> ] ...]
      Как мы видим, для длинных имен также можно назначить псевдоним, указав его после ключевого слова as.

      В каких ситуациях необходим частичный импорт?
      1. Нужно импортировать только один или несколько модулей из пакета.
      2. Нужно импортировать только один или несколько атрибутов(функций или классов) из модуля.
      Приведем примеры использования в каждом из этих случаев:

      1. Импорт одного или нескольких модулей из пакета
      В качестве примера снова обратимся в пакету из Стандартной библиотеки - json. Импортируем не весь пакет, а только несколько модулей:
      Python - интерактивный режим
      # Импортируем модуль encoder из пакета json
      >>> from json import encoder
      
      # Импортируем модуль encoder из пакета json и даем ему псевдоним
      >>> from json import encoder as enc
      
      # Импортируем модули encoder и decoder из пакета json и даем им псевдонимы
      >>> from json import encoder as en, decoder as dec
      Python. Инструкция from ... import. Синтаксис.
      Инструкция from ... import. Синтаксис.
      2. Импорт одного или нескольких атрибутов из модуля
      Для примера импортируем несколько атрибутов из стандартного модуля math:
      Python - интерактивный режим
      # Импортируем число e из модуля math
      >>> from math import e
      >>> e
      2.718281828459045
      
      # Импортируем функцию cos() из модуля math
      >>> from math import cos
      >>> math.cos(0)
      1.0
      
      # Импортируем число Пи из модуля math и дадим ему псевдоним
      >>> from math import pi as number_pi
      >>> number_pi
      3.141592653589793
      Также существует еще одни формат инструкции from - так называемый Wildcard импорт. Он позволяет подключить все (точнее, почти все) переменные из модуля. Синтаксис:
      Синтаксис
      from <модуль/пакет> import *
      Однако, PEP8 использовать его не рекомендует, потому что в случае такого типа импорта становится не всегда понятно, какие имена доступны в текущем пространстве имен. Это создает сложности как для людей, которые читают код, так и для автоматизированных систем, работающих с таким кодом.
      Six
      6

      Относительный и абсолютный импорт

      При работе с пакетами может возникнуть ситуация, когда необходимо импортировать подпакет или модуль из другого каталога - соседнего или на уровень выше/ниже. Чтобы интерпретатор Python понял, где искать, ему нужно указать правильный путь в дереве каталогов к модулю/пакету, который вы собираетесь импортировать. В Python данный путь(как и сам импорт) может быть двух видов:
      1. Абсолютный
      2. Относительный
      Далее поговорим о каждом из них более подробно.

      1. Абсолютный импорт
      При абсолютном импорте используется полный путь к желаемому(импортируемому) модулю.
      Полный путь к модулю - это путь от корневой папки проекта. Формат абсолютного пути:
      <пакет_1>.<пакет_2>.<пакет_n>.<модуль/пакет>

      Например, если рассмотреть проект со следующей структурой:
        Пример проекта на Python
        projectfruits
            ├── citrus
                  ├── __init__.py
                  ├── grapefruit.py
                  ├── lemon.py
                  └── orange.py
            ├── apple.py
            └── banana.py
        То абсолютные пути модулей проекта будут выглядеть следующим образом:
        Абсолютные пути проекта на Python
        citrus.grapefruit
        citrus.lemon
        citrus.orange
        apple
        banana
        Идем дальше. При абсолютном импорте одинаково могут использоваться обе выше рассмотренные инструкции:
        1. import <полный_путь>
        2. from <полный_путь> import <объект_импорта>
        И несколько примеров вдогонку:
        Python
        # Импортируем модуль apple в модуль lemon
        import apple
        
        # Импортируем функцию baz из модуля apple в модуль lemon
        from apple import baz
        
        # Импортируем модуль lemon в модуль apple двумя равнозначными способами
        import citrus.lemon
        from citrus import lemon
        
        # Импортируем функцию foo из модуля lemon в модуль apple
        from citrus.lemon import foo
        
        
        Python. Абсолютный и относительный импорт.
        Абсолютный и относительный импорт
        2. Относительный импорт

        Как несложно будет догадаться, при относительном виде импорта используются относительные пути к импортируемому файлу. Относительный путь показывает, на сколько директорий вверх необходимо подняться. Формат относительного пути:
        .<модуль/пакет>

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

        При относительном импорте(в отличие от абсолютного) может использоваться только вторая инструкция:
        from <относительный путь> import <объект_импорта>

        И в завершение пара примеров:
        Python
        # Импортируем модуль lemon в модуль orange(находятся в одном пакете citrus)
        from . import lemon
        
        # Импортируем функцию foo из модуля lemon в модуль orange(находятся в одном пакете citrus)
        from .lemon import foo
        ВАЖНО!
        Стоит отметить несколько важных моментов при работе с абсолютными и относительными импортами:
        1. Корневая директория проекта, а также текущая директория(директория, в которой лежит исполняемый скрипт) уже находятся в списке каталогов для поиска модулей sys.path. То есть при запуске определенных модулей у вас может сработать импорт даже без указания абсолютного пути, просто потому что этот модуль находится в одной из указанных директорий.
        2. Абсолютный путь строится от корневой папки проекта.
        3. Единственный приемлемый синтаксис для относительных импортов - from .<модуль/пакет> import <объект_импорта>. Все импорты, которые начинаются не с точки . , считаются абсолютными.
        4. Как правило, абсолютные импорты предпочтительнее относительных. PEP 8 рекомендует использовать абсолютный импорт, но утверждает, что в некоторых сценариях допустим и относительный импорт. Цитата: "Absolute imports are recommended, as they are usually more readable and tend to be better behaved (or at least give better error messages) if the import system is incorrectly configured (such as when a directory inside a package ends up on sys.path)".
        5. Постарайтесь запомнить: любой скрипт с относительными импортами НЕЛЬЗЯ запустить напрямую. Если вы попробуете это сделать, то неминуемо получите ошибку. Ошибка возникает из-за того, что при запуске модуля Python его имя становится __main__, соответственно, относительный импорт будет производиться относительно __main__, а не пакета, в котором он находится. То есть, например, при запуске скрипта с относительным импортом вместо директории для поиска 'citrus.orange' вы получите '__main__' и ваш импорт упадет c ошибкой вроде этой: 'ImportError: attempted relative import with no known parent package.'.
        Seven
        7

        Виртуальные окружения Python. Модуль venv.

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

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

        Для решения вышеперечисленных задач используется подход, основанный на построении виртуальных окружений Python – своего рода песочниц, внутри которых изолированно запускается приложение со своими библиотеками. При этом если данное приложение обновляет и изменяет данные библиотеки, это никак не затрагивает другие приложения с такими же библиотеками-зависимостями. Таким образом, виртуальное окружение в Python — способ изолировать зависимости (пакеты) для определённого проекта.
        Python. Виртуальные окружения venv.
        Виртуальные окружения Python
        Каков алгоритм работы с виртуальным пространством?
        1. Создать ВП
        2. Активировать ВП
        3. Внести изменения(например, установить новый модуль)
        4. Деактивировать ВП

        А теперь подробнее.

        1. Как создать виртуальное окружение?
        Существует достаточно много модулей, которые позволяют создавать виртуальные окружения в Python. Некоторые уже входят в стандартную библиотеку(venv), другие необходимо установить из каталога PyPI(virtualenv, pyenv).

        Создать виртуальную среду с помощью выбранной утилиты можно по-разному, в зависимости от того, где вы работаете с кодом:
        1. Можно создать виртуальное окружение в консоли. Например, в случае стандартного модуля venv это будет выглядеть следующим образом: python3 -m venv /path/to/new/virtual/environment
        2. Если вы работаете с IDE(например, PyCharm) при создании проекта необходимо выбрать соответствующую опцию по созданию виртуального пространства. Обратите внимание, что в зависимости от уже установленных библиотек, в выпадающем списке могут быть доступны несколько вариантов модулей, создающих виртуальные среды:
        Python. Создание виртуального пространства проекта venv в PyCharm.
        Создание виртуального пространства проекта в PyCharm
        В результате создается директория с говорящим названием venv, которая содержит все файлы, необходимые для поддержания и корректного функционирования свежесозданной виртуальной среды. Содержимое данного каталога на Linux выглядит приблизительно так:
        Директория venv
        ├── bin
        │   ├── activate
        │   ├── activate.csh
        │   ├── activate.fish
        │   ├── easy_install
        │   ├── easy_install-3.5
        │   ├── pip
        │   ├── pip3
        │   ├── pip3.8
        │   ├── python -> python3.8
        │   ├── python3 -> python3.8
        │   └── python3.8 -> /Library/Frameworks/Python.framework/Versions/3.8/bin/python3.8
        ├── include
        ├── lib
        │   └── python3.8
        │       └── site-packages
        └── pyvenv.cfg
        В ОС Windows структура директории venv выглядит схожим образом.

        Что находится в этих директориях?
        1. bin – файлы, обеспечивающие взаимодействие с виртуальной средой;
        2. include – С-заголовки, компилирующие пакеты Python;
        3. lib – копия глобальной версии Python вместе с папкой site-packages, в которой установлены библиотеки для общего пространства

        2. Как активировать виртуальную среду?
        Итак, вы создали виртуальное пространство для вашего проекта и хотите им воспользоваться. Для этого необходимо его активировать. Процесс активации среды немного различается в зависимости от типа операционной системы:
        Консоль
        # Для Linux
        # Используем команду source и передаем ей скрипт activate из папки bin
        $ source my_project/venv/bin/activate
        
        # Для Windows
        # Запускаем bat-файл activate.bat
        > D:\home\python\project\env\Scripts\activate.bat
        3. Работа внутри виртуальной среды
        Теперь с помощью одного из менеджеров пакетов(pip или easy_install) можно просматривать/устанавливать/изменять/удалять пакеты. Несколько примеров с использованием менеджера pip:

        Консоль
        # Список установленных библиотек
        $ pip3 list
        Package            Version 
        ------------------ -------- 
        certifi            2019.3.9     
        pip                19.3.1   
        pytest             5.4.2   
        requests           2.22.0  
        selenium           3.141.0 
        setuptools         41.6.0  
        six                1.12.0  
        urllib3            1.25.2  
        
        # Установка библиотеки requests
        $ pip3 install requests
        
        # Удаление библиотеки six
        $ pip3 uninstall six

        4. Как деактивировать виртуальную среду?
        После того, как вы завершили работу с текущей средой, необходимо ее деактивировать. Процесс так же немного отличается на разных типах ОС:
        Консоль
        # Для Linux
        # В рамках текущей сессии вызываем команду deactivate
        (venv) $ deactivate
        
        # Для Windows
        # Запускаем bat-файл deactivate.bat
        > D:\home\python\project\env\Scripts\deactivate.bat

        ПРАКТИЧЕСКИЙ БЛОК

        One
        1

        Исполняемая часть модуля. Переменная __name__.

        Модуль в Python можно использовать следующим образом:
        1. Запустить автономно. Модуль - это скрипт на Python, а значит, его можно запустить в терминале/консоли или через IDE.
        2. Импортировать. При этом, как мы уже рассмотрели выше, используется инструкция import.
        При написании модуля необходимо заранее продумать, будет он запускаться самостоятельно, или он предназначен для импорта в другие модули. Почему это важно? Потому что, как мы писали выше, при импорте исполняемая часть кода будет выполнена интерпретатором.

        Рассмотрим пример. Перед нами модуль calculator, который содержит две функции(sum_up() для сложения и sub() для вычитания) и исполняемую часть(тесты функций модуля):

        calculator.py
        # Функции
        def sum_up(a, b):
            return a + b
        
        
        def sub(a, b):
            return a - b
        
        
        # Исполняемый код
        print('Сумма: ', sum_up(2, 3))
        print('Разность: ', sub(5, 1))
        Если мы запустим модуль calculator самостоятельно, то будет выполнена исполняемая часть. Вывод в консоль:
        Терминал
        $ python3 calculator.py 
        Сумма:  5
        Разность:  4
        А что произойдет с исполняемой частью, если мы импортируем модуль calculator внутрь другого модуля? Ответ - то же самое! Она также будет выполнена интерпретатором. Нужно ли это во время импорта? В подавляющем большинстве случаев - нет.

        Как этого избежать? Как сделать так, чтобы при автономном запуске скрипта исполняемая часть выполнялась, а при импорте - нет? Ответ следующий: достаточно использовать специальный атрибут модуля __name__, который меняет свое значение в зависимости от того, запущен модуль или импортирован:
        1. Атрибут __name__ содержит имя модуля, если он был импортирован (например, "calculator" или "math")
        2. Атрибут __name__ принимает значение "__main__", если модуль был запущен автономно.
          Python. Проверка значения атрибута __name__​.
          Проверка значения атрибута __name__
          Соответственно для решения проблемы поступают следующим образом:
          1. Вспомогательные модули(т. е. те модули, которые планируется импортировать) избавляются от кода вне функций и/или классов.
          2. В основном файле программы(тот модуль, который планируется запускать) вставляется проверка атрибута __name__. Выглядит эта проверка следующим образом(наверняка, вы уже видели ее не раз, но не заостряли внимание, как это работает):
          Python
          # Классы/ функции модуля
          # <..>
          
          if __name__ == '__main__':
              # Исполняемая часть
              # <..>
          При наличии такой проверки если этот файл будет импортирован, его исполняемый код не будет выполняться интерпретатором Python.
          One
          2

          Решаем задачи на модули

          Мы теперь знаем, что модули и пакеты в Python бывают разными - одни поставляются сразу с интерпретатором Python, другие необходимо устанавливать из репозитория пакетов PyPI, третьи - собственные модули разработчиков для конкретных проектов. Большинство модулей подлежат импорту. Импорт может осуществляться с помощью инструкций import и from..import. Иногда модуль, который мы хотим импортировать, лежит в каталоге, отличном от места импорта. Тогда необходимо обратить особое внимание на построение пути к импортируемому модулю - ведь путь может быть абсолютным и относительным.

          В практическом задании мы поработаем со следующими модулями и пакетами:
          1. this
          2. http
          3. requests
          4. wget
          И также рассмотрим такие аспекты как:
          1. Работа с менеджером пакетов pip и репозиторием пакетов PyPI
          2. Создание и работа с виртуальными окружениями venv
          3. Абсолютный и относительный импорт

          Сами задания выглядят следующим образом:
          Возможные способы выполнения предложенных заданий смотрите в нашей видео-инструкции:
          Хронометраж
          00:15 Roadmap
          01:30 ТЕОРЕТИЧЕСКАЯ ЧАСТЬ
          01:35 Модули
          02:40 Пакеты
          03:45 Классификация
          06:00 Команды импорта
          06:45 Команда import
          08:15 Команда from … import
          10:25 Абсолютный и относительный импорт
          11:00 Абсолютный путь
          12:30 Относительный путь
          14:05 Виртуальные окружения venv
          15:45 Способы поиска установленных модулей
          22:20 ПРАКТИЧЕСКАЯ ЧАСТЬ
          22:25 Задание 1. Стандартная библиотека. Модуль this. Пакет http.
          36:15 Задание 2. Модули из репозитория пакетов PyPI. Менеджер пакетов pip. Виртуальные окружения. Пакеты requests и wget.
          49:55 Задание 3. Собственные модули. Абсолютный и относительный импорт.

          Читайте также

          Three
          3

          Домашнее задание

          Задание 1
          Стандартная библиотека. Модуль calendar.
          Выполните следующие действия:
          1. Изучите справку для модуля calendar
          2. Импортируйте модуль calendar
          3. Найдите расположение файла модуля calendar и изучите его содержимое
          4. Получите список доступных атрибутов модуля calendar
          5. С помощью модуля calendar узнайте, является ли 2027 год високосным
          6. С помощью модуля calendar узнайте, каким днем недели был день 25 июня 1995 года
          7. Выведите в консоль календарь на 2023 год
            Задание 2
            Репозиторий PyPI. Пакет FuzzyWuzzy.
            Пакет FuzzyWuzzy - это библиотека для нечеткого сравнения строк. Нечеткое сравнение строк позволяет не просто сказать - одинаковые строки или нет, а определить степень их похожести. В текущем задании предлагаем вам поработать с данной библиотекой:

            1. Изучите документацию для пакета fuzzywuzzy на https://pypi.org/
            2. Установите его с помощью менеджера пакетов pip
            3. Определите, какие модули включает пакет fuzzywuzzy
            4. Изучите модуль для базового сравнения строк fuzz(входит в пакет): импортируйте его и получите список доступных атрибутов.
            5. Изучите синтаксис метода для базового нечеткого сравнения строк ratio() (входит в состав модуля fuzz). Прим.: Данный метод возвращает индекс схожести 2 срок
            6. Воспользуйтесь методом ratio() для сравнения следующих срок:
            1) 'Плохой код на самом деле не плохой.' и 'Его просто не так поняли.'
            2) 'Работает? Не трогай.' и 'Работает? Не трогай.'
            3) 'Работает? Не трогай.' и 'Работает? Не трогай!
            Также предлагаем вам к рассмотрению и изучению наши варианты решений и соответствующие комментарии к каждому из заданий.
            Как вам материал?

            Читайте также