По вашему запросу ничего не найдено :(
Убедитесь, что запрос написан правильно, или посмотрите другие
наши статьи:
Невозможно реализовать управление контейнерами приложений в требуемом масштабе (особенно в контексте CI/CD или конвейера DevOps) без автоматизации. Примерно 57% компаний имеют от 2 до 8 контейнеров на каждое приложение (31% компаний имеют от 11 до 100 на каждое приложение). Именно поэтому нецелесообразно будет использовать десятки или даже сотни приложений без оркестровки контейнеров, особенно если речь идет о долгосрочной перспективе.
Эта статья является введением в тему оркестровки контейнеров, и она подчеркивает важность того, что при управлении контейнеризованными службами и рабочими нагрузками необходимо избегать трудоемких задач. Я предлагаю прочесть вам эту статью, чтобы узнать, что предлагает вашему вниманию эта стратегия, а также как оркестровка может поспособствовать повышению продуктивности IT-команд и увеличению дохода.
Что такое оркестровка контейнеров?
Оркестровка контейнеров – это стратегия использования автоматизации для управления жизненным циклом контейнеров приложений. Такой подход автоматизирует трудоемкие задачи, такие как (повторное) создание, масштабирование и обновление контейнеров. Таким образом, он избавляет команды от рутинной ручной работы. Оркестровка также помогает в управлении возможностями сети и хранилища.
Контейнеры – это упрощенные исполняемые компоненты приложения, которые содержат все необходимое для надежного запуска программного кода в различных IT-средах. Команды разбивают программное обеспечение на контейнеры с целью упростить запуск, перемещение, обновление и упаковку приложений. Один контейнер содержит:
исходный код приложения;
библиотеки операционной системы (ОС);
зависимости, которые необходимы для того, чтобы запустить программное обеспечение (например, определенные версии сред выполнения языка программирования).
Контейнеры считаются более переносимыми и более эффективными с точки зрения ресурсов в сравнении с виртуальными машинами. Они также являются одной из лучших вычислительных стратегий разработки современного программного обеспечения и архитектуры приложений, оптимизированной для выполнения в облаке. Но есть здесь одно «но» -
чем больше используется контейнеров, тем больше времени и ресурсов разработчики должны тратить на то, чтобы ими управлять.
Представим, что у вас есть 40 контейнеров, которые необходимо обновить. Можно выполнить это вручную, но это займет часы, а то и дни. И вот здесь в игру вступает оркестровка контейнеров – вместо того, чтобы делать все вручную, вы указываете инструменту выполнить 40 обновлений с помощью всего одного YAML-файла.
По данным недавнего опроса, 70% разработчиков, которые работают с контейнерами, используют платформу оркестровки контейнеров. При этом, 75% из них полагаются на полностью управляемую службу оркестровки контейнеров от поставщика облачных услуг. Нет ничего удивительного в том, что самые высокие показатели скорости внедрения оркестровки контейнеров именно в командах DevOps.
Для чего нужна оркестровка контейнеров?
Оркестровка контейнеров автоматизирует многие подвижные части контейнеризованного программного обеспечения. В зависимости от платформы возможности различаются, но большая часть инструментов позволяют автоматизировать следующие задачи:
конфигурация и планирование контейнеров (когда и как контейнеры запускаются и останавливаются, планирование и согласование действий каждого компонента и т.д.);
подготовка к работе и развертывание контейнеров;
масштабирование контейнеров (как в большую сторону, так и в меньшую) для балансировки рабочих нагрузок;
распределение ресурсов и перемещение файлов (например, если один из контейнеров начинает потреблять слишком много оперативной памяти в узле, то платформа перемещает все остальные контейнеры в другой узел);
балансировка нагрузки и маршрутизация трафика;
управление кластерами;
обнаружение служб (как микрослужбы или приложения обнаруживают друг друга в сети);
наблюдение за работоспособностью системы, включая процессы отката и восстановления после отказа (как для контейнеров, так и для хостов);
доступность и резервирование контейнеров;
защита взаимодействий типа контейнер-контейнер и контейнер-хост;
обновления и модификации контейнеров.
Принцип работы оркестровки контейнеров
Большая часть платформ оркестровки поддерживают декларативную модель конфигурации, которая позволяет пользователям определять необходимый результат выполнения, не предоставляя при этом подробных инструкций. Разработчик пишет файл конфигурации (обычно на YAML или JSON), чтобы описать ту конфигурацию, которую он хочет получить, и инструмент работает так, чтобы сделать все возможное для получения необходимого результата. Роль такого файла конфигурации состоит в следующем:
определять, какие образы контейнеров являются частью приложения;
направлять платформу в сторону расположения образов, например, Docker Hub;
обеспечивать контейнеры необходимыми ресурсами (например, хранилищем);
определять и защищать сетевые соединения между контейнерами;
предоставлять инструкции по установке объема памяти и хранению журналов.
Большинство команд разветвляют файлы конфигурации и контролируют их версии. Именно по этой причине инженеры могут развертывать одно и то же приложение в различных средах разработки и тестирования перед тем, как пустить приложение в производство.
После того, как файл конфигурации будет предоставлен, инструмент оркестровки автоматически запланирует развертывание контейнера. Платформа выбирает оптимальный хост, основываясь на доступности процессора, памяти и других условиях, которые указаны в файле конфигурации (например, в зависимости от метаданных или близкого расположения какого-то конкретного хоста). Если не указаны иные основания, то большинство инструментов развертывают копии для того, чтобы обеспечить резервирование контейнеров.
После того, как инструмент развернет контейнер, платформа начнет управлять жизненным циклом контейнеризованного приложения. Сюда входит:
управление масштабируемостью, маршрутизацией трафика и распределением ресурсов между контейнерами;
обеспечение высокого уровня доступности и производительности каждого контейнера;
сбор и хранение данных журналов для контроля за работоспособностью и производительностью приложений;
попытки устранить проблемы и восстановить контейнеры при сбое (оно же самовосстановление).
Оркестровка контейнеров работает в любой среде, которая поддерживает контейнеры – от привычных выделенных серверов до облачного развертывания любого типа.
Что можно сказать об оркестровки мультиоблачных контейнеров?
Мультиоблако – это стратегия облачных вычислений, при которой вы прибегаете к помощи двух или более сторонних поставщиков. Оркестровка мультиоблачных контейнеров – это использование инструмента для управления контейнерами, которые перемещаются в мультиоблачных средах вместо того, чтобы работать в одной инфраструктуре.
Настройка оркестровки контейнеров для разных поставщиков иногда бывает довольно сложной, но если немного постараться, то можно получить множество преимуществ, например,
повышенная производительность инфраструктуры;
возможности для оптимизации расходов на облако;
улучшенная гибкость и переносимость контейнеров;
меньшая возможность появления зависимости от поставщика;
дополнительные возможности масштабирования.
Контейнеры и мультиоблако можно отлично совмещать. Несколько сред поддерживают переносимость контейнеров, которая позволяет «запускать их где угодно», в то время как контейнеризованные приложения раскрывают эффективность использования двух или более облачных предложений на максимум.
Преимущества оркестровки контейнеров
Ниже приведены основные преимущества оркестровки контейнеров:
ускоренное выполнение действия за счет автоматизации
: оркестровка контейнеров экономит невероятное количество времени за счет автоматизации таких задач, как выделение ресурсов для контейнеров, балансировка нагрузки, настройка конфигураций, планирование и оптимизация сетей.
более простое управление
: по своей сути контейнеры существенно усложняют обычные повседневные операции. Одно приложение может иметь сотни, а то и тысячи, контейнеров. Именно по этой причине все очень быстро может выйти из-под контроля, если не использовать платформу оркестровки.
повышение продуктивности сотрудников
: примерно 74% компаний отмечают, что их команды становятся более продуктивными, если не тратят время на рутинные задачи. Команды выпускают новые функции быстрее, что приводит к тому, что продукт будет быстрее выведен на рынок, а также открывается больше возможностей для инновационных разработок с высоким финансовым результатом.
экономия ресурсов и средств
: оркестровка контейнеров придерживается оптимального использования ресурсов обработки и памяти, избегая лишних накладных расходов.
дополнительная безопасность
: оркестровка контейнеров ощутимо сокращает вероятность человеческого фактора, который является основной причиной успешного результата кибератак. Более 73% компаний отмечают улучшения с точки зрения безопасности после того, как они начали использовать оркестровку. Эта стратегия также изолирует процессы приложений и обеспечивает большую наглядность, что снижает количество потенциальных атак.
улучшенное качество приложения
: почти 78% команд отмечают, что, благодаря внедрению оркестровки контейнеров, улучшилось качество приложений. Также 73% компаний заявили, что они повысили уровень удовлетворенности пользователей за счет улучшения приложений.
улучшенные показатели удержания сотрудников
: оркестровка контейнеров освобождает команды от рутинной работы и дает им возможность заниматься более интересными задачами, что повышает уровень удовлетворенности от работы у сотрудников и помогает компании не растерять таланты.
увеличенное время работы служб
: платформа оркестровки контейнеров находит и устраняет такие проблемы, как сбои инфраструктуры, гораздо быстрее, чем если бы это делал человек. Более 72% компаний отмечают, что время простоя служб значительно уменьшилось после того, как была внедрена оркестровка.
Самые популярные инструменты оркестровки контейнеров
Чтобы использовать оркестровку контейнеров, вам потребуется соответствующий инструмент. Давайте взглянем на пять самых популярных инструментов, которые можно сейчас найти на рынке.
Kubernetes
Kubernetes (K8s или Kube) – это инструмент оркестровки контейнеров с открытым исходным кодом для контейнеризованных рабочих нагрузок и служб. В 2015 году Google подарил K8s Фонду облачно-ориентированных вычислений (CNCF - Cloud Native Computing Foundation). После этого он стал самым популярным инструментом оркестровки контейнеров в мире.
По данным исследования CNCF 2021 года, в прошлом году количество инженеров, работающих с Kubernetes, выросло на 67% и достигло рекордной отметки в 3,9 миллиона человек. Популярность К8s послужила толчком к появлению разного рода предложений Kubernetes как услуги (KaaS - Kubernetes-as-a-Service) (они все будут полезны для вас, если вы все-таки решите работать с оркестровкой), в том числе:
Amazon Elastic Container Service (ECS);
Azure Kubernetes Services (AKS);
Google Kubernetes Engine (GKE);
VMwaare Tanzu;
Knative;
Istio;
Cloudify;
Rancher.
Главные причины использовать Kubernetes
Ведущие в отрасли функциональные возможности (обнаружение служб, оркестровка хранилища, автоматическое внедрение и откат, самовосстановление, использование технологии Dual-Stack и т.д.) и набор инструментов поддержки с открытым исходным кодом, который постоянно расширяется.
Дополнительные функции автоматического масштабирования позволяют проводить высокоуровневое масштабирование (HPA - для горизонтального масштабирования, VPA - для вертикального масштабирования, и Cluster Autoscaler - для оптимизации количества узлов).
Поддержка огромного сообщества, которое постоянно добавляет новые функции.
Docker Swarm
Docker Swarm – это платформа оркестровки контейнеров с открытым исходным кодом. Она известна за счет свой простоты в настройке и использовании. Swarm – это режим работы в собственной системе команд Docker (инструмент для контейнеризации), который позволяет пользователям управлять «докеризированными» приложениями.
Главные причины использовать Docker Swarm
Проще с точки зрения настройки и использования в сравнении с Kubernetes (также имеет меньше функций, что делает Swarm более приемлемым вариантом для не очень сложных сценариев использования).
Идеальный вариант для тех пользователей Docker, которые ищут более простой и быстрый способ развертывания контейнеров.
Низкая кривая обучения делает Swarm идеальным вариантом для менее опытных команд и новичков в оркестровке контейнеров.
Nomad
Nomad – это инструмент оркестровки как для контейнеризованных, так и для неконтейнеризованных приложений, который был разработан HashiCorp (компания, которая стоит за Terraform – одним из лучших инструментов инфраструктуры как кода (Infrastructure-as-Code) на рынке). Платформу можно использовать как самостоятельный оркестратор, так и в качестве дополнения к Kubernetes.
Главные причины использовать Nomad
Идеальный вариант, если вы уже используете продукты компании HashiCorp, такие как Terraform, Vault или Consul.
Инструмент занимает мало места (Nomad работает как самостоятельный двоичный файл и работает на всех основных операционных системах).
Гибкий и простой в использовании оркестратор, который поддерживает рабочие нагрузки не только в контейнерах (ПО предыдущих версий, виртуальные машины, рабочие нагрузки Docker и т.д.).
OpenShift
OpenShift от компании Red Hat – это ведущая платформа как услуга (PaaS – Platform-as-a-Service) для создания, развертывания и управления контейнеризованными приложениями. Платформа позволяет расширить функциональные возможности Kubernetes и является популярным вариантом для рабочих процессов непрерывной интеграции за счет встроенного конвейера Jenkins.
Главные причины использовать OpenShift
Различные функции для управления кластерами через пользовательский интерфейс и интерфейс командной строки.
Высокооптимизированная платформа, которая хорошо подходит для развертывания гибридных облачных сред.
Большой выбор шаблонов и готовых образов для создания баз данных, фреймворков и служб.
Apache Mesos (с использованием Marathon)
Mesos – это платформа с открытым исходным кодом для управления кластерами, которая вкупе с собственным фреймворком Marathon становится отличным (пусть даже и немного дорогим) инструментом оркестровки контейнеров.
Несмотря на то, что Mesos не так популярен, как, например, Kubernetes или Docker Swarm, он все же является излюбленным инструментом оркестровки для некоторых известных компаний, таких как Twitter, Yelp, Airbnb, Uber и Paypal.
Главные причины использовать Apache Mesos
Высокомодульная архитектура, которая позволяет пользователям легко масштабировать систему до 10 000 с лишним узлов.
Упрощенная кроссплатформенная платформа оркестровки с свойственной ей гибкостью и масштабируемостью.
API-интерфейсы Mesos поддерживают Java, C++ и Python, а платформа работает на Linux, Windows и OSX.
Kubernetes, Docker Swarm и Apache Mesos пережили так называемую «оркестровую войну» в начале и середине 2010-х годов. Была гонка за право называться отраслевым стандартом для управления контейнерами. 29 ноября 2017 года «победил» K8s. Это произошло, когда AWS анонсировала свое предложение Elastic Container Service для Kubernetes.
Отраслевой стандарт для контейнеризованных приложений
Контейнеры изменили наше представление о том, как надо создавать и сопровождать программное обеспечение. В основу этого процесса эволюции легла оркестровка контейнеров, так как она позволила извлечь максимальную выгоду от использования микрослужб и ощутимо оптимизировать повседневные операции. Эффективное управление контейнерами так и останется приоритетным направлением в будущем, так что настройтесь на то, что оркестровка будет только набирать популярность в мире контейнеризованных приложений.
Хотите работать с объектно-ориентированным проектированием в Python? Начните уже сегодня, изучив метод Python под названием
__init__
.
В этом руководстве мы пробежимся по основам классов и объектов Python, после чего посмотрим, что же такое метод
__init__
.
После прочтения вы сможете ответить на такие вопросы, как:
Что такое переменные экземпляра класса и атрибуты класса?
Каким образом метод
__init__
инициализирует атрибуты класса?
Как можно установить для атрибутов значения по умолчанию?
Как можно использовать методы класса в качестве конструкторов для создания объектов?
Давайте начнем.
Классы и объекты Python
Классы – это основа объектно-ориентированного программирования в Python. Мы можем создать класс и определить
атрибуты
и
методы
для того, чтобы связать
данные
и соответствующие
функции
.
После того, как вы создадите класс, вы можете использовать его как макет (или шаблон) для создания объектов (экземпляров класса).
Время примеров! Давайте создадим класс
Employee
, где у каждого объекта класса есть следующие атрибуты:
full_name
: полное имя сотрудника в формате
firstName lastName
emp_id
: идентификатор сотрудника
department
: отдел, в котором работает сотрудник
experience
: опыт, который имеет сотрудник (количество лет)
Что это значит?
Каждый отдельный сотрудник – это экземпляр или объект класса
Employee
, и у каждого объекта есть свои значения для атрибутов
full_name
,
emp_id
,
department
и
experience
.
Эти атрибуты также называются
переменными экземпляра
. Дальше мы будем использовать оба термина (атрибуты и переменные экземпляра), так как они взаимозаменяемы.
Атрибуты мы добавим чуть позже. А пока мы создадим класс
Employee
:
class Employee:
pass
Ключевое слово
pass
(которое мы используем в качестве заполнителя) помогает избежать возникновения ошибок при запуске сценария.
Несмотря на то, что такая версия класса
Employee
мало чем может нам помочь, она все же является допустимым классом. Итак, теперь мы можем создавать объекты класса
Employee
:
employee_1 = Employee()
print(employee_1)
#Output: <__main__.Employee object at 0x00FEE7F0>
Кроме того, мы можем добавить атрибуты и инициализировать их значения:
employee_1.full_name = 'Amy Bell'
employee_1.department = 'HR'
Однако при таком подходе довольно часто возникают ошибки, и по сути он считается неэффективным. Кроме того, в данном случае вы не сможете использовать класс в качестве шаблона для создания объектов. И вот здесь на помощь приходит метод
__init__
.
Роль метода __init__ в классе Python
Когда мы создаем экземпляр класса, у нас должна быть возможность инициализировать переменные этого экземпляра, и в этом нам помогает метод
__init__
. Метод
__init__
вызывается каждый раз, когда создается новый объект класса, для того, чтобы инициализировать значения переменных экземпляра.
Если вы когда-нибудь работали с таким языком, как С++, то вы заметите, что метод
__init__
работает по аналогии с конструкторами.
Определение метода __init__
Давайте добавим метод
__init__
в класс
Employee
:
class Employee:
def __init__(self, full_name,emp_id,department,experience):
self.full_name = full_name
self.emp_id = emp_id
self.department = department
self.experience = experience
Параметр
self
- это экземпляр класса, а
self.attribute
присваивает атрибутам экземпляра класса значения, указанные справа.
И теперь мы можем создавать вот такие объекты:
employee_2 = Employee('Bella Joy','M007','Marketing',3)
print(employee_2)
# Output: <__main__.Employee object at 0x017F88B0>
Когда мы попытаемся распечатать объекты, которые обозначают сотрудников, мы не получим никакой полезной информации, кроме класса, к которому они принадлежат. Давайте добавим метод
__repr__
, который будет задавать способ вывода информации для класса:
def __repr__(self):
return f"{self.full_name},{self.emp_id} from {self.department} with {self.experience} years of experience."
Добавим метод
__repr__
в класс
Employee
и получим:
class Employee:
def __init__(self, full_name,emp_id,department,experience):
self.full_name = full_name
self.emp_id = emp_id
self.department = department
self.experience = experience
def __repr__(self):
return f"{self.full_name},{self.emp_id} from {self.department} with {self.experience} years of experience."
Теперь вывод объектов класса
Employee
стал более полезным с точки зрения информации, которую он содержит:
print(employee_2)
# Output: Bella Joy,M007 from Marketing with 3 years of experience.
Некоторые соглашения
Прежде чем двигаться дальше, обратите внимание на несколько замечаний:
Мы использовали
self
в качестве первого параметра в методе
__init__
, чтобы сделать ссылку на сам экземпляр класса, а для инициализации различных атрибутов мы использовали
self.attribute_name
. Рекомендуется использовать именно параметр
self
(впрочем, вы можете использовать любое другое имя).
Когда мы определяли метод
__init__
, мы устанавливали имена параметров так, чтобы они соответствовали именам атрибутов. При таком подходе читать код гораздо проще.
Как добавить значения по умолчанию для атрибутов
В нашем примере до сих пор нет атрибутов, нам нужно их добавить. Под успешным созданием объекта понимается то, что мы должны передать в конструктор значения для всех полей.
Давайте попробует создать экземпляр класса
Employee
, но при этом мы не будем передавать ему значение для атрибута
experience
:
employee_3 = Employee('Jake Lee','E001','Engineering')
Вы получите ошибку:
Traceback (most recent call last):
File "main.py", line 22, in
employee_3 = Employee('Jake Lee','E001','Engineering')
TypeError: __init__() missing 1 required positional argument: 'experience'
Но если вы хотите, чтобы не все атрибуты были обязательными, определяя метод
__init__
, вы можете указать для них значения по умолчанию.
В данном случае мы указали для атрибута
experience
значение по умолчанию
0
:
class Employee:
def __init__(self, full_name,emp_id,department,experience=0):
self.full_name = full_name
self.emp_id = emp_id
self.department = department
self.experience = experience
def __repr__(self):
return f"{self.full_name},{self.emp_id} from {self.department} with {self.experience} years of experience."
Мы смогли создать объект
employee_3
, не указывая значение для атрибута
experience
; значение по умолчанию для этого атрибута – 0.
employee_3 = Employee('Jake Lee','E001','Engineering')
print(employee_3.experience)
# Output: 0
Альтернативные конструкторы классов, которые используют методы класса
Пока мы только разобрали, как можно определить метод
__init__
и как можно установить значения по умолчанию для атрибутов (если это необходимо). Кроме того, мы знаем, что мы должны передать значения в конструктор для всех необходимых атрибутов.
Однако бывают такие ситуации, когда значения этих переменных экземпляра класса (или атрибутов) могут иметь совсем иную структуру данных, например, кортеж, словарь или строка JSON.
Так что же нам делать?
Давайте приведем пример. Представим, что у нас есть значения для переменных экземпляра класса, но они хранятся в словаре Python:
dict_fanny = {'name':'Fanny Walker','id':'H203','dept':'HR','exp':2}
Мы можем обратиться к словарю и получить все атрибуты следующим образом:
name = dict_fanny['name']
id = dict_fanny['id']
dept = dict_fanny['dept']
exp = dict_fanny['exp']
После чего вы можете создать объект, передав все эти значения в конструктор класса:
employee_4 = Employee(name, id, dept, exp)
print(employee_4)
# Output: Fanny Walker,H203 from HR with 2 years of experience.
Не забывайте, что вы должны проделать все это для каждого нового объекта, который вы создаете. Конечно, этот подход нельзя назвать эффективным, и мы безусловно можем сделать лучше.
Но как?
В Python в качестве конструкторов для создания объектов класса мы можем использовать
методы класса
. Для того, чтобы создать метод класса, воспользуемся декоратором
@classmethod
.
Давайте определим метод, который проанализирует словарь, получит значения для переменных экземпляра класса и воспользуется ими для того, чтобы создать объекты класса
Employee
.
@classmethod
def from_dict(cls,data_dict):
full_name = data_dict['name']
emp_id = data_dict['id']
department = data_dict['dept']
experience = data_dict['exp']
return cls(full_name, emp_id, department, experience)
Теперь, когда нам нужно будет создать объекты с помощью данных, которые хранятся в словаре, мы можем использовать метод класса
from_dict()
.
?
Обратите внимание, что в методе класса мы используем не
self
, а
cls
. Здесь все по аналогии: параметр
self
используется для ссылки на экземпляр класса, а
cls
– для ссылки на класс. Кроме того, помните о том, что методы класса привязаны к классу, а не к объектам.
Именно поэтому, когда для создания объектов мы вызываем метод класса
from_dict()
, мы делаем это в классе
Employee
:
И теперь, если у нас есть словарь для каждого из n сотрудников, то для того, чтобы создать экземпляры класса, мы можем воспользоваться методом класса
from_dict()
в качестве конструктора. При этом нам не нужно будет извлекать из словаря значения для переменных экземпляра.
Замечание касательно переменных класса
Здесь мы определили метод класса, который привязан к классу, а не к отдельным экземплярам. Так же как у нас могут быть методы класса, у нас могут быть и переменные класса.
Подобно методам класса,
переменные класса
также привязаны к классу, а не к экземпляру. Когда атрибут принимает некое фиксированное значение (не зависимо от экземпляра класса), мы можем определить его как переменную класса.
Часто задаваемые вопросы
1. Для чего нужен метод __init__ в Python?
Определив в классе метод
__init__
, вы сможете инициализировать атрибуты и переменные класса для всех экземпляров класса. Метод
__init__
необходимо вызывать каждый раз, когда вы создаете новый экземпляр.
2. Может ли быть несколько методов __init__ в классе Python?
В чем состоит цель наличия нескольких методов
__init__
? Возможность иметь несколько конструкторов для создания экземпляров класса. Однако вы не можете определить несколько методов
__init__
. Если вы попытаетесь определить несколько методов
__init__
, то каждый последующий будет переопределять предыдущий. И тем не менее, вы можете воспользоваться декоратором
@classmethod
для того, чтобы определить методы класса. Эти методы класса можно использовать в качестве конструкторов для создания экземпляров класса.
3. Что будет, если вы не определите метод __init__ в классе?
Если вы не определите метод
__init__
, вы в любом случае сможете создавать экземпляры класса. Но в таком случае вам придется самостоятельно добавлять переменные экземпляров и присваивать им значения. Вы не сможете передать значения для переменных экземпляра через конструктор. Это не только может привести к возникновению ошибок, но и в принципе противоречит цели наличия классов как шаблонов, с помощью которых мы можем создавать экземпляры классов.
4. Можно ли установить значения по умолчанию для аргументов в методе __init__?
Да, при определении метода
__init__
вы можете указать значения по умолчанию для одного или нескольких атрибутов. Таким образом, вы можете сделать эти атрибуты необязательными. В случае, если вы не передадите значение для этих атрибутов в конструкторе, то они примут соответствующие значения по умолчанию.
5. Можно ли менять значение атрибута вне метода __init__?
Да, вы всегда можете поменять значение атрибута вне метода
__init__
. Кроме того, после того, как вы создадите отдельный экземпляр, вы можете динамически добавлять в нему новые атрибуты.
Заключение
В этом руководстве мы разобрали, как можно использовать метод
__init__
для инициализации значений переменных экземпляра класса. Но несмотря на то, что это просто, это может оказаться довольно рутинно, так как вы без конца будете повторять одни и те же действия, особенно если у вас много атрибутов.
Если вам интересно, то вы можете изучить, что такое классы данных (dataclasses). В Python 3.7 и более поздних версиях для создания классов данных, в которых хранятся данные, вы можете использовать модуль
dataclasses
. Его можно использовать как дополнение к методу
__init__
и других часто используемых методов; у этого модуля есть большое количество интересных функций: подсказки при вводе кода, задание более сложных значений по умолчанию и оптимизация.
Несколько недель назад я решил, что хочу создать свой первый пакет Python, и я попытался понять, с чего лучше начать.
Так вот, пытаясь найти какой-нибудь простой учебник, который подошел бы для начала, я запутался и начал немного переживать. Именно поэтому я решил написать эту статью. Я захотел создать руководство, которое бы описывало процесс создания моего первого пакета Python.
Что такое пакет Python?
Прежде чем мы начнем, мы должны понять, что такое пакет Python.
Пакет Python – это каталог, который содержит набор модулей и файл зависимостей
__init__.py
. Этот файл может быть абсолютно пустым. Он необходим для того, чтобы пометить каталог на диске как пакет Python.
Ниже приведен пример каталога пакета:
package
__init__.py
module_a.py
module_b.py
module_c.py
Пример каталога пакета
__init__.py
- это файл зависимостей, который помогает Python находить доступные модули в каталоге пакета. Если мы удалим этот файл, то Python не сможет импортировать модули.
Пакеты vs. Модули
Теперь вы знаете, что пакеты Python создают структурированный каталог с несколькими модулями внутри, а что насчет модулей? Давайте убедимся, что мы понимаем, в чем разница между пакетом и модулем:
Модуль
– это всегда один файл Python (
turtle.py)
. Он содержит логику, то есть классы, функции и константы.
Пакет
– это, по сути, тоже модуль, но он может содержать множество других модулей и подпакетов.
Структура пакета
И все же, пакеты содержат не только модули. Они также содержат высокоуровневые сценарии, документацию и тесты. Ниже приведен пример того, как можно структурировать стандартный пакет Python:
package_name/
docs/
scripts/
src/
package_a
__init__.py
module_a.py
package_b
__init__.py
module_b.py
tests/
__init__.py
test_module_a.py
test_module_b.py
LICENSE.txt
CHANGES.txt
MANIFEST.in
README.txt
pyproject.toml
setup.py
setup.cfg
Пример структуры пакета
Давайте разберемся, для чего нужен каждый файл в этом дереве:
package_name
: обозначает основной пакет.
docs
: содержит документацию по использованию пакета.
scripts/
: ваши высокоуровневые сценарии.
src
: то, куда заходит ваш код. Он содержит пакеты, модули, подпакеты и т.д.
tests
: здесь вы можете хранить модульные тестирования.
LICENSE.txt
: содержит текст лицензии (например, MIT).
CHANGES.txt:
регистрирует изменения, внесенные в каждую версию.
MANIFEST.in
: то, куда вы помещаете инструкции о том, какие дополнительные файлы вы хотите добавить (файлы без кода).
README.txt
: содержит описание пакета (markdown-формат).
pyproject.toml
: файл, предназначенный для регистрации систем сборки.
setup.py
: содержит сценарий сборки для ваших соответствующих систем.
setup.cfg
: файл конфигурации ваших систем сборки.
Обратите внимание, что мы можем добавить тестовые файлы в основной пакет двумя способами. Мы можем оставить их на верхнем уровне, как мы это делали выше, или поместить их внутрь пакета, как показано ниже:
package_name/
__init__.py
module_a.py
module_b.py
test/
__init__.py
test_module_a.py
test_module_b.py
Пример независимых тестирований
Как по мне, подход с хранением тестирований на верхнем уровне может оказаться крайне полезным, особенно когда эти тесты подразумевают чтение и запись других внешних файлов.
Что использовать: setup.cfg или setup.py?
setup.py и setup.cfg – это инструменты организации пакетов по умолчанию в PyPl, setuptools, pip и стандартной библиотеке Python.
Здесь они представляют собой сценарии конфигурации и сборки для setuptools. Они оба указывают setuprools, как собирать и устанавливать пакет.
Упомянутый файл содержит такую информацию, как версия, пакеты и файлы, которые необходимо добавить, а также любые другие требования.
Ниже приведен пример файла
setup.py
, который использует некоторые аргументы
setup()
.
import setuptools
with open("README.md", "r", encoding = "utf-8") as fh:
long_description = fh.read()
setuptools.setup(
name = "package-name",
version = "0.0.1",
author = "author",
author_email = "author@example.com",
description = "short package description",
long_description = long_description,
long_description_content_type = "text/markdown",
url = "package URL",
project_urls = {
"Bug Tracker": "package issues URL",
},
classifiers = [
"Programming Language :: Python :: 3",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
],
package_dir = {"": "src"},
packages = setuptools.find_packages(where="src"),
python_requires = ">=3.6"
)
setup.py
Файл
setup.cfg
выглядит совсем иначе. Как правило, он содержит только два обязательных ключа:
command
и
options
.
Ключ
command
– это одна из команд
distutils
, а ключ
options
определяет параметры, которые может поддерживать команда.
[command]
option = value
setup.cfg
Ниже приведен пример файла
setup.cfg
, который использует некоторые параметры и метаданные.
[metadata]
name = package-name
version = 0.0.1
author = name of the author
author_email = author@example.com
description = short package description
long_description = file: README.md
long_description_content_type = text/markdown
url = package url
project_urls =
Bug Tracker = package issues url
classifiers =
Programming Language :: Python :: 3
License :: OSI Approved :: MIT License
Operating System :: OS Independent
[options]
package_dir =
= src
packages = find:
python_requires = >=3.6
[options.packages.find]
where = src
setup.cfg
Оба файла -
setup.py
и
setup.cfg
, предназначены только для setuptools. Кроме того, файл
setup.cfg
можно безопасно переместить в
pyproject.toml
.
В данном случае идея состоит в том, что, если мы однажды заходим сменить систему сборки, например, на
flit
или
poetry
, все, что нам нужно будет сделать, это изменить запись о системе сборки (например, setuptools) в
pyproject.toml
на что-то вроде flit или poetry, а не писать все заново.
Абсолютно не важно, какой файл конфигурации мы выбрали (pyproject.toml, setup.cfg или setup.py), мы обязаны сопровождать этот файл.
Руководство по работе с пакетами Python гласит, что лучше всего использовать файл
setup.cfg
, так как он статичен, понятно написан, легко читается и позволяет избежать ошибок кодирования.
Как создать свой первый пакет Python
А теперь пришло время создать простой пакет Python. В качестве системы сборки мы возьмем setuptools, а setup.cfg и pyproject.toml помогут нам с настройкой нашего проекта.
Настроим файлы пакета
Мы создаем довольно простой пакет, и мы должны структурировать наш каталог, добавив в него файлы зависимостей, которые необходимы для того, чтобы мы могли распространять пакет. Структура пакета будет выглядеть так:
basicpkg/
src/
divide
__init__.py
divide_by_three.py
multiply
__init__.py
multiply_by_three.py
tests/
__init__.py
test_divide_by_three.py
test_multiply_by_three.py
LICENSE.txt
README.txt
pyproject.toml
setup.cfg
Структура нашего пакета
Наш основной пакет состоит из двух пакетов: первый предназначен для деления чисел на три, а второй – для умножения чисел на три.
В данном случае мы игнорируем некоторые файлы, например,
CONTEXT.txt
,
MANIFEST.in
и каталог
docs/
, для того, чтобы упростить задачу. Но при этом нам нужен каталог
test/
для того, чтобы добавить туда наши модульные тесты для проверки того, как ведет себя пакет.
Добавим в наши модули некоторую логику
Как и всегда, мы оставляем файл
__init__.py
пустым. Далее мы должны добавить в наши модули некоторую логику, чтобы мы могли выполнять различные операции.
Возьмем пакет, предназначенный для деления чисел. Добавим в файл
divide_by_three.py
следующее содержимое, чтобы иметь возможность делить числа на три:
def divide_by_three(num):
return num / 3
divide_by_three.py
Аналогичную логику добавляем в файл
multiply_by_three.py
, который находится внутри пакета, предназначенного для умножения чисел. Только в этом случае мы хотим иметь возможность умножать числа на три:
def multiply_by_three(num):
return num * 3
multiply_by_three.py
Не бойтесь добавлять другие пакеты и модули для каких-то других действий. Например, вы можете добавить пакеты для выполнения сложения и вычитания чисел.
Протестируем наши модули
Лучше всего добавлять автоматизированные тестирования в программы, которые мы создаем. В данном случае для проведения тестирования наших модулей и поведения пакета мы будем использовать
unittest
.
Давайте добавим следующий код в файл
test_divide_by_three.py
, расположенный в каталоге
test/
:
import unittest
from divide.by_three import divide_by_three
class TestDivideByThree(unittest.TestCase):
def test_divide_by_three(self):
self.assertEqual(divide_by_three(12), 4)
unittest.main()
test_divide_by_three.py
Для того, чтобы выполнить автоматизированное тестирование, мы импортировали TestCase из
unittest
. После чего мы импортировали наш метод
divide_by_three()
из модуля
by_three
, который расположен в пакете, отвечающем за деление чисел.
Если мы удалим здесь файл
__init__.py
, то Python больше не сможет найти наши модули.
Метод
.assertEqual()
предназначен для проверки двух значений (
divide_by_three(12)
и
4
) на равенство. А метод
unittest.main()
был реализован для запуска всех наших тестирований.
Логика для
test_multiply_by_three.py
аналогична:
import unittest
from multiply.by_three import multiply_by_three
class TestMultiplyByThree(unittest.TestCase):
def test_multiply_by_three(self):
self.assertEqual(multiply_by_three(3), 9)
unittest.main()
test_multiply_by_three.py
Для того, чтобы запустить тестирования, введите в терминал/командную строку следующее:
Для Linux:
python3 tests/test_divide_by_three.py
Для Windows:
py tests/test_divide_by_three.py
Для того, чтобы выполнить тестирование модуля, отвечающего за умножение чисел, мы должны сделать тоже самое. Если наши тестирования будут запущены успешно, вы увидите следующее:
.
----------------------------------------------------------------------
Ran 1 test in 0.000s
OK
Если вы захотите добавить дополнительные пакеты и модули, попробуйте добавить к ним несколько методов из
unittest
. Отличная задачка для вас.
Настроим метаданные с помощью setup.cfg
Теперь нам нужно добавить файл конфигурации для setuptools. Как мы уже упоминали, этот файл конфигурации укажет setuptools, как собрать и установить наш пакет.
Итак, мы должны добавить в наш файл setup.cfg следующие метаданные и параметры. Не забудьте изменить имя, так как я уже загрузил пакет под таким названием на TestPyPI. Кроме того, поменяйте дополнительную информацию, то есть автора, адрес электронной почты и URL-адреса проекта, чтобы ваш пакет распространялся с вашей информацией.
[metadata]
name = basicpkg
version = 1.0.0
author = your name
author_email = your email
description = A simple Python package
long_description = file: README.md, LICENSE.txt
long_description_content_type = text/markdown
url = https://gitlab.com/codasteroid/basicpkg
project_urls =
Bug Tracker = https://gitlab.com/codasteroid/basicpkg/-/issues
repository = https://gitlab.com/codasteroid/basicpkg
classifiers =
Programming Language :: Python :: 3
License :: OSI Approved :: MIT License
Operating System :: OS Independent
[options]
package_dir =
= src
packages = find:
python_requires = >=3.6
[options.packages.find]
where = src
setup.cfg
Что касается параметров, оставьте значения по умолчанию. Параметр
package_dir
определяет местонахождение корневого каталога пакета, где хранятся пакеты, модули и все исходные файлы Python.
С помощью ключа
packages
мы можем перечислить наши пакеты вручную, то есть
[divide, multiply]
.
Но если мы хотим указать все пакеты, то можем просто написать
find:
и указать, где нам нужно искать эти пакеты с помощью
[options.packages.find]
, где ключу
where
присваивается имя корневого каталога пакета.
Обязательно добавим в файл конфигурации ключ
classifiers
(это нужно делать всегда). С его помощью мы можем добавить некоторую важную информацию, например, версию Python и операционную систему, для которой подходит ваш пакет.
Создаем pyproject.toml
В качестве системы сборки мы будем использовать setuptools. Для того, чтобы сообщить
pip
или какому-то другому инструменту сборки о нашей системе сборки, нам потребуются две переменные (см. ниже).
Для того, чтобы добавить все то, что нам нужно для сборки пакета, мы воспользуемся
build-system.require
, и при этом
system.build-back-end
определяет объект, который будет выполнять сборку.
Итак, давайте добавим следующее содержимое в файл
pyproject.toml
:
[build-system]
requires = ['setuptools>=42']
build-backend = 'setuptools.build_meta'
pyproject.toml
Обратите внимание, если вы захотите сменить систему сборки, например, на flit или poetry, вы можете безопасно переместить все параметры конфигурации из файла
setup.cfg
в
pyproject.toml
. Эта функция сэкономит вам время.
Создаем README.md
Очень важно создать грамотный файл
README.md
. Давайте добавим описание к нашему пакету и некоторые инструкции по его установке.
# `basicpkg`
The `basicpkg` is a simple testing example to understand the basics of developing your first Python package.
README.md
Кроме того, мы можем добавить информацию о том, как его использовать:
from multiply.by_three import multiply_by_three
from divide.by_three import divide_by_three
multiply_by_three(9)
divide_by_three(21)
README.md
Не стесняйтесь добавлять любую информацию, которая может помочь другим разработчикам понять, для чего нужен ваш пакет, как его устанавливать и как с ним работать.
Обратите внимание, что наш файл конфигурации будет загружать
README.md
и будет добавлен при распространении нашего пакета.
Добавляем лицензию
Крайне важно добавить лицензию в ваш проект, чтобы пользователи знали, как они могут использовать ваш код. Давайте выберем для нашего пакета лицензию MIT и добавим в файл
LICENSE.txt
следующее содержимое:
MIT License
Copyright (c) [year] [fullname]
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
LICENSE.txt
Не забудьте поменять
[year]
на текущий год, а
[fullname]
- на ваше имя или имена правообладателей.
Создаем архивы дистрибутива
И остался последний шаг перед тем, как мы сможем перейти к распространению нашего пакета: создать архивы дистрибутива нашего пакета Python. Для этого нам нужно обновить нашу сборку PyPA, а затем создать архивы исходного кода и сборки.
Запустим следующие команды в терминале/командной строке из того же каталога, где хранится файл
pyproject.toml
:
Для Linux:
python3 -m pip install --upgrade build
python3 -m build
Для Windows:
py -m pip install --upgrade build
py -m build
Как только этот процесс завершится, будет создан новый каталог под названием
dist/
, в котором будут находиться два файла. Файл
.tag.tz
- архив исходного кода, и файл
.whl*
- архив сборки. Эти файлы – это и есть архивы дистрибутива нашего пакета Python, который мы далее загрузим в Python Package Index и установим с помощью
pip
.
Как загрузить пакет в Python
Python Package Index – это, то куда мы будем загружать наш пакет. Поскольку наш пакет находится на этапе тестирования, и мы все еще можем добавлять в него новые функции в качестве эксперимента, нам стоит использовать отдельную версию PyPI под названием TestPyPI. Эта версия была создана специально для проведения экспериментов и тестирования. После чего, когда ваш пакет будет готов и будет полностью вас удовлетворять, вы сможете загрузить его в PyPI как готовый пакет.
Следующие инструкции помогут нам подготовить TestPyPI к загрузке нашего пакета:
Перейдите на TestPyPI и создайте там учетную запись.
Подтвердите свой адрес электронной почты, чтобы вы могли загружать пакеты.
Настройте профиль (добавьте фотографию и т.д.).
Перейдите в api-tokens и создайте свой токен API для того, чтобы вы могли безопасно загружать свои пакеты.
На этой же странице установите область действия («вся учетная запись»).
Скопируйте и сохраните токен в безопасном месте на диске.
Далее мы должны загрузить наши архивы дистрибутива. Для этого нам понадобиться инструмент загрузки. Официальный инструмент загрузки PyPI – это
Twine
. Поэтому мы должны установить Twine и загрузить архивы дистрибутива в каталог
dist/
.
Запустим следующие команды в терминале/командной строке из того же каталога, где хранится файл
pyproject.toml
:
Для Linux:
python3 -m pip install --upgrade twine
python3 -m twine upload --repository testpypi dist/*
Для Windows:
py -m pip install --upgrade twine
py -m twine upload --repository testpypi dist/*
Затем введите
__token__
в качестве имени пользователя, а токен, который вы сохранили (в том числе префикс pypi-), - в качестве пароля. А теперь нажмите Enter, чтобы загрузить дистрибутивы.
Как установить загруженный пакет Python
А теперь пришло время установить наш пакет. Для того, чтобы установить его из TestPyPI, вы можете создать виртуальное окружение и воспользоваться инструментом
pip
:
Для Linux:
python3 -m venv env
source env/bin/activate
(env) python3 -m pip install --index-url https://test.pypi.org/simple/ --no-deps basicpkg
Для Windows:
py -m venv env
.\env\Scripts\activate
(env) py -m pip install --index-url https://test.pypi.org/simple/ --no-deps basicpkg
Прежде чем проверять, правильно ли работает ваш пакет, убедитесь, что ваше виртуальное окружение активировано.
Откройте терминал/командную строку и запустите команду
python3
(для пользователей Linux) или команду
py
(для пользователей Windows). После чего введите следующий код, чтобы убедиться, что пакеты, отвечающие за умножение и деление чисел, работают как надо:
from multiply.by_three import multiply_by_three
from divide.by_three import divide_by_three
multiply_by_three(9)
divide_by_three(21)
# Output: 27
# Output: 7
Не забывайте, что для выполнения необходимых операций, мы должны импортировать соответствующие методы из наших модулей.
Ура! Наш пакет работает как надо.
Дальше, после того, как вы поэкспериментируете и протестируете свой пакет, вам нужно выполнить следующие инструкции для того, чтобы загрузить свой пакет в настоящий PyPI:
Перейдите на PyPI и создайте учетную запись.
Запустите в терминале/командной строке команду
twine upload dist/*
.
Введите учетные данные, с которыми вы регистрировались на PyPI.
Затем запустите команду
pip install [package_name]
для того, чтобы установить ваш пакет.
Поздравляю! Ваш пакет был установлен с реального PyPI.
Что дальше?
Было бы просто замечательно, если бы вы придумали какую-нибудь простенькую идею, взяли ее за основу и создали свой первый настоящий пакет Python. В этой статье я сделал акцент на основах, которые нужны для того, чтобы начать работать, но в мире модулей и пакетов есть еще чему поучиться.
Надеюсь, что мой первый опыт разработки пакетов на Python помог вам понять, что вам нужно для того, чтобы создать свой собственный.