Блог

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

Выход из этой ситуации прост — запускать различные версии Python через Docker.

Docker и версии Python

С прекращением поддержки Python 2.7 в 2020 году, долгий переход от Python 2 к Python 3 вошел в финальную фазу. Однако, двигаясь вперёд, важно знать о различных версиях Python и о том, как их опробовать.

Типы версий Python

1. Официальные релизы (Released versions). Обычно, в этом случае речь идёт о чём-то вроде Python 3.6, 3.7 или 3.8. В каждой из этих версий добавлены новые возможности. Поэтому, чтобы правильно оценивать функционал, нужно знать, какая именно версия релиза запущена. К примеру, f-строки (метод форматирования f-strings) ввели в Python 3.6. На более ранних версиях он не работает. Подобным образом, выражения присваивания доступны только начиная с Python 3.8.
2. Разрабатываемые версии (Development versions). Сообщество Python постоянно работает над новыми версиями. Пользователям доступны разрабатываемые версии, отмеченные как альфа, бета и релиз-кандидат (release candidate).
3. Реализации (Implementations). Python — язык, имеющий несколько вариантов дополнительных реализаций на основе вышедших официальных версий. Каждая из них содержит интерпретатор и соответствующие библиотеки. CPython — эталонная реализация Python, ее используют чаще всего. Тем не менее есть и другие реализации, ориентированные под специфические нужды. Среди них PyPy, IronPython, Jython, MicroPython и CircuitPython.

Версию используемого Python можно увидеть при запуске интерпретатора REPL. Можно также получить дополнительную информацию c помощью команды «sys.implementation».

>>> import sys

>>> sys.implementation.name

‘cpython’

>>> sys.implementation.version

sys.version_info(major=3, minor=9, micro=0, releaselevel=’alpha’, serial=1)

Как видно, код выполнен на первой альфа-версии CPython 3.9.

Традиционно для управления различными версиями Python используются инструменты вроде «pyenv» и «conda». В большинстве случаев их может заменить Docker. И он часто оказывается проще в использовании. Ниже мы практически покажем, как это сделать.

Использование Docker

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

Установка Docker

Docker доступен для всех основных ОС: Windows, macOS и Linux. Инструкции по установке Docker на конкретную систему можно найти в их официальных руководствах.

Если специфических требований нет, можно использовать ядро приложения — Docker Engine — в свободно распространяемой «общественной» редакции (Community Edition).

Запуск контейнеров

Работа Docker основана на двух базовых элементах — образах и контейнерах.

• Образ — автономный пакет, который может выполнить Docker.
• Контейнер — выполняемый образ с определённым состоянием (как пользовательский процесс).

Есть несколько репозиториев, содержащих предварительно собранные образы для Docker. Самым распространённым является Docker Hub — публичный репозиторий, который будет использоваться в данном руководстве по умолчанию.

Для примера установим образ «hello-world».

$ docker run hello-world

Unable to find image ‘hello-world:latest’ locally

latest: Pulling from library/hello-world

1b930d010525: Pull complete

Digest: sha256:451ce787d12369c5df2a32c85e5a03d52cbcef6eb3586dd03075f3…

Status: Downloaded newer image for hello-world:latest

Hello from Docker!

This message shows that your installation appears to be working correctly.

[ … Результат выполнения команды сокращён … ]

Первые строки показывают, что Docker скачал образ  «hello-world» из репозитория Docker Hub. При запуске этого образа итоговый контейнер выводит на терминал сообщение «Hello from Docker!».

Создание собственных образов с помощью Dockerfile

С помощью Dockerfile можно создавать собственные образы. Это обычный текстовый файл, который описывает, как именно будет устанавливаться образ Docker.

Вот пример Dockerfile:

FROM ubuntu

RUN apt update && apt install -y cowsay

CMD [“/usr/games/cowsay”, “Dockerfile это круто!”]

Файл Dockerfile состоит из перечня команд Docker. В приведённом выше фрагменте три шага:

• Строка 1 создаёт на базе существующего образа под названием «ubuntu» новый. Она выполнима вне зависимости от ОС, на которой запущен Docker.
• Строка 2 устанавливает программу под названием «cowsay».
• Строка 3 задаёт команду, которая сразу запускает «cowsay» при выполнении образа.

Создание Dockerfile начинается с правильного сохранения — под именем «Dockerfile» без какого-либо расширения.

Примечание. Создавать и запускать образы Linux можно на любой платформе. Поэтому такие образы, как «ubuntu», прекрасно подходят для разработки кросс-платформенных приложений. В то же время образ Windows запустится только на Windows, а образ macOS — только на macOS.

Далее создаём при помощи Dockerfile образ:

$ docker build -t cowsay

В результате последует множество сообщений, и будет создан образ. Опция «-t cowsay» задаёт «cowsay» в качестве его имени. Такие теги удобно использовать для отслеживания образов. Финальная точка в команде указывает текущий каталог в качестве контекста сборки для вашего образа. Это должен быть каталог, где находится ваш Dockerfile.

Теперь образ Docker можно выполнить:

$ docker run –rm cowsay

_______________________

< Dockerfile это круто! >

———————–

\ ^__^

\ (oo)\_______

(__)\ )\/\

||—-w |

|| ||

Опция «—rm» очистит контейнер после использования. Её применение  позволяет не засорять систему уже ненужными контейнерами Docker.

Примечание. Вывести список ваших образов и контейнеров можно, используя команду «docker ps -a».

И образ, и контейнер имеют 12-символьный идентификатор «ID», который можно найти в результатах выполнения этих команд. Чтобы удалить образ или контейнер, можно использовать «docker rmi <ID образа>» либо «docker rm <ID контейнера>», указав их правильный идентификатор.

Возможности команды «docker» очень велики. За расширенной справкой можно обратиться к команде «docker —help» или к официальной документации.

Запуск Python в контейнере Docker

Сообщество Docker выпускает и поддерживает релизы в виде файлов Dockerfile для всех новых версий Python. Опробовать новые функции Python можно, воспользовавшись ими.

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

Запуск REPL

При запуске образов Python из Docker Hub, открывается интерпретатор REPL, в котором будет проходить дальнейшая работа. Чтобы открыть его в контейнере Python, следует выполнить следующую команду:

$ docker run -it –rm python:rc

Python 3.8.0rc1 (default, Oct 2 2019, 23:30:03)

[GCC 8.3.0] on linux

Type “help”, “copyright”, “credits” or “license” for more information.

>>>

Эта команда скачает образ «python:rc» с сайта Docker Hub, сделает на его основе контейнер и уже в нём выполнит команду «python».

Опции «-it» необходимы для интерактивного запуска контейнера. Тег «rc» означает «релиз-кандидат» и указывает на последнюю разрабатываемую бета-версию Python. В нашем случае это последний релиз-кандидат Python 3.8:

>>> import sys

>>> f”{sys.version_info[:] = }”

“sys.version_info[:] = (3, 8, 0, ‘candidate’, 1)”

При первом запуске контейнера Python на его скачивание может потребоваться некоторое время. Но дальнейшие вызовы уже будут происходить практически мгновенно. Выйти из интерпретатора REPL можно, введя «exit()». Одновременно произойдёт выход из контейнера.

Примечание. Образы Python для Docker Hub поддерживаются в достаточно актуальном состоянии. По мере готовности, альфа- и бета-версии становятся доступны под тегом «rc».

Если нужно опробовать самые последние версии Python, то больше подойдёт образ от ключевых разработчиков:

$ docker run -it –rm quay.io/python-devs/ci-image:master

В хранилище Docker Hub можно найти полный список доступных образов Python. Последняя версия Python (стабильная) доступна как «python:latest», а свежая разрабатываемая версия — как «python:rc».

Также можно запросить и точные версии. Например,  «python:3.6.3» или «python:3.8.0b4», т.е. четвёртую бету Python 3.8. Можно даже запустить последнюю реализацию PyPy, используя теги вроде «pypy:latest».

Настройка рабочей среды Python в Docker

Контейнер Docker представляет собой изолированное окружение. Таким образом, добавлять внутри контейнера виртуальную среду обычно не требуется. Вместо этого, для установки необходимых модулей Python в Docker можно запустить непосредственно систему управления пакетами pip.

Чтобы модифицировать контейнер включением дополнительных пакетов, используется Dockerfile. В приведенном ниже примере в образ Python 3.7.5 добавляются пакеты «parse» и «realpython-reader».

FROM python:3.7.5-slim

RUN python -m pip install \

parse \

realpython-reader

Этот файл нужно сохранить под именем «Dockerfile». Тег «-slim» в первой строке показывает, что Dockerfile исходит из минимальной установки дистрибутива Debian. Этот тег задаёт существенно меньший размер образа Docker. Недостаток в том, что может потребоваться устанавливать дополнительные инструменты самому.

Помимо этого, в число тегов входят такие, как «-alpine» и «-windowsservercore». Подробную информацию о таких вариациях образа можно найти на Docker Hub.

Примечание. Если нужно использовать внутри контейнера Docker виртуальную среду, есть одно важное предостережение. Каждая команда «RUN» выполняется как отдельный процесс.

Типичная активация виртуальной среды в Dockerfile работать не будет. Вместо этого необходимо активировать виртуальную среду вручную, задав переменные среды «VIRTUAL_ENV» и «PATH»:

FROM python:3.7.5-slim

# Настроить и активировать виртуальную среду

ENV VIRTUAL_ENV “/venv”

RUN python -m venv $VIRTUAL_ENV

ENV PATH “$VIRTUAL_ENV/bin:$PATH”

# Команды Python будут выполнены в виртуальной среде

RUN python -m pip install \

parse \

realpython-reader

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

$ docker build -t rp .

[ … Результат выполнения команды сокращён … ]

$ docker run -it –rm rp

Образу будет задан тег «rp». Затем он будет использоваться для открытия созданного образа из сеанса интерпретатора REPL. Можно убедиться, что в контейнер установлен пакет «parse».

>>> import parse

>>> parse.__version__

‘1.12.1’

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

$ docker run –rm rp realpython

The latest tutorials from Real Python (https://realpython.com/)

0 Run Python Versions in Docker: How to Try the Latest Python Release

[ … Результат выполнения команды сокращён … ]

Вместо запуска интерпретатора REPL, внутри контейнера «rp» выполняется команда «realpython». Она выводит список последних руководств, опубликованных на специализированном сайте Real Python.

Запуск Python скрипта в Docker

В этом разделе мы расскажем, как запускать скрипты внутри Docker.

Прежде всего, следует сохранить приводимый пример скрипта у себя на компьютере в файл под названием «headlines.py».

# headlines.py

import parse

from reader import feed

tutorial = feed.get_article(0)

headlines = [

r.named[“header”]

for r in parse.findall(“\n## {header}\n”, tutorial)

]

print(“\n”.join(headlines))

Сначала этот скрипт скачивает последнее руководство с сайта Real Python. Затем он использует пакет «parse», чтобы найти все заголовки и вывести их на терминал.

Есть два основных способа запускать такие скрипты в контейнере Docker:

1. Смонтировать локальный каталог в качестве тома (volume) контейнера Docker.
2. Скопировать скрипт в нужный контейнер.

Первый вариант особенно удобен при тестировании, поскольку не нужно собирать образ Docker заново при каждом изменении скрипта. Для монтирования каталога в качестве тома, используйте опцию «-v»:

$ docker run –rm -v /home/realpython/code:/app rp python /app/headlines.py

Understanding Python Versions and Docker

Using Docker

Running Python in a Docker Container

Conclusion

Further Reading

Если же скрипт будет использован на другом компьютере, нужно скопировать его внутрь контейнера. Это можно сделать, добавив в Dockerfile пару шагов:

FROM python:3.7.5-slim

WORKDIR /usr/src/app

RUN python -m pip install \

parse \

realpython-reader

COPY headlines.py .

CMD [“python”, “headlines.py”]

Опцией «WORKDIR» внутри контейнера задается рабочий каталог, в котором будут выполняться команды. Можно скопировать файл «headlines.py» в этот каталог внутри контейнера, после чего изменить команду по умолчанию на выполнение «headlines.py» с помощью «python».

Соберите образ, как обычно. Остается лишь запустить контейнер:

$ docker build -t rp .

[ … Результат выполнения команды сокращён … ]

$ docker run –rm rp

Understanding Python Versions and Docker

Using Docker

Running Python in a Docker Container

Conclusion

Further Reading

Обратите внимание, поскольку в Dockerfile была указана команда «CMD», при запуске контейнера сразу выполняется нужный скрипт.

Подробности о том, как создавать собственные файлы Dockerfile — в описании образа Python на сайте Docker Hub.

Заключение

Это руководство — краткое введение в работу с различными версиями Python при использовании Docker. Оно поможет быстро протестировать код и убедиться, что он совместим с последними версиями Python.

Изучив эту инструкцию, вы сможете:

• Запускать интерпретатор Python REPL при помощи Docker.
• Настраивать среду Python внутри образа Docker.
• Запускать внутри контейнеров Docker скрипты.

Поместить скрипт Python в Docker контейнер — дело пары минут. Теперь опробовать последнюю альфа-версию языка можно сразу после публикации.

Источник

Сегодня Python вошел в число самых популярных языков программирования в мире. Этот интерпретируемый язык высокого уровня общего назначения был разработан Гвидо ван Россумом в 1991 году и с тех пор неуклонно набирал репутацию среди пользователей.

Синтаксис Python схож с английским, что делает его крайне доступным и простым в освоении для новичков. Команды языка программирования Python просты в использовании, легко пишутся и запоминаются. В этой шпаргалке для тех, кто начинает изучать «змеиный язык», мы разберем синтаксис и назначение основных команд Python.

Важно! Согласно официальной документации, в Python нет самого понятия «команды», но есть различные встроенные методы или функции, которые можно выполнять в оболочке языка, как обычные команды. Поэтому в данном справочнике команд Python, мы будем использовать термины «команды», «функции» и «методы» (специальные классы функций) взаимозаменяемо.

Базовые команды Python

pip

Менеджер пакетов Python. Команда pip install используется для установки любого программного пакета из онлайн-репозитория общедоступных пакетов или Индекса пакетов Python (PyPI, Python Package Index).

pip install имя-пакета

print

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

print(объект)

class

Команда для создания классов. Python поддерживает объектно-ориентированное программирование и позволяет пользователям создавать классы и инициализировать объекты. Класс может состоять из переменных с модификаторами доступа, функций с возвращаемыми типами и даже других классов (вложенный класс). Синтаксис выглядит class так:

class ИмяКласса:
код_тела_класса

Пример кода ниже продемонстрирует применение class при создании класса «student»:

«student»:

class student:

name = ""

def setName(self, passedValue):

self.name = passedValue

def displayName(self):

print(self.name)

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

ИмяКласса()

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

имя_переменной = ИмяКласса()

Пример создания объекта для класса «student»:

mystudent = student()

mystudent.setName(“Alex Ignatov”)

mystudent.displayName()

В результате мы получим вывод:

Alex Ignatov

Как и в других языках программирования, в Python также можно реализовать конструкторы и статические методы в классах, используя соответственно метод dunder init() и декоратор @staticmethod.

type

Команда для проверки типа или класса объекта.

type(объект)

range

Команда для генерации последовательности целых чисел, начиная с 0 по умолчанию и заканчивая n, где n не включено в сгенерированные числа. Эта команда в основном используется в циклах for.

range(start, stop, step)

В приведенном синтаксисе:

• start — начало диапазона (опционально; по умолчанию — 0);
• stop — номер, перед которым нужно остановиться (обязательно);
• step — счетчик приращений (опционально; по умолчанию — 1).

Важно. Если функции range() будут даны только два параметра, она всегда будет рассматривать их как (start, stop), а не как (stop, step).

round

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

round(number, digits)

В приведенном синтаксисе:

• number — число с плавающей запятой;
• digits — количество цифр после десятичной точки (опционально; по умолчанию — 0).

input

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

input(message)

В приведенном синтаксисе: message — текст, который нужно отобразить пользователю (опционально).

def

Команда определения функции Python дает возможность оборачивать повторно используемый код внутри функций, чтобы вызваны его позже, когда это необходимо. Функция def позволяет свести к минимуму избыточность кода.

def имя_функции (параметры):

“””строка документации”””

состояние(я)

len

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

len(object)

В приведенном синтаксисе: object — объект, длину которого необходимо найти (обязательно).

Циклические команды

В Python есть две простейшие команды цикла (loop commands) — while и for. Команда while используется для выполнения набора операторов, если заданное условие истинно.

while condition:

statements

update iterator

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

for x in sequence:

statements

Команды Python среднего уровня

Строковые команды

В языке программирования Python есть различные команды для строковых объектов. Они не изменяют исходный строковый объект, а просто возвращают новый. Наиболее важные функции и методы строк в Python — isalnum(), capitalize(), find(), count() и center().

isalnum()

Команда isalnum() проверяет, являются ли все символы данной строки буквенно-цифровыми или нет. Он возвращает логическое значение.

stringname.isalnum()

capitalize()

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

stringname.capitalize()

find()

Команда find() используется для поиска подстроки в строке. Если таковая найдена, find() возвращает индекс первого вхождения подстроки, в противном случае возвращает -1.

string.find(substring)

В приведенном синтаксисе:

• string — строка, где будет выполняться поиск.
• substring — подстрока, значение которой нужно найти.

count()

Строковая функция count() возвращает количество вхождений подстроки в строковый объект.

stringname.count(substring, start, end)

В приведенном синтаксисе:

• stringname — строка, где будет выполняться поиск.
• substring — подстрока, значение которой нужно найти.
• start — начальный индекс в строке, с которого начинается поиск (опционально).
• end — конечный индекс в строке, где заканчивается поиск (опционально).

center()

Команда center() используется для выравнивания строки по центру с заполнением указанным символом.

string.center(length, character)

В приведенном синтаксисе:

• string — строка, которую нужно выровнять по центру.
• length — полная длина новой строки.
• character — символ для заполнения пропущенного места с каждой стороны. По умолчанию — « » (пробел).

Команды для объектов списка

Списки используются для хранения нескольких элементов с различными типами данных в одном объекте. Наиболее важные методы списков Python — append(), copy(), insert(), pop(), reverse() и sort().

append()

Команда списка append() используется для добавления элемента в конец списка.

list.append(element)

В приведенном синтаксисе:

• list — объект списка, в который нужно добавить элемент.
• element — новый элемент, который добавляется в список.

copy()

Команда copy() создает новую копию объекта списка. Она возвращает новый объект списка.

list.copy()

insert()

Команда insert() добавляет элемент в указанное место в объекте списка.

listname.insert(position, element)

В приведенном синтаксисе:

• position — позиция, в которую нужно вставить новый элемент. Если указанная позиция превышает количество элементов в списке, элемент будет вставляться в конец.
• element — новый элемент, который необходимо добавить.

pop()

Метод pop() используется для удаления элемента из указанной позиции в списке. Он возвращает элемент после удаления его из списка.

listname.pop(position)

В приведенном синтаксисе: position — позиция откуда нужно удалить элемент.

reverse()

Метод reverse() изменяет порядок всех элементов в списке. Команда изменяет исходный объект списка и ничего не возвращает.

list.reverse()

sort()

Метод sort() по умолчанию используется для сортировки элементов списка в порядке возрастания.

list.sort()

Команды кортежа

Кортеж (tuple) — встроенный тип данных, который используется для хранения нескольких элементов в одной переменной. Объекты кортежа упорядочены и неизменны. В Python есть два встроенных метода кортежа — count() и index().

count()

Метод count() используется для подсчета вхождений элемента в кортеже.

tuple.count(элемент)

index()

Метод index() используется для поиска индекса первого вхождения элемента. Если элемент не найден во всем кортеже, будет выведена ошибка «ValueError».

tuple.index(элемент)

Продвинутые команды Python

Команды множества

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

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

add()

Команда add() позволяет добавить новый элемент в множество.

setname.add(element)

В приведенном синтаксисе:

• setname — имя переменной set, в которую нужно добавить новый элемент.
• element — элемент, который необходимо добавить.

clear ()

Функция clear () удаляет все элементы set. Она не принимает никаких параметров.

setname.clear()

discard()

Команда discard() позволяет удалить указанный элемент из набора. Если элемент не найден в наборе, она не выдаст ошибку.

setname.discard(element)

В приведенном синтаксисе:

• setname — имя переменной set, из которой нужно удалить элемент.
• element — элемент, который необходимо удалить.

remove()

Команда remove() также используется для удаления указанного элемента из множества. От команды discard() она отличается сообщением об ошибке, которое выводится, если указанный элемент не найден.

setname.remove(element)

В приведенном синтаксисе:

• setname — имя переменной множества, из которой нужно удалить элемент.
• element — элемент, который необходимо удалить.

difference()

Метод difference() используется для получения множества, содержащего разность двух множеств. В нем будут только те элементы, которые присутствуют только в одном множестве и отсутствуют в другом. Например, difference() для множеств setA {1,2,3} и setB {2, 4, 6} будет {1,3}.

setA.difference(setB)

difference_update()

Метод difference_update() позволяет получить набор элементов, которые присутствуют в первом множестве и не являются общими для обоих. Это означает, что difference_update() удаляет элементы, существующие в обоих множествах. Он не возвращает новый set, а просто удаляет общие элементы из первого множества.

setA.difference_update(setB)

intersection()

Метод intersection() отображает множество, содержащее элементы, которые существуют во всех указанных множествах.

set.intersection(set1, set2, … setn)

issubset()

Метод issubset() проверяет, все ли элементы множества setA присутствуют в setB. Команда возвращает логическое значение.

setA.issubset(setB)

symmetric_difference()

Метод symmetric_difference() возвращает симметричную разность двух множеств, содержащую все элементы, за исключением общих.

setA.symmetric_difference(setB)

union()

Метод union() возвращает все элементы из обоих множеств, кроме повторяющихся.

setA.union(setB)

if, elif, else

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

• Команда if оценивает выражение и, если оно истинно (true), выполняет операторы под ним.
• Команда elif (else if) предоставляет другое выражение, которое оценивается, если предыдущий оператор if возвращает отрицательное значение «false».
• Если никакие предыдущие операторы (if или elif) не возвращают положительное значение «true», вычисляется выражение, предоставленное командой else.

Обратите внимание. В одном блоке кода может быть несколько операторов if и elif.

В качестве простейшего примера использования if, elif и else приведем программу, которая оценивает, является ли заданное число положительным, отрицательным или нулем:

number = int(input(“Введите число для оценки: “))

if (number > 0):

print(“Положительно”)

elif (number < 0):

print(“Отрицательно”)

else:

print(“Ноль”)

В приведенном примере пришлось обернуть метод input() с помощью int(), так как ввод по умолчанию сохраняется как строковый тип, а нужно, чтобы переменная «number» имела целочисленный тип.

Разница между if и elif заключается в том, что все операторы if в блоке кода будут оцениваться один за другим, несмотря ни на что, а оператор elif будет оцениваться только, если предыдущий оператор if имеет значение false.

Команды словаря

Словарь (dictionary) — встроенный тип объектов в Python, который используется для хранения пар ключ-значение. Он упорядочен, модифицируем и не допускает дублирования значения ключей. Среди основных встроенных методов словаря в Python выделяются следующие: fromkeys(), get(), items(), keys(), values(), pop(), popitem() и setdefault().

fromkeys()

Метод fromkeys() используется для создания словаря с указанными ключами и значением.

dict.fromkeys(keys, value)

В приведенном синтаксисе:

• keys — кортеж или список ключевых элементов.
• value — значение, которое будет связано со всеми указанными ключами.

get()

Метод get() позволяет получить значения указанного ключа. Если ключ не найден в словаре, get() ничего не вернет, если что-то не будет указано в параметрах.

dictionary.get(key, value)

В приведенном синтаксисе:

• dictionary — имя объекта словаря, в котором нужно выполнить поиск.
• key — ключ, который нужно найти в словаре.
• value — значение, которое будет возвращено, если ключ не будет найден в словаре.

items()

Метод items() используется для отображения всех элементов словаря. Он возвращает объект представления, который будет содержать все пары ключ-значение в виде кортежей в списке. items() не принимает никаких параметров.

dictionary.items()

keys()

Метод keys() используется для получения всех ключей, присутствующих в словаре. Он возвращает объект представления, содержащий все ключи словаря в виде списка. keys() не принимает никаких параметров.

dictionary.keys()

values()

Метод values() позволяет получить всех значения в словаре. Он возвращает объект представления, содержащий все значения словаря в виде списка. values() не принимает никаких параметров.

dictionary.values()

pop()

Метод pop() используется для удаления пары ключ-значение из словаря путем указания ключа. Он возвращает значение пары ключ-значение, которую необходимо удалить.

dictionary.pop(ключ)

Команда popitem () позволяет удалить последнюю вставленную пару из словаря. Она не принимает никаких параметров. popitem () возвращает удаленную пару в виде кортежа.

dictionary.popitem()

Метод setdefault() используется для получения значения указанного ключа. Если ключ не существует, он вставит ключ со значением, переданным в качестве параметра. Если значение не будет указано, setdefault() вставит ключ со значением «None».

dictionary.setdefault(key, value)

Магические команды IPython

«Магические команды» (magic commands) или магические методы Python — одно из важнейших дополнений, сделанных к оригинальной оболочке Python Shell в процессе создания ядра IPython и его официальной реализации Jupyter Notebook. Эти встроенные команды IPython упрощают решение задач по анализу данных с помощью Python, а также обеспечивают упрощенное взаимодействие «змеиного языка» с операционными системами, другими языками программирования или ядрами.

Магические команды Python делятся на 2 типа:

• Строчные (line magics) — обычно начинаются с символа % и работают только в одной строке, Строчные магические команды могут использоваться как выражения, а их возвращаемое значение может быть присвоено переменной.
• Ячеечные (cell magics) — обозначаются двойным префиксом %% и работают во всей ячейке. Они могут вносить произвольные изменения в получаемые входные данные, которые необязательно должны быть кодом Python.

%lsmagic

Команда, которая выводит список всех магических функций, доступных на данный момент.

%quickref

Это команда-шпаргалка, похожая на %lsmagic. Он отображает краткую справку со списком возможностей каждой магической функции.

%who

Позволяет вам увидеть список всех ранее определенных переменных. Вместе с %who используются 2 производные от нее магические команды:

• %whos, которая дает дополнительную информацию о каждой переменной;
• %who_ls — возвращает отсортированный список текущих переменных.

%xdel

Удаляет переменную и любые ссылки на нее из механизма IPython.

%time

Возвращает время выполнения инструкции или выражения Python. Эту команду можно использовать для измерения времени необходимого среде IPython для выполнения выражения Python.

%pinfo

Эта волшебная команда Jupyter Notebook позволяет получить информацию об объекте.

%run

Функция запускает файл Python как программу в Jupyter Notebook. Это может быть особенно полезно, если нужно применить функции, хранящиеся во внешних файлах Python.

%run [имя файла]

В приведенном синтаксисе аргумент «имя файла» должен быть либо скриптом Python (с расширением .py), либо файлом с пользовательским синтаксисом IPython.

%load

Волшебная функция очень похожая на %run. Она загружает код файла в текущий интерфейс Jupyter Notebook. Источником может быть имя файла в каталоге используемого документа (Notebook), URL-адрес или макрос.

%load [имя файла]

В приведенном синтаксисе аргумент «имя файла» должен быть либо скриптом Python (с расширением .py), либо файлом с пользовательским синтаксисом IPython.

Более функциональным аналогом %load служит магическая команда %pycat, которая показывает код внешнего файла Python с подсветкой синтаксиса.

%%writefile

Копирует содержимое ячейки во внешний файл. Магическая команда полезна, если нужно быстро создать файл с кодом в Jupyter Notebook с помощью экспорта всего содержимого указанной ячейки.

Для выполнения экспорта нужно просто добавить %%writefile перед кодом. Команда создаст новый файл, если он не существует. В противном случае файл будет перезаписываться, пока после команды не будет добавлено -a.

%paste

Команда одновременно вводит и выполняет код, делая функцию готовой к использованию. Команда с аналогичным функционалом %cpaste открывает интерактивную многострочную подсказку, в которую можно вставить один или несколько фрагментов кода для выполнения в пакете.

Команды рабочего каталога

%pwd

Волшебная функция %pwd отображает текущий путь к рабочему каталогу.

%cd

Команда %cd позволяет сменить каталог, если после нее указать новый путь. Ее можно использовать несколькими способами:

• %cd <dir> — изменяет текущий рабочий каталог на <dir>;
• % cd .. — изменяет текущий каталог на родительский;
• %cd — изменяет текущий каталог на последний посещенный.

%history

Команда %history отображает все предыдущие команды в текущем сеансе. Увидеть подобный список команд и функций может быть полезно, если была случайно удалена команда и ее результат.

%dhist

Волшебная команда %dhist выводит все каталоги, посещенные в текущем сеансе. Каждый раз, когда используется команда %cd, этот список обновляется в переменной «dh».

%env

Магическая функция используется для получения, установки и перечисления переменных среды. Запуск команды без аргументов отобразит список всех переменных среды. Также можно ввести имя переменной среды, за которой следует команда, и она вернет ее значение:

%env HOMEDRIVE

или использовать %env для установки значения переменной окружения:

%env: HOMEDRIVE=F:

%edit

Эта волшебная команда вызывает текстовый редактор, используемый по умолчанию в текущей ОС (например, «Блокнот» Windows) для редактирования скрипта Python. Скрипт выполняется при закрытии редактора.

%autocall

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

%autocall [режим]

Для приведенного синтаксиса доступно 3 аргумента режима:

1. 0 — выключено;
2. 1  — smart-режим (по умолчанию);
3. 2 — всегда включен.

%automagic

Позволяет вводить магические команды без префикса «%», если установлено значение «1». Без аргументов функция включается/выключается. Для деактивации нужно установить значение «0».

%matplotlib

Магическая функция активирует интерактивную поддержку matplotlib во время сеанса IPython. Однако она не импортирует библиотеку matplotlib.

%notebook

Эта функция преобразует текущую историю IPython в файл «блокнота» IPython с расширением ipynb.

%recall

При выполнении без каких-либо параметров эта функция выполняет предыдущую команду. При указании номера ячейки (%recall n) после команды, вызывается команда в этой ячейке (n).

%gui [GUINAME]

При использовании без аргумента команда включает или отключает интеграцию цикла событий IPython GUI. С аргументом GUINAME магическая функция заменяет наборы инструментов GUI, используемые по умолчанию, на указанный.

Заключение

В этой статье мы провели краткий экскурс по основным методам Python, которыми должен овладеть каждый программист, изучающий «змеиный язык». Приведенный список команд для Python с пояснениями и примерами поможет каждому новичку быстро освоить базовые приемы работы с функционалом этого востребованного языка программирования.

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

Источник

Автоматизированные чат-боты весьма полезны для стимулирования взаимодействия. Мы можем создавать чат-боты для Slack, Discord и других платформ.

В этой статье я расскажу вам, как создать чат-бота в Telegram, который будет сообщать вам ваш гороскоп. Итак, приступим!

Как получить токен вашего бота

Чтобы настроить нового бота, вам нужно будет поговорить с BotFather. Нет, это не человек — это тоже бот, и он руководит всеми ботами Telegram.

1. Найдите @botfather в Telegram.

2. Начните диалог с BotFather, нажав на кнопку «Начать».

3. Введите /newbot и следуйте инструкциям по настройке нового бота. BotFather выдаст вам токен, который вы будете использовать для аутентификации вашего бота и предоставления ему доступа к API Telegram.

Примечание: убедитесь, что вы надежно храните токен. Любой, у кого есть доступ к вашему токену, может легко управлять вашим ботом.

Как настроить среду для программирования

Давайте настроим среду программирования. Для создания Telegram-бота доступны различные библиотеки, но мы будем использовать библиотеку pyTelegramBotAPI. Это простая, но расширяемая реализация Python для API Telegram Bot с синхронными и асинхронными возможностями.

Установите библиотеку pyTelegramBotAPI с помощью pip:

pip install pyTelegramBotAPI

Затем откройте свой любимый редактор кода и создайте файл .env для хранения вашего токена, как показано ниже:

export BOT_TOKEN=your-bot-token-here

После этого выполните команду source .env для считывания переменных среды из файла .env

Как создать своего первого бота

Все реализации API хранятся в одном классе под названием TeleBot. Он предлагает множество способов прослушивания входящих сообщений, а также такие функции, как send_message(), send_document(), и другие для отправки сообщений.

Создайте новый файл bot.py и вставьте в него следующий код:

import os

import telebot

BOT_TOKEN = os.environ.get('BOT_TOKEN')

bot = telebot.TeleBot(BOT_TOKEN)

В приведенном выше коде мы используем библиотеку os для считывания переменных среды, хранящихся в нашей системе.

Если вы помните, на предыдущем шаге мы экспортировали переменную среды с именем BOT_TOKEN. Значение BOT_TOKEN считывается в переменную с именем BOT_TOKEN. Далее мы используем класс TeleBot для создания экземпляра бота и передаём ему BOT_TOKEN

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

Давайте определим обработчик сообщений, который будет обрабатывать входящие команды /start и /hello.

@bot.message_handler(commands=['start', 'hello'])
def send_welcome(message):
    bot.reply_to(message, "Howdy, how are you doing?")

Для функции, которая оформлена как обработчик сообщений, допустимо любое имя, но она может иметь только один параметр (сообщение).

Давайте добавим ещё один обработчик, который будет отправлять все входящие текстовые сообщения обратно отправителю.

@bot.message_handler(func=lambda msg: True)
def echo_all(message):
    bot.reply_to(message, message.text)

Приведенный выше код использует lambda выражение для проверки сообщения. Поскольку нам нужно повторить все сообщения, мы всегда возвращаем True из lambda функции.

Теперь у вас есть простой бот, который отвечает на команды /start и /hello статическим сообщением и повторяет все остальные отправленные сообщения. Добавьте следующее в конец вашего файла, чтобы запустить бота:

bot.infinity_polling()

Вот и всё! У нас готов Telegram-бот. Давайте запустим файл Python и перейдём в Telegram, чтобы протестировать бота.

Если вы не можете найти бота, поищите его по имени пользователя. Вы можете проверить его, отправив такие команды, как /hello и /start и другие случайные тексты.

Примечание: все обработчики сообщений тестируются в том порядке, в котором они были объявлены в исходном файле.

Дополнительную информацию об использовании библиотеки pyTelegramBotAPI можно найти в документации.

Как написать код для бота-гороскопа

Давайте теперь сосредоточимся на создании нашего бота-гороскопа. Мы будем использовать в боте цепочку сообщений. Бот сначала запросит ваш знак зодиака, затем день, а затем ответит гороскопом на этот конкретный день.

По сути, бот взаимодействует с API для получения данных о гороскопе.

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

Как получить данные о гороскопе

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

import requests

def get_daily_horoscope(sign: str, day: str) -> dict:
    """Get daily horoscope for a zodiac sign.
    Keyword arguments:
    sign:str - Zodiac sign
    day:str - Date in format (YYYY-MM-DD) OR TODAY OR TOMORROW OR YESTERDAY
    Return:dict - JSON data
    """
    url = "https://horoscope-app-api.vercel.app/api/v1/get-horoscope/daily"
    params = {"sign": sign, "day": day}
    response = requests.get(url, params)

    return response.json()

В приведенном выше коде Python мы создали функцию, которая принимает два строковых аргумента — sign и day — и возвращает данные в формате JSON. Мы отправляем запрос GET по URL-адресу API и передаем sign и day в качестве параметров запроса.

Если вы протестируете функцию, то получите результат, похожий на этот:

{
   "data":{
      "date": "Dec 15, 2022",
      "horoscope_data": "Lie low during the day and try not to get caught up in the frivolous verbiage that dominates the waking hours. After sundown, feel free to speak your mind. You may notice that there is a sober tone and restrictive sensation today that leaves you feeling like you will never be able to break free from your current situation. Don't get caught in this negative mindset."
   },
   "status": 200,
   "success": true
}

Примечание: подробнее о библиотеке requests в Python можно узнать в этом руководстве.

Как добавить обработчик сообщений

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

@bot.message_handler(commands=['horoscope'])
def sign_handler(message):
    text = "What's your zodiac sign?\nChoose one: *Aries*, *Taurus*, *Gemini*, *Cancer,* *Leo*, *Virgo*, *Libra*, *Scorpio*, *Sagittarius*, *Capricorn*, *Aquarius*, and *Pisces*."
    sent_msg = bot.send_message(message.chat.id, text, parse_mode="Markdown")
    bot.register_next_step_handler(sent_msg, day_handler)

Приведённая выше функция немного отличается от других функций, которые мы определили ранее. Функция гороскопа бота будет вызываться командой /horoscope. Мы отправляем пользователю текстовое сообщение, но обратите внимание, что при отправке сообщения мы установили parse_mode на Markdown.

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

Давайте определим функцию day_handler(), которая принимает сообщение.

def day_handler(message):
    sign = message.text
    text = "What day do you want to know?\nChoose one: *TODAY*, *TOMORROW*, *YESTERDAY*, or a date in format YYYY-MM-DD."
    sent_msg = bot.send_message(
        message.chat.id, text, parse_mode="Markdown")
    bot.register_next_step_handler(
        sent_msg, fetch_horoscope, sign.capitalize())

Мы получаем знак зодиака из атрибута message.text. Как и предыдущая функция, она также запрашивает день, на который вы хотите узнать гороскоп.

В итоге мы используем тот же метод register_next_step_handler() и передаём sent_msg, функцию обратного вызова fetch_horoscope и sign.

Теперь давайте определим функцию fetch_horoscope(), которая принимает сообщение и знак.

def fetch_horoscope(message, sign):
    day = message.text
    horoscope = get_daily_horoscope(sign, day)
    data = horoscope["data"]
    horoscope_message = f'*Horoscope:* {data["horoscope_data"]}\\n*Sign:* {sign}\\n*Day:* {data["date"]}'
    bot.send_message(message.chat.id, "Here's your horoscope!")
    bot.send_message(message.chat.id, horoscope_message, parse_mode="Markdown")

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

Затем мы получаем гороскоп с помощью функции get_daily_horoscope() и составляем наше сообщение. В конце мы отправляем сообщение с данными гороскопа.

Демо-версия Бота

Как только вы запустите файл Python, вы сможете протестировать эту функцию. Вот демонстрация:

Рекомендуемые Следующие Шаги

На данный момент бот перестаёт работать, как только мы останавливаем наше приложение на Python. Чтобы он работал постоянно, вы можете развернуть бот на таких платформах, как Heroku, Render и так далее.

Вот ссылка на репозиторий GitHub для этого проекта — не стесняйтесь, ознакомьтесь с ним.

Вы также можете расширить функциональность бота, изучив API Telegram.

Спасибо, что читаете! Вы можете следить за мной в Twitter.

Перевод: Building A Blog Application With Django

В этом руководстве мы создадим приложение для блога на Django, которое позволит пользователям создавать, редактировать и удалять посты. На главной странице будут отображаться все посты блога, а для каждого отдельного поста будет выделена отдельная страница. Django способен создавать более сложные приложения, но создание блога — отличный первый шаг для того, чтобы хорошо разобраться в фреймворке. Цель этой главы — получить общее представление о работе Django.

Вот краткий обзор того, что мы собираемся сделать.

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

Django — это веб-фреймворк с открытым исходным кодом, написанный на Python, который следует архитектурному шаблону «модель-представление-шаблон». Таким образом, на вашем компьютере должен быть установлен Python. К сожалению, несколько лет назад в Python было внесено значительное обновление, которое привело к большому разрыву между версиями Python, а именно: Python 2 — устаревшая версия и Python 3 — версия, находящаяся в активной разработке.

Поскольку Python 3 является текущей версией, находящейся в активной разработке и рассматриваемой как будущее Python, Django выпустил значительное обновление, и теперь все выпуски после Django 2.0 совместимы только с Python 3.x. Поэтому это руководство предназначено исключительно для Python 3.x. Убедитесь, что на вашем компьютере установлен Python 3, если нет, следуйте приведенным ниже инструкциям.

Пользователи Windows

• Как установить Python в Windows

Пользователи Mac и Unix

• Как установить Python 3 на Mac OS

Создание И Активация виртуальной среды

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

Пользователи Windows

cd Desktop
virtualenv django
cd django
Scripts\activate.bat

Пользователи Mac и Unix

mkdir django
cd django
python3 -m venv django
source django/bin/activate

Теперь вы должны увидеть в своем терминале (django) префикс, который указывает на успешную активацию виртуальной среды. Если нет, то повторите руководство еще раз.

Установка Django в виртуальной среде

Если вы уже установили Django, вы можете пропустить этот раздел и перейти сразу к разделу «Настройка проекта». Чтобы установить Django в вашей виртуальной среде, выполните следующую команду

pip install Django

Это позволит установить последнюю версию Django в нашей виртуальной среде. Чтобы узнать больше об установке Django, прочтите: «Как установить Django»

Примечание: необходимо установить версию Django, превышающую 2.0

Настройка проекта

В вашем рабочем пространстве создайте каталог с именем mysite и перейдите в него.

cd Desktop
mkdir mysite
cd mysite

Теперь выполните следующую команду в командной строке, чтобы создать проект Django.

django-admin startproject mysite

Это создаст структуру проекта с несколькими каталогами и скриптами на Python.

├── mysite
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   ├── wsgi.py
├── manage.py

Далее нам нужно создать приложение Django под названием «Блог». Приложение Django предназначено для выполнения определённой задачи. Вам нужно создать конкретные приложения, которые будут отвечать за желаемые функции вашего сайта.

Перейдите во внешний каталог, в котором находится скрипт manage.py, и выполните следующую команду.

cd mysite
python manage.py startapp blog

С их помощью мы создадим приложение под названием «Блог» в нашем проекте.

├── db.sqlite3
├── mysite
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   ├── wsgi.py
├── manage.py
└── blog
    ├── __init__.py
    ├── admin.py
    ├── apps.py
    ├── migrations
    │   └── __init__.py
    ├── models.py
    ├── tests.py
    └── views.py

Теперь нам нужно сообщить Django, что создано новое приложение. Откройте файл settings.py и перейдите в раздел «Установленные приложения», где должны быть указаны уже установленные приложения.

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

Теперь добавьте только что созданное приложение в блог внизу и сохраните его.

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'blog'
]

Затем произведите миграцию.

python manage.py migrate

Это позволит применить все неприменённые миграции к базе данных SQLite, которая поставляется вместе с установкой Django.

Давайте проверим наши настройки, запустив встроенный сервер разработки Django.

python manage.py runserver

Откройте свой браузер и перейдите по этому адресу.http://127.0.0.1:8000/ Если все прошло успешно, вы увидите эту страницу.

Модели баз данных

Теперь мы определим модели данных для нашего блога. Модель — это класс Python, который является подклассом django.db.models.Model, в котором каждый атрибут представляет собой поле базы данных. Используя эту функциональность подклассов, мы автоматически получаем доступ ко всему, что находится в django.db.models.Models, и можем добавлять дополнительные поля и методы по желанию. В нашей базе данных будет модель Post для хранения постов.

from django.db import models
from django.contrib.auth.models import User


STATUS = (
    (0,"Draft"),
    (1,"Publish")
)

class Post(models.Model):
    title = models.CharField(max_length=200, unique=True)
    slug = models.SlugField(max_length=200, unique=True)
    author = models.ForeignKey(User, on_delete= models.CASCADE,related_name='blog_posts')
    updated_on = models.DateTimeField(auto_now= True)
    content = models.TextField()
    created_on = models.DateTimeField(auto_now_add=True)
    status = models.IntegerField(choices=STATUS, default=0)

    class Meta:
        ordering = ['-created_on']

    def __str__(self):
        return self.title

В верхней части мы импортируем класс models и затем создаём подкласс models.Model Как и в любом обычном блоге, у каждого поста будет заголовок, ссылка, имя автора и отметка времени или дата публикации или последнего обновления статьи.

Обратите внимание, как мы объявили кортеж дляSTATUSсохранения черновиков и опубликованных постов отдельно друг от друга при их отображении с помощью шаблонов.

Класс Meta внутри модели содержит метаданные. Мы указываем Django сортировать результаты по полю created_on в порядке убывания по умолчанию при запросе к базе данных. Мы указываем порядок убывания с помощью отрицательного префикса. Таким образом, недавно опубликованные посты будут отображаться первыми.

Этот __str__() метод является читаемым человеком представлением объекта по умолчанию. Django будет использовать его во многих местах, например на сайте администрирования.

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

(django) $ python manage.py makemigrations
(django) $ python manage.py migrate

Теперь мы закончили работу с базой данных.

Создание сайта администрирования

Мы создадим панель администратора для создания постов и управления ими. К счастью, в Django есть встроенный интерфейс администратора для таких задач.

Чтобы использовать Django admin, сначала нужно создать суперпользователя, выполнив в командной строке следующую команду.

python manage.py createsuperuser

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

Username (leave blank to use 'user'): admin
Email address: admin@gamil.com
Password:
Password (again):

Введите любые данные, вы всегда сможете изменить их позже. После этого перезапустите сервер разработки и перейдите по адресу http://127.0.0.1:8000/admin/

python manage.py runserver

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

После входа в систему вы должны увидеть базовую панель администратора с моделями «Группы» и «Пользователи», которые взяты из фреймворка аутентификации Django, расположенного в django.contrib.auth.

Тем не менее, мы не можем создавать публикации с панели администратора. Нам нужно добавить модель публикации в наш админку.

Добавление моделей в админку

Откройте файл blog/admin.py и зарегистрируйте в нём модель Post следующим образом.

from django.contrib import admin
from .models import Post

admin.site.register(Post)

Сохраните файл и обновите страницу. Там должна появиться модель «Сообщения».

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

После того как вы сохраните пост, вы будете перенаправлены на страницу со списком постов с сообщением об успешном завершении в верхней части страницы.

Хотя это и так работает, мы можем настроить отображение данных в панели администратора по своему усмотрению. Снова откройте файл admin.py и замените его кодом ниже.

from django.contrib import admin
from .models import Post

class PostAdmin(admin.ModelAdmin):
    list_display = ('title', 'slug', 'status','created_on')
    list_filter = ("status",)
    search_fields = ['title', 'content']
    prepopulated_fields = {'slug': ('title',)}

admin.site.register(Post, PostAdmin)

Это сделает нашу панель администратора более эффективной. Теперь, если вы зайдете в список публикаций, вы увидите больше информации о публикации.

Обратите внимание, что я добавил несколько постов для тестирования.

Атрибут list_display делает то, что следует из его названия: отображает свойства, упомянутые в кортеже, в списке сообщений для каждого сообщения.

Если вы заметили, справа есть фильтр, который отбирает посты в зависимости от их статуса. Это делается автоматически. list_filter

Теперь у нас есть панель поиска в верхней части списка, которая будет искать в базе данных по search_fields атрибутам. Последний атрибут prepopulated_fields заполняет слаг, теперь, если вы создадите публикацию, слаг будет автоматически заполнен на основе вашего заголовка.

Теперь, когда наша модель базы данных готова, нам нужно создать необходимые представления, URL-адреса и шаблоны, чтобы мы могли отображать информацию в нашем веб-приложении.

Виды на здание

Представление Django — это просто функция Python,которая получает веб-запрос и возвращает веб-ответ. Мы будем использовать представления на основе классов, затем сопоставим URL-адреса для каждого представления и создадим HTML-шаблон для данных, возвращаемых представлениями.

Откройте blog/views.py файл и начните писать код.

from django.views import generic
from .models import Post

class PostList(generic.ListView):
    queryset = Post.objects.filter(status=1).order_by('-created_on')
    template_name = 'index.html'

class PostDetail(generic.DetailView):
    model = Post
    template_name = 'post_detail.html'

Встроенный ListView, который является подклассом универсальных представлений на основе классов, отображает список объектов указанной модели. Нам нужно только указать шаблон. Аналогично, DetailView предоставляет подробное представление для заданного объекта модели в указанном шаблоне.

Обратите внимание, что для PostList просмотра мы применили фильтр, чтобы на главной странице нашего блога отображались только публикации со статусом «опубликована». Также в этом запросе мы упорядочили все публикации по дате их создания. Знак ( – ) перед created_on означает, что самая последняя публикация будет вверху и так далее.

Добавление шаблонов URL-адресов для представлений

Нам нужно сопоставить URL-адрес с представлениями, которые мы создали выше. Когда пользователь запрашивает страницу в вашем веб-приложении, контроллер Django ищет соответствующее представление в urls.py файле, а затем возвращает HTML-ответ или ошибку 404 «Не найдено», если представление не найдено.

Создайте urls.py файл в каталоге вашего блога и добавьте следующий код.

from . import views
from django.urls import path

urlpatterns = [
    path('', views.PostList.as_view(), name='home'),
    path('<slug:slug>/', views.PostDetail.as_view(), name='post_detail'),
]

Мы сопоставили общие шаблоны URL для наших представлений с помощью функции path. Первый шаблон принимает пустую строку, обозначаемую ' ', и возвращает результат, сгенерированный из PostList представления, которое, по сути, представляет собой список постов для нашей домашней страницы, и, наконец, у нас есть необязательный параметр name, который, по сути, является именем представления, которое впоследствии будет использоваться в шаблонах.

Имена — необязательный параметр, но рекомендуется давать представлениям уникальные и запоминающиеся имена, чтобы упростить нашу работу при создании шаблонов и поддерживать порядок по мере роста количества URL-адресов.

Далее у нас есть обобщённое выражение для PostDetail представлений, которые преобразуют слаг (строку, состоящую из букв или цифр ASCII) Django использует угловые скобки < > для получения значений из URL и возврата эквивалентной страницы с подробностями публикации.

Теперь нам нужно добавить эти URL-адреса блога в сам проект. Для этого откройте mysite/urls.py

from django.contrib import admin

urlpatterns = [
    path('admin/', admin.site.urls),
]

Теперь сначала импортируйте функцию включения, а затем добавьте путь к новому urls.py файлу в список шаблонов URL.

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('blog.urls')),
]

Теперь все запросы будут напрямую обрабатываться приложением для ведения блога.

Создание шаблонов для представлений

Мы закончили с моделями и представлениями, теперь нам нужно создать шаблоны для отображения результата нашим пользователям. Чтобы использовать шаблоны Django, нам нужно настроить параметр шаблона Первый.

Теперь в разделе settings.py прокрутите до,TEMPLATES который должен выглядеть так.

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

Теперь добавьте BASE_DIR / 'templates' в DIRS так, чтобы Django мог найти наши шаблоны.

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        #  Add  'TEMPLATE_DIRS' here
        'DIRS': [
 BASE_DIR / 'templates'
 ],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]КопироватьКопировать

Теперь сохраните и закройте файл, мы закончили с настройками.

Django позволяет разделять Python и HTML: Python используется в представлениях, а HTML — в шаблонах. Django имеет мощный язык шаблонов, который позволяет указывать, как отображаются данные. Он основан на тегах шаблонов, переменных шаблонов и фильтрах шаблонов.

Я начну с base.html файла и index.html файла, который наследуется от него. Затем позже, когда мы добавим шаблоны для главной страницы и страниц с подробностями, они тоже смогут наследоваться от base.html.

Давайте начнём с файла base.html, в котором будут общие элементы для блога на любой странице, такие как навигационная панель и нижний колонтитул. Кроме того, мы используем Bootstrap для пользовательского интерфейса и шрифт Roboto.

<!DOCTYPE html>
<html>

    <head>
        <title>Django Central</title>
        <link href="https://fonts.googleapis.com/css?family=Roboto:400,700" rel="stylesheet">
        <meta name="google" content="notranslate" />
        <meta name="viewport" content="width=device-width, initial-scale=1" />
        <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm"
            crossorigin="anonymous" />
    </head>

    <body>
        <style>
            body {
            font-family: "Roboto", sans-serif;
            font-size: 17px;
            background-color: #fdfdfd;
        }
        .shadow {
            box-shadow: 0 4px 2px -2px rgba(0, 0, 0, 0.1);
        }
        .btn-danger {
            color: #fff;
            background-color: #f00000;
            border-color: #dc281e;
        }
        .masthead {
            background: #3398E1;
            height: auto;
            padding-bottom: 15px;
            box-shadow: 0 16px 48px #E3E7EB;
            padding-top: 10px;
        }
    </style>

        <!-- Navigation -->
        <nav class="navbar navbar-expand-lg navbar-light bg-light shadow" id="mainNav">
            <div class="container-fluid">
                <a class="navbar-brand" href="{% url 'home' %}">Django central</a>
                <button class="navbar-toggler navbar-toggler-right" type="button" data-toggle="collapse" data-target="#navbarResponsive"
                    aria-controls="navbarResponsive" aria-expanded="false" aria-label="Toggle navigation">
                    <span class="navbar-toggler-icon"></span>
                </button>
                <div class="collapse navbar-collapse" id="navbarResponsive">
                    <ul class="navbar-nav ml-auto">
                        <li class="nav-item text-black">
                            <a class="nav-link text-black font-weight-bold" href="#">About</a>
                        </li>
                        <li class="nav-item text-black">
                            <a class="nav-link text-black font-weight-bold" href="#">Policy</a>
                        </li>
                        <li class="nav-item text-black">
                            <a class="nav-link text-black font-weight-bold" href="#">Contact</a>
                        </li>
                    </ul>
                </div>
            </div>
        </nav>
        {% block content %}
        <!-- Content Goes here -->
        {% endblock content %}
        <!-- Footer -->
        <footer class="py-3 bg-grey">
            <p class="m-0 text-dark text-center ">Copyright &copy; Django Central</p>
        </footer>
    </body>
</html>

Это обычный HTML-файл, за исключением тегов внутри фигурных скобок { }. Они называются тегами шаблонов.

{% url 'home' %} Возвращает абсолютную ссылку на путь, она генерирует ссылку на главную страницу, которая также является страницей списка публикаций.

{% block content %} Определяет блок, который может быть переопределен дочерними шаблонами. Сюда будет добавлен контент из другого HTML-файла.

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

{% block sidebar %}

<style>
        .card{
            box-shadow: 0 16px 48px #E3E7EB;
        }

</style>

<!-- Sidebar Widgets Column -->
<div class="col-md-4 float-right ">
<div class="card my-4">
        <h5 class="card-header">About Us</h5>
    <div class="card-body">
        <p class="card-text"> This awesome blog is made on the top of our Favourite full stack Framework 'Django', follow up the tutorial to learn how we made it..!</p>
        <a href="https://djangocentral.com/building-a-blog-application-with-django"
           class="btn btn-danger">Know more!</a>
    </div>
</div>
</div>

{% endblock sidebar %}

Затем создайте файл index.html для нашего блога, который будет главной страницей.

{% extends "base.html" %}
{% block content %}
<style>
    body {
        font-family: "Roboto", sans-serif;
        font-size: 18px;
        background-color: #fdfdfd;
    }

    .head_text {
        color: white;
    }

    .card {
        box-shadow: 0 16px 48px #E3E7EB;
    }
</style>

<header class="masthead">
    <div class="overlay"></div>
    <div class="container">
        <div class="row">
            <div class=" col-md-8 col-md-10 mx-auto">
                <div class="site-heading">
                    <h3 class=" site-heading my-4 mt-3 text-white"> Welcome to my awesome Blog </h3>
                    <p class="text-light">We Love Django As much as you do..! &nbsp
                    </p>
                </div>
            </div>
        </div>
    </div>
</header>
<div class="container">
    <div class="row">
        <!-- Blog Entries Column -->
        <div class="col-md-8 mt-3 left">
            {% for post in post_list %}
            <div class="card mb-4">
                <div class="card-body">
                    <h2 class="card-title">{{ post.title }}</h2>
                    <p class="card-text text-muted h6">{{ post.author }} | {{ post.created_on}} </p>
                    <p class="card-text">{{post.content|slice:":200" }}</p>
                    <a href="{% url 'post_detail' post.slug  %}" class="btn btn-primary">Read More &rarr;</a>
                </div>
            </div>
            {% endfor %}
        </div>
        {% block sidebar %} {% include 'sidebar.html' %} {% endblock sidebar %}
    </div>
</div>
{%endblock%}

С помощью тега шаблона {% extends %} мы указываем Django наследоваться от шаблона base.html. Затем мы заполняем блоки контента базового шаблона содержимым.

Обратите внимание, что мы используем цикл for в HTML. Это сила шаблонов Django, которая делает HTML динамичным. Цикл перебирает записи и отображает их заголовок, дату, автора и текст, включая ссылку в заголовке на канонический URL записи.

В основной части публикации мы также используем фильтры шаблонов, чтобы ограничить количество слов в отрывках до 200 символов. Фильтры шаблонов позволяют изменять переменные для отображения и выглядят как {{ variable | filter }}.

Теперь запустите сервер и перейдите по адресу http://127.0.0.1:8000/, вы увидите главную страницу нашего блога.

Выглядит неплохо ..!

Возможно, вы заметили, что я импортировал некоторый фиктивный контент для заполнения страницы. Вы можете сделать то же самое с помощью этого генератора Lorem Ipsum.

Теперь давайте создадим HTML-шаблон для подробного просмотра наших публикаций.

Затем создайте файл post_detail.html и вставьте в него приведенный ниже HTML-код.

{% extends 'base.html' %} {% block content %}

<div class="container">
  <div class="row">
    <div class="col-md-8 card mb-4  mt-3 left  top">
      <div class="card-body">
        <h1>{% block title %} {{ object.title }} {% endblock title %}</h1>
        <p class=" text-muted">{{ post.author }} | {{ post.created_on }}</p>
        <p class="card-text ">{{ object.content | safe }}</p>
      </div>
    </div>
    {% block sidebar %} {% include 'sidebar.html' %} {% endblock sidebar %}
  </div>
</div>

{% endblock content %}

В верхней части мы указываем, от чего наследуется этот шаблон. base.html Затем отображаем body из нашего объекта контекста, который DetailView делает доступным как объект.

Теперь перейдите на главную страницу и нажмите «Читать дальше». Вы должны быть перенаправлены на страницу с подробностями публикации.

Ссылки:

Build a Blog From Scratch With Django